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