Firebase Genkit zapewnia prosty interfejs do generowania treści przy użyciu modeli LLM.
Modele
Modele w Firebase Genkit to biblioteki i abstrakcje, które zapewniają dostęp do z wieloma modelami LLM od Google i innych firm.
Modele są w pełni przystrojone pod kątem dostrzegalności i mają narzędzia dostępnych w interfejsie programisty Genkit – możesz wypróbować dowolny model, czyli biegacza modelu.
Podczas pracy z modelami w Genkit musisz najpierw skonfigurować model, z którymi chcesz współpracować. Konfiguracja modelu jest wykonywana przez system wtyczek. W w tym przykładzie konfigurujesz wtyczkę Vertex AI, która udostępnia Gemini modeli ML.
Go
import "github.com/firebase/genkit/go/ai"
import "github.com/firebase/genkit/go/plugins/vertexai"
// 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 := vertexai.Init(ctx, nil); err != nil {
return err
}
Aby używać modeli dostarczanych przez wtyczkę, musisz mieć odniesienie do konkretnego modelu i wersja:
Go
gemini15pro := vertexai.Model("gemini-1.5-pro")
Obsługiwane modele
Genkit zapewnia obsługę modelu przez system wtyczek. Te wtyczki są oficjalnie obsługiwane:
Wtyczka | Modele |
---|---|
Generatywna AI od Google | Gemini Pro, Gemini Pro Vision |
Google Vertex AI | Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2 |
Ollama | Wiele modeli lokalnych, w tym Gemma, Llama 2 czy Mistral |
W dokumentacji każdej wtyczki znajdziesz informacje o jej konfiguracji i korzystaniu.
Jak generować treści
Genkit udostępnia prostą funkcję pomocniczą do generowania treści za pomocą modeli.
Aby po prostu wywołać model:
Go
request := ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")}},
}}
response, err := gemini15pro.Generate(ctx, &request, nil)
if err != nil {
return err
}
responseText, err := response.Text()
if err != nil {
return err
}
fmt.Println(responseText)
Opcje możesz przekazywać wraz z wywołaniem modelu. Obsługiwane opcje zależą od modelu i jego interfejsu API.
Go
request := ai.GenerateRequest{
Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart("Tell me a joke about dogs.")}},
},
Config: ai.GenerationCommonConfig{
Temperature: 1.67,
StopSequences: []string{"abc"},
MaxOutputTokens: 3,
},
}
Strumieniowanie odpowiedzi
Genkit obsługuje strumieniowanie odpowiedzi modelu podzielone na fragmenty:
Go
Aby użyć dzielonego przesyłania strumieniowego, przekaż funkcję wywołania zwrotnego do Generate()
:
request := ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart("Tell a long story about robots and ninjas.")}},
}}
response, err := gemini15pro.Generate(
ctx,
&request,
func(ctx context.Context, grc *ai.GenerateResponseChunk) error {
text, err := grc.Text()
if err != nil {
return err
}
fmt.Printf("Chunk: %s\n", text)
return nil
})
if err != nil {
return err
}
// You can also still get the full response.
responseText, err := response.Text()
if err != nil {
return err
}
fmt.Println(responseText)
Wprowadzanie wielomodalne
Jeśli model obsługuje dane wejściowe multimodalne, możesz przekazywać prompty dotyczące obrazów:
Go
imageBytes, err := os.ReadFile("img.jpg")
if err != nil {
return err
}
encodedImage := base64.StdEncoding.EncodeToString(imageBytes)
request := ai.GenerateRequest{Messages: []*ai.Message{
{Content: []*ai.Part{
ai.NewTextPart("Describe the following image."),
ai.NewMediaPart("", "data:image/jpeg;base64,"+encodedImage),
}},
}}
gemini15pro.Generate(ctx, &request, nil)
Dokładny format promptu dotyczącego obrazu (URL https
, URL gs
, identyfikator URI data
) to
w zależności od modelu.
Wywoływanie funkcji (narzędzia)
Modele Genkit udostępniają interfejs do wywoływania funkcji w przypadku modeli, które obsługują .
Go
myJoke := &ai.ToolDefinition{
Name: "myJoke",
Description: "useful when you need a joke to tell",
InputSchema: make(map[string]any),
OutputSchema: map[string]any{
"joke": "string",
},
}
ai.DefineTool(
myJoke,
nil,
func(ctx context.Context, input map[string]any) (map[string]any, error) {
return map[string]any{"joke": "haha Just kidding no joke! got you"}, nil
},
)
request := ai.GenerateRequest{
Messages: []*ai.Message{
{Content: []*ai.Part{ai.NewTextPart("Tell me a joke.")},
Role: ai.RoleUser},
},
Tools: []*ai.ToolDefinition{myJoke},
}
response, err := gemini15pro.Generate(ctx, &request, nil)
Spowoduje to automatyczne wywołanie narzędzi w celu spełnienia promptu użytkownika.
Rejestrowanie historii wiadomości
Modele Genkit obsługują przechowywanie historii wiadomości wysyłanych do modelu i odpowiedzi na nie, które można wykorzystać do tworzenia interaktywnych treści, czatboty.
Go
W pierwszym prompcie sesji „historia” jest po prostu prompt dla użytkownika:
history := []*ai.Message{{
Content: []*ai.Part{ai.NewTextPart(prompt)},
Role: ai.RoleUser,
}}
request := ai.GenerateRequest{Messages: history}
response, err := gemini15pro.Generate(context.Background(), &request, nil)
Gdy otrzymasz odpowiedź, dodaj ją do historii:
history = append(history, response.Candidates[0].Message)
Możesz zserializować tę historię i utrwalić ją w bazie danych lub pamięci sesji.
W kolejnych prośbach użytkownika dodaj je do historii, zanim zadzwonisz
Generate()
:
history = append(history, &ai.Message{
Content: []*ai.Part{ai.NewTextPart(prompt)},
Role: ai.RoleUser,
})
request = ai.GenerateRequest{Messages: history}
response, err = gemini15pro.Generate(ctx, &request, nil)
Jeśli używany model obsługuje rolę systemową, możesz użyć parametru początkowego w historii, aby ustawić komunikat systemowy:
Go
history = []*ai.Message{{
Content: []*ai.Part{ai.NewTextPart("Talk like a pirate.")},
Role: ai.RoleSystem,
}}