Appeler des flux Genkit à partir de votre application

Cloud Functions for Firebase dispose d'une méthode onCallGenkit qui vous permet de créer une fonction appelable avec une action Genkit (un flux). Ces fonctions peuvent être appelées avec genkit/beta/client ou un Cloud Functions for Firebase Client SDK, qui ajoute automatiquement les informations d'authentification.

Avant de commencer

• Vous devez connaître le concept de flux Genkit et savoir comment les écrire. Les instructions de cette page partent du principe que vous avez déjà défini des flux que vous souhaitez déployer.
• Il est utile, mais pas obligatoire, d'avoir déjà utilisé Cloud Functions for Firebase.

Configurer un projet Firebase

1. Créez un projet Firebase à l'aide de la console Firebase ou choisissez un projet existant.

2. Passez au forfait Blaze avec paiement à l'usage, qui est requis pour le déploiement en production de Cloud Functions.

3. Installez la CLI Firebase.

4. Connectez-vous à la CLI Firebase :

   firebase login
   firebase login --reauth # alternative, if necessary
   firebase login --no-localhost # if running in a remote shell

5. Créez un répertoire de projet :

   export PROJECT_ROOT=~/tmp/genkit-firebase-project1
   mkdir -p $PROJECT_ROOT

6. Initialisez un projet Firebase dans le répertoire :

   cd $PROJECT_ROOT
   firebase init functions

Le reste de cette page suppose que vous avez choisi d'écrire vos fonctions en JavaScript.

Encapsuler le flux dans onCallGenkit

Après avoir configuré un projet Firebase et y avoir initialisé Cloud Functions, vous pouvez copier ou écrire des définitions de flux dans le répertoire functions du projet. Voici un exemple de flux pour illustrer ce point :

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

const jokeTeller = ai.defineFlow({
  name: "jokeTeller",
  inputSchema: z.string().nullable(),
  outputSchema: z.string(),
  streamSchema: z.string(),
}, async (jokeType = "knock-knock", {sendChunk}) => {
  const prompt = `Tell me a ${jokeType} joke.`;

  // Call the `generateStream()` method to
  // receive the `stream` async iterable.
  const {stream, response: aiResponse} = ai.generateStream(prompt);

  // Send new words of the generative AI response
  // to the client as they are generated.
  for await (const chunk of stream) {
    sendChunk(chunk.text);
  }

  // Return the full generative AI response
  // to clients that may not support streaming.
  return (await aiResponse).text;
},
);
index.js

Pour déployer un flux comme celui-ci, encapsulez-le avec onCallGenkit, disponible dans firebase-functions/https. Cette méthode d'assistance dispose de toutes les fonctionnalités des fonctions appelables et est automatiquement compatible avec le streaming et les réponses JSON.

const {onCallGenkit} = require("firebase-functions/https");

exports.tellJoke = onCallGenkit({
  // Bind the Gemini API key secret parameter to the function.
  secrets: [apiKey],
},
// Pass in the genkit flow.
jokeTeller,
);
index.js

Mettre les identifiants d'API à la disposition des flux déployés

Une fois déployés, vos flux doivent pouvoir s'authentifier auprès des services distants dont ils dépendent. Au minimum, la plupart des flux ont besoin d'identifiants pour accéder au service d'API du modèle qu'ils utilisent.

Pour cet exemple, effectuez l'une des opérations suivantes, en fonction du fournisseur de modèle que vous avez choisi :

Le seul secret que vous devez configurer pour ce tutoriel est celui du fournisseur de modèle, mais en général, vous devez effectuer une opération similaire pour chaque service utilisé par votre flux.

(Facultatif) Ajouter l'application de Firebase App Check

Firebase App Check utilise l'attestation native pour vérifier que notre API n'est appelée que par votre application. La méthode onCallGenkit est compatible avec l'application de App Check de manière déclarative.

export const generatePoem = onCallGenkit({
  enforceAppCheck: true,
  // Optional. Makes App Check tokens only usable once. This adds extra security
  // at the expense of slowing down your app to generate a token for every API
  // call
  consumeAppCheckToken: true,
}, generatePoemFlow);

Configurer le partage de ressources interorigines (CORS)

Utilisez l'option cors pour contrôler les origines qui peuvent accéder à votre fonction.

Par défaut, les fonctions appelables ont CORS configuré pour autoriser les requêtes provenant de toutes les origines. Pour autoriser certaines requêtes interorigines, mais pas toutes, transmettez une liste de domaines spécifiques ou d'expressions régulières à autoriser. Exemple :

export const tellJoke = onCallGenkit({
  cors: 'mydomain.com',
}, jokeTeller);

Exemple complet

Une fois que vous avez apporté toutes les modifications décrites dans ce guide, votre flux déployable doit ressembler à l'exemple suivant :

const {onCallGenkit} = require("firebase-functions/https");
const {defineSecret} = require("firebase-functions/params");

// Dependencies for Genkit.
const {gemini15Flash, googleAI} = require("@genkit-ai/googleai");
const {genkit, z} = require("genkit");

// Store the Gemini API key in Cloud Secret Manager.
const apiKey = defineSecret("GOOGLE_GENAI_API_KEY");

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

const jokeTeller = ai.defineFlow({
  name: "jokeTeller",
  inputSchema: z.string().nullable(),
  outputSchema: z.string(),
  streamSchema: z.string(),
}, async (jokeType = "knock-knock", {sendChunk}) => {
  const prompt = `Tell me a ${jokeType} joke.`;

  // Call the `generateStream()` method to
  // receive the `stream` async iterable.
  const {stream, response: aiResponse} = ai.generateStream(prompt);

  // Send new words of the generative AI response
  // to the client as they are generated.
  for await (const chunk of stream) {
    sendChunk(chunk.text);
  }

  // Return the full generative AI response
  // to clients that may not support streaming.
  return (await aiResponse).text;
},
);

exports.tellJoke = onCallGenkit({
  // Bind the Gemini API key secret parameter to the function.
  secrets: [apiKey],
},
// Pass in the genkit flow.
jokeTeller,
);
index.js

Déployer des flux sur Firebase

Après avoir défini des flux à l'aide de onCallGenkit, vous pouvez les déployer comme vous le feriez pour d'autres fonctions :

cd $PROJECT_ROOT
firebase deploy --only functions