Découvrez les 10 meilleures fonctionnalités de Firebase Genkit pour une intégration d'application fluide et une gestion de modèles puissante

Les 10 meilleures fonctionnalités de Firebase Genkit

Dans le paysage technologique actuel, exploiter la puissance de l'IA peut faire ou défaire le succès de votre application. Firebase Genkit est un outil innovant conçu pour intégrer de manière fluide des fonctionnalités IA de pointe dans vos projets Next.js. Que vous cherchiez à générer du contenu, effectuer des recherches sémantiques ou gérer des prompts complexes, Genkit simplifie ces capacités IA avancées.

Firebase Genkit est conçu tant pour les développeurs novices que chevronnés et offre une approche unifiée et flexible pour implémenter une IA puissante. Dans ce tutoriel, nous explorerons les 10 fonctionnalités distinctives de Firebase Genkit et vous guiderons dans la configuration de votre premier projet dans Next.js.

1. Plusieurs modèles, une seule interface

Genkit simplifie le processus d'essai et d'intégration de divers modèles IA en utilisant une seule interface. La couche d'abstraction facilite le changement de modèles avec un simple changement d'argument tout en supportant des configurations personnalisées.

import { geminiPro } from '@genkit-ai/vertexai';
import { ollama } from 'genkit-ollama';
import { generate } from '@genkit-ai/ai';
 
const result = await generate({
  model: geminiPro,  // Passez facilement à 'ollama' ou tout autre modèle
  config: { temperature: 0.3, maxOutputTokens: 200 },
  prompt: 'Qu\'est-ce qui fait de vous le meilleur LLM ?',
});
 
console.log(result.text());

2. Sortie structurée

Genkit assure des sorties type-safe en utilisant le schéma Zod, fournissant des données structurées qui peuvent être facilement manipulées et utilisées. Cela aide à convertir du texte non structuré en insights organisés et exploitables.

import { generate } from "@genkit-ai/ai";
import { geminiPro } from "@genkit-ai/vertexai";
import { z } from "zod";
 
const CreatureSchema = z.object({
  name: z.string(),
  hitPoints: z.number(),
  attacks: z.array(z.object({ name: z.string(), damage: z.number() }))
});
 
const createCreature = defineFlow({
  name: "createCreature",
  inputSchema: z.string(),
  outputSchema: CreatureSchema,
}, async (habitat) => {
  const result = await generate({
    model: geminiPro,
    prompt: `Concevez une créature pour ${habitat}.`,
    output: { schema: CreatureSchema }
  });
  return result.output();
});
 
console.log(await createCreature("forêt"));

3. Multimodal, multimédia

Genkit excelle dans la gestion du contenu multimodal en fournissant des formats permettant d'intégrer texte, données et médias.

import { imagen2, geminiProVision } from '@genkit-ai/vertexai';
import { generate } from '@genkit-ai/ai';
 
const imageResult = await generate({
  model: imagen2,
  prompt: 'Générer une image d\'un marché médiéval animé.',
});
 
const descriptionResult = await generate({
  model: geminiProVision,
  prompt: [{ text: 'Décrivez cette image:' }, { media: imageResult.media() }],
});
 
console.log(descriptionResult.text());

4. Donner des outils aux LLMs

La configuration d'outils de Genkit simplifie l'intégration de l'appel de fonctions, permettant aux modèles d'effectuer un large éventail d'actions.

import { generate, defineTool } from '@genkit-ai/ai';
import { geminiPro } from '@genkit-ai/vertexai';
import { z } from 'zod';
 
const createReminder = defineTool({
  name: 'createReminder',
  description: 'Planifier des rappels.',
  inputSchema: z.object({ time: z.string(), reminder: z.string() }),
  outputSchema: z.number(),
}, (reminder) => db.reminders.create(reminder));
 
const result = await generate({
  model: geminiPro,
  tools: [createReminder],
  prompt: 'Définir un rappel pour ma réunion avec Anna.',
});
 
console.log(result.text());

5. Gestion des prompts avec Dotprompt

Le format Dotprompt de Genkit unifie la gestion des prompts, modèles et configurations dans un seul fichier.

---
model: vertexai/gemini-1.0-pro
config:
  temperature: 0.9
input:
  schema:
    properties:
      location: {type: string}
      style: {type: string}
    required: [location]
  default:
    location: un restaurant
---
Vous êtes l'assistant IA le plus accueillant au monde travaillant à {{location}}. Accueillez un invité.

6. Exécuter les flows localement

Genkit fournit une interface développeur pour tester et ajuster vos flows de manière interactive.

7. Inspecter les traces

Le débogage des workflows IA complexes est simplifié avec l'inspecteur de traces de Genkit.

8. Ouvert et extensible

Le modèle de plugins de Genkit encourage les contributions de la communauté et une expansion rapide.

9. Conçu pour la production

Le déploiement de fonctionnalités IA est simplifié avec le support d'intégration pour des plateformes comme Google Cloud et Firebase.

10. Gestion de l'autorisation et de la sécurité

Genkit vous équipe de mécanismes pour gérer l'autorisation et assurer des transactions de données sécurisées.

import { defineFlow } from '@genkit-ai/flow';
import { z } from 'zod';
 
export const selfSummaryFlow = defineFlow({
  name: 'selfSummaryFlow',
  inputSchema: z.object({ uid: z.string() }),
  outputSchema: z.string(),
  authPolicy: (auth, input) => {
    if (!auth || input.uid !== auth.uid) throw new Error('Accès non autorisé.');
  }
}, async (input) => {
  return `Résumé pour l'utilisateur ${input.uid}`;
});

Démarrer avec Firebase Genkit dans Next.js

Prérequis : Assurez-vous d'avoir Node.js 20 ou ultérieur installé.

Procédure étape par étape

1. Installer le CLI Genkit :

   npm i -g genkit
   

2. Créer une application Next.js :

   npx create-next-app@latest
   

3. Initialiser Genkit dans votre projet :

   cd votre-projet-nextjs
   genkit init
   

4. Configurer les identifiants API :

   • Pour Google AI : Définissez la variable d'environnement GOOGLE_GENAI_API_KEY.
   • Pour Vertex AI : Définissez GCLOUD_PROJECT, GCLOUD_LOCATION, et authentifiez-vous avec gcloud.

5. Démonstration d'un flow exemple :

   import { callMenuSuggestionFlow } from '@/app/genkit';
    
   export async function callMenuSuggestionFlow(theme) {
     const flowResponse = await runFlow(menuSuggestionFlow, theme);
     return flowResponse;
   }
    
   // Utiliser la fonction dans une page Next.js
   'use client';
   import { useState } from 'react';
   import { callMenuSuggestionFlow } from '@/app/genkit';
    
   export default function Home() {
     const [menuItem, setMenu] = useState('');
     async function getMenuItem(formData) {
       const theme = formData.get('theme')?.toString() ?? '';
       const suggestion = await callMenuSuggestionFlow(theme);
       setMenu(suggestion);
     }
     return (
       <form onSubmit={(e) => { e.preventDefault(); getMenuItem(new FormData(e.target)) }}>
         <input name="theme" placeholder="Thème" />
         <button type="submit">Générer</button>
       </form>
       <div>{menuItem}</div>
     );
   }

Exécutez votre application Next.js pour voir Genkit en action :

npm run dev

Explorez davantage Genkit et ses capacités en consultant la documentation officielle.

Conclusion

En suivant ce tutoriel guidé, vous devriez maintenant avoir une compréhension solide des dix principales fonctionnalités de Firebase Genkit et comment les intégrer dans vos projets Next.js. Adoptez ces outils IA puissants pour transformer vos applications avec une intégration IA fluide et une gestion de modèles sophistiquée.

Source : Documentation Firebase Genkit | Auteur : Équipe Firebase