Beta: Firebase Genkit is in Beta, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Beta period, Firebase Genkit and its documentation will be updated and improved.

Se usó la API de Cloud Translation para traducir esta página.

Genera contenido con modelos de IA

En el centro de la IA generativa, se encuentran los modelos de IA. Actualmente, los dos ejemplos más destacados de modelos generativos son los modelos grandes de lenguaje (LLM) y los modelos de generación de imágenes. Estos modelos toman entradas, llamadas indicaciones (por lo general, texto, una imagen o una combinación de ambas), y a partir de ellas producen como salida texto, una imagen o incluso audio o video.

El resultado de estos modelos puede ser sorprendentemente convincente: los LLM generan texto que parece haber sido escrito por un ser humano, y los modelos de generación de imágenes pueden producir imágenes muy similares a fotografías reales o obras de arte creadas por humanos.

Además, los LLM demostraron ser capaces de realizar tareas más allá de la generación de texto simple:

Escribir programas de computadora
Planificar subtareas que se requieren para completar una tarea más grande
Organizar datos desorganizados
Comprender y extraer datos de información de un corpus de texto
Seguir y realizar actividades automatizadas según una descripción de texto de la actividad

Hay muchos modelos disponibles de varios proveedores diferentes. Cada modelo tiene sus propias fortalezas y debilidades, y uno puede destacarse en una tarea, pero no rendir tan bien en otras. A menudo, las apps que usan IA generativa pueden beneficiarse del uso de varios modelos diferentes según la tarea en cuestión.

Como desarrollador de apps, por lo general, no interactúas directamente con los modelos de IA generativa, sino a través de servicios disponibles como APIs web. Si bien estos servicios suelen tener una funcionalidad similar, todos los proporcionan a través de APIs diferentes e incompatibles. Si deseas usar varios servicios de modelos, debes usar cada uno de sus SDKs propietarios, que pueden ser incompatibles entre sí. Y si quieres actualizar de un modelo al más nuevo y capaz, es posible que debas volver a compilar esa integración.

Genkit aborda este desafío proporcionando una sola interfaz que abstrae los detalles del acceso potencialmente a cualquier servicio de modelo de IA generativa, con varias implementaciones compiladas previamente disponibles. Compilar tu app potenciada por IA con Genkit simplifica el proceso de realizar tu primera llamada a la IA generativa y facilita combinar varios modelos o cambiar uno por otro a medida que surgen nuevos modelos.

Antes de comenzar

Si deseas ejecutar los ejemplos de código de esta página, primero completa los pasos de la guía de introducción. En todos los ejemplos, se supone que ya instalaste Genkit como una dependencia en tu proyecto.

Modelos compatibles con Genkit

Genkit está diseñado para ser lo suficientemente flexible como para usar potencialmente cualquier servicio de modelos de IA generativa. Sus bibliotecas principales definen la interfaz común para trabajar con modelos, y los complementos de modelos definen los detalles de la implementación para trabajar con un modelo específico y su API.

El equipo de Genkit mantiene complementos para trabajar con modelos proporcionados por Vertex AI, Google Generative AI y Ollama:

La familia de LLM de Gemini, a través del complemento de Google Cloud Vertex AI
La familia de LLM de Gemini, a través del complemento de Google AI
Modelos de generación de imágenes Imagen2 e Imagen3, a través de Google Cloud Vertex AI
Familia de LLM de Claude 3 de Anthropic, a través del jardín de modelos de Vertex AI de Google Cloud
Gemma 2, Llama 3 y muchos más modelos abiertos a través del complemento Ollama (debes alojar el servidor de Ollama por tu cuenta)

Además, hay varios complementos con asistencia de la comunidad que proporcionan interfaces para estos modelos:

Familia de LLMs Claude 3, a través del complemento de Anthropic
La familia de LLM de GPT a través del complemento de OpenAI
La familia de LLM de GPT a través del complemento de Azure OpenAI
Controla la familia R de LLM a través del complemento de Cohere
La familia de LLMs Mistral a través del complemento Mistral
Gemma 2, Llama 3 y muchos más modelos abiertos alojados en Groq a través del complemento de Groq

Para descubrir más, busca paquetes etiquetados con genkit-model en npmjs.org.

Carga y configura complementos de modelos

Antes de usar Genkit para comenzar a generar contenido, debes cargar y configurar un complemento de modelo. Si vienes de la guía de introducción, ya lo hiciste. De lo contrario, consulta la guía de introducción o la documentación del complemento individual y sigue los pasos que se indican allí antes de continuar.

La función generate()

En Genkit, la interfaz principal a través de la cual interactúas con modelos de IA generativa es la función generate().

La llamada generate() más simple especifica el modelo que deseas usar y una instrucción de texto:

import { generate } from '@genkit-ai/ai';
import { configureGenkit } from '@genkit-ai/core';
import { gemini15Flash } from '@genkit-ai/googleai';

configureGenkit(/* ... */);

(async () => {
  const llmResponse = await generate({
    model: gemini15Flash,
    prompt: 'Invent a menu item for a pirate themed restaurant.',
  });

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

Cuando ejecutes este breve ejemplo, se imprimirá cierta información de depuración, seguida del resultado de la llamada a generate(), que suele ser texto Markdown, como en el siguiente ejemplo:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

Vuelve a ejecutar la secuencia de comandos y obtendrás un resultado diferente.

En la muestra de código anterior, se especificó el modelo mediante una referencia de modelo que exportó el complemento de modelo. También puedes especificar el modelo con un identificador de cadena:

const llmResponse = await generate({
  model: 'googleai/gemini-1.5-flash-latest',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Un identificador de cadena de modelo se parece a providerid/modelid, en el que el ID del proveedor (en este caso, googleai) identifica el complemento, y el ID del modelo es un identificador de cadena específico del complemento para una versión específica de un modelo.

Algunos complementos de modelo, como el de Ollama, proporcionan acceso a decenas de modelos diferentes y, por lo tanto, no exportan referencias de modelos individuales. En estos casos, solo puedes especificar un modelo para generate() con su identificador de cadena:

const llmResponse = await generate({
  model: 'ollama/gemma2',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Todos los ejemplos anteriores también ilustran un punto importante: cuando usas generate() para realizar llamadas a modelos de IA generativa, solo debes pasar un valor diferente al parámetro del modelo para cambiar el modelo que quieres usar. Cuando usas generate() en lugar de los SDK de modelos nativos, te das la flexibilidad para usar con mayor facilidad varios modelos diferentes en tu app y cambiar modelos en el futuro.

Hasta ahora, solo viste ejemplos de las llamadas generate() más simples. Sin embargo, generate() también proporciona una interfaz para interacciones más avanzadas con modelos generativos, que verás en las siguientes secciones.

Parámetros del modelo

La función generate() toma un parámetro config, a través del cual puedes especificar parámetros de configuración opcionales que controlan cómo el modelo genera contenido:

const llmResponse = await generate({
  prompt: "Suggest an item for the menu of a pirate themed restaurant",
  model: gemini15Flash,
  config: {
    maxOutputTokens: 400,
    stopSequences: ["<end>", "<fin>"],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

Los parámetros exactos que se admiten dependen del modelo individual y de la API del modelo. Sin embargo, los parámetros del ejemplo anterior son comunes a casi todos los modelos. A continuación, se explica cada uno de estos parámetros:

Parámetros que controlan la longitud de la salida

maxOutputTokens

Los LLM operan en unidades llamadas tokens. Por lo general, un token se asigna a una secuencia específica de caracteres, pero no es necesariamente así. Cuando pasas una instrucción a un modelo, uno de los primeros pasos que realiza es tokenizar la cadena de instrucciones en una secuencia de tokens. Luego, el LLM genera una secuencia de tokens a partir de la entrada con asignación de token. Por último, la secuencia de tokens se vuelve a convertir en texto, que es tu resultado.

El parámetro de tokens de salida máximos simplemente establece un límite en la cantidad de tokens que se deben generar con el LLM. Cada modelo puede usar un analizador de tokens diferente, pero una buena regla general es considerar que una sola palabra en inglés está compuesta de 2 a 4 tokens.

Como se indicó anteriormente, es posible que algunos tokens no se asignan a secuencias de caracteres. Un ejemplo de esto es que, a menudo, hay un token que indica el final de la secuencia: cuando un LLM genera este token, deja de generar más. Por lo tanto, es posible y, a menudo, es el caso que un LLM genere menos tokens que el máximo porque generó el token "stop".

stopSequences

Puedes usar este parámetro para establecer los tokens o las secuencias de tokens que, cuando se generan, indican el final de la salida de LLM. Los valores correctos que se deben usar aquí generalmente dependen de cómo se entrenó el modelo y, por lo general, los establece el complemento del modelo. Sin embargo, si solicitaste que el modelo genere otra secuencia de detención, puedes especificarla aquí.

Ten en cuenta que estás especificando secuencias de caracteres, no tokens en sí. En la mayoría de los casos, especificarás una secuencia de caracteres que el analizador del modelo asignará a un solo token.

Parámetros que controlan la "creatividad"

En conjunto, los parámetros temperature, top-p y top-k controlan qué tan "creativo" quieres que sea el modelo. A continuación, se incluyen explicaciones muy breves sobre el significado de estos parámetros, pero lo más importante que debes tener en cuenta es que estos parámetros se usan para ajustar el carácter del resultado de un LLM. Los valores óptimos para ellos dependen de tus objetivos y preferencias, y es probable que se encuentren solo a través de la experimentación.

temperatura

Los LLM son, en esencia, máquinas que predicen tokens. Para una secuencia dada de tokens (como la instrucción), un LLM predice, para cada token de su vocabulario, la probabilidad de que el token aparezca a continuación en la secuencia. La temperatura es un factor de escalamiento por el que se dividen estas predicciones antes de normalizarse a una probabilidad entre 0 y 1.

Los valores de temperatura baja (entre 0.0 y 1.0) amplifican la diferencia en las probabilidades entre los tokens, lo que hace que sea aún menos probable que el modelo produzca un token que ya evaluó como poco probable. Esto a menudo se percibe como un resultado menos creativo. Aunque, técnicamente, 0.0 no es un valor válido, muchos modelos lo consideran como un indicador de que el modelo debe comportarse de manera determinista y solo considerar el token más probable.

Los valores de temperatura alta (aquellos superiores a 1.0) comprimen las diferencias en las probabilidades entre los tokens, lo que aumenta la probabilidad de que el modelo produzca tokens que antes evaluó como poco probables. Esto suele percibirse como un resultado más creativo. Algunas APIs de modelos imponen una temperatura máxima, a menudo de 2.0.

topP

Top-p es un valor entre 0.0 y 1.0 que controla la cantidad de tokens posibles que deseas que el modelo considere, ya que especifica la probabilidad acumulativa de los tokens. Por ejemplo, un valor de 1.0 significa considerar todos los tokens posibles (pero aún tener en cuenta la probabilidad de cada token). Un valor de 0.4 significa que solo se deben considerar los tokens más probables, cuyas probabilidades suman 0.4, y excluir los tokens restantes.

topK

Top-K es un valor entero que también controla la cantidad de tokens posibles que quieres que el modelo considere, pero esta vez especificando explícitamente la cantidad máxima de tokens. Especificar un valor de 1 significa que el modelo debería comportarse de manera determinista.

Experimenta con los parámetros del modelo

Puedes experimentar con el efecto de estos parámetros en el resultado que generan diferentes combinaciones de modelos y mensajes con la IU para desarrolladores. Inicia la IU para desarrolladores con el comando genkit start, y se cargarán automáticamente todos los modelos definidos por los complementos configurados en tu proyecto. Puedes probar rápidamente diferentes instrucciones y valores de configuración sin tener que realizar estos cambios en el código de forma reiterada.

Resultados estructurados

Cuando usas la IA generativa como componente en tu aplicación, a menudo quieres que el resultado sea un formato diferente al texto sin formato. Incluso si solo generas contenido para mostrarlo al usuario, puedes beneficiarte de los resultados estructurados solo con el objetivo de presentarlo de forma más atractiva al usuario. Sin embargo, para aplicaciones más avanzadas de la IA generativa, como el uso programático del resultado del modelo o la alimentación del resultado de un modelo a otro, el resultado estructurado es imprescindible.

En Genkit, puedes solicitar un resultado estructurado de un modelo especificando un esquema cuando llamas a generate():

import { z } from "zod";

const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.number(),
  allergens: z.array(z.string()),
});

const llmResponse = await generate({
  prompt: "Suggest an item for the menu of a pirate themed restaurant",
  model: gemini15Flash,
  output: {
    schema: MenuItemSchema,
  },
});

Los esquemas de salida del modelo se especifican con la biblioteca Zod. Además de un lenguaje de definición de esquemas, Zod también proporciona una verificación de tipos de tiempo de ejecución, que cierra la brecha entre los tipos estáticos de TypeScript y el resultado impredecible de los modelos de IA generativa. Zod te permite escribir código que puede confiar en el hecho de que una llamada de generación correcta siempre mostrará un resultado que se ajusta a tus tipos de TypeScript.

Cuando especificas un esquema en generate(), Genkit realiza varias acciones en segundo plano:

Aumenta la instrucción con orientación adicional sobre el formato de salida deseado. Esto también tiene el efecto secundario de especificarle al modelo qué contenido quieres generar exactamente (por ejemplo, no solo sugerir un elemento de menú, sino también generar una descripción, una lista de alérgenos, etcétera).
Analiza la salida del modelo en un objeto de JavaScript.
Verifica que la salida se ajuste al esquema.

Para obtener un resultado estructurado de una llamada de generación correcta, usa el método output() del objeto de respuesta:

type MenuItem = z.infer<typeof MenuItemSchema>;

const output: MenuItem | null = llmResponse.output();

Maneja los errores

Ten en cuenta que, en el ejemplo anterior, el método de salida puede mostrar null. Esto puede suceder cuando el modelo no genera resultados que se ajusten al esquema. También puedes detectar esta condición capturando la excepción NoValidCandidatesError que genera generate:

import { NoValidCandidatesError } from "@genkit-ai/ai";

try {
  llmResponse = await generate(/* ... */);
} catch (e) {
  if (e instanceof NoValidCandidatesError) {
    // Output doesn't conform to schema.
  }
}

La mejor estrategia para lidiar con estos errores dependerá de tu caso de uso exacto, pero estas son algunas sugerencias generales:

Prueba un modelo diferente. Para que el resultado estructurado tenga éxito, el modelo debe ser capaz de generar resultados en JSON. Los LLM más potentes, como Gemini y Claude, son lo suficientemente versátiles como para hacerlo. Sin embargo, los modelos más pequeños, como algunos de los modelos locales que usarías con Ollama, podrían no ser capaces de generar resultados estructurados de forma confiable, a menos que se hayan entrenado específicamente para hacerlo.
Usa las capacidades de coerción de Zod: Puedes especificar en tus esquemas que Zod debe intentar coercionar tipos no conformes al tipo especificado por el esquema. Si tu esquema incluye tipos primitivos que no sean strings, el uso de la coerción de Zod puede reducir la cantidad de fallas de generate() que experimentas. La siguiente versión de MenuItemSchema usa la conversión de tipos para corregir automáticamente situaciones en las que el modelo genera información de calorías como una cadena en lugar de un número:
```
const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.coerce.number(),
  allergens: z.array(z.string()),
});
```
Vuelve a intentar la llamada a generate(). Si el modelo que elegiste rara vez no puede generar un resultado compatible, puedes tratar el error como lo harías con un error de red y simplemente reintentar la solicitud con algún tipo de estrategia de retirada incremental.

Transmisión

Cuando generas grandes cantidades de texto, puedes mejorar la experiencia de los usuarios si presentas el resultado a medida que se genera: transmite el resultado. Se puede ver un ejemplo familiar de la transmisión en acción en la mayoría de las apps de chat del LLM: los usuarios pueden leer la respuesta del modelo a sus mensajes mientras se genera, lo que mejora la capacidad de respuesta percibida de la aplicación y aumenta la ilusión de chatear con un homólogo inteligente.

En Genkit, puedes transmitir el resultado con la función generateStream(). Su sintaxis es similar a la función generate():

import { generateStream } from "@genkit-ai/ai";
import { GenerateResponseChunk } from "@genkit-ai/ai/lib/generate";

const llmResponseStream = await generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant',
  model: gemini15Flash,
});

Sin embargo, esta función muestra un iterable asíncrono de fragmentos de respuesta. Controla cada uno de estos fragmentos a medida que estén disponibles:

for await (const responseChunkData of llmResponseStream.stream()) {
  const responseChunk = responseChunkData as GenerateResponseChunk;
  console.log(responseChunk.text());
}

De cualquier manera, puedes obtener la respuesta completa de una vez:

const llmResponse = await llmResponseStream.response();

La transmisión también funciona con resultados estructurados:

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});
type Menu = z.infer<typeof MenuSchema>;

const llmResponseStream = await generateStream({
  prompt: "Suggest a complete menu for a pirate themed restaurant",
  model: gemini15Flash,
  output: { schema: MenuSchema },
});

for await (const responseChunkData of llmResponseStream.stream()) {
  const responseChunk = responseChunkData as GenerateResponseChunk<Menu>;
  // output() returns an object representing the entire output so far
  const output: Menu | null = responseChunk.output();
  console.log(output);
}

La transmisión de resultados estructurados funciona de manera un poco diferente a la transmisión de texto. Cuando llamas al método output() de un fragmento de respuesta, obtienes un objeto construido a partir de la acumulación de los fragmentos que se produjeron hasta el momento, en lugar de un objeto que representa un solo fragmento (que podría no ser válido por sí solo). En cierto sentido, cada fragmento de resultado estructurado reemplaza al anterior.

Por ejemplo, estos son los primeros cinco resultados del ejemplo anterior:

null
{ starters: [ {} ] }
{
  starters: [ { name: "Captain's Treasure Chest", description: 'A' } ]
}
{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350
    }
  ]
}
{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350,
      allergens: [Array]
    },
    { name: 'Shipwreck Salad', description: 'Fresh' }
  ]
}

Entrada multimodal

En los ejemplos que viste hasta ahora, se usaron cadenas de texto como instrucciones del modelo. Si bien esta sigue siendo la forma más común de solicitar modelos de IA generativa, muchos modelos también pueden aceptar otros medios como instrucciones. Las instrucciones multimedia se usan con mayor frecuencia junto con instrucciones de texto que le indican al modelo que realice alguna operación en el contenido multimedia, como agregar una leyenda a una imagen o transcribir una grabación de audio.

La capacidad de aceptar entradas de contenido multimedia y los tipos de contenido multimedia que puedes usar dependen por completo del modelo y su API. Por ejemplo, la serie de modelos Gemini 1.5 puede aceptar imágenes, videos y audio como instrucciones.

Para proporcionar una instrucción multimedia a un modelo que la admita, en lugar de pasar una instrucción de texto simple para generar, pasa un array que consta de una parte multimedia y una parte de texto:

const llmResponse = await generate({
  prompt: [
    { media: { url: 'https://example.com/photo.jpg' } },
    { text: 'Compose a poem about this image.' },
  ],
  model: gemini15Flash,
});

En el ejemplo anterior, especificaste una imagen con una URL HTTPS de acceso público. También puedes pasar datos multimedia directamente si los codificas como una URL de datos. Por ejemplo:

import { readFile } from 'node:fs/promises';

const b64Data = await readFile('output.png', { encoding: 'base64url' });
const dataUrl = `data:image/png;base64,${b64Data}`;

const llmResponse = await generate({
  prompt: [
    { media: { url: dataUrl } },
    { text: 'Compose a poem about this image.' },
  ],
  model: gemini15Flash,
});

Todos los modelos que admiten entradas multimedia admiten URLs de datos y URLs HTTPS. Algunos complementos de modelos agregan compatibilidad con otras fuentes de contenido multimedia. Por ejemplo, el complemento de Vertex AI también te permite usar las URLs de Cloud Storage (gs://).

Generando contenido multimedia

Hasta ahora, la mayoría de los ejemplos de esta página se han ocupado de generar texto con LLM. Sin embargo, Genkit también se puede usar con modelos de generación de imágenes. Usar generate() con un modelo de generación de imágenes es similar a usar un LLM. Por ejemplo, para generar una imagen con el modelo Imagen2 a través de Vertex AI, haz lo siguiente:

Genkit usa URLs de data: como el formato de salida estándar para el contenido multimedia generado. Este es un formato estándar con muchas bibliotecas disponibles para manejarlos. En este ejemplo, se usa el paquete data-urls de jsdom:
```
npm i data-urls
npm i --save-dev @types/data-urls
```

Para generar una imagen y guardarla en un archivo, llama a generate() y especifica un modelo de generación de imágenes y el tipo de medio del formato de salida:

import { generate } from '@genkit-ai/ai';
import { configureGenkit } from '@genkit-ai/core';
import { vertexAI, imagen2 } from '@genkit-ai/vertexai';
import parseDataURL from 'data-urls';

import { writeFile } from 'node:fs/promises';

configureGenkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

(async () => {
  const mediaResponse = await generate({
    model: imagen2,
    prompt: 'photo of a meal fit for a pirate',
    output: { format: 'media' },
  });

  const media = mediaResponse.media();
  if (media === null) throw new Error('No media generated.');

  const data = parseDataURL(media.url);
  if (data === null) throw new Error('Invalid ‘data:’ URL.');

  await writeFile(`output.${data.mimeType.subtype}`, data.body);
})();

Historial de mensajes de grabación

Muchos de tus usuarios habrán interactuado con modelos grandes de lenguaje por primera vez a través de chatbots. Aunque los LLM son capaces de hacer mucho más que simular conversaciones, siguen siendo un estilo de interacción familiar y útil. Incluso cuando tus usuarios no interactúen directamente con el modelo de esta manera, el estilo de indicaciones de conversación es una forma eficaz de influir en el resultado que genera un modelo de IA.

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

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 la instrucción en 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 historial inicial para configurar el mensaje del sistema:

import { MessageData } from "@genkit-ai/ai/model";

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,
});

Próximos pasos

Más información sobre Genkit

Como desarrollador de apps, la forma principal en la que influyes en el resultado de los modelos de IA generativa es a través de instrucciones. Lee Administración de instrucciones para descubrir cómo Genkit te ayuda a desarrollar instrucciones eficaces y administrarlas en tu base de código.
Si bien generate() es el núcleo de cada aplicación potenciada por IA generativa, las aplicaciones del mundo real suelen requerir trabajo adicional antes y después de invocar un modelo de IA generativa. Para reflejar esto, Genkit presenta el concepto de flujos, que se definen como funciones, pero agregan características adicionales, como la observabilidad y la implementación simplificada. Para obtener más información, consulta Define flujos de trabajo.

Uso avanzado de LLM

Una forma de mejorar las capacidades de los LLM es proporcionarles una lista de formas en las que pueden solicitarte más información o pedirte que realices alguna acción. Esto se conoce como llamada a herramientas o llamada a función. Los modelos que se entrenan para admitir esta función pueden responder a una instrucción con una respuesta con formato especial, que le indica a la aplicación que realiza la llamada que debe realizar alguna acción y enviar el resultado al LLM junto con la instrucción original. Genkit tiene funciones de biblioteca que automatizan la generación de instrucciones y los elementos del bucle de llamada y respuesta de una implementación de llamada a herramienta. Consulta Llamadas a herramientas para obtener más información.
La generación aumentada de recuperación (RAG) es una técnica que se usa para introducir información específica del dominio en el resultado de un modelo. Para ello, se inserta información relevante en una instrucción antes de pasarla al modelo de lenguaje. Una implementación de RAG completa requiere que reúnas varias tecnologías: modelos de generación de incorporación de texto, bases de datos de vectores y modelos grandes de lenguaje. Consulta Generación aumentada de recuperación (RAG) para obtener información sobre cómo Genkit simplifica el proceso de coordinación de estos elementos.

Prueba la salida del modelo

Como ingeniero de software, estás acostumbrado a los sistemas deterministas en los que la misma entrada siempre produce el mismo resultado. Sin embargo, con los modelos de IA que son probabilísticos, la salida puede variar en función de matices sutiles en la entrada, los datos de entrenamiento del modelo y la aleatoriedad introducida de forma deliberada por parámetros como la temperatura.

Los evaluadores de Genkit son formas estructuradas de evaluar la calidad de las respuestas de tu LLM con una variedad de estrategias. Obtén más información en la página Evaluación.