Generación de texto

La API de Gemini puede generar un resultado de texto cuando se proporcionan texto, imágenes, video y audio como entrada.

En esta guía, se muestra cómo generar texto con los métodos generateContent y streamGenerateContent. Para obtener información sobre cómo trabajar con las capacidades de visión y audio de Gemini, consulta las guías de Vision y audio.

Genera texto a partir de una entrada de solo texto

La forma más sencilla de generar texto con la API de Gemini es proporcionarle al modelo una sola entrada de solo texto, como se muestra en este ejemplo:

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[{"text": "Write a story about a magic backpack."}]
        }]
       }' 2> /dev/null

En este caso, la instrucción ("Explica cómo funciona la IA") no incluye ejemplos de resultados, instrucciones del sistema ni información de formato. Es un enfoque sin ejemplos. En algunos casos de uso, una instrucción única o de varias imágenes podría producir un resultado más alineado con las expectativas de los usuarios. En algunos casos, también es posible que desees proporcionar instrucciones del sistema para ayudar al modelo a comprender la tarea o seguir lineamientos específicos.

Genera texto a partir de una entrada de texto y una imagen

La API de Gemini admite entradas multimodales que combinan texto con archivos multimedia. En el siguiente ejemplo, se muestra cómo generar texto a partir de una entrada de texto y una imagen:

# Use a temporary file to hold the base64 encoded image data
TEMP_B64=$(mktemp)
trap 'rm -f "$TEMP_B64"' EXIT
base64 $B64FLAGS $IMG_PATH > "$TEMP_B64"

# Use a temporary file to hold the JSON payload
TEMP_JSON=$(mktemp)
trap 'rm -f "$TEMP_JSON"' EXIT

cat > "$TEMP_JSON" << EOF
{
  "contents": [{
    "parts":[
      {"text": "Tell me about this instrument"},
      {
        "inline_data": {
          "mime_type":"image/jpeg",
          "data": "$(cat "$TEMP_B64")"
        }
      }
    ]
  }]
}
EOF

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d "@$TEMP_JSON" 2> /dev/null

Al igual que con las instrucciones de solo texto, las instrucciones multimodales pueden implicar varios enfoques y mejoras. Según el resultado de este ejemplo, es posible que desees agregar pasos a la instrucción o ser más específico en tus instrucciones. Para obtener más información, consulta Estrategias de instrucciones de archivos.

Genera una transmisión de texto

De forma predeterminada, el modelo muestra una respuesta después de completar todo el proceso de generación de texto. Puedes lograr interacciones más rápidas si no esperas el resultado completo y, en su lugar, usas la transmisión para controlar los resultados parciales.

En el siguiente ejemplo, se muestra cómo implementar la transmisión con el método streamGenerateContent para generar texto a partir de una instrucción de entrada de solo texto.

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?alt=sse&key=${GOOGLE_API_KEY}" \
        -H 'Content-Type: application/json' \
        --no-buffer \
        -d '{ "contents":[{"parts":[{"text": "Write a story about a magic backpack."}]}]}'

Cómo crear un chat interactivo

El SDK de Gemini te permite recopilar varias rondas de preguntas y respuestas, lo que permite a los usuarios avanzar de forma incremental hacia las respuestas o obtener ayuda con problemas de varias partes. Esta función del SDK proporciona una interfaz para hacer un seguimiento del historial de conversaciones, pero en segundo plano usa el mismo método generateContent para crear la respuesta.

En el siguiente ejemplo de código, se muestra una implementación básica de chat:

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Hello"}]},
        {"role": "model",
         "parts":[{
           "text": "Great to meet you. What would you like to know?"}]},
        {"role":"user",
         "parts":[{
           "text": "I have two dogs in my house. How many paws are in my house?"}]},
      ]
    }' 2> /dev/null | grep "text"

Habilita la transmisión de chat

También puedes usar la transmisión con chat, como se muestra en el siguiente ejemplo:

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:streamGenerateContent?alt=sse&key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Hello"}]},
        {"role": "model",
         "parts":[{
           "text": "Great to meet you. What would you like to know?"}]},
        {"role":"user",
         "parts":[{
           "text": "I have two dogs in my house. How many paws are in my house?"}]},
      ]
    }' 2> /dev/null | grep "text"

Configura la generación de texto

Cada instrucción que envías al modelo incluye parámetros que controlan cómo el modelo genera respuestas. Puedes usar GenerationConfig para configurar estos parámetros. Si no configuras los parámetros, el modelo usará las opciones predeterminadas, que pueden variar según el modelo.

En el siguiente ejemplo, se muestra cómo configurar varias de las opciones disponibles.

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
        "contents": [{
            "parts":[
                {"text": "Write a story about a magic backpack."}
            ]
        }],
        "safetySettings": [
            {
                "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
                "threshold": "BLOCK_ONLY_HIGH"
            }
        ],
        "generationConfig": {
            "stopSequences": [
                "Title"
            ],
            "temperature": 1.0,
            "maxOutputTokens": 800,
            "topP": 0.8,
            "topK": 10
        }
    }'  2> /dev/null | grep "text"

stopSequences especifica el conjunto de secuencias de caracteres (hasta 5) que detendrán la generación de resultados. Si se especifica, la API se detendrá en la primera aparición de un stop_sequence. La secuencia de detención no se incluirá como parte de la respuesta.

temperature controla la aleatoriedad del resultado. Usa valores más altos para respuestas más creativas y valores más bajos para respuestas más determinísticas. Los valores pueden variar de [0.0, 2.0].

maxOutputTokens establece la cantidad máxima de tokens que se incluirán en un candidato.

topP cambia la manera en que el modelo selecciona tokens para el resultado. Los tokens se seleccionan del más al menos probable hasta que la suma de sus probabilidades sea igual al valor de topP. El valor predeterminado de topP es 0.95.

topK cambia la manera en que el modelo selecciona tokens para el resultado. Un topK de 1 significa que el token seleccionado es el más probable entre todos los tokens en el vocabulario del modelo, mientras que un topK de 3 significa que el siguiente token se selecciona de los 3 más probables con la temperatura. Los tokens se filtran según topP con el token final seleccionado mediante el muestreo de temperatura.

Agrega instrucciones del sistema

Las instrucciones del sistema te permiten dirigir el comportamiento de un modelo según tus necesidades y casos de uso específicos.

Cuando le das instrucciones del sistema al modelo, le proporcionas contexto adicional para comprender la tarea, generar respuestas más personalizadas y cumplir con lineamientos específicos sobre la interacción completa del usuario con el modelo. También puedes especificar el comportamiento a nivel del producto configurando instrucciones del sistema, aparte de las instrucciones que proporcionan los usuarios finales.

Puedes establecer instrucciones del sistema cuando inicializas tu modelo:

curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY" \
-H 'Content-Type: application/json' \
-d '{ "system_instruction": {
    "parts":
      { "text": "You are a cat. Your name is Neko."}},
    "contents": {
      "parts": {
        "text": "Hello there"}}}'

Para ver un ejemplo interactivo de extremo a extremo del uso de instrucciones del sistema, consulta las instrucciones del sistema de Colab.

¿Qué sigue?

Ahora que exploraste los conceptos básicos de la API de Gemini, te recomendamos que pruebes lo siguiente:

  • Comprensión visual: Aprende a usar la comprensión visual nativa de Gemini para procesar imágenes y videos.
  • Comprensión de audio: Aprende a usar la comprensión de audio nativa de Gemini para procesar archivos de audio.