Instructivo: Comienza a usar la API de Gemini


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

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

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

Requisitos previos

En este instructivo, se supone que estás familiarizado con la compilación de aplicaciones con Node.js.

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

  • Node.js v18 y versiones posteriores
  • npm

Configura tu proyecto

Antes de llamar a la API de Gemini, debes configurar tu proyecto, lo que incluye configurar la 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 una, créala 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 sistema de control de versión. 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 instalar el paquete GoogleGenerativeAI para Node.js:

npm install @google/generative-ai

Inicializa el modelo generativo

Antes de realizar llamadas a la API, debes importar y, luego, inicializar el modelo generativo.

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// ...

// The Gemini 1.5 models are versatile and work with most use cases
const model = genAI.getGenerativeModel({ model: "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 entrada multimodal). En esta guía, las instrucciones para cada implementación enumeran el modelo recomendado para cada caso de uso.

Implementa casos de uso comunes

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

En la sección de casos de uso avanzados, puedes encontrar 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 con generateContent para generar una salida de texto:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
  const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

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

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

run();

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

Gemini 1.5 Flash y 1.5 Pro pueden controlar la entrada multimodal para que puedas ingresar texto e imágenes. Asegúrate de revisar los requisitos de imagen para las instrucciones.

Cuando la entrada de la instrucción incluya tanto texto como imágenes, usa modelos de Gemini 1.5 con el método generateContent para generar salida de texto:

const { GoogleGenerativeAI } = require("@google/generative-ai");
const fs = require("fs");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

// Converts local file information to a GoogleGenerativeAI.Part object.
function fileToGenerativePart(path, mimeType) {
  return {
    inlineData: {
      data: Buffer.from(fs.readFileSync(path)).toString("base64"),
      mimeType
    },
  };
}

async function run() {
  // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
  const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });

  const prompt = "What's different between these pictures?";

  const imageParts = [
    fileToGenerativePart("image1.png", "image/png"),
    fileToGenerativePart("image2.jpeg", "image/jpeg"),
  ];

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

run();

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, por lo que, a diferencia de generateContent, no tienes que almacenar el historial de la conversación.

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

Existen dos opciones posibles para role asociado al contenido de una conversación:

  • user: Es la función que proporciona los mensajes. Este valor es el predeterminado para las llamadas sendMessage.

  • model: Es la función que proporciona las respuestas. Esta función se puede usar cuando se llama a startChat() con history existentes.

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
  const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash"});

  const chat = model.startChat({
    history: [
      {
        role: "user",
        parts: [{ text: "Hello, I have 2 dogs in my house." }],
      },
      {
        role: "model",
        parts: [{ text: "Great to meet you. What would you like to know?" }],
      },
    ],
    generationConfig: {
      maxOutputTokens: 100,
    },
  });

  const msg = "How many paws are in my house?";

  const result = await chat.sendMessage(msg);
  const response = await result.response;
  const text = response.text();
  console.log(text);
}

run();

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

De forma predeterminada, el modelo muestra una respuesta después de completar todo el proceso de generación. Puedes lograr interacciones más rápidas si no esperas todo el resultado y, en su lugar, usa la transmisión para controlar 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 un mensaje de entrada de imagen y texto.

//...

const result = await model.generateContentStream([prompt, ...imageParts]);

let text = '';
for await (const chunk of result.stream) {
  const chunkText = chunk.text();
  console.log(chunkText);
  text += chunkText;
}

//...

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

// Use streaming with text-only input
const result = await model.generateContentStream(prompt);

Consulta el ejemplo de chat anterior para obtener una instancia de chat.

// Use streaming with multi-turn conversations (like chat)
const result = await chat.sendMessageStream(msg);

Implementa casos de uso avanzados

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

Usa incorporaciones

La incorporación es una técnica que se usa para representar la 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) de forma vectorizada, lo que facilita la comparación y el contraste de las incorporaciones. Por ejemplo, dos textos que comparten un tema o una opinión similares deben tener incorporaciones similares, que pueden identificarse 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 el método batchEmbedContent) para generar incorporaciones. En el siguiente ejemplo, se genera una incorporación para una sola cadena:

const { GoogleGenerativeAI } = require("@google/generative-ai");

// Access your API key as an environment variable (see "Set up your API key" above)
const genAI = new GoogleGenerativeAI(process.env.API_KEY);

async function run() {
  // For embeddings, use the embedding-001 model
  const model = genAI.getGenerativeModel({ model: "embedding-001"});

  const text = "The quick brown fox jumps over the lazy dog."

  const result = await model.embedContent(text);
  const embedding = result.embedding;
  console.log(embedding.values);
}

run();

Llamada a función

Las llamadas a función facilitan la obtención de resultados de datos estructurados de modelos generativos. Luego, puedes usar estos resultados para llamar a otras APIs y mostrar los datos de respuesta relevantes al modelo. En otras palabras, las llamadas a función te ayudan a conectar 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, puede ser útil contar los tokens antes de enviar contenido al modelo. En los siguientes ejemplos, se muestra cómo usar countTokens() para varios casos de uso:

// For text-only input
const { totalTokens } = await model.countTokens(prompt);

// For text-and-image input (multimodal)
const { totalTokens } = await model.countTokens([prompt, ...imageParts]);

// For multi-turn conversations (like chat)
const history = await chat.getHistory();
const msgContent = { role: "user", parts: [{ text: msg }] };
const contents = [...history, msgContent];
const { totalTokens } = await model.countTokens({ contents });

Opciones para controlar la generación de contenido

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

Ten en cuenta que pasar generationConfig o safetySettings a un método de solicitud de modelo (como generateContent) anulará por completo el objeto de configuración con el mismo nombre pasado en getGenerativeModel.

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 los parámetros del modelo.

const generationConfig = {
  stopSequences: ["red"],
  maxOutputTokens: 200,
  temperature: 0.9,
  topP: 0.1,
  topK: 16,
};

// The Gemini 1.5 models are versatile and work with most use cases
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash",  generationConfig });

Usar la configuración de seguridad

Puedes usar la configuración de seguridad para ajustar la probabilidad de recibir respuestas que puedan considerarse dañinas. De forma predeterminada, la configuración de seguridad bloquea el contenido con probabilidad media o alta de ser contenido no seguro en todas las dimensiones. Obtén más información sobre la configuración de seguridad.

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

import { HarmBlockThreshold, HarmCategory } from "@google/generative-ai";

// ...

const safetySettings = [
  {
    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
    threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
  },
];

// The Gemini 1.5 models are versatile and work with most use cases
const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash", safetySettings });

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

const safetySettings = [
  {
    category: HarmCategory.HARM_CATEGORY_HARASSMENT,
    threshold: HarmBlockThreshold.BLOCK_ONLY_HIGH,
  },
  {
    category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
    threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
  },
];

¿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 varias variaciones del modelo para satisfacer las necesidades de distintos casos de uso, como los tipos de entrada y la complejidad, las implementaciones para chat y otras tareas de lenguaje de diálogo, y las restricciones de tamaño. Obtén más información sobre los modelos de Gemini disponibles.