Geração de conteúdo

O Firebase Genkit oferece 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 UI do desenvolvedor Genkit. Você pode testar qualquer modelo usando o executor de modelo.

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

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

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

Para usar modelos fornecidos pelo plug-in, você pode se referir a eles pelo nome (por exemplo, 'vertexai/gemini-1.5-flash') ou alguns plug-ins exportam objetos ref de modelo que fornecem mais informações sobre os recursos e as opções do modelo.

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

Modelos compatíveis

O Genkit oferece suporte a modelos pelo sistema de plug-ins. Os plug-ins a seguir são oficialmente compatíveis:

Plug-in	Modelos
IA generativa do Google	Gemini Pro, Gemini Pro Vision
Vertex AI do Google	Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro e Imagen2
Ollama	Muitos modelos locais, como Gemma, Llama 2, Mistral, entre outros

Consulte a documentação de cada plug-in para ver informações de configuração e uso. Também há uma ampla variedade de modelos disponíveis com suporte da comunidade que podem ser procurando pacotes começando com genkitx- em npmjs.org.

Como gerar conteúdo

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

Basta chamar o modelo:

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

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

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

Se o modelo oferecer suporte à entrada multimodal, é possível transmitir imagens como entrada:

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

Ou a partir de um arquivo 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',
      },
    },
  ],
});

Ferramentas e chamada de funções

Model também oferece suporte a ferramentas e chamadas de funções. O suporte a ferramentas depende 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,
  },
});

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

Você pode especificar returnToolRequests: true para controle manual de chamadas de ferramentas.

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

Como adicionar contexto do recuperador

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: gemini15Flash,
  prompt: `Answer using the available context from company policy: ${question}`,
  context: docs,
});

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

Como gravar o histórico de mensagens

Os modelos Genkit suportam a manutenção de um histórico das mensagens enviadas ao modelo e suas respostas, que você pode usar para construir experiências interativas, como chatbots.

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:

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

Respostas de streaming

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