Generuję treści

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.

import {
       
"github.com/firebase/genkit/go/ai"
       
"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:

model := vertexai.Model("gemini-1.5-flash")

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:

responseText, err := ai.GenerateText(ctx, model, ai.WithTextPrompt("Tell me a joke."))
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.

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

Strumieniowanie odpowiedzi

Genkit obsługuje strumieniowanie odpowiedzi modelu podzielone na fragmenty. Aby użyć przesyłania kawałkowego: przekaż funkcję wywołania zwrotnego do Generate():

response, err := ai.Generate(ctx, gemini15pro,
        ai
.WithTextPrompt("Tell a long story about robots and ninjas."),
       
// stream callback
        ai
.WithStreaming(
                func
(ctx context.Context, grc *ai.GenerateResponseChunk) 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())

Wprowadzanie wielomodalne

Jeśli model obsługuje dane wejściowe multimodalne, możesz przekazywać prompty dotyczące obrazów:

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

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

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ą .

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

response
, err := ai.Generate(ctx, gemini15pro,
        ai
.WithTextPrompt("Tell me a joke."),
        ai
.WithTools(myJokeTool))

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.

W pierwszym prompcie sesji „historia” jest po prostu prompt dla użytkownika:

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

response
, err := ai.Generate(context.Background(), gemini15pro, ai.WithMessages(history...))

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

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

Jeśli używany model obsługuje rolę systemową, możesz użyć parametru początkowego w historii, aby ustawić komunikat systemowy:

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

Code-first framework for orchestrating, deploying, and monitoring generative AI workflows.

Aktualizacja: Nov 6, 2024

Code-first framework for orchestrating, deploying, and monitoring generative AI workflows.

Aktualizacja: Nov 6, 2024

Code-first framework for orchestrating, deploying, and monitoring generative AI workflows.

Aktualizacja: Oct 23, 2024