Gerar conteúdo

O Firebase Genkit tem uma interface fácil para gerar conteúdo com LLMs.

Modelos

Os modelos no Firebase Genkit são bibliotecas e abstrações que dão acesso a vários LLMs do Google e de terceiros.

Os modelos são totalmente instrumentados para observabilidade e vêm com integrações de ferramentas fornecidas pela interface do desenvolvedor do Genkit. É possível testar qualquer modelo usando o executor de modelos.

Ao trabalhar com modelos no Genkit, primeiro é preciso configurar o modelo com que você quer trabalhar. A configuração do modelo é executada pelo sistema de plug-ins. Neste exemplo, você está configurando o plug-in Vertex AI, que fornece modelos do Gemini.

import { configureGenkit } from '@genkit-ai/core';
import { firebase } from '@genkit-ai/firebase';
import { vertexAI } from '@genkit-ai/vertexai';

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

Para usar os modelos fornecidos pelo plug-in, é possível se referir a eles pelo nome (por exemplo, 'vertexai/gemini-1.0-pro') ou alguns plug-ins de exportação de objetos de referência do modelo que fornecem mais informações de tipo sobre os recursos e as opções do modelo.

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

Modelos compatíveis

O Genkit é compatível com modelos pelo sistema de plug-ins. Estes plug-ins têm suporte oficial:

Plug-in	Modelos
IA generativa do Google	Gemini Pro e Gemini Pro Vision
Vertex AI do Google	Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
Olama	Muitos modelos locais, incluindo Gemma, Llama 2, Mistral e muito mais

Consulte a documentação de cada plug-in para ver informações de configuração e uso.

Como gerar conteúdo

generate é uma função auxiliar para trabalhar com modelos.

Para chamar o modelo:

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

É possível transmitir várias opções para esse modelo, incluindo a especificação de um modelo personalizado para LLMs específicos.

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

Se o modelo for compatível com entrada multimodal, será possível transmitir imagens como entrada:

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

Ou a partir de um arquivo 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 também oferece suporte a chamadas de ferramentas e funções. O suporte às ferramentas 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,
  },
});

Isso chamará as ferramentas automaticamente para atender ao comando do usuário.

É possível especificar returnToolRequests: true para controle manual da chamada de ferramentas.

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

E é possível transmitir saídas de modelos compatíveis:

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

Adicionar contexto de recuperação

Os documentos de um recuperador podem ser transmitidos diretamente para generate para fornecer contexto de embasamento:

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

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

O contexto do documento é anexado automaticamente ao conteúdo do comando enviado ao modelo.

Gravando histórico de mensagens

Os modelos do Genkit permitem manter um histórico das mensagens enviadas ao modelo e das respostas dele, que você pode usar para criar experiências interativas, como bots de chat.

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

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

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

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

Se o modelo que você está usando for compatível com o papel system, use o histórico inicial para definir a mensagem do 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();

Respostas de streaming

O Genkit é compatível com o streaming em partes das respostas do modelo pelo 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());