Generar contenido

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 varios LLM de Google y de terceros.

Los modelos están completamente instrumentados para la observabilidad e incluyen herramientas que ofrece la IU de desarrollador de Genkit puedes probar cualquier modelo usando el ejecutor de modelos.

Cuando trabajas con modelos en Genkit, primero debes configurar el modelo con el que quieres trabajar. La configuración del modelo la realiza el sistema de complementos. En este ejemplo, configuras el complemento de Vertex AI, que proporciona Gemini e implementar modelos automáticamente.

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
}

Para usar los modelos que proporciona el complemento, necesitas una referencia al modelo específico y la versión:

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

Modelos compatibles

Genkit proporciona compatibilidad con los modelos a través de su sistema de complementos. Se admiten oficialmente los siguientes complementos:

Complemento	Modelos
IA generativa de Google	Gemini Pro, Gemini Pro Vision
Google Vertex AI	Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro e 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:

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

Puedes pasar opciones junto con la llamada al modelo. Las opciones compatibles dependen del modelo y su 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,
	}))

Respuestas de transmisión

Genkit admite la transmisión fragmentada de las respuestas del modelo. Para usar una transmisión fragmentada, pasa una función de devolución de llamada a 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())

Entrada multimodal

Si el modelo admite la entrada multimodal, puedes pasar instrucciones de imagen:

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

El formato exacto del mensaje de imagen (https URL, gs URL, data URI) depende del modelo.

Llamadas a función (herramientas)

Los modelos de Genkit proporcionan una interfaz para las llamadas a función, para los modelos compatibles

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

De esta forma, se llamará automáticamente a las herramientas para cumplir con la instrucción del usuario.

Historial de mensajes de grabación

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.

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

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

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 a Generate():

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

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

Si el modelo que usas admite el rol del sistema, puedes usar el rol para configurar el mensaje del sistema:

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