Firebase Genkit proporciona una interfaz sencilla para generar contenido con LLM.
Modelos
Los modelos de Firebase Genkit son bibliotecas y abstracciones que proporcionan acceso a con varios LLM de Google y de terceros.
Los modelos están completamente instrumentados para la observabilidad y vienen con herramientas que ofrece Genkit Developer UI; puedes probar cualquier modelo usando el ejecutor de modelos.
Cuando trabajas con modelos en Genkit, primero debes configurar el modelo que con el que quieres trabajar. La configuración del modelo la realiza el sistema de complementos. En En este ejemplo, configuras el complemento de Vertex AI, que proporciona Gemini e implementar modelos automáticamente.
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
}
Para usar los modelos que proporciona el complemento, necesitas una referencia al modelo específico y la versión:
Go
gemini15pro := vertexai.Model("gemini-1.5-pro")
Modelos compatibles
Genkit proporciona compatibilidad con los modelos a través de su sistema de complementos. Los siguientes complementos se admiten oficialmente:
| Complemento | Modelos |
|---|---|
| IA generativa de Google | Gemini Pro y Gemini Pro Vision |
| Vertex AI de Google | Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro y Imagen2 |
| Ollama | Muchos modelos locales, como Gemma, Llama 2, Mistral y muchos más |
Consulta la documentación de cada complemento para obtener información sobre la configuración y el uso.
Cómo generar contenido
Genkit proporciona una función auxiliar simple para generar contenido con modelos.
Para llamar solo al modelo, haz lo siguiente:
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)
Puedes pasar opciones junto con la llamada al modelo. Opciones compatibles dependen del modelo y su 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,
},
}
Respuestas de transmisión
Genkit admite la transmisión fragmentada de las respuestas del modelo:
Go
Para usar una transmisión fragmentada, pasa una función de devolución de llamada a 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)
Entrada multimodal
Si el modelo admite la entrada multimodal, puedes pasar instrucciones de imagen:
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)
El formato exacto del mensaje de imagen (https URL, gs URL, data URI) es
que dependen del modelo.
Llamadas a función (herramientas)
Los modelos de Genkit proporcionan una interfaz para las llamadas a funciones, para los modelos que admiten que la modifica.
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)
De esta forma, se llamará automáticamente a las herramientas para cumplir con la indicación del usuario.
Registrando historial de mensajes
Los modelos de Genkit admiten mantener un historial de los mensajes enviados al modelo y sus respuestas, que puedes usar para crear experiencias interactivas, como chatbots.
Go
En el primer mensaje de una sesión, el "historial" es simplemente el mensaje del usuario:
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)
Cuando recibas una respuesta, agrégala al historial:
history = append(history, response.Candidates[0].Message)
Puedes serializar este historial y conservarlo en una base de datos o en un almacenamiento de sesión.
Para las solicitudes de usuario posteriores, agrégalas al historial antes de llamar
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)
Si el modelo que usas admite el rol del sistema, puedes usar el rol para configurar el mensaje del sistema:
Go
history = []*ai.Message{{
Content: []*ai.Part{ai.NewTextPart("Talk like a pirate.")},
Role: ai.RoleSystem,
}}