Firebase Genkit

Firebase Genkit to platforma open source, która pomaga w tworzeniu, wdrażaniu i monitorowaniu aplikacji opartych na AI gotowych do produkcji.

Genkit został zaprojektowany z myślą o deweloperach aplikacji. Ma Ci pomóc łatwo zintegrować zaawansowane funkcje AI z aplikacjami o znanych wzorcach i wzorcach. Opracowuje go ten sam zespół, który odpowiada za Firebase, wykorzystując nasze doświadczenie w tworzeniu narzędzi używanych przez miliony deweloperów na całym świecie.

Użyj Genkit, aby tworzyć aplikacje do generowania niestandardowych treści, korzystania z wyszukiwania semantycznego, obsługi nieuporządkowanych danych wejściowych, odpowiadania na pytania za pomocą firmowych baz danych, samodzielnego podejmowania decyzji, administrowania wywołaniami narzędzi i nie tylko.

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

Możesz śledzić jej rozwój lub dodawać własne materiały do repozytorium GitHub.

Najważniejsze funkcje

Genkit pomoże Ci na każdym etapie rozwoju AI – od tworzenia prototypu po monitorowanie w środowisku produkcyjnym. Masz więc wiele do omówienia.

Na początek przedstawiamy 10 najważniejszych funkcji Genkit, które mogą Ci się spodobać:

1. Wiele modeli, jeden interfejs

Genkit zawiera wtyczki, które od razu dają Ci dostęp do popularnych modeli, oraz elastyczną abstrakcję modeli, która ułatwia integrację dowolnego interfejsu API modelu i używanie modeli obsługiwanych przez społeczność. Aby wypróbować nowy model, wystarczy zmienić 1 argument, 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

Generowanie danych o silnym typie za pomocą Genkit przy użyciu schematu Zod. Może to pomóc w analizowaniu nieuporządkowanego tekstu, generowaniu kreatywnych treści, wybieraniu zadań i wysyłaniu wyników z powrotem do aplikacji w postaci uporządkowanych obiektów.

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 to popularny format treści, który obsługuje mieszankę tekstu, danych i dowolnych multimediów. Dzięki temu możesz używać Genkit na potrzeby modeli wykonujących dowolne zadania generatywne (takie jak generowanie obrazów), a nie tylko modele 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. Daj narzędzia LLM

Genkit ułatwia wykonywanie wywołań 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 i 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 promptami za pomocą Dotprompt

Inżynieria to nie tylko wprowadzanie poprawek w tekście. Na jakość danych wyjściowych wpływa używany model, dostarczone parametry i formatowany format. Genkit zawiera Dotprompt – format pliku promptów, który pozwala umieścić wszystko w jednym pliku, aby ułatwić testowanie i uporzą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. Uruchamiaj przepływy lokalnie

Generatywna AI cechuje się dużą zmiennością wyników, dlatego eksperymentowanie jest niezwykle ważne. Lokalny interfejs programisty Genkit umożliwia interakcję z niezbędnymi komponentami AI, takimi jak modele i moduły pobierania, oraz ręczne testowanie kompleksowych procesów z uwzględnieniem całego napisanego przez Ciebie niestandardowego kodu.

7. Sprawdź logi czasu

Debugowanie złożonych, wieloetapowych przepływów pracy za pomocą AI może być trudne ze względu na losowe i ukryte procesy. Genkit udostępnia inspektora śledzenia w interfejsie programisty, który umożliwia badanie logów czasu w przypadku każdego wywołania modelu i kroku w procesie. Może wyświetlać ślady produkcji, a nawet renderować obrazy.

8. Otwarte i elastyczne rozwiązania

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

Nie możesz znaleźć wtyczki do integracji, której potrzebujesz? Nie ma problemu. Abstrakcje Genkit są elastyczne i ułatwiają tworzenie niestandardowych komponentów zintegrowanych z platformą, takich jak ten niestandardowy moduł 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 do produkcji

Łatwo wdrażaj swoje przepływy na dowolnej platformie, która może obsługiwać aplikację Express.js. Genkit jest w pełni wyposażony w platformę OpenTelemetry i niestandardowe metadane, aby monitorować produkcję na potrzeby korporacji.

Istnieją też oficjalne wtyczki do Google Cloud i Firebase, które ułatwiają eksportowanie danych do pakietu operacyjnego Google Cloud i integrację z usługami Firebase, takimi jak Cloud Functions dla Firebase, Uwierzytelnianie Firebase, Sprawdzanie aplikacji i Firestore.

10. Autoryzacja i obsługa zabezpieczeń

Przy tworzeniu aplikacji dostępnych publicznie należy chronić dane przechowywane w Twoim systemie. W przypadku LLM należy zachować szczególną ostrożność, aby mieć pewność, że model uzyskuje dostęp tylko do danych, na których powinien mieć dostęp, wywołania narzędzi są prawidłowo ograniczone do użytkownika wywołującego LLM, a przepływ jest wywoływany tylko przez zweryfikowane aplikacje klienckie.

Genkit zapewnia mechanizmy zarządzania zasadami autoryzacji i kontekstami.

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 zapewnia integrację z modelami AI, bazami danych wektorowych, platformami telemetrycznymi i nie tylko za pomocą systemu wtyczek. Tymi wtyczkami zarządza zespół Genkit:

Oficjalne wtyczki
googleai	Modele generatywne: Gemini Pro, Gemini 1.5 Pro, Gemini Pro Vision Umieszczanie modeli: wstawianie tekstu gekonu
vertexai	Modele generatywne: Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2, Anthropic Claude 3 Umieszczanie modeli: wstawianie tekstu gekonu Ewaluatory: ocena Vertex AI
ollama	Modele generatywne: wiele modeli lokalnych, w tym Gemma, Llama 3 i Mistral.
chroma	Baza danych wektorów: 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 sieci i narzędzi LangChain w procesach Genkit

Pierwsze kroki

Przeczytaj przewodnik dla początkujących, aby dowiedzieć się, jak zainstalować Genkit i uruchomić pierwszy przepływ AI.