Descripción general de la API de Gemini

La API de Gemini te brinda acceso a los modelos generativos más recientes de Google. Una vez que te familiarices con las funciones generales disponibles a través de la API, prueba un instructivo para comenzar a desarrollar tu lenguaje preferido.

ajustables

Gemini es una serie de modelos de IA generativa multimodal desarrollado por Google. Los modelos de Gemini pueden aceptar imágenes y texto en instrucciones, según la variación del modelo que elijas, y generar respuestas de texto.

Para obtener información más detallada del modelo, consulta la página Modelos de Gemini. También puedes usar el método list_models para enumerar todos los modelos disponibles y, luego, el método get_model a fin de obtener los metadatos de un modelo en particular.

Datos de instrucciones y diseño

Los modelos específicos de Gemini aceptan datos de texto y archivos multimedia como entrada. Esta función crea muchas posibilidades adicionales para generar contenido, analizar datos y resolver problemas. Se deben tener en cuenta algunas limitaciones y requisitos, incluido el límite de tokens de entrada general del modelo que usas. Para obtener más información sobre los límites de tokens para modelos específicos, consulta Modelos de Gemini.

Los mensajes que usan la API de Gemini no pueden superar los 20 MB de tamaño. La API de Gemini proporciona una API de File para almacenar temporalmente archivos multimedia y usarlos en las instrucciones, lo que te permite proporcionar datos de instrucciones más allá del límite de 20 MB. Si quieres obtener más información para usar la API de Archivos y los formatos de archivo compatibles con las instrucciones, consulta Cómo solicitar archivos multimedia.

Diseño de instrucciones y entrada de texto

Crear instrucciones eficaces, o ingeniería de instrucciones, es una combinación de arte y ciencia. Consulta la introducción a las instrucciones para obtener orientación sobre cómo abordar las instrucciones y la guía Introducción a las instrucciones para obtener información sobre los diferentes enfoques de las instrucciones.

Generación de contenido

La API de Gemini te permite usar datos de imágenes y texto para las instrucciones, según la variación del modelo que uses. Por ejemplo, puedes generar texto mediante instrucciones de texto con el modelo gemini-pro y usar datos de imágenes y texto para solicitar el modelo gemini-pro-vision. En esta sección, se proporcionan ejemplos de código simples de cada uno. Consulta la referencia de la API de generateContent para obtener un ejemplo más detallado que abarca todos los parámetros.

Entrada de imagen y texto

Puedes enviar una instrucción de texto con una imagen al modelo gemini-pro-vision para realizar una tarea relacionada con la visión. Por ejemplo, subtitular una imagen o identificar lo que hay en una imagen.

En los siguientes ejemplos de código, se muestra una implementación simple de una instrucción de imagen y texto para cada idioma compatible:

Python

model = genai.GenerativeModel('gemini-pro-vision')

cookie_picture = [{
    'mime_type': 'image/png',
    'data': pathlib.Path('cookie.png').read_bytes()
}]
prompt = "Do these look store-bought or homemade?"

response = model.generate_content(
    model="gemini-pro-vision",
    content=[prompt, cookie_picture]
)
print(response.text)

Consulta el instructivo de Python para ver el fragmento de código completo.

Go 

vmodel := client.GenerativeModel("gemini-pro-vision")

data, err := os.ReadFile(filepath.Join("path-to-image", imageFile))
if err != nil {
  log.Fatal(err)
}
resp, err := vmodel.GenerateContent(ctx, genai.Text("Do these look store-bought or homemade?"), genai.ImageData("jpeg", data))
if err != nil {
  log.Fatal(err)
}

Consulta el instructivo de Go para ver un ejemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: Buffer.from(fs.readFileSync("cookie.png")).toString("base64"),
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Consulta el instructivo de Node.js para ver un ejemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro-vision" });

const prompt = "Do these look store-bought or homemade?";
const image = {
  inlineData: {
    data: base64EncodedImage /* see JavaScript quickstart for details */,
    mimeType: "image/png",
  },
};

const result = await model.generateContent([prompt, image]);
console.log(result.response.text());

Consulta el instructivo web para ver un ejemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro-vision', apiKey: apiKey);
final prompt = 'Do these look store-bought or homemade?';
final imageBytes = await File('cookie.png').readAsBytes();
final content = [
  Content.multi([
    TextPart(prompt),
    DataPart('image/png', imageBytes),
  ])
];

final response = await model.generateContent(content);
print(response.text);

Consulta el instructivo de Dart (Flutter) para ver un ejemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro-vision", apiKey: "API_KEY")
let cookieImage = UIImage(...)
let prompt = "Do these look store-bought or homemade?"

let response = try await model.generateContent(prompt, cookieImage)

Consulta el instructivo de Swift para ver un ejemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro-vision",
    apiKey = BuildConfig.apiKey
)

val cookieImage: Bitmap = // ...
val inputContent = content() {
  image(cookieImage)
  text("Do these look store-bought or homemade?")
}

val response = generativeModel.generateContent(inputContent)
print(response.text)

Consulta el instructivo de Android para ver un ejemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro-vision:generateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    -X POST \
    -d @<(echo'{
          "contents":[
            { "parts":[
                {"text": "Do these look store-bought or homemade?"},
                { "inlineData": {
                    "mimeType": "image/png",
                    "data": "'$(base64 -w0 cookie.png)'"
                  }
                }
              ]
            }
          ]
         }')

Consulta el instructivo de la API de REST para obtener más detalles.

Entrada de solo texto

La API de Gemini también puede controlar entradas de solo texto. que te permite realizar tareas de procesamiento de lenguaje natural (PLN), como completar y resumir texto.

En los siguientes ejemplos de código, se muestra una implementación simple de un mensaje de solo texto para cada idioma compatible:

Python

model = genai.GenerativeModel('gemini-pro-vision')

prompt = "Write a story about a magic backpack."

response = model.generate_content(prompt)

Consulta el instructivo de Python para ver el ejemplo completo.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-pro")
resp, err := model.GenerateContent(ctx, genai.Text("Write a story about a magic backpack."))
if err != nil {
  log.Fatal(err)
}

Consulta el instructivo de Go para ver un ejemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Consulta el instructivo de Node.js para ver un ejemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContent(prompt);
console.log(result.response.text());

Consulta el instructivo web para ver un ejemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = await model.generateContent(content);
print(response.text);

Consulta el instructivo de Dart (Flutter) para ver un ejemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let response = try await model.generateContent(prompt)

Consulta el instructivo de Swift para ver un ejemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Consulta el instructivo de Android para ver un ejemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[
      { "parts":[{"text": "Write a story about a magic backpack"}]}
    ]
}'

Consulta el instructivo de la API de REST para obtener más detalles.

Conversaciones de varios turnos (chat)

Puedes usar la API de Gemini para crear experiencias de chat interactivas para tus usuarios. El uso de la función de chat de la API te permite recopilar varias rondas de preguntas y respuestas, lo que permite a los usuarios avanzar progresivamente hacia las respuestas o conseguir ayuda con problemas de varias partes. Esta función es ideal para aplicaciones que requieren comunicación continua, como chatbots, tutores interactivos o asistentes de asistencia al cliente.

En los siguientes ejemplos de código, se muestra una implementación simple de la interacción de chat para cada lenguaje compatible:

Python

  model = genai.GenerativeModel('gemini-pro')
  chat = model.start_chat(history=[])

  response = chat.send_message(
      "Pretend you\'re a snowman and stay in character for each response.")
  print(response.text)

  response = chat.send_message(
      "What\'s your favorite season of the year?")
  print(response.text)

Para ver un ejemplo completo, consulta la demostración del chat en el instructivo de Python.

Go 

model := client.GenerativeModel("gemini-pro")
cs := model.StartChat()
cs.History = []*genai.Content{
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Pretend you're a snowman and stay in character for each response."),
    },
    Role: "user",
  },
  &genai.Content{
    Parts: []genai.Part{
      genai.Text("Hello! It's cold! Isn't that great?"),
    },
    Role: "model",
  },
}

resp, err := cs.SendMessage(ctx, genai.Text("What's your favorite season of the year?"))
if err != nil {
  log.Fatal(err)
}

Consulta la demostración del chat en el instructivo de Go para ver un ejemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Consulta la demostración del chat en el instructivo de Node.js para ver un ejemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro"});

const chat = model.startChat({
  history: [
    {
      role: "user",
      parts: "Pretend you're a snowman and stay in character for each response.",
    },
    {
      role: "model",
      parts: "Hello! It's so cold! Isn't that great?",
    },
  ],
  generationConfig: {
    maxOutputTokens: 100,
  },
});

const msg = "What's your favorite season of the year?";
const result = await chat.sendMessage(msg);
console.log(result.response.text());

Consulta la demostración del chat en el instructivo web para ver un ejemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final chat = model.startChat(history: [
  Content.text(
      "Pretend you're a snowman and stay in character for each response."),
  Content.model([TextPart("Hello! It's cold! Isn't that great?")]),
]);
final content = Content.text("What's your favorite season of the year?");
final response = await chat.sendMessage(content);
print(response.text);

Consulta la demostración del chat en el instructivo de Dart (Flutter) para ver un ejemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let chat = model.startChat()

var message = "Pretend you're a snowman and stay in character for each response."
var response = try await chat.sendMessage(message)

message = "What\'s your favorite season of the year?"
response = try await chat.sendMessage(message)

Consulta la demostración del chat en el instructivo de Swift para ver un ejemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val chat = generativeModel.startChat()
val response = chat.sendMessage("Pretend you're a snowman and stay in
        character for each response.")
print(response.text)

Consulta el instructivo de Android para ver un ejemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [
        {"role":"user",
         "parts":[{
           "text": "Pretend you're a snowman and stay in character for each
        {"role": "model",
            response."}]},
         "parts":[{
           "text": "Hello! It's so cold! Isn't that great?"}]},
        {"role": "user",
         "parts":[{
           "text": "What\'s your favorite season of the year?"}]},
       ]
    }' 2> /dev/null | grep "text"
# response example:
"text": "Winter, of course!"

Consulta el instructivo de la API de REST para obtener más detalles.

Respuestas transmitidas

La API de Gemini proporciona una forma adicional de recibir respuestas de modelos de IA generativa: como un flujo de datos. Una respuesta transmitida envía datos incrementales de vuelta a tu aplicación a medida que el modelo la genera. Esta función te permite responder rápidamente a una solicitud de usuario para mostrar el progreso y crear una experiencia más interactiva.

Las respuestas transmitidas son una opción para las instrucciones de formato libre y los chats con modelos de Gemini. En los siguientes ejemplos de código, se muestra cómo solicitar una respuesta transmitida para un mensaje en cada idioma compatible:

Python

prompt = "Write a story about a magic backpack."

response = genai.stream_generate_content(
    model="models/gemini-pro",
    prompt=prompt
)

Consulta el instructivo de Python para ver el fragmento de código completo.

Go 

ctx := context.Background()
client, err := genai.NewClient(ctx, option.WithAPIKey(os.Getenv("API_KEY")))
if err != nil {
  log.Fatal(err)
}
defer client.Close()

model := client.GenerativeModel("gemini-pro")

iter := model.GenerateContentStream(ctx, genai.Text("Write a story about a magic backpack."))
for {
  resp, err := iter.Next()
  if err == iterator.Done {
    break
  }
  if err != nil {
    log.Fatal(err)
  }

  // print resp
}

Consulta el instructivo de Go para ver un ejemplo completo.

Node.js

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consulta el instructivo de Node.js para ver un ejemplo completo.

Web

const model = genAI.getGenerativeModel({ model: "gemini-pro" });
const prompt = "Write a story about a magic backpack.";

const result = await model.generateContentStream([prompt]);
// print text as it comes in
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
}

Consulta el instructivo web para ver un ejemplo completo.

Dart (Flutter) 

final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final prompt = 'Write a story about a magic backpack.';
final content = [Content.text(prompt)];
final response = model.generateContentStream(content);
await for (final chunk in response) {
  print(chunk.text);
}

Consulta el instructivo de Dart (Flutter) para ver un ejemplo completo.

Swift

let model = GenerativeModel(name: "gemini-pro", apiKey: "API_KEY")
let prompt = "Write a story about a magic backpack."

let stream = model.generateContentStream(prompt)
for try await chunk in stream {
  print(chunk.text ?? "No content")
}

Consulta el instructivo de Swift para ver un ejemplo completo.

Android

val generativeModel = GenerativeModel(
    modelName = "gemini-pro",
    apiKey = BuildConfig.apiKey
)

val inputContent = content {
  text("Write a story about a magic backpack.")
}

var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
  print(chunk.text)
  fullResponse += chunk.text
}

Consulta el instructivo de Android para ver un ejemplo completo.

cURL

curl https://generativelanguage.googleapis.com/v1/models/gemini-pro:streamGenerateContent?key=${API_KEY} \
    -H 'Content-Type: application/json' \
    --no-buffer \
    -d '{ "contents":[
            {"role": "user",
              "parts":[{"text": "Write a story about a magic backpack."}]
            }
          ]
        }' > response.json

Consulta el instructivo de la API de REST para obtener más detalles.

Respuestas en formato JSON

Según tu aplicación, es posible que quieras que la respuesta a una solicitud se muestre en un formato de datos estructurados, en especial si usas las respuestas para propagar interfaces de programación. La API de Gemini proporciona un parámetro de configuración para solicitar una respuesta en formato JSON.

Para usar esta función de salida, debes establecer la opción de configuración response_mime_type en application/json y, además, incluir una especificación de formato JSON en el cuerpo de la solicitud. En el siguiente ejemplo de código, se muestra cómo solicitar una respuesta JSON para un mensaje:

cURL

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-pro-latest:generateContent?key=$API_KEY \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{ "contents":[{
            "parts":[{"text": "List 5 popular cookie recipes using this JSON schema: \{ \"type\": \"object\", \"properties\": \{ \"recipe_name\": \{ \"type\": \"string\" \},\}\}"}] }],
          "generationConfig": {
            "response_mime_type": "application/json",
          } }'

Incorporaciones

El servicio de incorporación de la API de Gemini genera incorporaciones de vanguardia para palabras, frases y oraciones. Las incorporaciones resultantes se pueden usar para tareas de PLN, como búsqueda semántica, clasificación de texto y agrupamiento en clústeres, entre muchas otras. Consulta la guía de incorporaciones para saber qué son las incorporaciones y conocer algunos casos de uso clave del servicio de incorporación que te ayudarán a comenzar.

Próximos pasos