Migrer depuis la version 0.5

Genkit 0.9 introduit un certain nombre de modifications destructives, ainsi que des améliorations de fonctionnalités qui améliorent le fonctionnement global. Si vous avez développé des applications avec Genkit 0.5, vous devrez mettre à jour le code de votre application lorsque vous passerez à la dernière version. Ce guide décrit les modifications les plus importantes et explique comment migrer vos applications existantes en douceur.

Guide de démarrage rapide

Les étapes suivantes vous aideront à passer rapidement de Genkit 0.5 à Genkit 0.9. Pour en savoir plus sur ces modifications, consultez le journal des modifications détaillé ci-dessous.

1. Installer la nouvelle CLI

• Désinstaller l'ancienne CLI

  npm uninstall -g genkit && npm uninstall genkit
  

• Installer la nouvelle CLI

  npm i -D genkit-cli
  

2. Mettre à jour vos dépendances

• Supprimer des packages de base Genkit individuels

  npm uninstall @genkit-ai/ai @genkit-ai/core @genkit-ai/dotprompt @genkit-ai/flow
  

• Installer le nouveau package genkit consolidé

  npm i --save genkit
  

• Mettre à niveau toutes les versions du plug-in (exemple ci-dessous)

  npm upgrade @genkit-ai/firebase
  

3. Modifier vos importations

• Suppression des importations pour les packages principaux Genkit individuels

  import { … } from '@genkit-ai/ai';
  import { … } from '@genkit-ai/core';
  import { … } from '@genkit-ai/flow';
  

• Supprimer les importations zod

  import * as z from 'zod';
  

• Importer genkit et zod depuis genkit

  import { z, genkit } from 'genkit';
  

4. Mettre à jour votre code

Supprimez les blocs configureGenkit.

La configuration de Genkit est désormais effectuée par instance. La télémétrie et la journalisation sont configurées globalement et séparément de l'instance Genkit.

• Remplacez configureGenkit par des blocs ai = genkit({...}). Conservez uniquement la configuration du plug-in.

  import { genkit } from 'genkit';
  
  const ai = genkit({ plugins: [...]});
  

• Configurer la télémétrie à l'aide de enableFirebaseTelemetry ou enableGoogleCloudTelemetry

  Pour Firebase:

  import { enableFirebaseTelemetry } from '@genkit-ai/firebase';
  
  enableFirebaseTelemetry({...});
  

  Pour Google Cloud:

  import { enableGoogleCloudTelemetry } from '@genkit-ai/google-cloud';
  
  enableGoogleCloudTelemetry({...});
  

• Définissez votre niveau de journalisation indépendamment ```js import { logger } from 'genkit/logging';

  logger.setLogLevel('debug'); ```

Pour en savoir plus sur la configuration de la télémétrie et de la journalisation, consultez la documentation Surveillance et journalisation.

Pour en savoir plus sur la configuration d'une instance Genkit, consultez la documentation Premiers pas.

Migrer les actions Genkit à appeler à partir de l'instance genkit

Les actions (flux, outils, récupérateurs, indexeurs, etc.) sont définies par instance. Consultez le journal des modifications pour connaître toutes les fonctionnalités que vous devrez modifier. Voici quelques exemples courants.

import { genkit } from 'genkit';
import { onFlow } from '@genkit-ai/firebase/functions';

const ai = genkit({ plugins: [...]});

// Flows and tools are defined on the specific genkit instance
// and are directly callable.
const sampleFlow = ai.defineFlow(...);
const sampleTool = ai.defineTool(...);

async function callMyFlow() {
  // Previously, text output could accessed via .text()
  // Now it is either .output() or .text
  return await sampleFlow().output();
}

// onFlow now takes the Genkit instance as first argument
// This registers the flow as a callable firebase function
onFlow(ai, ...);
const flows = [ sampleFlow, ... ];
// Start the flow server to make the registered flows callable over HTTP
ai.startFlowServer({flows});

5. Exécuter l'application

# run the DevUI and your js code
genkit start -- <command to run node>
# run a defined flow
genkit flow:run <flowName>

Journal des modifications

1. Modifications apportées à la CLI

L'interface de ligne de commande (CLI) a subi des modifications importantes dans Genkit 0.9. La commande permettant de démarrer Genkit a changé, et la CLI a été séparée dans son propre package autonome, que vous devez désormais installer séparément.

Pour installer la CLI:

npm i -g genkit-cli

Des modifications ont été apportées à la commande genkit start:

Démarre votre code d'application Genkit et l'UI de développement ensemble:

genkit start -- [start command]
genkit start -- tsx src/index.ts
genkit start -- go run main.go

Le mode Lecture est également pris en charge:

genkit start -- tsx --watch src/index.ts

Démarre UNIQUEMENT le code de votre application en mode développement Genkit:

genkit start --noui -- <start command>
genkit start --noui -- tsx src/index.ts

Démarre l'UI de développement UNIQUEMENT:

genkit start

Auparavant, la commande genkit start démarrait l'interface utilisateur de développement et le code de votre application ensemble. Si vous avez des pipelines CI/CD qui s'appuient sur cette commande, vous devrez peut-être les mettre à jour.

L'UI de développement interagit directement avec le serveur de flux pour déterminer les flux enregistrés et vous permettre de les appeler directement avec des exemples d'entrées.

2. Packages et importations simplifiés

Auparavant, les bibliothèques Genkit étaient séparées en plusieurs modules, que vous deviez installer et importer individuellement. Ces modules ont désormais été regroupés dans une seule importation. En outre, le module Zod est désormais réexporté par Genkit.

Anciennement:

npm i @genkit-ai/core @genkit-ai/ai @genkit-ai/flow @genkit-ai/dotprompt

Nouveauté:

npm i genkit

Anciennement:

import { … } from '@genkit-ai/ai';
import { … } from '@genkit-ai/core';
import { … } from '@genkit-ai/flow';
import * as z from 'zod';

Nouveauté:

import { genkit, z } from 'genkit';

Les plug-ins Genkit doivent toujours être installés et importés individuellement.

3. Configurer Genkit

Auparavant, l'initialisation de Genkit était effectuée une fois globalement en appelant la fonction configureGenkit. Les ressources Genkit (flux, outils, invites, etc.) seraient toutes automatiquement câblées avec cette configuration globale.

Genkit 0.9 introduit des instances Genkit, chacune encapsulant une configuration. Consultez les exemples suivants :

Anciennement:

import { configureGenkit } from '@genkit-ai/core';

configureGenkit({
  telemetry: {
    instrumentation: ...,
    logger: ...
  }
});

Nouveauté:

import { genkit } from 'genkit';
import { logger } from 'genkit/logging';
import { enableFirebaseTelemetry } from '@genkit-ai/firebase';

logger.setLogLevel('debug');
enableFirebaseTelemetry({...});

const ai = genkit({ ... });

Décomposons cela:

• configureGenkit() a été remplacé par genkit(), qui renvoie une instance Genkit configurée plutôt que de configurer des configurations de manière globale.
• La fonction d'initialisation de Genkit se trouve désormais dans le package genkit.
• La journalisation et la télémétrie sont toujours configurées globalement à l'aide de leurs propres méthodes explicites. Ces configurations s'appliquent de manière uniforme à toutes les instances Genkit.

4. Définir des flux et démarrer le serveur de flux explicitement

Maintenant que vous avez une instance Genkit configurée, vous devez définir vos flux. Toutes les méthodes d'API principales destinées aux développeurs, telles que defineFlow, defineTool et onFlow, sont désormais appelées via cette instance.

Contrairement à la méthode précédente, où les flux et les outils étaient enregistrés globalement.

Anciennement:

import { defineFlow, defineTool, onFlow } from '@genkit-ai/core';

defineFlow(...);
defineTool(...);

onFlow(...);

Nouveauté:

// Define tools and flows
const sampleFlow = ai.defineFlow(...);
const sampleTool = ai.defineTool(...);

// onFlow now takes the Genkit instance as first argument
// This registers the flow as a callable firebase function
onFlow(ai, ...);  

const flows = [ sampleFlow, ... ];
// Start the flow server to make the registered flows callable over HTTP
ai.startFlowServer({flows});

Pour le moment, tous les flux que vous souhaitez mettre à disposition doivent être enregistrés explicitement dans le tableau flows ci-dessus.

5. Les outils et les requêtes doivent être définis de manière statique

Dans les versions précédentes de Genkit, vous pouviez définir de manière dynamique des outils et des invites au moment de l'exécution, directement à partir d'un flux.

Dans Genkit 0.9, ce comportement n'est plus autorisé. Vous devez plutôt définir toutes les actions et tous les flux en dehors de l'exécution du flux (c'est-à-dire de manière statique).

Cette modification applique une séparation plus stricte des définitions d'action de l'exécution.

Si l'un de vos codes est défini de manière dynamique, vous devez le refactorer. Sinon, une erreur sera générée au moment de l'exécution du flux.

❌ À ÉVITER:

const flow = defineFlow({...}, async (input) => {
  const tool = defineTool({...});
  await tool(...);
});

✅ À FAIRE:

const tool = ai.defineTool({...});

const flow = ai.defineFlow({...}, async (input) => {
  await tool(...);
});

6. Nouvelle API pour les flux de streaming

Dans Genkit 0.9, nous avons simplifié la syntaxe permettant de définir et d'appeler un flux de streaming.

Tout d'abord, defineFlow et defineStreamingFlow ont été dissociés. Si vous avez un flux destiné à être diffusé en streaming, vous devrez mettre à jour votre code pour le définir via defineStreamingFlow.

Deuxièmement, au lieu d'appeler des fonctions stream() et response() distinctes, le flux et la réponse sont désormais des valeurs renvoyées directement à partir du flux. Cette modification simplifie le streaming de flux.

Anciennement:

import { defineFlow, streamFlow } from '@genkit-ai/flow';

const myStreamingFlow = defineFlow(...);
const { stream, output } = await streamFlow(myStreamingFlow, ...);

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

console.log(await output());

Nouveauté:

const myStreamingFlow = ai.defineStreamingFlow(...);
const { stream, response } = await myStreamingFlow(...);

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

console.log(await response);

7. Remplacement des méthodes de la classe GenerateResponse par des propriétés getter

Auparavant, vous aviez accès à la sortie structurée ou au texte de la réponse à l'aide de méthodes de classe, comme output() ou text().

Dans Genkit 0.9, ces méthodes ont été remplacées par des propriétés getter. Cela simplifie le travail avec les réponses.

Anciennement:

const response = await generate({ prompt: 'hi' });
console.log(response.text());

Nouveauté:

const response = await ai.generate('hi');
console.log(response.text);

Il en va de même pour output:

Anciennement:

console.log(response.output());

Nouveauté:

console.log(response.output);

8. Suppression de la génération de candidats

Genkit 0.9 simplifie la gestion des réponses en supprimant l'attribut candidates. Auparavant, les réponses pouvaient contenir plusieurs candidats, que vous deviez gérer explicitement. Désormais, seul le premier candidat est renvoyé directement dans une réponse plate.

Tout code qui accède directement aux candidats ne fonctionnera plus.

Anciennement:

const response = await generate({
 messages: [ { role: 'user', content: ...} ]
});
console.log(response.candidates); // previously you could access candidates directly

Nouveauté:

const response = await ai.generate({
 messages: [ { role: 'user', content: ...} ]
});
console.log(response.message); // single candidate is returned directly in a flat response

9. API Generate : améliorations pour les conversations multi-tours

Pour les conversations multitours, l'ancienne méthode toHistory() a été remplacée par messages, ce qui simplifie encore la gestion de l'historique des conversations.

Anciennement:

const history = response.toHistory();

Nouveauté:

const response = await ai.generate({
 messages: [ { role: 'user', content: ...} ]
});
const history = response.messages;

10. API Chat simplifiée

Dans Genkit 0.9, l'API Chat a été repensée pour faciliter la gestion et l'interaction des sessions. Voici comment l'utiliser pour les expériences de chat synchrone et en streaming:

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

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

const session = ai.createSession({ store: firestoreSessionStore() });
const chat = await session.chat({ system: 'talk like a pirate' });

let response = await chat.send('hi, my name is Pavel');
console.log(response.text()); // "hi Pavel, I'm llm"

// continue the conversation
response = await chat.send("what's my name");
console.log(response.text()); // "Pavel"

// can stream
const { response, stream } = await chat.sendStream('bye');
for await (const chunk of stream) {
 console.log(chunk.text());
}
console.log((await response).text());

// can load session from the store
const prevSession = await ai.loadSession(session.id, { store });
const prevChat = await prevSession.chat();
await prevChat.send('bye');