Beta: Firebase Genkit is in Beta, which means that it is not subject to any SLA or deprecation policy and could change in backwards-incompatible ways. Throughout the Beta period, Firebase Genkit and its documentation will be updated and improved.

Cette page a été traduite par l'API Cloud Translation.

Générer du contenu avec des modèles d'IA

L'IA générative repose sur des modèles d'IA. Actuellement, les deux exemples les plus marquants de modèles génératifs sont les grands modèles de langage (LLM) et les modèles de génération d'images. Ces modèles reçoivent une entrée, appelée invite (généralement du texte, une image ou une combinaison des deux), et produisent en sortie du texte, une image, voire de l'audio ou de la vidéo.

Le résultat de ces modèles peut être étonnamment convaincant: les LLM génèrent du texte qui semble avoir été écrit par un être humain, et les modèles de génération d'images peuvent produire des images très proches de vraies photographies ou d'œuvres d'art créées par des humains.

De plus, les LLM ont prouvé qu'ils pouvaient effectuer des tâches au-delà de la simple génération de texte:

Écrire des programmes informatiques
Planifier les sous-tâches nécessaires pour accomplir une tâche plus importante
Organiser des données désorganisées
Comprendre et extraire des données d'informations à partir d'un corpus de texte
Suivre et effectuer des activités automatisées en fonction d'une description textuelle de l'activité

De nombreux modèles sont disponibles auprès de plusieurs fournisseurs. Chaque modèle a ses propres forces et faiblesses. Un modèle peut exceller dans une tâche, mais être moins performant dans d'autres. Les applications qui utilisent l'IA générative peuvent souvent tirer parti de l'utilisation de plusieurs modèles différents en fonction de la tâche à accomplir.

En tant que développeur d'applications, vous n'interagissez généralement pas directement avec les modèles d'IA générative, mais via des services disponibles en tant qu'API Web. Bien que ces services présentent souvent des fonctionnalités similaires, ils les fournissent tous via des API différentes et incompatibles. Si vous souhaitez utiliser plusieurs services de modèles, vous devez utiliser chacun de leurs SDK propriétaires, potentiellement incompatibles les uns avec les autres. Et si vous souhaitez passer d'un modèle au plus récent et le plus performant, vous devrez peut-être recréer cette intégration.

Genkit répond à ce défi en fournissant une interface unique qui élimine les détails d'accès à n'importe quel service de modèle d'IA générative, avec plusieurs implémentations prédéfinies déjà disponibles. Créer votre application optimisée par l'IA autour de Genkit simplifie le processus d'appel de votre premier modèle d'IA générative et vous permet de combiner plusieurs modèles ou d'en remplacer un par un autre lorsque de nouveaux modèles apparaissent.

Avant de commencer

Si vous souhaitez exécuter les exemples de code de cette page, suivez d'abord les étapes du guide Premiers pas. Tous les exemples supposent que vous avez déjà installé Genkit en tant que dépendance dans votre projet.

Modèles compatibles avec Genkit

Genkit est conçu pour être suffisamment flexible pour utiliser potentiellement n'importe quel service de modèle d'IA générative. Ses bibliothèques principales définissent l'interface commune pour travailler avec les modèles, et les plug-ins de modèle définissent les détails d'implémentation pour travailler avec un modèle spécifique et son API.

L'équipe Genkit gère des plug-ins pour travailler avec les modèles fournis par Vertex AI, Google Generative AI et Ollama:

Famille de LLM Gemini via le plug-in Google Cloud Vertex AI
La famille de LLM Gemini, via le plug-in Google AI
Modèles de génération d'images Imagen2 et Imagen3, via Google Cloud Vertex AI
La famille de LLM Claude 3 d'Anthropic, via le jardin de modèles de Google Cloud Vertex AI
Gemma 2, Llama 3 et de nombreux autres modèles ouverts via le plug-in Ollama (vous devez héberger vous-même le serveur Ollama)

De plus, plusieurs plug-ins gérés par la communauté fournissent des interfaces à ces modèles:

Famille de LLM Claude 3, via le plug-in Anthropic
Famille de LLM GPT via le plug-in OpenAI
Famille de LLM GPT via le plug-in Azure OpenAI
Famille de LLM R via le plug-in Cohere
Famille de LLM Mistral via le plug-in Mistral
Gemma 2, Llama 3 et de nombreux autres modèles ouverts hébergés sur Groq, via le plug-in Groq

Pour en savoir plus, recherchez les packages tagués avec genkit-model sur npmjs.org.

Charger et configurer des plug-ins de modèle

Avant de pouvoir utiliser Genkit pour commencer à générer du contenu, vous devez charger et configurer un plug-in de modèle. Si vous venez du guide de démarrage, vous l'avez déjà fait. Sinon, consultez le guide de démarrage ou la documentation du plug-in individuel, puis suivez les étapes indiquées avant de continuer.

La méthode generate()

Dans Genkit, la méthode generate() est l'interface principale avec laquelle vous interagissez avec les modèles d'IA générative.

L'appel generate() le plus simple spécifie le modèle que vous souhaitez utiliser et une invite de texte:

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);
})();

Lorsque vous exécutez cet exemple, des informations de débogage s'affichent, suivies de la sortie de l'appel generate(), qui est généralement un texte Markdown, comme dans l'exemple suivant:

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

Exécutez à nouveau le script pour obtenir un résultat différent.

L'exemple de code précédent a envoyé la requête de génération au modèle par défaut, que vous avez spécifié lorsque vous avez configuré l'instance Genkit.

Vous pouvez également spécifier un modèle pour un seul appel generate():

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

Cet exemple utilise une référence de modèle exportée par le plug-in de modèle. Vous pouvez également spécifier le modèle à l'aide d'un identifiant de chaîne:

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

Un identifiant de chaîne de modèle se présente sous la forme providerid/modelid, où l'ID du fournisseur (dans ce cas, googleai) identifie le plug-in, et l'ID du modèle est un identifiant de chaîne spécifique au plug-in pour une version spécifique d'un modèle.

Certains plug-ins de modèle, tels que le plug-in Ollama, donnent accès à des dizaines de modèles différents et n'exportent donc pas de références de modèle individuelles. Dans ce cas, vous ne pouvez spécifier un modèle à generate() qu'à l'aide de son identifiant de chaîne.

Ces exemples illustrent également un point important: lorsque vous utilisez generate() pour effectuer des appels de modèle d'IA générative, il vous suffit de transmettre une valeur différente au paramètre du modèle pour modifier le modèle que vous souhaitez utiliser. En utilisant generate() au lieu des SDK de modèle natif, vous vous donnez la flexibilité d'utiliser plus facilement plusieurs modèles différents dans votre application et de modifier les modèles à l'avenir.

Jusqu'à présent, vous n'avez vu que des exemples des appels generate() les plus simples. Cependant, generate() fournit également une interface pour des interactions plus avancées avec les modèles génératifs, comme vous le verrez dans les sections suivantes.

Requêtes système

Certains modèles permettent de fournir une invite système, qui donne au modèle des instructions sur la façon dont vous souhaitez qu'il réponde aux messages de l'utilisateur. Vous pouvez utiliser l'invite système pour spécifier un persona que vous souhaitez que le modèle adopte, le ton de ses réponses, le format de ses réponses, etc.

Si le modèle que vous utilisez est compatible avec les requêtes système, vous pouvez en fournir une avec le paramètre system:

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

Paramètres du modèle

La fonction generate() utilise un paramètre config, via lequel vous pouvez spécifier des paramètres facultatifs qui contrôlent la manière dont le modèle génère du contenu:

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,
  },
});

Les paramètres exacts compatibles dépendent du modèle et de l'API de modèle. Toutefois, les paramètres de l'exemple précédent sont communs à presque tous les modèles. Voici une explication de ces paramètres:

Paramètres qui contrôlent la longueur de la sortie

maxOutputTokens

Les LLM fonctionnent sur des unités appelées jetons. Un jeton est généralement mappé sur une séquence de caractères spécifique, mais ce n'est pas nécessairement le cas. Lorsque vous transmettez une requête à un modèle, l'une des premières étapes consiste à tokeniser votre chaîne de requête en une séquence de jetons. Le LLM génère ensuite une séquence de jetons à partir de l'entrée tokenisée. Enfin, la séquence de jetons est convertie à nouveau en texte, qui est votre sortie.

Le paramètre "max_output_tokens" définit simplement une limite sur le nombre de jetons à générer à l'aide du LLM. Chaque modèle utilise potentiellement un tokenizer différent, mais une bonne règle d'or est de considérer qu'un seul mot anglais est composé de deux à quatre jetons.

Comme indiqué précédemment, il est possible que certains jetons ne soient pas mappés à des séquences de caractères. Par exemple, il existe souvent un jeton qui indique la fin de la séquence : lorsqu'un LLM génère ce jeton, il cesse de générer d'autres jetons. Par conséquent, il est possible et souvent que le LLM génère moins de jetons que le nombre maximal, car il a généré le jeton "stop".

stopSequences

Vous pouvez utiliser ce paramètre pour définir les jetons ou les séquences de jetons qui, lorsqu'ils sont générés, indiquent la fin de la sortie LLM. Les valeurs correctes à utiliser ici dépendent généralement de la manière dont le modèle a été entraîné et sont généralement définies par le plug-in du modèle. Toutefois, si vous avez demandé au modèle de générer une autre séquence d'arrêt, vous pouvez la spécifier ici.

Notez que vous spécifiez des séquences de caractères, et non des jetons en tant que tels. Dans la plupart des cas, vous spécifiez une séquence de caractères que le tokenizer du modèle mappe à un seul jeton.

Paramètres qui contrôlent la "créativité"

Les paramètres temperature, top-p et top-k contrôlent ensemble le niveau de créativité que vous souhaitez pour le modèle. Vous trouverez ci-dessous une brève explication de la signification de ces paramètres. Toutefois, le point le plus important à retenir est le suivant: ces paramètres servent à ajuster le caractère de la sortie d'un LLM. Les valeurs optimales pour ces paramètres dépendent de vos objectifs et de vos préférences, et ne peuvent être déterminées qu'au moyen d'expérimentations.

température

Les LLM sont fondamentalement des machines de prédiction de jetons. Pour une séquence de jetons donnée (comme la requête), un LLM prédit, pour chaque jeton de son vocabulaire, la probabilité que le jeton soit le suivant dans la séquence. La température est un facteur de mise à l'échelle par lequel ces prédictions sont divisées avant d'être normalisées pour obtenir une probabilité comprise entre 0 et 1.

Les valeurs de température basse (entre 0,0 et 1,0) amplifient la différence de probabilités entre les jetons, ce qui fait que le modèle est encore moins susceptible de produire un jeton qu'il a déjà évalué comme peu probable. Cela est souvent perçu comme un résultat moins créatif. Bien que 0, 0 ne soit techniquement pas une valeur valide, de nombreux modèles le considèrent comme indiquant que le modèle doit se comporter de manière déterministe et ne prendre en compte que le jeton le plus probable.

Les valeurs de température élevée (supérieures à 1,0) compressent les différences de probabilités entre les jetons, ce qui augmente la probabilité que le modèle produise des jetons qu'il avait précédemment évalués comme peu probables. Cela est souvent perçu comme un résultat plus créatif. Certaines API de modèle imposent une température maximale, souvent 2,0.

topP

Top-p est une valeur comprise entre 0,0 et 1,0 qui contrôle le nombre de jetons possibles que vous souhaitez que le modèle prenne en compte, en spécifiant la probabilité cumulée des jetons. Par exemple, une valeur de 1,0 signifie que vous devez prendre en compte tous les jetons possibles (mais en tenant compte de la probabilité de chaque jeton). Une valeur de 0,4 signifie que seuls les jetons les plus probables, dont les probabilités s'additionnent à 0,4, sont pris en compte, et que les jetons restants sont exclus.

topK

Top-k est une valeur entière qui contrôle également le nombre de jetons possibles que vous souhaitez que le modèle prenne en compte, mais cette fois en spécifiant explicitement le nombre maximal de jetons. Spécifier une valeur de 1 signifie que le modèle doit se comporter de manière déterministe.

Tester les paramètres du modèle

Vous pouvez tester l'effet de ces paramètres sur la sortie générée par différentes combinaisons de modèle et d'invite à l'aide de l'UI du développeur. Démarrez l'interface utilisateur du développeur avec la commande genkit start. Elle chargera automatiquement tous les modèles définis par les plug-ins configurés dans votre projet. Vous pouvez rapidement essayer différentes invites et valeurs de configuration sans avoir à effectuer ces modifications à plusieurs reprises dans le code.

Sortie structurée

Lorsque vous utilisez l'IA générative comme composant dans votre application, vous souhaitez souvent obtenir une sortie dans un format autre que le texte brut. Même si vous ne générez que du contenu à afficher à l'utilisateur, vous pouvez bénéficier d'une sortie structurée simplement pour le présenter de manière plus attrayante. Toutefois, pour les applications plus avancées de l'IA générative, telles que l'utilisation programmatique de la sortie du modèle ou l'alimentation de la sortie d'un modèle dans un autre, une sortie structurée est indispensable.

Dans Genkit, vous pouvez demander une sortie structurée à partir d'un modèle en spécifiant un schéma lorsque vous appelez 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 },
});

Les schémas de sortie du modèle sont spécifiés à l'aide de la bibliothèque Zod. En plus d'un langage de définition de schéma, Zod fournit également une vérification de type d'exécution, qui comble le fossé entre les types TypeScript statiques et la sortie imprévisible des modèles d'IA générative. Zod vous permet d'écrire du code qui peut s'appuyer sur le fait qu'un appel de génération réussi renverra toujours une sortie conforme à vos types TypeScript.

Lorsque vous spécifiez un schéma dans generate(), Genkit effectue plusieurs opérations en arrière-plan:

Complète la requête avec des conseils supplémentaires sur le format de sortie souhaité. Cela a également pour effet secondaire de spécifier au modèle le contenu exact que vous souhaitez générer (par exemple, non seulement suggérer un élément de menu, mais aussi générer une description, une liste d'allergènes, etc.).
Analyse la sortie du modèle dans un objet JavaScript.
Vérifie que la sortie est conforme au schéma.

Pour obtenir une sortie structurée à partir d'un appel de génération réussi, utilisez la propriété output de l'objet de réponse:

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

Traiter les erreurs

Notez dans l'exemple précédent que la propriété output peut être null. Cela peut se produire lorsque le modèle ne parvient pas à générer une sortie conforme au schéma. La meilleure stratégie pour gérer ces erreurs dépend de votre cas d'utilisation exact, mais voici quelques conseils généraux:

Essayez un autre modèle. Pour que la sortie structurée aboutisse, le modèle doit pouvoir générer une sortie au format JSON. Les LLM les plus puissants, comme Gemini et Claude, sont suffisamment polyvalents pour ce faire. Toutefois, les modèles plus petits, comme certains des modèles locaux que vous utiliseriez avec Ollama, ne pourront peut-être pas générer de sortie structurée de manière fiable, sauf s'ils ont été spécifiquement entraînés à le faire.
Utilisez les capacités de coercition de Zod: vous pouvez spécifier dans vos schémas que Zod doit essayer de forcer les types non conformes au type spécifié par le schéma. Si votre schéma inclut des types primitifs autres que des chaînes, l'utilisation de la coercition Zod peut réduire le nombre d'échecs generate() que vous rencontrez. La version suivante de MenuItemSchema utilise la coercition de type pour corriger automatiquement les situations où le modèle génère des informations sur les calories sous forme de chaîne plutôt que de nombre:
```
const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.coerce.number(),
  allergens: z.array(z.string()),
});
```
Réessayez l'appel generate(). Si le modèle que vous avez choisi ne parvient que rarement à générer une sortie conforme, vous pouvez traiter l'erreur comme vous le feriez pour une erreur réseau, et simplement réessayer la requête à l'aide d'une stratégie d'intervalle entre les tentatives incrémentielle.

Streaming

Lorsque vous générez de grandes quantités de texte, vous pouvez améliorer l'expérience pour vos utilisateurs en présentant la sortie au fur et à mesure de sa génération (streaming de la sortie). Un exemple familier de streaming en action peut être observé dans la plupart des applications de chat LLM: les utilisateurs peuvent lire la réponse du modèle à leur message au fur et à mesure de sa génération, ce qui améliore la réactivité perçue de l'application et renforce l'illusion de discuter avec un homologue intelligent.

Dans Genkit, vous pouvez diffuser la sortie à l'aide de la méthode generateStream(). Sa syntaxe est semblable à celle de la méthode generate():

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

L'objet de réponse possède une propriété stream, que vous pouvez utiliser pour itérer sur la sortie de streaming de la requête à mesure qu'elle est générée:

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

Vous pouvez également obtenir la sortie complète de la requête, comme vous pouvez le faire avec une requête non en streaming:

const completeText = (await response).text;

Le streaming fonctionne également avec la sortie structurée:

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;

La sortie structurée en streaming fonctionne un peu différemment du texte en streaming: la propriété output d'un bloc de réponse est un objet construit à partir de l'accumulation des blocs produits jusqu'à présent, plutôt qu'un objet représentant un seul bloc (qui peut ne pas être valide en soi). Chaque bloc de sortie structurée remplace en quelque sorte le bloc précédent.

Par exemple, voici à quoi pourraient ressembler les cinq premières sorties de l'exemple précédent:

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' }
  ]
}

Entrée multimodale

Les exemples que vous avez vus jusqu'à présent utilisaient des chaînes de texte comme requêtes du modèle. Bien que ce soit le moyen le plus courant d'inviter des modèles d'IA générative, de nombreux modèles peuvent également accepter d'autres supports comme des requêtes. Les requêtes multimédias sont le plus souvent utilisées avec des requêtes textuelles qui indiquent au modèle d'effectuer une opération sur le contenu multimédia, par exemple pour ajouter des sous-titres à une image ou transcrire un enregistrement audio.

La possibilité d'accepter des entrées multimédias et les types de contenus multimédias que vous pouvez utiliser dépendent entièrement du modèle et de son API. Par exemple, la série de modèles Gemini 1.5 peut accepter des images, des vidéos et des contenus audio comme requêtes.

Pour fournir une requête multimédia à un modèle qui la prend en charge, au lieu de transmettre une requête textuelle simple à generate, transmettez un tableau composé d'une partie multimédia et d'une partie textuelle:

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

Dans l'exemple ci-dessus, vous avez spécifié une image à l'aide d'une URL HTTPS accessible au public. Vous pouvez également transmettre des données multimédias directement en les encodant en tant qu'URL de données. Exemple :

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.' },
]);

Tous les modèles compatibles avec l'entrée multimédia acceptent à la fois les URL de données et les URL HTTPS. Certains plug-ins de modèle sont compatibles avec d'autres sources multimédias. Par exemple, le plug-in Vertex AI vous permet également d'utiliser des URL Cloud Storage (gs://).

Générer des contenus multimédias

Jusqu'à présent, la plupart des exemples de cette page concernaient la génération de texte à l'aide de LLM. Toutefois, Genkit peut également être utilisé avec des modèles de génération d'images. L'utilisation de generate() avec un modèle de génération d'images est semblable à celle d'un LLM. Par exemple, pour générer une image à l'aide du modèle Imagen2 via Vertex AI:

Genkit utilise les URL data: comme format de sortie standard pour les contenus multimédias générés. Il s'agit d'un format standard avec de nombreuses bibliothèques disponibles pour les gérer. Cet exemple utilise le package data-urls à partir de jsdom:
```
npm i --save data-urls
npm i --save-dev @types/data-urls
```

Pour générer une image et l'enregistrer dans un fichier, appelez generate(), en spécifiant un modèle de génération d'images et le type de support du format de sortie:

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);
})();

Étapes suivantes

En savoir plus sur Genkit

En tant que développeur d'applications, le principal moyen d'influencer les résultats des modèles d'IA générative est d'utiliser des requêtes. Consultez Gestion des requêtes pour découvrir comment Genkit vous aide à développer des requêtes efficaces et à les gérer dans votre codebase.
Bien que generate() soit le noyau de chaque application optimisée par l'IA générative, les applications du monde réel nécessitent généralement des tâches supplémentaires avant et après l'appel d'un modèle d'IA générative. Pour refléter cela, Genkit introduit le concept de flux, qui sont définis comme des fonctions, mais qui ajoutent des fonctionnalités supplémentaires telles que l'observabilité et le déploiement simplifié. Pour en savoir plus, consultez la section Définir des workflows.

Utilisation avancée du LLM

Pour améliorer les capacités des LLM, vous pouvez leur fournir une liste de façons dont ils peuvent vous demander des informations supplémentaires ou vous demander d'effectuer une action. C'est ce qu'on appelle l'appel d'outil ou l'appel de fonction. Les modèles entraînés pour prendre en charge cette fonctionnalité peuvent répondre à une invite avec une réponse au format spécial, qui indique à l'application appelante qu'elle doit effectuer une action et renvoyer le résultat au LLM avec l'invite d'origine. Genkit dispose de fonctions de bibliothèque qui automatisent à la fois la génération d'invites et les éléments de boucle d'appel-réponse d'une implémentation d'appel d'outil. Pour en savoir plus, consultez la section Appel d'outils.
La génération augmentée de récupération (RAG) est une technique utilisée pour introduire des informations spécifiques au domaine dans la sortie d'un modèle. Pour ce faire, insérez les informations pertinentes dans une invite avant de les transmettre au modèle de langage. Une implémentation complète du RAG nécessite de combiner plusieurs technologies: modèles de génération d'embeddings textuels, bases de données vectorielles et grands modèles de langage. Consultez la page Génération augmentée de récupération (RAG) pour découvrir comment Genkit simplifie le processus de coordination de ces différents éléments.

Tester la sortie du modèle

En tant qu'ingénieur logiciel, vous êtes habitué aux systèmes déterministes, où la même entrée produit toujours la même sortie. Cependant, comme les modèles d'IA sont probabilistes, la sortie peut varier en fonction de nuances subtiles dans l'entrée, des données d'entraînement du modèle et même du caractère aléatoire délibérément introduit par des paramètres tels que la température.

Les évaluateurs de Genkit sont des méthodes structurées permettant d'évaluer la qualité des réponses de votre LLM à l'aide de diverses stratégies. Pour en savoir plus, consultez la page Évaluation.