Generuję treści

Firebase Genkit zapewnia prosty interfejs do generowania treści za pomocą LLM.

Modele

Modele w Firebase Genkit to biblioteki i abstrakcje zapewniające dostęp do różnych modeli LLM Google i innych firm.

Modele są w pełni instrumentowane pod kątem dostrzegalności i mają integracje narzędzi dostępne w interfejsie programisty Genkit. Możesz wypróbować dowolny model, używając mechanizmu uruchamiania modeli.

Jeśli pracujesz z modelami w Genkit, musisz najpierw skonfigurować ten, z którym chcesz pracować. Konfiguracja modelu jest wykonywana przez system wtyczek. W tym przykładzie konfigurujesz wtyczkę Vertex AI, która udostępnia modele Gemini.

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

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

Aby korzystać z modeli dostarczonych przez wtyczkę, możesz odwoływać się do nich według nazwy (np. 'vertexai/gemini-1.0-pro') lub przywoływać obiekty referencyjne modeli eksportu wtyczek, które zawierają dodatkowe informacje o możliwościach i opcjach modelu.

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

Obsługiwane modele

Genkit zapewnia obsługę modelu przez system wtyczek. Oficjalnie obsługiwane są te wtyczki:

Wtyczka Modele
Generatywna AI od Google Gemini Pro, Gemini Pro Vision
Google Vertex AI Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2
Ollama Wiele modeli lokalnych, w tym Gemma, Llama 2, Mistral i wiele innych.

Informacje na temat konfiguracji i użycia poszczególnych wtyczek można znaleźć w dokumentacji poszczególnych wtyczek.

Jak generować treści

generate to funkcja pomocnicza do pracy z modelami.

Aby wywołać model:

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

Możesz przekazywać różne opcje swojego modelu, w tym określić model niestandardowy dla konkretnych modeli LLM.

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

Jeśli model obsługuje multimodalne dane wejściowe, możesz przekazywać obrazy jako dane wejściowe:

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

Lub z pliku lokalnego:

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 obsługuje też wywoływanie narzędzi i funkcji. Dostępność narzędzi zależy od konkretnych modeli.

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

Spowoduje to automatyczne wywołanie narzędzi w celu wykonania polecenia.

Możesz określić returnToolRequests: true do ręcznej kontroli wywoływania narzędzi.

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

Możesz też przesyłać strumieniowo dane wyjściowe z modeli, które je obsługują:

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

Dodaję kontekst modułu do pobierania

Dokumenty z modułu pobierającego można przekazywać bezpośrednio do narzędzia generate, aby podać kontekst umocowania:

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

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

Kontekst dokumentu jest automatycznie dołączany do treści promptu wysłanego do modelu.

Rejestruję historię wiadomości

Modele Genkit obsługują utrzymywanie historii wiadomości wysyłanych do modelu i jego odpowiedzi, co można wykorzystać do tworzenia interaktywnych funkcji, takich jak czatboty.

Aby wygenerować historię wiadomości na podstawie odpowiedzi modelu, wywołaj metodę toHistory():

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

Możesz zserializować tę historię i zachować ją w bazie danych lub pamięci sesji. Następnie przekaż historię wraz z pytaniem przy kolejnych połączeniach z numerem generate():

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

Jeśli używany model obsługuje rolę system, możesz użyć początkowej historii, aby ustawić komunikat systemowy:

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

Strumieniowanie odpowiedzi

Genkit obsługuje stopniowe przesyłanie odpowiedzi modelu za pomocą metody 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());