Inhalte werden generiert

bookmark_border Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Firebase Genkit bietet eine einfache Benutzeroberfläche zum Generieren von Inhalten mit LLMs.

Modelle

Modelle in Firebase Genkit sind Bibliotheken und Abstraktionen, die Zugriff auf verschiedene LLMs von Google und anderen.

Die Modelle sind vollständig für Beobachtbarkeit instrumentiert und verfügen über Tools Integrationen bereitgestellt werden, die über die Genkit-Entwickler-UI bereitgestellt werden. Sie können jedes Modell mit Modell-Runner.

Wenn Sie mit Modellen in Genkit arbeiten, müssen Sie zuerst das Modell konfigurieren, arbeiten möchten. Die Modellkonfiguration wird vom Plug-in-System durchgeführt. In In diesem Beispiel konfigurieren Sie das Vertex AI-Plug-in, das Gemini bietet Modelle.

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
}

Wenn Sie die vom Plug-in bereitgestellten Modelle verwenden möchten, benötigen Sie einen Verweis auf das jeweilige Modell und die Version:

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

Unterstützte Modelle

Genkit bietet Modellunterstützung über sein Plug-in-System. Die folgenden Plug-ins werden offiziell unterstützt:

Informationen zur Einrichtung und Verwendung finden Sie in der Dokumentation der einzelnen Plug-ins.

Inhalte erstellen

Genkit bietet eine einfache Hilfsfunktion zum Generieren von Inhalten mit Modellen.

So rufen Sie das Modell einfach auf:

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

Sie können Optionen zusammen mit dem Modellaufruf übergeben. Unterstützte Optionen vom Modell und seiner API abhängig.

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

Streamingantworten

Genkit unterstützt das Chunked-Streaming von Modellantworten. Wenn du das Chunked-Streaming verwenden möchtest, musst du Generate() eine Callback-Funktion übergeben:

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

Multimodale Eingabe

Wenn das Modell multimodale Eingaben unterstützt, können Sie Bildprompts übergeben:

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

Das genaue Format des Bildprompts (https-URL, gs-URL, data-URI) ist modellabhängig.

Funktionsaufrufe (Tools)

Genkit-Modelle bieten eine Schnittstelle für den Funktionsaufruf, sofern das Modell dies unterstützt.

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

Dadurch werden automatisch die Tools aufgerufen, um die Aufforderung des Nutzers auszuführen.

Nachrichtenverlauf wird aufgezeichnet

Genkit-Modelle unterstützen das Verwalten eines Verlaufs der an das Modell gesendeten Nachrichten und die Antworten, mit denen Sie interaktive Erlebnisse erstellen können, Chatbots.

Beim ersten Prompt einer Sitzung ist der „Verlauf“ einfach der Nutzerprompt:

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

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

Wenn Sie eine Antwort erhalten, fügen Sie sie dem Verlauf hinzu:

history = append(history, response.Message)

Sie können diesen Verlauf serialisieren und in einer Datenbank oder einem Sitzungsspeicher speichern. Fügen Sie weitere Nutzer-Prompts dem Verlauf hinzu, bevor Sie sie aufrufen. 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...))

Wenn das von Ihnen verwendete Modell die Systemrolle unterstützt, können Sie die Systemmeldung über den ursprünglichen Verlauf festlegen:

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