Como gerar conteúdo com modelos de IA

No centro da IA generativa estão os modelos de IA. Atualmente, as duas ferramentas exemplos de modelos generativos são modelos de linguagem grande (LLMs) e modelos de geração de texto. Esses modelos recebem entradas, chamadas de comandos (geralmente texto, imagem ou uma combinação de ambos) e produz como texto de saída, uma imagem, ou até mesmo áudio ou vídeo.

A saída desses modelos pode ser surpreendentemente convincente: LLMs geram textos que parece ter sido escrita por um ser humano, e imagens de geração de imagens, podem produzir imagens muito próximas a fotografias reais ou obras de arte criadas por humanos.

Além disso, os LLMs provaram ser capazes de realizar tarefas além da simples geração de texto:

  • Escrever programas de computador
  • Planejar subtarefas necessárias para concluir uma tarefa maior
  • Organizar dados não organizados
  • Compreender e extrair dados de informação de um corpus de texto
  • Seguir e realizar atividades automatizadas com base em uma descrição de texto de a atividade

Há muitos modelos disponíveis para você, de vários fornecedores diferentes. Cada tem os próprios pontos fortes e fracos, e um modelo pode se destacar em uma tarefa mas tem um desempenho pior em outras. Os apps que usam a IA generativa podem, muitas vezes, se beneficiar do uso de vários modelos diferentes dependendo da tarefa em questão.

Como desenvolvedor de apps, você normalmente não interage com a IA generativa. modelos de ML diretamente, mas por meio de serviços disponíveis como APIs da Web. Embora esses serviços tenham funcionalidades semelhantes, todos eles oferecem usando APIs diferentes e incompatíveis. Se você quiser usar vários de modelos, você precisa usar cada um dos SDKs próprios, possivelmente incompatíveis entre si. Se quiser atualizar de um modelo para o a mais recente e a mais capacitada, talvez tenha que construir essa integração em todo de novo.

O Genkit resolve esse desafio fornecendo uma única interface que abstrai os detalhes do acesso possivelmente a qualquer serviço de modelo de IA generativa, com várias implementações pré-criadas já estão disponíveis. Como criar um ambiente com tecnologia de IA baseado no Genkit simplifica o processo de fazer sua primeira chamada de IA generativa e facilita a combinação de vários modelos ou a troca de um outro à medida que novos modelos surgem.

Antes de começar

Se você quiser executar os exemplos de código nesta página, primeiro conclua as etapas em o guia de Primeiros passos. Todos os exemplos pressupõem que você já instalou o Genkit como uma dependência em seu projeto.

Modelos com suporte do Genkit

O Genkit foi projetado para ser flexível o suficiente para usar potencialmente qualquer IA generativa serviço de modelo. Suas bibliotecas principais definem a interface comum para trabalhar com e plug-ins de modelos definem os detalhes de implementação para trabalhar com um um modelo específico e a API dele.

A equipe do Genkit mantém plug-ins para trabalhar com modelos fornecidos pela Vertex AI, IA generativa do Google e Ollama:

  • de LLMs pela família Gemini, Plug-in da Vertex AI do Google Cloud
  • família de LLMs do Gemini, criada com o plug-in da IA do Google
  • Modelos de geração de imagens Imagen2 e Imagen3 com a Vertex AI do Google Cloud
  • Família de LLMs Claude 3 da Anthropic, usando o modelo da Vertex AI do Google Cloud jardim
  • Gemma 2, Llama 3 e muitos outros modelos abertos pela Ollama plugin (você precisa hospedar o servidor Ollama por conta própria)

Além disso, existem vários plug-ins com suporte da comunidade que fornecem para esses modelos:

Saiba mais pesquisando pacotes com a tag genkit-model em npmjs.org (em inglês).

Como carregar e configurar plug-ins de modelo

Antes de poder usar o Genkit para começar a gerar conteúdo, você precisa carregar e configurar um plug-in de modelo. Se você estiver vindo do Guia explicativo, você já fez isso. Caso contrário, consulte os guias Primeiros passos ou a documentação do plug-in individual e siga as etapas apresentadas nele antes continuar.

Função generate()

No Genkit, a principal interface de interação com a IA generativa é a função generate().

A chamada generate() mais simples especifica o modelo que você quer usar e um texto prompt:

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

Ao executar este breve exemplo, ele imprimirá algumas informações de depuração. seguida pela saída da chamada generate(), que geralmente será Markdown como no exemplo a seguir:

## 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.

Execute o script novamente para ter uma saída diferente.

O exemplo de código anterior especificou o modelo usando uma referência exportada pelo plug-in do modelo. Também é possível especificar o modelo usando um identificador de string:

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

Um identificador de string de modelo é semelhante a providerid/modelid, em que o ID do provedor (neste caso, googleai) identifica o plug-in, e o ID do modelo é um identificador de string específico do plug-in para uma versão específica de um modelo.

Alguns plug-ins de modelo, como o Ollama, oferecem acesso a dezenas de modelos diferentes e, portanto, não exportam modelos individuais de referência. Nesses casos, só é possível especificar um modelo para generate() usando seu identificador de string:

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

Todos os exemplos anteriores também ilustram um ponto importante: quando você usa generate() para fazer chamadas de modelo de IA generativa, mudando o modelo que você quer usar é simplesmente uma questão de passar um valor diferente ao parâmetro do modelo. De usando generate() em vez dos SDKs do modelo nativo, você atribui a si mesmo o flexibilidade para usar mais facilmente vários modelos diferentes no seu aplicativo e alterar modelos no futuro.

Até agora, você conheceu apenas exemplos das chamadas generate() mais simples. No entanto, O generate() também fornece uma interface para interações mais avançadas com modelos generativos, que você vai conhecer nas seções a seguir.

Parâmetros do modelo

A função generate() usa um parâmetro config, que pode ser usado especifique configurações opcionais que controlam como o modelo gera conteúdo:

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

Os parâmetros exatos aceitos dependem do modelo individual e do modelo API. No entanto, os parâmetros do exemplo anterior são comuns a quase todos um modelo de machine learning. Veja a seguir uma explicação desses parâmetros:

Parâmetros que controlam o comprimento da saída

maxOutputTokens (link em inglês).

Os LLMs operam em unidades chamadas tokens. Geralmente, um token, mapear para uma sequência específica de caracteres. Quando você passa um comando um modelo, uma das primeiras etapas é tokenizar a string do comando; em uma sequência de tokens. Depois, o LLM gera uma sequência de tokens do entrada tokenizada. Por fim, a sequência de tokens é convertida de volta em texto, que é sua saída.

O parâmetro máximo de tokens de saída simplesmente define um limite para o número de tokens gerados usando o LLM. Cada modelo usa um tokenizador diferente, mas uma boa regra prática é considerar que uma única palavra em inglês deve ter de 2 a 4 tokens.

Como mencionado anteriormente, alguns tokens podem não ser mapeados para sequências de caracteres. Uma dessas exemplo é que muitas vezes há um token que indica o fim da sequência: quando um LLM gera esse token, ele para de gerar mais. Portanto, possível e, muitas vezes, o caso de um LLM gerar menos tokens do que o porque ela gerou a parada com base no token correto anterior.

stopSequences

É possível usar esse parâmetro para definir os tokens ou sequências de token que, quando gerado, indicam o fim da saída do LLM. Os valores corretos a serem usados aqui geralmente dependem de como o modelo foi treinado e são definidos pelo modelo plug-in. No entanto, se você solicitou ao modelo que gerasse outra parada, você pode especificá-la aqui.

Você está especificando sequências de caracteres e não tokens em si. Na maioria casos, você especificará uma sequência de caracteres que o tokenizador do modelo mapeia para um único token.

Parâmetros que controlam "criatividade"

Os parâmetros temperature, top-p e top-k juntos controlam como "criativo" como você quer que o modelo fique. Veja a seguir explicações resumidas sobre o que significam esses parâmetros, mas o ponto mais importante a ser considerado é que eles são usados para ajustar o caractere da saída de um LLM. O ideal para elas dependem das suas metas e preferências e provavelmente serão encontrados somente por meio de testes.

temperatura

LLMs são máquinas que preveem tokens. Para uma determinada sequência de tokens (como o comando) que um LLM prevê, para cada token no vocabulário dele, probabilidade de que o token seja o próximo na sequência. A temperatura é fator de escalonamento pelo qual essas previsões são divididas antes de serem normalizadas para uma probabilidade entre 0 e 1.

Valores de temperatura baixos, entre 0,0 e 1,0 amplificam a diferença na entre os tokens, fazendo com que o modelo seja ainda menor probabilidade de produzir um token que já avalia ser improvável. Isso geralmente acontece percebidos como um resultado menos criativo. Embora 0.0 não seja tecnicamente um válido, muitos modelos o tratam como indicando que o modelo deve se comportar determinista e considerar apenas o token mais provável.

Valores de temperatura altos (maiores do que 1,0) compactam a diferenças nas probabilidades entre tokens, e o resultado é que o modelo fica mais propenso a produzir tokens que haviam avaliado anteriormente improvável. Geralmente, isso é considerado um resultado mais criativo. Algum modelo As APIs impõem uma temperatura máxima, geralmente de 2,0.

topP (link em inglês)

Top-p é um valor entre 0,0 e 1,0 que controla o número de que você quer que o modelo considere, especificando a probabilidade cumulativa dos tokens. Por exemplo, um valor de 1,0 significa considerar todas as token, mas ainda assim levar em consideração a probabilidade de cada um deles. Um valor de 0,4 significa considerar apenas os tokens mais prováveis, com probabilidades que 0, 4 e excluir os tokens restantes.

topK (link em inglês)

Top-k é um valor inteiro que também controla o número de possíveis tokens que você o modelo deve considerar, mas, dessa vez, especificando explicitamente o máximo de tokens. Especificar um valor de 1 significa que o modelo deve se comportar de forma determinista.

Teste os parâmetros do modelo

É possível testar o efeito desses parâmetros na saída gerada por diferentes combinações de modelo e comando usando a interface do desenvolvedor. Inicie o interface de desenvolvedor com o comando genkit start, que vai carregar automaticamente dos modelos definidos pelos plug-ins configurados no projeto. Você pode rapidamente e testar diferentes comandos e valores de configuração sem precisar fazer alterações essas mudanças no código.

Saída estruturada

Ao usar a IA generativa como componente de um aplicativo, é comum querer a saída em um formato diferente de texto simples. Mesmo se você estiver apenas gerando conteúdo exibir ao usuário, você pode se beneficiar da saída estruturada simplesmente para que para apresentá-lo de forma mais atraente para o usuário. Para consultas mais avançadas aplicações da IA generativa, como o uso programático da saída do modelo, ou alimentar a saída de um modelo em outro, a saída estruturada é essencial.

No Genkit, é possível solicitar uma saída estruturada de um modelo especificando um esquema quando você chamar 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,
  },
});

Os esquemas de saída do modelo são especificados usando o Zod biblioteca. Além da linguagem de definição de esquemas, o Zod também oferece verificação de tipo, que preenche a lacuna entre os tipos estáticos do TypeScript e os resultados imprevisíveis dos modelos de IA generativa. O Zod permite que você escreva um código dependem do fato de que uma chamada de geração bem-sucedida sempre retornará uma saída que está de acordo com seus tipos do TypeScript.

Quando você especifica um esquema em generate(), o Genkit realiza várias ações por trás do cenas:

  • Aumenta o comando com mais orientações sobre o formato de saída desejado. Isso também tem o efeito colateral de especificar ao modelo qual conteúdo exatamente que você quer gerar (por exemplo, não apenas sugerir um item de menu, mas também gerar uma descrição, uma lista de alérgenos e assim por diante).
  • Analisa a saída do modelo em um objeto JavaScript.
  • Verifica se a saída está em conformidade com o esquema.

Para receber a saída estruturada de uma chamada de geração bem-sucedida, use a resposta método output() do objeto:

type MenuItem = z.infer<typeof MenuItemSchema>;

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

Tratamento de erros

Observe no exemplo anterior que o método de saída pode retornar null. Isso pode acontecer quando o modelo não gera uma saída em conformidade com o esquema. Você também pode detectar essa condição capturando o NoValidCandidatesError exceção gerada por generate:

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

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

A melhor estratégia para lidar com esses erros dependerá do seu uso exato mas aqui estão algumas dicas gerais:

  • Tente usar um modelo diferente. Para que a saída estruturada dê certo, o modelo precisa ser é capaz de gerar saídas em JSON. Os LLMs mais potentes, como Gemini e Claude, são versáteis o bastante para fazer isso. No entanto, modelos menores, dos modelos locais que você usaria com o Ollama, talvez não consiga gerar de saída estruturada de forma confiável, a menos que tenham sido treinados especificamente para fazer assim.

  • Use as habilidades de coerção de Zod: você pode especificar nos seus esquemas que O Zod deve tentar coagir os tipos não conformes para o tipo especificado pelo esquema. Caso seu esquema inclua tipos primitivos diferentes de strings, use o Zod coerção pode reduzir o número de falhas generate() encontradas. A versão a seguir de MenuItemSchema usa a conversão de tipos para automaticamente situações corretas em que o modelo gera informações de calorias como uma string em vez de um número:

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

  • Repetir a chamada generate(). Se o modelo escolhido raramente falhar gerar uma saída em conformidade, você pode tratar o erro como trataria uma erro de rede e simplesmente tenta executar a solicitação novamente usando algum tipo uma estratégia de espera.

Streaming

Ao gerar grandes quantidades de texto, você pode melhorar a experiência de seus usuários, apresentando a saída à medida que ela é gerada, transmitindo a saída. Um um exemplo conhecido de streaming em ação pode ser visto na maioria dos apps de chat de LLM: pode ler a resposta do modelo às mensagens enquanto elas são geradas, o que melhora a capacidade de resposta percebida do aplicativo e melhora a a ilusão de conversar com um colega inteligente.

No Genkit, é possível fazer streaming da saída usando a função generateStream(). Seu é semelhante à função 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,
});

No entanto, essa função retorna um iterável assíncrono de blocos de resposta. Gerencie cada um desses blocos à medida que se tornarem disponíveis:

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

Você ainda pode receber a resposta completa de uma só vez:

const llmResponse = await llmResponseStream.response();

O streaming também funciona com saída estruturada:

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

O streaming de saída estruturada é um pouco diferente do streaming de texto. Quando você chamar o método output() de um bloco de resposta, receberá um objeto construídas com o acúmulo de pedaços que foram produzidos até agora, em vez de um objeto que representa um único bloco (o que pode não ser válido em por conta própria). De certa forma, cada bloco da saída estruturada substitui um bloco que vieram antes.

Por exemplo, aqui estão as cinco primeiras saídas do exemplo 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

Os exemplos que você viu até agora usaram strings de texto como comandos de modelo. essa continua sendo a maneira mais comum de criar comandos para modelos de IA generativa, também aceita outras mídias como comandos. Os comandos de mídia são usados com mais frequência com comandos de texto que instruem o modelo a realizar alguma operação na mídia, como para legendar uma imagem ou transcrever uma gravação de áudio.

A capacidade de aceitar entrada de mídia e os tipos de mídia que podem ser usados são são totalmente dependentes do modelo e da API. Por exemplo, o Gemini 1.5 de modelos pode aceitar imagens, vídeos e áudios como comandos.

Para fornecer um prompt de mídia a um modelo que o suporte, em vez de passar uma comando de texto simples para gerar, passar uma matriz que consiste em uma parte de mídia e um parte do texto:

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

No exemplo acima, você especificou uma imagem usando um endereço HTTPS URL. Você também pode transmitir dados de mídia diretamente, codificando-os como um URL de dados. Exemplo:

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 os modelos com suporte a entrada de mídia oferecem suporte a URLs de dados e HTTPS. Algumas Os plug-ins de modelo adicionam suporte a outras fontes de mídia. Por exemplo, a Vertex AI O plug-in também permite usar URLs do Cloud Storage (gs://).

Gerando mídia

Até agora, a maioria dos exemplos nesta página lidaram com a geração de texto usando ou LLMs No entanto, o Genkit também pode ser usado com modelos de geração de imagens. Usando A generate() com um modelo de geração de imagens é semelhante a usar um LLM. Para exemplo, para gerar uma imagem usando o modelo Imagen2 pela Vertex AI:

  1. O Genkit usa URLs data: como formato de saída padrão para a mídia gerada. Esse é um formato padrão com muitas bibliotecas disponíveis para lidar com ele. Isso exemplo usa o pacote data-urls de jsdom:

    npm i data-urls
npm i --save-dev @types/data-urls

  2. Para gerar uma imagem e salvá-la em um arquivo, chame generate(), especificando um modelo de geração de imagens e o tipo de mídia do formato de saída:

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

Como gravar o histórico de mensagens

Muitos dos seus usuários vão interagir com modelos de linguagem grandes pela primeira tempo por meio de chatbots. Embora os LLMs sejam capazes de muito mais do que simular conversas, continua sendo um estilo de interação familiar e útil. Mesmo quando os usuários não vão interagir diretamente com o modelo, o estilo coloquial de comandos é uma forma poderosa de influenciar os resultados geradas por um modelo de IA.

Para gerar o histórico de mensagens com base em uma resposta de modelo, chame o método toHistory() :

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

É possível serializar esse histórico e mantê-lo em um armazenamento de sessão ou banco de dados. Em seguida, transmita o histórico com a solicitação em chamadas futuras para generate():

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

Se o modelo que você está usando for compatível com o papel system, será possível usar o histórico para definir a mensagem do 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óximas etapas

Saiba mais sobre o Genkit

  • Ao desenvolver apps, sua principal maneira de influenciar os resultados da IA generativa modelos é por meio de prompts. Leia Gerenciamento de comandos para saber como O Genkit ajuda você a desenvolver comandos eficientes e gerenciá-los na sua base de código.
  • Embora o generate() seja o núcleo de todas as tecnologias de IA generativa aplicativos do mundo real normalmente exigem trabalho adicional e depois de invocar um modelo de IA generativa. Para refletir isso, o Genkit introduz o conceito de fluxos, que são definidos como funções, mas acrescentam como observabilidade e implantação simplificada. Para saber mais, consulte Como definir fluxos de trabalho.

Uso avançado de LLM

  • Uma forma de aprimorar as capacidades dos LLMs é enviar uma lista de maneiras pelas quais eles podem solicitar mais informações suas ou solicitar que você realize alguma ação. Isso é conhecido como chamada de ferramenta ou chamada de função. Modelos treinados para suportar essa capacidade podem responder a um prompt especialmente formatada, que indica ao aplicativo de chamada que ele vai executar uma ação e enviar o resultado de volta ao LLM com o comando original. O Genkit tem funções de biblioteca que automatizam o a geração de comandos e os elementos do loop de chamada/resposta de uma ferramenta de chamada implementação. Consulte Chamada de ferramenta para saber mais.
  • A geração aumentada de recuperação (RAG) é uma técnica usada para introduzir informações específicas do domínio na saída de um modelo. Isso é alcançado ao inserindo informações relevantes em um comando antes de passar para o um modelo de linguagem grande. Uma implementação RAG completa requer que você traga vários tecnologias juntas: modelos de geração de embedding de texto, bancos de dados de vetores e modelos de linguagem grandes. Consulte Geração aumentada de recuperação (RAG) para aprender como o Genkit simplifica o processo de coordenação dessas várias os elementos.

Como testar a saída do modelo

Como engenheiro de software, você está acostumado a determinísticos em que as mesmas entrada sempre produz a mesma saída. No entanto, com modelos de IA probabilísticos, a saída pode variar com base em nuances sutis na entrada, a dados de treinamento do modelo e até mesmo a aleatoriedade deliberadamente introduzida por parâmetros como temperatura.

Os avaliadores do Genkit são formas estruturadas de avaliar a qualidade dos LLMs usando uma variedade de estratégias. Leia mais na Avaliação.