Génération de contenu...

bookmark_border Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Firebase Genkit offre une interface simple pour générer du contenu à l'aide des LLM.

Modèles

Dans Firebase Genkit, les modèles sont des bibliothèques et des abstractions qui donnent accès avec divers LLM Google et autres.

Les modèles sont entièrement instrumentés pour l'observabilité et sont fournis avec des intégrations d'outils fournies par l'UI du développeur Genkit. Vous pouvez essayer n'importe quel modèle à l'aide du moteur d'exécution de modèles.

Lorsque vous travaillez avec des modèles dans Genkit, vous devez d'abord configurer le modèle avec lequel vous souhaitez travailler. La configuration du modèle est effectuée par le système de plug-in. Dans Dans cet exemple, vous configurez le plug-in Vertex AI, qui fournit à Gemini des modèles de ML.

import {
	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/googlegenai"
}

// Default to the value of GCLOUD_PROJECT for the project,
// and "us-central1" for the location.
// To specify these values directly, pass a vertexai.Config value to Init.
if err := (&googlegenai.VertexAI{}).Init(ctx, g); err != nil {
	return err
}

Pour utiliser les modèles fournis par le plug-in, vous avez besoin d'une référence au modèle spécifique et sa version:

model := googlegenai.VertexAIModel(g, "gemini-1.5-flash")

Modèles compatibles

Genkit est compatible avec les modèles via son système de plug-in. Les plug-ins suivants sont officiellement prises en charge:

Pour en savoir plus sur la configuration et l'utilisation de chaque plug-in, consultez la documentation correspondante.

Générer du contenu

Genkit fournit une fonction d'assistance simple pour générer du contenu à l'aide de modèles.

Pour appeler le modèle, procédez comme suit:

responseText, err := genkit.GenerateText(ctx, g, ai.WithModel(model), ai.WithPromptText("Tell me a joke."))
if err != nil {
	return err
}
fmt.Println(responseText)

Vous pouvez transmettre des options avec l'appel du modèle. Les options compatibles dépendent du modèle et de son API.

response, err := genkit.Generate(ctx, g,
	ai.WithModel(model),
	ai.WithPromptText("Tell me a joke about dogs."),
	ai.WithConfig(&ai.GenerationCommonConfig{
		Temperature:     1.67,
		StopSequences:   []string{"cat"},
		MaxOutputTokens: 3,
	}))

Réponses en streaming

Genkit est compatible avec la diffusion fragmentée des réponses du modèle. Pour utiliser les flux fragmentés, transmettez une fonction de rappel à Generate():

response, err := genkit.Generate(ctx, g,
	ai.WithModel(gemini15pro),
	ai.WithPromptText("Tell a long story about robots and ninjas."),
	// stream callback
	ai.WithStreaming(
		func(ctx context.Context, grc *ai.ModelResponseChunk) error {
			fmt.Printf("Chunk: %s\n", grc.Text())
			return nil
		}))
if err != nil {
	return err
}

// You can also still get the full response.
fmt.Println(response.Text())

Saisie multimodale

Si le modèle est compatible avec l'entrée multimodale, vous pouvez transmettre des requêtes d'image:

imageBytes, err := os.ReadFile("img.jpg")
if err != nil {
	return err
}
encodedImage := base64.StdEncoding.EncodeToString(imageBytes)

resp, err := genkit.Generate(ctx, g,
	ai.WithModel(gemini15pro),
	ai.WithMessages(
		ai.NewUserMessage(
			ai.NewTextPart("Describe the following image."),
			ai.NewMediaPart("", "data:image/jpeg;base64,"+encodedImage))))

Le format exact de la requête image (URL https, URL gs, URI data) est dépend du modèle.

Appel de fonction (outils)

Les modèles Genkit fournissent une interface pour les appels de fonction, pour les modèles qui les acceptent.

myJokeTool := genkit.DefineTool(
	g,
	"myJoke",
	"useful when you need a joke to tell",
	func(ctx *ai.ToolContext, input *any) (string, error) {
		return "haha Just kidding no joke! got you", nil
	},
)

response, err := genkit.Generate(ctx, g,
	ai.WithModel(gemini15pro),
	ai.WithPromptText("Tell me a joke."),
	ai.WithTools(myJokeTool))

Les outils sont alors automatiquement appelés pour répondre à l'invite de l'utilisateur.

Enregistrement de l'historique des messages

Les modèles Genkit permettent de conserver un historique des messages envoyés au modèle et ses réponses, que vous pouvez utiliser pour créer des expériences interactives, telles que chatbots.

Dans la première requête d'une session, "history" correspond simplement à la requête utilisateur :

history := []*ai.Message{{
	Content: []*ai.Part{ai.NewTextPart(prompt)},
	Role:    ai.RoleUser,
}}

response, err := genkit.Generate(ctx, g,
	ai.WithModel(gemini15pro),
	ai.WithMessages(history...))

Lorsque vous recevez une réponse, ajoutez-la à l'historique:

history = append(history, response.Message)

Vous pouvez sérialiser cet historique et le conserver dans une base de données ou un espace de stockage de session. Pour les invites utilisateur suivantes, ajoutez-les à l'historique avant d'appeler Generate() :

history = append(history, &ai.Message{
	Content: []*ai.Part{ai.NewTextPart(prompt)},
	Role:    ai.RoleUser,
})

response, err = genkit.Generate(ctx, g,
	ai.WithModel(gemini15pro),
	ai.WithMessages(history...))

Si le modèle que vous utilisez est compatible avec le rôle système, vous pouvez utiliser le rôle pour définir le message système:

history = []*ai.Message{{
	Content: []*ai.Part{ai.NewTextPart("Talk like a pirate.")},
	Role:    ai.RoleSystem,
}}