Generuję treści

Firebase Genkit zapewnia prosty interfejs do generowania treści przy użyciu modeli LLM.

Modele

Modele w Firebase Genkit to biblioteki i abstrakcje, które zapewniają dostęp do z wieloma modelami LLM od Google i innych firm.

Modele są w pełni przystrojone pod kątem dostrzegalności i mają narzędzia dostępnych w interfejsie programisty Genkit – możesz wypróbować dowolny model, czyli biegacza modelu.

Podczas pracy z modelami w Genkit musisz najpierw skonfigurować model, z którymi chcesz współpracować. Konfiguracja modelu jest wykonywana przez system wtyczek. W w tym przykładzie konfigurujesz wtyczkę Vertex AI, która udostępnia Gemini modeli ML.

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

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

Aby używać modeli udostępnianych przez wtyczkę, możesz odwoływać się do nich po nazwie (np. 'vertexai/gemini-1.5-flash'), lub niektóre wtyczki eksportują obiekty odwołujące się do obiektów, które podaj dodatkowe informacje o możliwościach i opcjach modelu.

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

Obsługiwane modele

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

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 czy Mistral

W dokumentacji każdej wtyczki znajdziesz informacje o jej konfiguracji i korzystaniu. Jest też Google oferuje wiele różnych modeli wspieranych przez społeczność, które możesz poznać, wyszukiwaniem pakietów zaczynających się od genkitx- na npmjs.org.

Jak generować treści

generate to funkcja pomocnicza do pracy z modelami.

Aby po prostu wywołać model:

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

Możesz przekazać różne opcje dla tego modelu, w tym określić dla określonych modeli LLM.

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

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

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

Lub z pliku lokalnego:

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

Wywołania narzędzi i funkcji

Model obsługuje też narzędzia i wywoływanie funkcji. Obsługa narzędzi zależy od określonych 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: gemini15Flash,
  prompt: 'Tell me a joke.',
  tools: [myTool],
  config: {
    temperature: 0.5,
  },
});

Spowoduje to automatyczne wywołanie narzędzi w celu spełnienia promptu użytkownika.

Możesz określić returnToolRequests: true, aby ręcznie kontrolować wywoływanie narzędzi.

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

Dodawanie kontekstu retrievera

Dokumenty z retrievera można przekazać bezpośrednio do generate, aby kontekst umocowania:

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

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

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

Rejestrowanie historii wiadomości

Modele Genkit obsługują przechowywanie historii wiadomości wysyłanych do modelu i odpowiedzi na nie, które można wykorzystać do tworzenia interaktywnych treści, czatboty.

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

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

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

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

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

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

Strumieniowanie odpowiedzi

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