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 { configureGenkit } from '@genkit-ai/core';
import { firebase } from '@genkit-ai/firebase';
import { vertexAI } from '@genkit-ai/vertexai';

configureGenkit({
  plugins: [vertexAI()],
});

Para usar los modelos proporcionados por el complemento, puedes hacer referencia a ellos por su nombre (p.ej., 'vertexai/gemini-1.5-flash') o algunos complementos exportan objetos de referencia de modelo que proporcionar información adicional de tipos sobre las capacidades y opciones del modelo.

import { gemini15Flash } from '@genkit-ai/vertexai';

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. También está una amplia variedad de modelos disponibles con asistencia de la comunidad que puedes descubrir buscando paquetes que comienzan con genkitx- en npmjs.org.

Cómo generar contenido

generate es una función auxiliar para trabajar con modelos.

Para llamar solo al modelo, haz lo siguiente:

import { generate } from '@genkit-ai/ai';
import { gemini15Flash } from '@genkit-ai/vertexai';

(async () => {
  const llmResponse = await generate({
    model: gemini15Flash,
    prompt: 'Tell me a joke.',
  });

  console.log(await llmResponse.text());
})();

Puedes pasar varias opciones para ese modelo, incluida la especificación de un personalizado para LLM específicos.

const response = await generate({
  model: gemini15Flash,
  prompt,
  config: {
    temperature: 1,
    stopSequences: ['abc'],
  },
});

Si el modelo admite entradas multimodales, puedes pasar imágenes como entrada:

const result = await generate({
  model: gemini15Flash,
  prompt: [
    { text: 'describe the following image:' },
    { media: { url: imageUrl, contentType: 'image/jpeg' } },
  ],
});

O desde un archivo local:

const result = await generate({
  model: gemini15Flash,
  prompt: [
    { text: 'describe the following image:' },
    {
      data: {
        url: fs.readFileSync(__dirname + '/image.jpeg', {
          encoding: 'base64',
          flag: 'r',
        }),
        contentType: 'image/jpeg',
      },
    },
  ],
});

Herramientas y llamadas a funciones

Model también admite herramientas y llamadas a funciones. La compatibilidad de las herramientas depende de modelos específicos.

const myTool = action(
  {
    name: 'myJoke',
    description: 'useful when you need a joke to tell.',
    inputSchema: z.object({ subject: z.string() }),
    outputSchema: z.string(),
  },
  async (input) => 'haha Just kidding no joke! got you'
);

const llmResponse = await generate({
  model: gemini15Flash,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  config: {
    temperature: 0.5,
  },
});

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

Puedes especificar returnToolRequests: true para controlar de forma manual las llamadas a herramientas.

const llmResponse = await generate({
  model: gemini15Flash,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  returnToolRequests: true,
  config: {
    temperature: 0.5,
  },
});

Cómo agregar contexto de retriever

Los documentos de un retriever se pueden pasar directamente a generate para proporcionar contexto de los fundamentos:

const docs = await companyPolicyRetriever({ query: question });

await generate({
  model: gemini15Flash,
  prompt: `Answer using the available context from company policy: ${question}`,
  context: docs,
});

El contexto del documento se agrega automáticamente al contenido de la instrucción enviados al modelo.

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.

Para generar un historial de mensajes a partir de una respuesta del modelo, llama al toHistory() método:

let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
});
let history = response.toHistory();

Puedes serializar este historial y conservarlo en una base de datos o en un almacenamiento de sesión. Luego, pasa el historial junto con el mensaje en las llamadas futuras a generate():

response = await generate({
  model: gemini15Flash,
  prompt: 'How about in Spanish?',
  history,
});
history = response.toHistory();

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

let history: MessageData[] = [
  { role: 'system', content: [{ text: 'Talk like a pirate.' }] },
];
let response = await generate({
  model: gemini15Flash,
  prompt: "How do you say 'dog' in French?",
  history,
});
history = response.toHistory();

Respuestas de transmisión

Genkit admite la transmisión fragmentada de respuestas del modelo a través del método generateStream():

// import { generateStream } from '@genkit-ai/ai';
const { response, stream } = await generateStream({
  model: gemini15Flash,
  prompt: 'Tell a long story about robots and ninjas.',
});

for await (const chunk of stream()) {
  console.log(chunk.text());
}

// you can also await the full response
console.log((await response()).text());