Firebase Genkit

Genkit è un framework progettato per aiutarti a creare applicazioni e funzionalità basate sull'IA. Fornisce librerie open source per Node.js e Go, oltre a strumenti per sviluppatori per test e debug.

Questa documentazione riguarda Genkit per Node.js. Se sei uno sviluppatore Go, consulta la documentazione di Genkit Go.

Puoi eseguire il deployment e l'esecuzione delle librerie Genkit ovunque sia supportato Node.js. È progettato per funzionare con qualsiasi API di modello di IA generativa o database vettoriale. Sebbene offriamo integrazioni per Firebase e Google Cloud, puoi utilizzare Genkit indipendentemente da qualsiasi servizio Google.

Inizia

Funzionalità chiave

API unificata per la generazione di AI Utilizza un'API per generare o riprodurre in streaming contenuti da vari modelli di IA. Funziona con input/output multimodali e impostazioni del modello personalizzate.
Output strutturato Genera o riproduci in streaming oggetti strutturati (come JSON) con convalida integrata. Semplifica l'integrazione con la tua app e converti i dati non strutturati in un formato utilizzabile.
Chiamate di strumenti Consenti ai modelli di IA di chiamare le tue funzioni e API come strumenti per completare le attività. Il modello decide quando e quali strumenti utilizzare.
Chat Genkit offre un'API specifica per le chat che facilita le conversazioni multi-turno con i modelli di IA, che possono essere con stato e persistenti.
Agenti Crea agenti intelligenti che utilizzano strumenti (inclusi altri agenti) per automatizzare attività e flussi di lavoro complessi.
Recupero dei dati Migliora l'accuratezza e la pertinenza dell'output generato integrando i tuoi dati. API semplici ti aiutano a incorporare, indicizzare e recuperare informazioni da varie fonti.
Modelli di prompt Crea prompt efficaci che includono modelli di testo avanzato, impostazioni del modello, supporto multimodale e integrazione di strumenti, il tutto in un file prompt eseguibile e compatto.

Consulta gli esempi di codice riportati di seguito per avere un'idea concreta di come utilizzare queste funzionalità nel codice:

Generazione di base

import { genkit } from 'genkit';
import { googleAI, gemini15Flash } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,  // Set default model
});

// Simple generation
const { text } = await ai.generate('Why is AI awesome?');
console.log(text);

// Streamed generation 
const { stream } = await ai.generateStream('Tell me a story');
for await (const chunk of stream) {
  console.log(chunk.text);
}

Output strutturato

import { genkit, z } from 'genkit';
import { googleAI, gemini15Flash } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const { output } = await ai.generate({
  prompt: 'Create a brief profile for a character in a fantasy video game.',
  // Specify output structure using Zod schema
  output: {
    format: 'json',  
    schema: z.object({
      name: z.string(),
      role: z.enum(['knight', 'mage', 'archer']),
      backstory: z.string(),
    }),
  },
});

console.log(output);

Chiamata di funzione

import { genkit, z } from 'genkit';
import { googleAI, gemini15Flash } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

// Define tool to get current weather for a given location
const getWeather = ai.defineTool(
  {
    name: "getWeather",
    description: "Gets the current weather in a given location",
    inputSchema: z.object({ 
      location: z.string().describe('The location to get the current weather for')
    }),
    outputSchema: z.string(),
  },
  async (input) => {
    // Here, we would typically make an API call or database query. For this
    // example, we just return a fixed value.
    return `The current weather in ${input.location} is 63°F and sunny.`;
  }
);

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

console.log(text);

Chat

import { genkit, z } from 'genkit';
import { googleAI, gemini15Flash } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

const chat = ai.chat({ system: 'Talk like a pirate' });

let response = await chat.send('Hi, my name is Pavel');

response = await chat.send('What is my name?');
console.log(response.text);
// Ahoy there! Your name is Pavel, you scurvy dog

Agenti

import { genkit, z } from 'genkit';
import { googleAI, gemini15Flash } from '@genkit-ai/googleai';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

// Define prompts that represent specialist agents
const reservationAgent = ai.definePrompt(
  {
    name: 'reservationAgent',
    description: 'Reservation Agent can help manage guest reservations',
    tools: [reservationTool, reservationCancelationTool, reservationListTool],

  },
  `{{role "system"}} Help guests make and manage reservations`
);

const menuInfoAgent = ...
const complaintAgent = ...

// Define a triage agent that routes to the proper specialist agent
const triageAgent = ai.definePrompt(
  {
    name: 'triageAgent',
    description: 'Triage Agent',
    tools: [reservationAgent, menuInfoAgent, complaintAgent],
  },
  `{{role "system"}} You are an AI customer service agent for Pavel's Cafe.
  Greet the user and ask them how you can help. If appropriate, transfer to an
  agent that can better handle the request. If you cannot help the customer with
  the available tools, politely explain so.`
);

// Create a chat to enable multi-turn agent interactions
const chat = ai.chat(triageAgent);

chat.send('I want a reservation at Pavel\'s Cafe for noon on Tuesday.' );

Recupero dei dati

import { genkit } from 'genkit';
import { googleAI, gemini15Flash, textEmbedding004 } from '@genkit-ai/googleai';
import { devLocalRetrieverRef } from '@genkit-ai/dev-local-vectorstore';

const ai = genkit({ 
  plugins: [
    googleAI()
    devLocalVectorstore([
      {
        indexName: 'BobFacts',
        embedder: textEmbedding004,
      },
    ]),
  ],
  model: gemini15Flash,
});

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

// Consistent API to retrieve most relevant documents based on semantic similarity to query
const docs = await ai.retrieve(
  retriever: retriever,
  query: 'How old is bob?',
);

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

Modello di prompt

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

Strumenti di sviluppo

Genkit fornisce un'interfaccia a riga di comando (CLI) e un'interfaccia utente per sviluppatori locale per semplificare la creazione di applicazioni di IA. Questi strumenti ti aiutano a:

  • Sperimenta:testa e perfeziona le funzioni, i prompt e le query di IA.
  • Debug:trova e correggi i problemi con tracce di esecuzione dettagliate.
  • Valuta:valuta i risultati generati in più casi di test.

Contattaci

  • Unisciti alla community:ricevi aggiornamenti, fai domande e condividi il tuo lavoro sul nostro server Discord.
  • Fornisci feedback:segnala i problemi o suggerisci nuove funzionalità utilizzando il nostro issue tracker di GitHub.

Passaggi successivi

Scopri come creare la tua prima applicazione di IA con Genkit nella nostra guida Introduzione.