Invites

La manipulation des requêtes est le principal moyen pour vous, en tant que développeur d'applications, d'influencer la sortie des modèles d'IA générative. Par exemple, lorsque vous utilisez des LLM, vous pouvez créer des invites qui influencent le ton, le format, la longueur et d'autres caractéristiques des réponses des modèles.

Genkit s'appuie sur le principe que les requêtes sont du code. Vous écrivez et gérez vos invites dans des fichiers sources, suivez les modifications apportées à l'aide du même système de contrôle des versions que celui que vous utilisez pour votre code, et les déployez avec le code qui appelle vos modèles d'IA générative.

La plupart des développeurs constateront que la bibliothèque Dotprompt incluse répond à ses besoins pour travailler avec les requêtes dans Genkit. Toutefois, d'autres approches sont également possibles en travaillant directement avec les invites.

Définir des requêtes

Les fonctions d'assistance de génération de Genkit acceptent des requêtes de chaîne. Vous pouvez ainsi appeler des modèles pour des cas d'utilisation simples.

genkit.Generate(context.Background(), g,
	ai.WithModel(model),
	ai.WithTextPrompt("You are a helpful AI assistant named Walt."))

Dans la plupart des cas, vous devrez inclure des entrées fournies par l'utilisateur dans votre requête. Vous pouvez définir une fonction pour les afficher comme suit:

func helloPrompt(name string) *ai.Part {
	prompt := fmt.Sprintf("You are a helpful AI assistant named Walt. Say hello to %s.", name)
	return ai.NewTextPart(prompt)
}

response, err := genkit.GenerateText(context.Background(), g,
	ai.WithModel(model),
	ai.WithMessages(ai.NewUserMessage(helloPrompt("Fred"))))

Toutefois, l'inconvénient de définir des requêtes dans votre code est que les tests nécessitent de les exécuter dans le cadre d'un flux. Pour accélérer l'itération, Genkit fournit une fonction pour définir vos requêtes et les exécuter dans l'UI du développeur.

Utilisez la fonction DefinePrompt pour enregistrer vos requêtes avec Genkit.

type HelloPromptInput struct {
	UserName string
}
helloPrompt := genkit.DefinePrompt(
	g,
	"prompts",
	"helloPrompt",
	nil, // Additional model config
	jsonschema.Reflect(&HelloPromptInput{}),
	func(ctx context.Context, input any) (*ai.ModelRequest, error) {
		params, ok := input.(HelloPromptInput)
		if !ok {
			return nil, errors.New("input doesn't satisfy schema")
		}
		prompt := fmt.Sprintf(
			"You are a helpful AI assistant named Walt. Say hello to %s.",
			params.UserName)
		return &ai.ModelRequest{Messages: []*ai.Message{
			{Content: []*ai.Part{ai.NewTextPart(prompt)}},
		}}, nil
	},
)

Une action d'invite définit une fonction qui renvoie un GenerateRequest, utilisables avec n'importe quel modèle. Vous pouvez aussi définir un schéma d'entrée pour la requête, qui est analogue au schéma d'entrée d'un flux. Les requêtes peuvent également définir n'importe quelle option de configuration de modèle courante, comme la température ou le nombre de jetons de sortie.

Vous pouvez afficher cette requête dans une requête de modèle à l'aide de la fonction d'assistance fournie. Indiquez les variables d'entrée attendues par la requête et le modèle à appeler.

request, err := helloPrompt.Render(context.Background(), HelloPromptInput{UserName: "Fred"})
if err != nil {
	return err
}
response, err := genkit.GenerateWithRequest(context.Background(), g, model, request, nil, nil, nil)

Dans l'interface utilisateur du développeur Genkit, vous pouvez exécuter n'importe quelle invite que vous avez définie de cette manière. Vous pouvez ainsi tester des invites individuelles en dehors du champ d'application des flux dans lesquels elles peuvent être utilisées.

Dotprompt

Genkit inclut la bibliothèque Dotprompt qui ajoute aux requêtes.

• Chargement des requêtes à partir de .prompt fichiers sources
• Modèles basés sur des guidons
• Prise en charge des modèles d'invites multi-tours et des contenus multimédias
• Définitions concises des schémas d'entrée et de sortie
• Utilisation fluide avec generate()