Instructivo: Comienza a usar la API de Gemini


En este instructivo, se muestra cómo acceder a la API de Gemini para Go aplicación con el SDK de IA de Google para Go.

En este instructivo, aprenderás a hacer lo siguiente:

Además, este instructivo contiene secciones sobre casos de uso avanzados (como las incorporaciones y recuento de tokens), así como opciones para controlar la generación de contenido.

Requisitos previos

En este instructivo, se da por sentado que estás familiarizado con la compilación de aplicaciones con Ir.

Para completar este instructivo, asegúrate de que tu entorno de desarrollo cumpla con los requisitos con los siguientes requisitos:

  • Go 1.20 y versiones posteriores

Configura tu proyecto

Antes de llamar a la API de Gemini, debes configurar tu proyecto, lo que incluye: configurar tu clave de API, instalar el paquete del SDK e inicializar el modelo

Cómo configurar tu clave de API

Para usar la API de Gemini, necesitarás una clave de API. Si aún no tienes uno, crea una clave en Google AI Studio.

Obtén una clave de API.

Protege tu clave de API

Te recomendamos que no incluyas una clave de API en tu versión un sistema de control de calidad. En su lugar, debes usar un almacén de secretos para tu clave de API.

En todos los fragmentos de este instructivo, se supone que accedes a tu clave de API como una variable de entorno.

Instala el paquete del SDK

Para usar la API de Gemini en tu propia aplicación, debes get el SDK de Go en el directorio de tu módulo:

go get github.com/google/generative-ai-go

Inicializa el modelo generativo

Antes de realizar cualquier llamada a la API, debes importar e inicializar el archivo generativo.

import "github.com/google/generative-ai-go/genai"
import "google.golang.org/api/option"

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

Cuando especifiques un modelo, ten en cuenta lo siguiente:

  • Usa un modelo que sea específico para tu caso de uso (por ejemplo, gemini-1.5-flash es para entradas multimodales). En esta guía, las instrucciones para cada de implementación, y luego enumerar el modelo recomendado para cada caso de uso.

Implementa casos de uso comunes

Ahora que tu proyecto está configurado, puedes explorar con la API de Gemini para implementar diferentes casos de uso:

En la sección de casos de uso avanzados, encontrarás información sobre la API de Gemini y las incorporaciones

Genera texto a partir de entradas de solo texto

Cuando la entrada de la instrucción solo incluya texto, usa un modelo de Gemini 1.5 o Modelo de Gemini 1.0 Pro con generateContent para generar salida de texto:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Generar texto a partir de entradas de texto e imágenes (multimodal)

Gemini proporciona varios modelos que pueden controlar entradas multimodales (modelos de Gemini 1.5) para que puedas ingresar texto e imágenes. Asegúrate de revisa el requisitos de imágenes para las instrucciones.

Cuando la entrada de instrucciones incluya imágenes y texto, usa un modelo de Gemini 1.5. con el método generateContent para generar una salida de texto:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

imgData1, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

imgData2, err := os.ReadFile(pathToImage1)
if err != nil {
  log.Fatal(err)
}

prompt := []genai.Part{
  genai.ImageData("jpeg", imgData1),
  genai.ImageData("jpeg", imgData2),
  genai.Text("What's different between these two pictures?"),
}
resp, err := model.GenerateContent(ctx, prompt...)

if err != nil {
  log.Fatal(err)
}

Crea conversaciones de varios turnos (chat)

Con Gemini, puedes entablar conversaciones de formato libre en múltiples turnos. El SDK simplifica el proceso, ya que administra el estado de la conversación, así que, con GenerateContent, no tienes que almacenar el historial de conversaciones de ti mismo.

Para crear una conversación de varios turnos (como el chat), usa un modelo de Gemini 1.5 o modelo de Gemini 1.0 Pro e inicializar el chat llamando a startChat(). Luego, usa sendMessage() para enviar un nuevo mensaje de usuario, que también agregará el y la respuesta al historial de chat.

Hay dos opciones posibles para role asociado con el contenido de una conversación:

  • user: Es la función que proporciona los mensajes. Este es el valor predeterminado para SendMessage llamada.

  • model: Es la función que proporciona las respuestas. Este rol puede usarse cuando Llamando a StartChat() con history existentes

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
model := client.GenerativeModel("gemini-1.5-flash")
// Initialize the chat
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello, I have 2 dogs in my house."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Great to meet you. What would you like to know?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("How many paws are in my house?"))
if err != nil {
  log.Fatal(err)
}

Usa la transmisión para tener interacciones más rápidas

De forma predeterminada, el modelo devuelve una respuesta después de completar toda la generación. el proceso de administración de recursos. Puede lograr interacciones más rápidas si no espera a que todo resultado y, en su lugar, usa la transmisión para manejar resultados parciales.

En el siguiente ejemplo, se muestra cómo implementar la transmisión con el Método GenerateContentStream para generar texto a partir de una entrada de imagen y texto mensaje.

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
model := client.GenerativeModel("gemini-1.5-flash")

imageBytes, err := os.ReadFile(pathToImage)

img := genai.ImageData("jpeg", imageBytes)
prompt := genai.Text("Tell me a story about this animal")
iter := model.GenerateContentStream(ctx, img, prompt)

for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // ... print resp
}

Puedes usar un enfoque similar para los casos de uso de entrada de solo texto y chat.

prompt := genai.Text("Tell me a story about a lumberjack and his giant ox")
iter := model.GenerateContentStream(ctx, prompt)

prompt := genai.Text("And how do you feel about that?")
iter := cs.SendMessageStream(ctx, prompt)

Implementa casos de uso avanzados

Los casos de uso comunes descritos en la sección anterior de este instructivo ayudan a a que te familiarices con la API de Gemini. En esta sección, se describen algunas que podrían considerarse más avanzados.

Usa incorporaciones

La incorporación es una técnica que se usa para representar información. como una lista de números de punto flotante en un array. Con Gemini, puedes representar texto (palabras, oraciones y bloques de texto) en forma vectorizada, lo que lo hace más fáciles de comparar y contrastar. Por ejemplo, dos textos que comparten un un tema o una opinión similares deben tener incorporaciones similares, que pueden identificados a través de técnicas matemáticas de comparación, como la similitud coseno.

Usa el modelo embedding-001 con el método EmbedContent (o las BatchEmbedContent) para generar incorporaciones. El siguiente ejemplo genera una incorporación para una sola cadena:

ctx := context.Background()
// Access your API key as an environment variable (see "Set up your API key" above)
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()
// For embeddings, use the embedding-001 model
em := client.EmbeddingModel("embedding-001")
res, err := em.EmbedContent(ctx, genai.Text("The quick brown fox jumps over the lazy dog."))

if err != nil {
  panic(err)
}
fmt.Println(res.Embedding.Values)

Llamada a función

Las llamadas a función facilitan la obtención de resultados de datos estructurados desde generativos. Luego, puedes usar estos resultados para llamar a otras APIs y mostrar los datos de respuesta relevantes para el modelo. En otras palabras, las llamadas a funciones ayudan conecta modelos generativos a sistemas externos para que el contenido generado incluya la información más actualizada y precisa. Obtén más información en el instructivo de llamada a funciones.

Contar tokens

Cuando se usan instrucciones largas, podría ser útil contar los tokens antes de enviar cualquiera contenido al modelo. En los siguientes ejemplos, se muestra cómo usar CountTokens() para varios casos de uso:

// For text-only input
text := "Parrots can be green and live a long time."
resp, err := model.CountTokens(ctx, genai.Text(text))
if err != nil {
  log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

// For text-and-image input (multimodal)
text := "Parrots can be green and live a long time."
imageBytes, err := os.ReadFile(pathToImage)
if err != nil {
  log.Fatal(err)
}

resp, err := model.CountTokens(
    ctx,
    genai.Text(text),
    genai.ImageData("png", imageBytes))
  if err != nil {
    log.Fatal(err)
}
fmt.Println(resp.TotalTokens)

Opciones para controlar la generación de contenido

Puedes controlar la generación de contenido a través de la configuración de los parámetros del modelo y el uso configuración de seguridad.

Configura los parámetros del modelo

Cada instrucción que envías al modelo incluye valores de parámetros que controlan cómo el modelo genera una respuesta. El modelo puede generar resultados diferentes para los valores de parámetros diferentes. Obtén más información sobre Parámetros del modelo. La configuración es durante la vida útil de tu instancia de modelo.

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

// Configure model parameters by invoking Set* methods on the model.
model.SetTemperature(0.9)
model.SetTopK(1)

// ...

Usar la configuración de seguridad

Puedes usar la configuración de seguridad para ajustar la probabilidad de recibir respuestas que puede considerarse perjudicial. Según la configuración predeterminada, la configuración de seguridad bloquea el contenido con o una alta probabilidad de ser contenido no seguro en todas las dimensiones. Aprendizaje Obtén más información sobre la configuración de seguridad.

Sigue estos pasos para establecer una configuración de seguridad:

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
}

// ...

También puedes establecer más de una configuración de seguridad:

// ...

// The Gemini 1.5 models are versatile and work with most use cases
model := client.GenerativeModel("gemini-1.5-flash")

model.SafetySettings = []*genai.SafetySetting{
  {
    Category:  genai.HarmCategoryHarassment,
    Threshold: genai.HarmBlockOnlyHigh,
  },
  {
    Category:  genai.HarmCategoryHateSpeech,
    Threshold: genai.HarmBlockMediumAndAbove,
  },
}

// ...

¿Qué sigue?

  • El diseño de instrucciones es el proceso de crear instrucciones que producen la respuesta deseada de los modelos de lenguaje. Escribir instrucciones bien estructuradas es una parte esencial de garantizar respuestas precisas y de alta calidad desde un modelo de lenguaje. Obtén más información sobre las prácticas recomendadas para la redacción de instrucciones.

  • Gemini ofrece diversas variaciones de modelos para satisfacer las necesidades de los distintos usos como tipos de entrada y complejidad, implementaciones para chat u otros las tareas de lenguaje de diálogo y las restricciones de tamaño. Obtén más información sobre los modelos de Gemini disponibles.