Firebase Genkit

O Genkit é um framework projetado para ajudar você a criar aplicativos e recursos com tecnologia de IA. Ele oferece bibliotecas de código aberto para Node.js e Go, além de ferramentas de desenvolvimento para teste e depuração.

Esta documentação aborda o Genkit para Node.js. Se você é um desenvolvedor Go, consulte a documentação do Genkit Go.

Você pode implantar e executar bibliotecas Genkit em qualquer lugar que tenha suporte ao Node.js. Ele foi projetado para funcionar com qualquer API de modelo de IA generativa ou banco de dados vetorial. Oferecemos integrações para o Firebase e o Google Cloud, mas você pode usar o Genkit independentemente dos serviços do Google.

Primeiros passos

Principais recursos

API unificada para geração de IA Use uma API para gerar ou fazer streaming de conteúdo de vários modelos de IA. Funciona com entrada/saída multimodal e configurações de modelo personalizado.
Geração estruturada Gere ou transmita objetos estruturados (como JSON) com validação integrada. Simplifique a integração com seu aplicativo e converta dados não estruturados em um formato usável.
Chamada de ferramenta Permita que os modelos de IA chamem suas funções e APIs como ferramentas para concluir tarefas. O modelo decide quando e quais ferramentas usar.
Geração aumentada de recuperação Melhore a precisão e a relevância da saída gerada integrando seus dados. APIs simples ajudam a incorporar, indexar e recuperar informações de várias fontes.
Modelos de comandos Crie comandos eficientes que incluem modelos em rich text, configurações de modelos, suporte multimodal e integração de ferramentas, tudo em um arquivo de comando compacto e executável.

Confira os exemplos de código abaixo para ter uma ideia concreta de como usar esses recursos no código:

Geração básica

import { generate } from `@genkit-ai/ai`;
import { gemini15Flash, claude3Sonnet, llama31 } from '@genkit-ai/vertexai';
import { gpt4o } from 'genkitx-openai';

// Use the same API to generate content from many models
const result = await generate({
    model: gemini15Flash, // Or use claude3Sonnet, llama31, gpt4o
    prompt: 'What makes you the best LLM out there?',
});

Geração estruturada

import { generate } from `@genkit-ai/ai`;
import { gemini15Flash } from `@genkit-ai/googleai`;
import { z } from `zod`;

const result = await generate({
    model: gemini15Flash,
    prompt: 'Create a brief profile for a character in a fantasy video game.',
    // Specify output structure using Zod schema
    output: {
        schema: z.object({
            name: z.string(),
            role: z.enum(['knight', 'mage', 'archer']),
            backstory: z.string(),
            attacks: z.array(z.object({
              name: z.string(),
              damage: z.number().describe('amount of damage, between 2 and 25'),
            })).describe('3 attacks the character can use')
        })
    }
});

Chamada de ferramenta

import { generate, defineTool } from `@genkit-ai/ai`;
import { gemini15Flash } from `@genkit-ai/googleai`;
import { z } from `zod`;

// Define tool to get weather data for a given location
const lookupWeather = defineTool({
    name: 'lookupWeather',
    description: 'Get the current weather in a location.',
    // Define input and output schema so the model knows how to use the tool
    inputSchema: z.object({
        location: z.string().describe('The location to get the weather for.'),
    }),
    outputSchema: z.object({
        temperature: z.number().describe('The current temperature in Fahrenheit.'),
        condition: z.string().describe('A brief description of the weather conditions.'),
    }),
    async (input) => {
        // Insert weather lookup API code
    }
});

const result = await generate({
    model: gemini15Flash,
    tools: [lookupWeather], // Give the model a list of tools it can call
    prompt: 'What is the weather like in New York? ',
});

Recuperação

import { generate, retrieve } from `@genkit-ai/ai`;
import { devLocalRetrieverRef } from '@genkit-ai/dev-local-vectorstore';
import { gemini15Flash } from `@genkit-ai/googleai`;

// Sample assumes Genkit documentation has been chunked, stored, and indexed in 
// local vectorstore in previous step.

// Reference to a local vector database storing Genkit documentation
const retriever = devLocalRetrieverRef('genkitQA');

const query = 'How do I retrieve relevant documents in Genkit?'

// Consistent API to retrieve most relevant documents based on semantic similarity to query
const docs = await retrieve({
    retriever: retriever,
    query: query,
    options: { limit: 5 },
});

const result = await generate({
    model: gemini15Flash
    prompt: 'Use the provided context from the Genkit documentation to answer this query: ${query}',
    context: docs // Pass retrieved documents to the model
});

Modelo de comando

---
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}}.

Ferramentas para Desenvolvedores

O Genkit oferece uma interface de linha de comando (CLI) e uma interface de desenvolvedor local para facilitar a criação de aplicativos de IA. Essas ferramentas ajudam você a:

  • Experimento:teste e refine funções, comandos e consultas de IA.
  • Depuração:encontre e corrija problemas com traces de execução detalhados.
  • Avaliar:avalie os resultados gerados em vários casos de teste.

Siga-nos

  • Participe da comunidade:fique por dentro, faça perguntas e compartilhe seu trabalho no servidor do Discord.
  • Envie feedback:informe problemas ou sugira novos recursos usando o Issue Tracker do GitHub.

Próximas etapas

Aprenda a criar seu primeiro aplicativo de IA com o Genkit no nosso guia Para iniciantes.