Genkit do Firebase

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

O Genkit foi projetado para desenvolvedores de apps (link em inglês) para ajudar a integrar facilmente recursos avançados de IA aos seus aplicativos 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 aplicativos que geram conteúdo personalizado, usam pesquisa semântica, processam entradas não estruturadas, respondem a perguntas com seus dados da empresa, tomam decisões de maneira 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 ou faça você mesmo no repositório do GitHub (link em inglês).

principais recursos

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

Para começar, confira estes 10 recursos principais do Genkit que podem ser do seu interesse:

1. Muitos modelos, uma interface

O Genkit fornece plug-ins que dão acesso a modelos conhecidos prontos para uso e uma abstração de modelo 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 para o app como objetos estruturados com segurança de tipo.

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 oferece um formato comum para conteúdo compatível com combinações de texto, dados e mídia arbitrária. Isso permite usar o Genkit para modelos que executam qualquer tarefa generativa (como 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 para LLMs

O Genkit simplifica a realização de chamadas de função com LLMs usando ferramentas. As ferramentas permitem que a IA busque dados, exiba a interface, grave em um banco de dados ou realize qualquer outra ação que você possa programar.

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 prompts é mais do que apenas ajustar textos. 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 prompt que permite colocar tudo em um único arquivo para facilitar testes e 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 variedade de resultados, então testar é muito importante. A interface local do desenvolvedor do Genkit permite interagir com componentes essenciais de IA, como modelos e extraídores, bem como testar manualmente seus fluxos de ponta a ponta, incluindo todo o código personalizado que você escreveu.

7. Inspecionar rastros

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

8. Aberto e extensível

O ecossistema de IA está crescendo mais rápido do que qualquer equipe consegue acompanhar. O Genkit tem um modelo de plug-in aberto que fornece integrações pré-criadas com novos modelos, coletores e muito mais. Embora a equipe do Genkit mantenha um pequeno conjunto de plug-ins oficiais, qualquer pessoa pode ficar à vontade para publicar seus próprios plug-ins do Genkit para o NPM.

Não consegue encontrar um plug-in para uma integração específica que você quer? Não tem problema. As abstração do Genkit são flexíveis e facilitam a criação de componentes personalizados que se integram ao framework, como este recuperador personalizado do 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. Criado para produção

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

Também existem plug-ins oficiais para o Google Cloud e o Firebase que ajudam você a exportar dados para o pacote de operações do Google Cloud e integrá-los aos serviços do Firebase, como Cloud Functions para Firebase, Firebase Authentication, App Check e Firestore.

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

Ao criar qualquer aplicativo público, é importante proteger os dados armazenados no seu sistema. Quando se trata de LLMs, é necessária uma diligência extra para garantir que o modelo acesse apenas os dados necessários, que as chamadas de ferramentas tenham o escopo correto do usuário que invoca o LLM e o fluxo seja invocado somente por aplicativos clientes verificados.

O Genkit fornece mecanismos para gerenciar políticas e contextos 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 vetoriais, plataformas de telemetria e muito mais por meio do sistema de plug-ins. Os plug-ins abaixo 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: incorporação 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 de vetores: armazenamento de vetores do Cloud Firestore
langchain	Usar cadeias e utilitários do LangChain em fluxos do Genkit

Começar

Leia o guia Introdução para saber como instalar o Genkit e executar seu primeiro fluxo de IA.