Generando contenido

Firebase Genkit brinda una interfaz sencilla para generar contenido con LLM.

ajustables

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 y vienen con integraciones de herramientas que proporciona la IU para desarrolladores de Genkit. Puedes probar cualquier modelo con el ejecutor de modelos.

Cuando trabajes con modelos en Genkit, primero debes configurar el modelo con el que deseas trabajar. El sistema de complementos realiza la configuración del modelo. En este ejemplo, se configura el complemento de Vertex AI, que proporciona modelos de Gemini.

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 que proporciona el complemento, puedes hacer referencia a ellos por nombre (p.ej., 'vertexai/gemini-1.0-pro') o algunos complementos exportan objetos de referencia de modelo que proporcionan información adicional de tipo sobre las capacidades y opciones del modelo.

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

Modelos compatibles

Genkit brinda compatibilidad de modelos a través de su sistema de complementos. Los siguientes complementos son compatibles oficialmente:

Plugin	ajustables
IA generativa de Google	Gemini Pro y Gemini Pro Vision
Vertex AI de Google	Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
Ollama	Muchos modelos locales, incluidos Gemma, Llama 2 y Mistral, entre otros

Consulta la documentación de cada complemento para obtener información sobre la configuración y el uso.

Cómo generar contenido

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

Para llamar al modelo, haz lo siguiente:

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

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

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

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

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

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

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

O desde un archivo local:

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

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: geminiPro,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  config: {
    temperature: 0.5,
  },
});

Esto llamará automáticamente a las herramientas para completar la solicitud del usuario.

Puedes especificar returnToolRequests: true para el control manual de las llamadas a herramientas.

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

Además, puedes transmitir resultados de modelos compatibles:

await generate({
  model: geminiPro,
  prompt: 'Tell me a very long joke.',
  streamingCallback: (chunk) => {
    console.log(chunk);
  },
});

Cómo agregar contexto de retriever

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

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

await generate({
  model: geminiPro,
  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 que se envía al modelo.

Registrando el historial de mensajes

Los modelos de Genkit admiten el mantenimiento de 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 método toHistory():

let response = await generate({
  model: geminiPro,
  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 llamadas futuras a generate():

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

Si el modelo que usas admite la función system, puedes usar el historial inicial para configurar el mensaje del sistema:

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

Respuestas en tiempo real

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: geminiPro,
  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());