Genkit do Firebase

O Firebase Genkit é um framework de código aberto que ajuda a criar, implantar e monitorar apps com tecnologia de IA prontos para produção.

O Genkit foi desenvolvido para desenvolvedores de apps para ajudar você a integrar facilmente recursos avançados de IA aos seus apps com padrões e paradigmas conhecidos. Ele foi desenvolvido pela mesma equipe do Firebase, aproveitando nossa experiência na criação de ferramentas usadas por milhões de desenvolvedores em todo o mundo.

Use o Genkit para criar apps que geram conteúdo personalizado, usam a pesquisa semântica, processam entradas não estruturadas, respondem a perguntas com seus dados da empresa, tomam decisões de forma autônoma, orquestram chamadas de ferramentas e muito mais.

Atualmente, o Genkit é compatível com o desenvolvimento do lado do servidor em JavaScript/TypeScript (Node.js) com suporte para Go em desenvolvimento ativo.

Acompanhe o desenvolvimento dele ou faça suas contribuições no repositório do GitHub (link em inglês).

principais recursos

O Genkit está aqui para ajudar você em cada etapa da sua jornada de desenvolvimento de IA, desde o início da prototipagem até o monitoramento na produção. Portanto, há muito o que falar.

Para começar, confira os 10 principais recursos do Genkit que você vai adorar:

1. Muitos modelos, uma interface

O Genkit fornece plug-ins que dão acesso a modelos conhecidos prontos para uso, além de uma abstração de modelos flexível que facilita a integração de qualquer API de modelo e o uso de modelos mantidos pela comunidade. Testar um novo modelo é tão fácil quanto alterar um único argumento, mas cada modelo pode especificar configurações personalizadas.

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. Saída estruturada

Gerar dados fortemente tipados com o Genkit usando o esquema Zod. Isso pode ajudar você a analisar textos não estruturados, gerar conteúdo criativo, selecionar tarefas e enviar resultados ao app como objetos estruturados com segurança de tipos.

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. Multimodal, multimídia

O Genkit fornece um formato comum para conteúdo que oferece suporte a combinações de texto, dados e mídia arbitrária. Isso permite que você use o Genkit para modelos que executam qualquer tarefa generativa, como a geração de imagens, não apenas LLMs.

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. Fornecer ferramentas aos LLMs

O Genkit simplifica a chamada de funções com LLMs usando ferramentas. As ferramentas permitem que a IA busque dados, mostre a interface, grave em um banco de dados ou realize qualquer outra ação que possa ser codificada.

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. Gerenciamento de comandos com o Dotprompt

A engenharia de comandos vai além do simples ajuste de texto. O modelo usado, os parâmetros fornecidos e o formato solicitado afetam a qualidade da saída. O Genkit oferece o Dotprompt, um formato de arquivo de comando que permite colocar tudo em um único arquivo para facilitar os testes e a organização.

---
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. Executar fluxos localmente

A IA generativa tem uma grande variação nos resultados, por isso testar é muito importante. A interface do desenvolvedor local do Genkit permite interagir com componentes essenciais de IA, como modelos e recuperadores, além de testar manualmente os fluxos completos, incluindo todo o código personalizado que você escreveu.

7. Inspecionar rastros

Depurar fluxos de trabalho complexos e de várias etapas com IA pode ser desafiador devido à aleatoriedade e aos processos ocultos. O Genkit oferece um inspetor de rastreamento na interface do desenvolvedor que permite inspecionar os traces para cada chamada de modelo e etapa do fluxo. Ele pode visualizar traces da produção e até mesmo renderizar imagens.

8. Aberto e extensível

O ecossistema de IA está crescendo mais rápido do que uma equipe consegue acompanhar. O Genkit tem um modelo de plug-in aberto que fornece integrações pré-criadas com novos modelos, recuperadores e muito mais. Enquanto a equipe do Genkit mantém um pequeno conjunto de plug-ins oficiais, qualquer pessoa pode publicar seus próprios plug-ins no NPM.

Não consegue encontrar um plug-in para uma integração específica que você quer? Sem problemas. As abstrações do Genkit são flexíveis e facilitam a criação de componentes personalizados que se integram ao framework, como este recuperador do Firestore personalizado:

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. Criado para produção

Implante seus fluxos com facilidade em qualquer plataforma que atenda um app Express.js. O Genkit é totalmente instrumentado com o OpenTelemetry e os metadados personalizados para monitoramento de produção de nível empresarial.

Também há plug-ins oficiais para o Google Cloud e o Firebase que ajudam a exportar dados para o pacote de operações do Google Cloud e fazer a integração com serviços do Firebase, como Cloud Functions para Firebase, Firebase Authentication, App Check e Firestore.

10. Autorização e processamento de segurança

Ao criar qualquer aplicativo público, é importante proteger os dados armazenados em seu sistema. Quando se trata de LLMs, é necessário ter mais cuidado para garantir que o modelo acesse apenas os dados necessários, as chamadas de ferramentas sejam definidas corretamente para o usuário que invoca o LLM e o fluxo seja invocado apenas por aplicativos cliente verificados.

O Genkit tem mecanismos para gerenciar contextos e políticas de autorização.

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) => { ... });

Integrações

O Genkit fornece integrações com modelos de IA, bancos de dados de vetores, plataformas de telemetria e muito mais por meio do sistema de plug-ins. Os plug-ins a seguir são mantidos pela equipe do Genkit:

Plug-ins oficiais
googleai	Modelos generativos: Gemini Pro, Gemini 1.5 Pro, Gemini Pro Vision Modelos de embedding: embedding de texto Gecko
vertexai	Modelos generativos: Gemini Pro, Gemini Pro Vision, Gemini 1.5 Flash, Gemini 1.5 Pro, Imagen2, Anthropic Claude 3 Modelos de embedding: embedding de texto Gecko Avaliadores: avaliação da Vertex AI
ollama	Modelos generativos: muitos modelos locais, incluindo Gemma, Llama 3, Mistral e muito mais
chroma	Banco de dados de vetores: ChromaDB
pinecone	Banco de dados de vetores: Pinecone
google-cloud	Ferramentas de monitoramento: Google Cloud Trace, Google Cloud Logging
firebase	Implantação do Cloud: Cloud Functions, Firebase Authentication, App Check Banco de dados vetorial: repositório de vetores do Cloud Firestore
langchain	Usar cadeias e utilitários do LangChain em fluxos do Genkit

Começar

Leia o guia Primeiros passos para saber como instalar o Genkit e executar seu primeiro fluxo de IA.