Firebase Genkit

Firebase Genkit to platforma open source, która ułatwia tworzenie, wdrażanie i monitorowanie aplikacji opartych na AI gotowych do produkcji.

Usługa Genkit została opracowana z myślą o deweloperach aplikacji, aby ułatwić integrację zaawansowanych funkcji AI z aplikacjami na podstawie dobrze znanych wzorców i paradygmatów. Tworzy ją ten sam zespół, który był w stanie Firebase. Wykorzystujemy nasze doświadczenie w tworzeniu narzędzi używanych przez miliony deweloperów na całym świecie.

Genkit pozwala tworzyć aplikacje generujące niestandardowe treści, używać wyszukiwania semantycznego, obsługiwać nieuporządkowane dane wejściowe, odpowiadać na pytania za pomocą firmowych baz danych, automatycznie podejmować decyzje, administrować wywołaniami narzędzi i nie tylko.

Genkit obecnie obsługuje programowanie po stronie serwera w języku JavaScript/TypeScript (Node.js) z aktywną obsługą języka Go.

Śledź jej rozwój lub wkład własny w jego repozytorium GitHub.

Najważniejsze funkcje

Genkit pomoże Ci na każdym etapie rozwoju AI – od opracowania prototypu po monitorowanie w środowisku produkcyjnym. Jest więc wiele tematów do rozmowy.

Oto 10 najważniejszych funkcji Genkit, które mogą Ci się spodobać:

1. Wiele modeli, jeden interfejs

Genkit udostępnia wtyczki, które od razu zapewniają dostęp do popularnych modeli, a także elastyczną abstrakcję modeli, co ułatwia integrację dowolnego interfejsu API modeli i korzystanie z modeli obsługiwanych przez społeczność. Wypróbowanie nowego modelu jest równie łatwe jak zmiana pojedynczego argumentu, ale każdy model może określać konfiguracje niestandardowe.

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

function flipACoin(a, b) {
  return Math.random() > 0.5 ? a : b;
}

const result = await generate({
  model: flipACoin(geminiPro, 'ollama/gemma'),
  config: { temperature: 0.3, maxOutputTokens: 200 },
  prompt: 'What makes you the best LLM out there?',
});

console.log(result.text());

2. Uporządkowane dane wyjściowe

Generuj dane ściśle wpisywane w aplikacji Genkit przy użyciu schematu Zod. Pomoże Ci to analizować nieuporządkowany tekst, generować treści kreatywne, wybierać zadania i odsyłać wyniki z powrotem do aplikacji jako obiekty zgodne z uporządkowanymi typami danych.

import { generate } from "@genkit-ai/ai";
import { geminiPro } from "@genkit-ai/vertexai";
import { z } from "zod";

const CreatureSchema = z.object({
  name: z.string().describe('the name of the creature'),
  hitPoints: z.number().describe('hit points, between 5 and 100'),
  attacks: z.array(z.object({
    name: z.string(),
    damage: z.number().describe('amount of damage, between 2 and 25'),
  })).describe('3 attacks the creature can use')
});

const createCreature = defineFlow({
    name: "createCreature",
    inputSchema: z.string(),
    outputSchema: CreatureSchema,
  },
  (habitat) => {
    const result = await generate({
      model: geminiPro,
      prompt: `You are a brilliant RPG designer. Generate a creature that lives in ${habitat}.`,
      output: {schema: CreatureSchema}
    });
    // strongly typed and ready to go
    return result.output();
  }
)

console.log(await createCreature("a developer conference"));

3. Multimodalne, multimedialne

Genkit udostępnia popularny format treści, który obsługuje połączenia tekstu, danych i dowolnych multimediów. Dzięki temu można używać Genkit do modeli, które wykonują dowolne zadania generatywne (takie jak generowanie obrazów), a nie tylko LLM.

import { imagen2, geminiProVision } from '@genkit-ai/vertexai';
import { generate } from '@genkit-ai/ai';

const imageResult = await generate({
  model: imagen2,
  prompt: 'Generate an image of a very specific historical time and place.',
});
const generatedImage = imageResult.media();

const descriptionResult = await generate({
  model: geminiProVision,
  prompt: [
    {
      text: 'What is the historical time and place represented in this picture?',
    },
    { media: generatedImage },
  ],
});
console.log(descriptionResult.text());

4. Udostępnienie narzędzi LLM

Genkit ułatwia wywoływanie funkcji za pomocą LLM za pomocą narzędzi. Narzędzia umożliwiają AI pobieranie danych, wyświetlanie interfejsu użytkownika, zapisywanie danych w bazie danych lub wykonywanie innych działań, które możesz zakodować.

import { generate, defineTool } from '@genkit-ai/ai';
import { geminiPro } from '@genkit-ai/vertexai';
import { z } from 'zod';

const createReminder = defineTool(
  {
    name: 'createReminder',
    description: 'Use this to create reminders for things in the future',
    inputSchema: z.object({
      time: z
        .string()
        .describe('ISO timestamp string, e.g. 2024-04-03T12:23:00Z'),
      reminder: z.string().describe('the content of the reminder'),
    }),
    outputSchema: z.number().describe('the ID of the created reminder'),
  },
  (reminder) => db.reminders.create(reminder)
);

const searchNotes = defineTool(
  {
    name: 'searchNotes',
    description: "Use this to search the user's notes for people or phrases",
    inputSchema: z.string().describe('the search query'),
    outputSchema: z.object({ notes: z.array(NoteSchema) }),
  },
  (query) => db.notes.search(query)
);

const result = await generate({
  model: geminiPro,
  tools: [createReminder, searchNotes],
  prompt: `
  You are a note-taking assistant. Using the tools available, try to answer the provided query.
  If you create a reminder, describe in text the reminder you created as a response.

  Query: I took a note about a meeting with Anna - can you set a reminder for the time?
  `,
});
console.log(result.text());

5. Zarządzanie prośbami za pomocą Dotprompt

Inżynieria to nie tylko ulepszanie tekstu. Używany model, dostarczane parametry i format, o które prosisz, wpływają na jakość wyników. Genkit oferuje Dotprompt – format pliku promptów, który pozwala umieścić wszystko w jednym pliku, co ułatwia testowanie i porządkowanie.

---
model: vertexai/gemini-1.0-pro
config:
  temperature: 0.9
input:
  schema:
    properties:
      location: {type: string}
      style: {type: string}
      name: {type: string}
    required: [location]
  default:
    location: a restaurant
---

You are the world's most welcoming AI assistant and are currently working at {{location}}.

Greet a guest{{#if name}} named {{name}}{{/if}}{{#if style}} in the style of {{style}}{{/if}}.

6. Uruchamianie przepływów lokalnie

Wyniki wygenerowane przez generatywną AI są bardzo zróżnicowane, więc eksperymentowanie jest bardzo ważne. Lokalny interfejs programisty Genkit umożliwia interakcję z kluczowymi komponentami AI, takimi jak modele i retrievery, a także ręczne testowanie kompleksowych procesów obejmujących cały napisany przez Ciebie kod niestandardowy.

7. Sprawdź ślady

Debugowanie złożonych, wieloetapowych przepływów pracy przy użyciu AI może być wyzwaniem ze względu na przypadkowe i ukryte procesy. W interfejsie programisty Genkit udostępnia inspektor logów czasu, który pozwala sprawdzać logi czasu dla każdego wywołania modelu i kroku w przepływie. Może wyświetlać ślady po produkcji, a nawet renderować obrazy.

8. Otwarte i elastyczne rozwiązania

Ekosystem AI rozwija się szybciej, niż jest w stanie dotrzymać jakikolwiek zespół. Genkit ma otwarty model wtyczki, który udostępnia gotowe integracje z nowymi modelami, modułami pobierania i nie tylko. Zespół Genkit zapewnia niewielki zestaw oficjalnych wtyczek, ale każdy może opublikować własne wtyczki Genkit w NPM.

Nie możesz znaleźć wtyczki do wybranej integracji? Nie ma problemu. Abstrakcje Genkit są elastyczne i umożliwiają łatwe tworzenie niestandardowych komponentów zintegrowanych z platformą, jak na przykład ten niestandardowy tryb do pobierania Firestore:

import { embed } from '@genkit-ai/ai/embedder';
import { Document, defineRetriever } from '@genkit-ai/ai/retriever';
import { textEmbeddingGecko } from '@genkit-ai/vertexai';
import {
  FieldValue,
  VectorQuery,
  VectorQuerySnapshot,
} from '@google-cloud/firestore';
import { Firestore } from 'firebase-admin/firestore';
import * as z from 'zod';
import { augmentedPrompt } from './prompt';

const QueryOptions = z.object({
  k: z.number().optional(),
});

const firestoreArtifactsRetriever = defineRetriever(
  {
    name: 'firestore/artifacts',
    configSchema: QueryOptions,
  },
  async (input, options) => {
    const embedding = await embed({
      embedder: textEmbeddingGecko,
      content: input,
    });

    const db = new Firestore();
    const coll = db.collection('vectors' /* your collection name */);

    const vectorQuery: VectorQuery = coll.findNearest(
      'embedding' /* the name of the field that contains the vector */,
      FieldValue.vector(embedding),
      {
        limit: options.k ?? 3,
        distanceMeasure: 'COSINE',
      }
    );

    const vectorQuerySnapshot: VectorQuerySnapshot = await vectorQuery.get();
    return {
      documents: vectorQuerySnapshot.docs.map((doc) =>
        // doc.data() represents the Firestore document. You may process
        // it as needed to generate a Genkit document object, depending on your
        // storage format.
        Document.fromText(doc.data().content.text)
      ),
    };
  }
);

9. Stworzone z myślą o produkcji

Łatwo wdrażaj przepływy na dowolnej platformie, która może obsługiwać aplikację Express.js. Genkit jest w pełni wyposażony w OpenTelemetry i niestandardowe metadane umożliwiające monitorowanie produkcji na poziomie korporacyjnym.

Dostępne są też oficjalne wtyczki do Google Cloud i Firebase, które pomagają eksportować dane do pakietu operacyjnego Google Cloud i integrować się z usługami Firebase, takimi jak Cloud Functions dla Firebase, Uwierzytelnianie Firebase, Sprawdzanie aplikacji czy Firestore.

10. Autoryzacja i obsługa zabezpieczeń

Podczas tworzenia dowolnej aplikacji dostępnej publicznie należy chronić dane przechowywane w systemie. W przypadku LLM konieczna jest dodatkowa staranność, aby model miał dostęp tylko do danych, do których powinien. Wywołania narzędzi powinny być odpowiednio ograniczone do użytkownika wywołującego ten model, a przepływ jest wywoływany tylko przez zweryfikowane aplikacje klienckie.

Genkit udostępnia mechanizmy zarządzania zasadami i kontekstami autoryzacji.

import { defineFlow, runFlow } from '@genkit-ai/flow';

export const selfSummaryFlow = defineFlow(
  {
    name: 'selfSummaryFlow',
    inputSchema: z.object({uid: z.string()}),
    outputSchema: z.string(),
    authPolicy: (auth, input) => {
      if (!auth) {
        throw new Error('Authorization required.');
      }
      if (input.uid !== auth.uid) {
        throw new Error('You may only summarize your own profile data.');
      }
    }
  },
  async (input) => { ... });

Integracje

Genkit umożliwia integrację z modelami AI, wektorowymi bazami danych, platformami telemetrycznymi i nie tylko za pomocą systemu wtyczek. Tymi wtyczkami obsługuje zespół Genkit:

Oficjalne wtyczki
googleai	Modele generatywne: Gemini Pro, Gemini 1.5 Pro, Gemini Pro Vision Modele osadzone: umieszczanie tekstu gekonu
vertexai	Modele generatywne: Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2, Anthropic Claude 3 Modele osadzone: osadzanie tekstu geko Oceniający: ocena Vertex AI
ollama	Modele generatywne: wiele modeli lokalnych, w tym Gemma, Llama 3 i Mistral
chroma	Baza danych wektorowych: ChromaDB
pinecone	Baza danych wektorowych: Pinecone
google-cloud	Narzędzia do monitorowania: Google Cloud Trace, Google Cloud Logging
firebase	Wdrożenie w chmurze: Cloud Functions, Uwierzytelnianie Firebase, Sprawdzanie aplikacji Baza danych wektorowych: magazyn wektorów Cloud Firestore
langchain	Używaj łańcuchów i narzędzi LangChain w procesach Genkit

Pierwsze kroki

Przeczytaj przewodnik Pierwsze kroki, aby dowiedzieć się, jak zainstalować Genkit i uruchomić pierwszy przepływ AI.