Generazione di contenuti in corso...

bookmark_border Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Firebase Genkit offre un'interfaccia semplice per la generazione di contenuti con gli LLM.

Modelli

I modelli in Firebase Genkit sono librerie e astrazioni che forniscono l'accesso vari LLM Google e non Google.

I modelli sono completamente strumentati per l'osservabilità e sono dotati di integrazioni degli strumenti fornite dall'interfaccia utente per gli sviluppatori di Genkit. Puoi provare qualsiasi modello utilizzando il runner del modello.

Quando lavori con i modelli in Genkit, devi prima configurare il modello con cui vuoi lavorare. La configurazione del modello viene eseguita dal sistema dei plug-in. In questo esempio configuri il plug-in Vertex AI, che fornisce i modelli Gemini.

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
}

Per utilizzare i modelli forniti dal plug-in, è necessario un riferimento al modello specifico e versione:

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

Modelli supportati

Genkit fornisce il supporto del modello attraverso il proprio sistema di plug-in. I seguenti plug-in sono ufficialmente supportati:

Per informazioni sulla configurazione e sull'utilizzo, consulta la documentazione di ciascun plug-in.

Come generare contenuti

Genkit fornisce una semplice funzione helper per la generazione di contenuti con modelli.

Per chiamare solo il modello:

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

Puoi passare le opzioni insieme alla chiamata del modello. Opzioni supportate dipendono dal modello e dall'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,
	}))

Risposte dinamiche

Genkit supporta flussi di dati suddivisi in blocchi delle risposte del modello. Per usare il flusso di dati in blocchi, passa una funzione di callback a 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())

Input multimodale

Se il modello supporta l'input multimodale, puoi passare i prompt di immagini:

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))))

Il formato esatto del prompt dell'immagine (URL https, URL gs, URI data) dipende dal modello.

Chiamata di funzioni (strumenti)

I modelli Genkit forniscono un'interfaccia per le chiamate di funzione, per i modelli che supportano li annotino.

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))

In questo modo gli strumenti verranno chiamati automaticamente per soddisfare la richiesta dell'utente.

Registrazione della cronologia dei messaggi

I modelli Genkit supportano la conservazione di una cronologia dei messaggi inviati al modello e le sue risposte, che puoi utilizzare per creare esperienze interattive, come i chatbot.

Nel primo prompt di una sessione, la "cronologia" è semplicemente il prompt dell'utente:

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

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

Quando ricevi una risposta, aggiungila alla cronologia:

history = append(history, response.Message)

Puoi serializzare questa cronologia e conservarla in un database o nello spazio di archiviazione della sessione. Per i successivi prompt dell'utente, aggiungili alla cronologia prima di chiamare 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...))

Se il modello che utilizzi supporta il ruolo di sistema, puoi utilizzare la cronologia iniziale per impostare il messaggio di sistema:

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