Generazione di contenuti con modelli di IA

Al centro dell'IA generativa ci sono i modelli di IA. Attualmente, i due esempi più importanti di modelli generativi sono i modelli linguistici di grandi dimensioni (LLM) e i modelli di generazione di immagini. Questi modelli accettano un input, chiamato prompt (in genere testo, un'immagine o una combinazione di entrambi), e producono come output testo, un'immagine o persino audio o video.

L'output di questi modelli può essere sorprendentemente convincente: gli LLM generano testo che sembra poter essere stato scritto da un essere umano e i modelli di generazione di immagini possono produrre immagini molto simili a fotografie reali o artwork creati da persone.

Inoltre, gli LLM si sono dimostrati in grado di svolgere attività oltre la semplice generazione di testo:

  • Scrittura di programmi per computer
  • Pianificare le attività secondarie necessarie per completare un'attività più grande
  • Organizzazione di dati non organizzati
  • Comprendere ed estrarre dati informativi da un corpus di testo
  • Seguire ed eseguire attività automatiche in base a una descrizione testuale dell'attività

Sono disponibili molti modelli di diversi fornitori. Ogni modello ha i suoi punti di forza e di debolezza e un modello potrebbe eccellere in un compito ma avere un rendimento inferiore in altri. Le app che utilizzano l'IA generativa possono spesso beneficiare dell'utilizzo di più modelli diversi a seconda dell'attività da svolgere.

In qualità di sviluppatore di app, in genere non interagisci direttamente con i modelli di IA generativa, ma tramite servizi disponibili come API web. Sebbene questi servizi abbiano spesso funzionalità simili, li forniscono tutti tramite API diverse e incompatibili. Se vuoi utilizzare più servizi di modelli, devi utilizzare ciascuno dei relativi SDK proprietari, potenzialmente incompatibili tra loro. Inoltre, se vuoi eseguire l'upgrade da un modello all'altro, quello più recente e più capace, potresti dover creare di nuovo l'integrazione.

Genkit risolve questo problema fornendo un'unica interfaccia che astrae i dettagli per accedere a qualsiasi servizio di modelli di IA generativa, con diverse implementazioni predefinite già disponibili. La creazione di un'app basata sull'IA con Genkit semplifica il processo di esecuzione della prima chiamata di IA generativa e rende altrettanto facile combinare più modelli o sostituirne uno con un altro man mano che vengono sviluppati nuovi modelli.

Prima di iniziare

Se vuoi eseguire gli esempi di codice in questa pagina, completa prima i passaggi descritti nella guida Introduzione. Tutti gli esempi presuppongono che tu abbia già installato Genkit come dipendenza nel tuo progetto.

Modelli supportati da Genkit

Genkit è progettato per essere sufficientemente flessibile da utilizzare potenzialmente qualsiasi servizio di modelli di IA generativa. Le librerie di base definiscono l'interfaccia comune per lavorare con i modelli, mentre i plug-in dei modelli definiscono i dettagli di implementazione per lavorare con un modello specifico e la relativa API.

Il team di Genkit gestisce i plug-in per lavorare con i modelli forniti da Vertex AI, Google Generative AI e Ollama:

  • La famiglia di LLM Gemini tramite il plug-in Vertex AI di Google Cloud
  • La famiglia di LLM Gemini, tramite il plug-in di IA di Google
  • Modelli di generazione di immagini Imagen2 e Imagen3 tramite Vertex AI di Google Cloud
  • La famiglia di LLM Claude 3 di Anthropic, tramite il garden di modelli di Google Cloud Vertex AI
  • Gemma 2, Llama 3 e molti altri modelli aperti tramite il plug-in Ollama (devi ospitare autonomamente il server Ollama)

Esistono anche diversi plug-in supportati dalla community che forniscono interfacce a questi modelli:

Per scoprire di più, cerca i pacchetti taggati con genkit-model su npmjs.org.

Caricamento e configurazione dei plug-in dei modelli

Prima di poter utilizzare Genkit per iniziare a generare contenuti, devi caricare e configurare un plug-in del modello. Se proveni dalla guida introduttiva, lo hai già fatto. In caso contrario, consulta la guida Guida introduttiva o la documentazione del singolo plug-in e segui i passaggi indicati prima di continuare.

Il metodo generate()

In Genkit, l'interfaccia principale tramite la quale interagisci con i modelli di IA generativa è il metodo generate().

La chiamata generate() più semplice specifica il modello che vuoi utilizzare e un prompt di testo:

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

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

(async () => {
  const { text } = await ai.generate(
    'Invent a menu item for a pirate themed restaurant.'
  );
  console.log(text);
})();

Quando esegui questo breve esempio, vengono stampate alcune informazioni di debug followed by the output of the generate() call, which will usually be Markdown text as in the following example:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

Esegui di nuovo lo script e otterrai un output diverso.

Il precedente esempio di codice ha inviato la richiesta di generazione al modello predefinito, che hai specificato durante la configurazione dell'istanza Genkit.

Puoi anche specificare un modello per una singola chiamata generate():

const { text } = await ai.generate({
  model: gemini15Pro,
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Questo esempio utilizza un riferimento modello esportato dal plug-in del modello. Un'altra opzione è specificare il modello utilizzando un identificatore di stringa:

const { text } = await ai.generate({
  model: 'googleai/gemini-1.5-pro-latest',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Un identificatore di stringa del modello ha il seguente aspetto: providerid/modelid, dove l'ID provider (in questo caso googleai) identifica il plug-in e l'ID modello è un identificatore di stringa specifico del plug-in per una versione specifica di un modello.

Alcuni plug-in dei modelli, come il plug-in Ollama, forniscono l'accesso a potenzialmente decine di modelli diversi e, pertanto, non esportano i riferimenti ai singoli modelli. In questi casi, puoi specificare un modello per generate() solo utilizzando il relativo identificatore di stringa.

Questi esempi illustrano anche un punto importante: quando utilizzi generate() per effettuare chiamate ai modelli di IA generativa, cambiare il modello che vuoi utilizzare è semplicemente una questione di passaggio di un valore diverso al parametro del modello. Se utilizzi generate() anziché gli SDK dei modelli nativi, hai la flessibilità di utilizzare più facilmente diversi modelli nella tua app e di modificarli in futuro.

Finora hai visto solo esempi delle chiamate generate() più semplici. Tuttavia, generate() fornisce anche un'interfaccia per interazioni più avanzate con i modelli generativi, che vedrai nelle sezioni che seguono.

Prompt di sistema

Alcuni modelli supportano la fornitura di un prompt di sistema, che fornisce al modello le istruzioni su come vuoi che risponda ai messaggi dell'utente. Puoi utilizzare il prompt di sistema per specificare la persona che vuoi che il modello adotti, il tono delle sue risposte, il formato delle sue risposte e così via.

Se il modello che utilizzi supporta i prompt di sistema, puoi fornirne uno con il parametro system:

const { text } = await ai.generate({
  system: 'You are a food industry marketing consultant.',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

Parametri del modello

La funzione generate() utilizza un parametro config, tramite il quale puoi specificare impostazioni facoltative che controllano il modo in cui il modello genera i contenuti:

const { text } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  config: {
    maxOutputTokens: 400,
    stopSequences: ['<end>', '<fin>'],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

I parametri esatti supportati dipendono dal singolo modello e dall'API del modello. Tuttavia, i parametri nell'esempio precedente sono comuni a quasi tutti i modelli. Di seguito è riportata una spiegazione di questi parametri:

Parametri che controllano la lunghezza dell'output

maxOutputTokens

Gli LLM operano su unità chiamate token. Un token in genere, ma non necessariamente, viene mappato a una sequenza specifica di caratteri. Quando passi un prompt a un modello, uno dei primi passaggi consiste nel tokenizzare la stringa del prompt in una sequenza di token. L'LLM genera quindi una sequenza di token dall'input tokenizzato. Infine, la sequenza di token viene convertita di nuovo in testo, che è l'output.

Il parametro Token di output massimi imposta semplicemente un limite al numero di token da generare utilizzando l'LLM. Ogni modello utilizza potenzialmente un tokenizzatore diverso, ma una buona regola empirica è considerare una singola parola inglese composta da 2-4 token.

Come affermato in precedenza, alcuni token potrebbero non essere mappati a sequenze di caratteri. Un esempio di questo tipo è che spesso esiste un token che indica la fine della sequenza: quando un LLM genera questo token, smette di generarne altri. Pertanto, è possibile e spesso accade che un LLM generi meno token rispetto al massimo perché ha generato il token "stop".

stopSequences

Puoi utilizzare questo parametro per impostare i token o le sequenze di token che, se generati, indicano la fine dell'output dell'LLM. I valori corretti da utilizzare qui in genere dipendono da come è stato addestrato il modello e di solito vengono impostati dal plug-in del modello. Tuttavia, se hai chiesto al modello di generare un'altra sequenza di fermate, puoi specificarla qui.

Tieni presente che stai specificando sequenze di caratteri e non token in sé. Nella maggior parte dei casi, specificherai una sequenza di caratteri che lo tokenizer del modello mappa a un singolo token.

Parametri che controllano "creativity"

I parametri temperature, top-p e top-k controllano insieme il livello di "creatività" del modello. Di seguito sono riportate spiegazioni molto brevi del significato di questi parametri, ma il punto più importante da ricordare è che questi parametri vengono utilizzati per regolare il carattere dell'output di un modello LLM. I valori ottimali dipendono dai tuoi obiettivi e dalle tue preferenze e probabilmente possono essere trovati solo tramite la sperimentazione.

temperature

Gli LLM sono essenzialmente macchine di previsione dei token. Per una determinata sequenza di token (come il prompt), un LLM prevede, per ogni token nel suo vocabolario, la probabilità che il token sia il successivo nella sequenza. La temperatura è un coefficiente di scala per cui queste previsioni vengono divise prima di essere normalizzate a una probabilità compresa tra 0 e 1.

I valori di temperatura bassi, compresi tra 0,0 e 1,0, amplificano la differenza di probabilità tra i token, con il risultato che il modello avrà meno probabilità di produrre un token già valutato come improbabile. Ciò viene spesso percepito come un output meno creativo. Anche se tecnicamente 0, 0 non è un valore valido, molti modelli lo considerano come un'indicazione del fatto che il modello deve comportarsi in modo deterministico e considerare solo il token più probabile.

I valori di temperatura elevati, ovvero quelli maggiori di 1, comprimono le differenze di probabilità tra i token, con il risultato che il modello diventa più propenso a produrre token che in precedenza aveva valutato come improbabili. Ciò viene spesso percepito come un risultato più creativo. Alcune API di modelli impongono una temperatura massima, spesso 2.0.

topP

Top-p è un valore compreso tra 0,0 e 1,0 che controlla il numero di possibili token che vuoi che il modello prenda in considerazione, specificando la probabilità cumulativa dei token. Ad esempio, un valore pari a 1,0 significa prendere in considerazione ogni possibile token (tenendo comunque conto della probabilità di ciascun token). Un valore di 0,4 significa considerare solo i token più probabili, le cui probabilità si sommano a 0,4, ed escludere i token rimanenti.

topK

Top-K è un valore intero che controlla anche il numero di token possibili che vuoi che il modello prenda in considerazione, ma questa volta specificando esplicitamente il numero massimo di token. Se specifichi un valore pari a 1, il modello deve comportarsi in modo deterministico.

Sperimenta con i parametri del modello

Puoi sperimentare l'effetto di questi parametri sull'output generato da diverse combinazioni di modelli e prompt utilizzando l'interfaccia utente per gli sviluppatori. Avvia l'interfaccia utente per gli sviluppatori con il comando genkit start e verranno caricati automaticamente tutti i modelli definiti dai plug-in configurati nel progetto. Puoi provare rapidamente diversi prompt e valori di configurazione senza dover apportare ripetutamente queste modifiche al codice.

Output strutturato

Quando utilizzi l'IA generativa come componente della tua applicazione, spesso vuoi un output in un formato diverso dal testo normale. Anche se stai solo generando contenuti da mostrare all'utente, puoi trarre vantaggio dall'output strutturato semplicemente per presentarli in modo più accattivante. Tuttavia, per applicazioni più avanzate dell'IA generativa, come l'utilizzo programmatico dell'output del modello o l'alimentazione dell'output di un modello in un altro, l'output strutturato è un must.

In Genkit, puoi richiedere un output strutturato da un modello specificando uno schema quando chiami generate():

import { z } from 'genkit'; // Import Zod, which is re-exported by Genkit.

const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.number(),
  allergens: z.array(z.string()),
});

const { output } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  output: { schema: MenuItemSchema },
});

Gli schemi di output del modello vengono specificati utilizzando la libreria Zod. Oltre a un linguaggio di definizione dello schema, Zod fornisce anche il controllo dei tipi di runtime, che colma il divario tra i tipi di TypeScript statici e l'output imprevedibile dei modelli di AI generativa. Zod ti consente di scrivere codice che può basarsi sul fatto che una chiamata generate andata a buon fine restituirà sempre un output conforme ai tuoi tipi TypeScript.

Quando specifichi uno schema in generate(), Genkit esegue diverse operazioni dietro le quinte:

  • Amplia il prompt con ulteriori indicazioni sul formato di output desiderato. Questo ha anche l'effetto collaterale di specificare al modello esattamente quali contenuti vuoi generare (ad esempio, non solo suggerire un elemento del menu, ma anche generare una descrizione, un elenco di allergeni e così via).
  • Analizza l'output del modello in un oggetto JavaScript.
  • Verifica che l'output sia conforme allo schema.

Per ottenere un output strutturato da una chiamata generate andata a buon fine, utilizza la proprietà output dell'oggetto risposta:

if (output) {
  const { name, description, calories, allergens } = output;
}

Gestione degli errori

Nell'esempio precedente, tieni presente che la proprietà output può essere null. Questo può accadere quando il modello non riesce a generare un output conforme allo schema. La strategia migliore per gestire questi errori dipende dal caso d'uso esatto, ma di seguito sono riportati alcuni suggerimenti generali:

  • Prova un altro modello. Affinché l'output strutturato vada a buon fine, il modello deve essere in grado di generare output in JSON. I modelli linguistici di grandi dimensioni più potenti, come Gemini e Claude, sono abbastanza versatili per farlo; tuttavia, i modelli più piccoli, come alcuni dei modelli locali che utilizzeresti con Ollama, potrebbero non essere in grado di generare output strutturati in modo affidabile, a meno che non siano stati addestrati specificamente per farlo.

  • Utilizza le funzionalità di coercizione di Zod: puoi specificare negli schemi che Zod debba provare a forzare i tipi non conformi nel tipo specificato dallo schema. Se lo schema include tipi primitivi diversi dalle stringhe, l'utilizzo della coercizione di Zod può ridurre il numero di errori generate() riscontrati. La seguente versione di MenuItemSchema utilizza la coercizione di tipo per correggere automaticamente le situazioni in cui il modello genera informazioni sulle calorie come stringa invece che come numero:

    const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.coerce.number(),
  allergens: z.array(z.string()),
});

  • Riprova a eseguire la chiamata generate(). Se il modello che hai scelto raramente non riesce a generare un output conforme, puoi trattare l'errore come faresti con un errore di rete e semplicemente riprovare a inviare la richiesta utilizzando una sorta di strategia di backoff incrementale.

Streaming

Quando generi grandi quantità di testo, puoi migliorare l'esperienza degli utenti presentando l'output man mano che viene generato, ovvero in streaming. Un esempio familiare di streaming in azione può essere visto nella maggior parte delle app di chat LLM: gli utenti possono leggere la risposta del modello al loro messaggio durante la generazione, il che migliora la reattività percepita dell'applicazione e migliora la illusione di chattare con una controparte intelligente.

In Genkit, puoi eseguire lo streaming dell'output utilizzando il metodo generateStream(). La sua sintassi è simile a quella del metodo generate():

const { response, stream } = await ai.generateStream(
  'Suggest a complete menu for a pirate themed restaurant.'
);

L'oggetto risposta ha una proprietà stream, che puoi utilizzare per eseguire l'iterazione sull'output in streaming della richiesta man mano che viene generata:

for await (const chunk of stream) {
  console.log(chunk.text);
}

Puoi anche ottenere l'output completo della richiesta, come per una richiesta non in streaming:

const completeText = (await response).text;

Lo streaming funziona anche con l'output strutturato:

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});

const { response, stream } = await ai.generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant.',
  output: { schema: MenuSchema },
});

for await (const chunk of stream) {
  // `output` is an object representing the entire output so far.
  console.log(chunk.output);
}

// Get the completed output.
const { output } = await response;

L'output strutturato in streaming funziona in modo leggermente diverso dal testo in streaming: la proprietà output di un chunk di risposta è un oggetto costruito dall'accumulo dei chunk prodotti fino a quel momento, anziché un oggetto che rappresenta un singolo chunk (che potrebbe non essere valido da solo). In un certo senso, ogni frammento di output strutturato sostituisce il frammento precedente.

Ad esempio, ecco come potrebbero essere i primi cinque output dell'esempio precedente:

null

{ starters: [ {} ] }

{
  starters: [ { name: "Captain's Treasure Chest", description: 'A' } ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350
    }
  ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350,
      allergens: [Array]
    },
    { name: 'Shipwreck Salad', description: 'Fresh' }
  ]
}

Input multimodale

Gli esempi che hai visto finora hanno utilizzato stringhe di testo come prompt del modello. Anche se rimane il modo più comune per fornire prompt ai modelli di IA generativa, molti modelli possono anche accettare altri contenuti multimediali come prompt. I prompt multimediali vengono utilizzati più spesso in combinazione con prompt di testo che chiedono al modello di eseguire alcune operazioni sui contenuti multimediali, ad esempio aggiungere una didascalia a un'immagine o trascrivere una registrazione audio.

La possibilità di accettare input multimediali e i tipi di contenuti multimediali che puoi utilizzare dipendono completamente dal modello e dalla relativa API. Ad esempio, la serie di modelli Gemini 1.5 può accettare immagini, video e audio come prompt.

Per fornire un prompt multimediale a un modello che lo supporta, anziché passare un semplice prompt di testo a generate, passa un array composto da una parte multimediale e una parte di testo:

const { text } = await ai.generate([
  { media: { url: 'https://example.com/photo.jpg' } },
  { text: 'Compose a poem about this image.' },
]);

Nell'esempio precedente, hai specificato un'immagine utilizzando un URL HTTPS accessibile pubblicamente. Puoi anche passare i dati multimediali direttamente codificandoli come URL di dati. Ad esempio:

import { readFile } from 'node:fs/promises';

const b64Data = await readFile('photo.jpg', { encoding: 'base64url' });
const dataUrl = `data:image/jpeg;base64,${b64Data}`;

const { text } = await ai.generate([
  { media: { url: dataUrl } },
  { text: 'Compose a poem about this image.' },
]);

Tutti i modelli che supportano l'input di contenuti multimediali supportano sia gli URL di dati sia gli URL HTTPS. Alcuni plug-in dei modelli aggiungono il supporto di altre origini multimediali. Ad esempio, il plug-in Vertex AI consente anche di utilizzare gli URL di Cloud Storage (gs://).

Generazione di contenuti multimediali

Finora, la maggior parte degli esempi in questa pagina ha riguardato la generazione di testo utilizzando gli LLM. Tuttavia, Genkit può essere utilizzato anche con i modelli di generazione di immagini. L'utilizzo di generate() con un modello di generazione di immagini è simile all'utilizzo di un LLM. Ad esempio, per generare un'immagine utilizzando il modello Imagen2 tramite Vertex AI:

  1. Genkit utilizza gli URL data: come formato di output standard per i contenuti multimediali generati. Si tratta di un formato standard con molte librerie disponibili per gestirlo. Questo esempio utilizza il pacchetto data-urls di jsdom:

    npm i --save data-urls
npm i --save-dev @types/data-urls

  2. Per generare un'immagine e salvarla in un file, chiama generate() specificando un modello di generazione di immagini e il tipo di media del formato di output:

    import { imagen3Fast, vertexAI } from '@genkit-ai/vertexai';
import parseDataURL from 'data-urls';
import { genkit } from 'genkit';

import { writeFile } from 'node:fs/promises';

const ai = genkit({
  plugins: [vertexAI({ location: 'us-central1' })],
});

(async () => {
  const { media } = await ai.generate({
    model: imagen3Fast,
    prompt: 'photo of a meal fit for a pirate',
    output: { format: 'media' },
  });

  if (media === null) throw new Error('No media generated.');

  const data = parseDataURL(media.url);
  if (data === null) throw new Error('Invalid "data:" URL.');

  await writeFile(`output.${data.mimeType.subtype}`, data.body);
})();

Passaggi successivi

Scopri di più su Genkit

  • In qualità di sviluppatore di app, il modo principale per influenzare l'output dei modelli di IA generativa è tramite i prompt. Leggi la sezione Gestione dei prompt per scoprire come Genkit ti aiuta a sviluppare prompt efficaci e a gestirli nella tua base di codice.
  • Sebbene generate() sia il nucleo di ogni applicazione basata sull'IA generativa, le applicazioni reali di solito richiedono un lavoro aggiuntivo prima e dopo l'invocazione di un modello di IA generativa. Per riflettere questo aspetto, Genkit introduce il concetto di flussi, che sono definiti come funzioni, ma aggiungono funzionalità aggiuntive come l'osservabilità e il deployment semplificato. Per scoprire di più, consulta la sezione Definire i flussi di lavoro.

Utilizzo avanzato di LLM

  • Un modo per migliorare le funzionalità degli LLM è fornire loro un elenco di modi in cui possono chiederti maggiori informazioni o chiederti di eseguire un'azione. Questa operazione è nota come chiamata di strumenti o chiamata di funzioni. I modelli addestrati per supportare questa funzionalità possono rispondere a un prompt con una risposta formattata in modo speciale, che indica all'applicazione chiamante di eseguire un'azione e inviare il risultato all'LLM insieme al prompt originale. Genkit dispone di funzioni di libreria che automatizzano sia la generazione di prompt sia gli elementi del loop di chiamata e risposta di un'implementazione di chiamata dello strumento. Per scoprire di più, consulta la sezione Chiamate di strumenti.
  • La generazione basata sul recupero (RAG) è una tecnica utilizzata per introdurre informazioni specifiche del dominio nell'output di un modello. Questo viene ottenuto inserendo informazioni pertinenti in un prompt prima di trasmetterle al modello linguistico. Un'implementazione completa di RAG richiede l'unione di diverse tecnologie: modelli di generazione di embedding di testo, database vettoriali e modelli linguistici di grandi dimensioni. Consulta la sezione Retrieval-Augmented Generation (RAG) per scoprire come Genkit semplifica il processo di coordinamento di questi vari elementi.

Test dell'output del modello

In qualità di ingegnere del software, sei abituato a sistemi deterministici in cui lo stesso input produce sempre lo stesso output. Tuttavia, poiché i modelli di IA sono probabilistici, l'output può variare in base a sfumature sottili dell'input, ai dati di addestramento del modello e persino alla casualità introdotta deliberatamente da parametri come la temperatura.

I valutatori di Genkit sono metodi strutturati per valutare la qualità delle risposte del tuo LLM, utilizzando una serie di strategie. Scopri di più nella pagina Valutazione.