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 { gemini15Flash } 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(gemini15Flash, '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 { gemini15Flash } 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: gemini15Flash,
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, gemini15Flash } 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: gemini15Flash,
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 { gemini15Flash } 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: gemini15Flash,
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.5-flash
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.