Premiers pas avec Genkit à l'aide de Go (alpha)

Les bibliothèques Genkit pour Go sont désormais disponibles en version preview. Étant donné que les bibliothèques Go sont actuellement en version alpha, vous pouvez constater des modifications fonctionnelles et des modifications de l'API au fur et à mesure du développement. Nous vous recommandons de ne l'utiliser que pour le prototypage et l'exploration.

Si vous découvrez des problèmes avec les bibliothèques ou cette documentation, veuillez les signaler dans notre dépôt GitHub.

Pour commencer à utiliser Genkit, installez la CLI Genkit et exécutez genkit init dans un projet Go. La suite de cette page vous explique comment procéder.

Conditions requises

Go 1.22 ou version ultérieure Consultez la section Télécharger et installer dans la documentation officielle de Go.
Node.js 20 ou version ultérieure (pour la CLI et l'UI Genkit) Consultez la section suivante pour obtenir un bref guide d'installation de Node.

Installer Genkit

Si Node 20 ou une version ultérieure n'est pas déjà installé sur votre système, installez-le maintenant.

Recommandation: Les outils nvm et nvm-windows sont un moyen pratique d'installer des versions spécifiques de Node s'il n'est pas déjà installé sur votre système. Ces outils installent Node par utilisateur. Vous n'avez donc pas besoin d'apporter de modifications à l'échelle du système.

Pour installer nvm, procédez comme suit :
Linux, macOS, etc.Windows
Exécutez la commande suivante :
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
```
Téléchargez et exécutez le programme d'installation comme décrit dans la documentation nvm-windows.
Pour installer Node et npm, ouvrez un nouveau shell et exécutez la commande suivante:
```
nvm install 20
```
Installez la CLI Genkit en exécutant la commande suivante:
```
npm i -g genkit
```
Cette commande installe la CLI Genkit dans votre répertoire d'installation Node afin qu'elle puisse être utilisée en dehors d'un projet Node.

Créer et explorer un exemple de projet

Créez un répertoire de projet:
```
mkdir genkit-intro && cd genkit-intro
```

Initialisez un projet Genkit:

genkit init

Sélectionnez Go comme environnement d'exécution.
Sélectionnez votre modèle:
Gemini (IA de Google)Gemini (Vertex AI)
Le moyen le plus simple de commencer est d'utiliser l'API Google AI Gemini. Vérifiez qu'il est disponible dans votre région.

Générez une clé API pour l'API Gemini à l'aide de Google AI Studio. Définissez ensuite la variable d'environnement GOOGLE_GENAI_API_KEY sur votre clé:
```
export GOOGLE_GENAI_API_KEY=<your API key>
```
Si l'API Google AI Gemini n'est pas disponible dans votre région, envisagez d'utiliser l'API Vertex AI, qui propose également Gemini et d'autres modèles. Vous devez disposer d'un projet Google Cloud pour lequel la facturation est activée, activer l'API AI Platform et définir quelques variables d'environnement supplémentaires:
```
gcloud services enable aiplatform.googleapis.com
export GCLOUD_PROJECT=<your project ID>
export GCLOUD_LOCATION=us-central1
```
Consultez les tarifs de Vertex AI.
Vous pouvez spécifier n'importe quel nom pour le module. Par exemple : example/genkit-intro
Choisissez des réponses par défaut pour le reste des questions, ce qui initialisera votre dossier de projet avec un exemple de code.

La commande genkit init crée un exemple de module Go et installe les dépendances requises. Le fichier main.go contient un seul flux, menuSuggestionFlow, qui invite un LLM à suggérer un élément pour un restaurant avec un thème donné.

Ce fichier ressemble à ceci (les étapes de configuration du plug-in peuvent être différentes si vous avez sélectionné Vertex AI):

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	// Import Genkit and the Google AI plugin
	"github.com/firebase/genkit/go/ai"
	"github.com/firebase/genkit/go/genkit"
	"github.com/firebase/genkit/go/plugins/googlegenai"
)

func main() {
	ctx := context.Background()

	// Initialize Genkit with the Google AI plugin. When you pass nil for the
	// Config parameter, the Google AI plugin will get the API key from the
	// GOOGLE_GENAI_API_KEY environment variable, which is the recommended
	// practice.
	g, err := genkit.Init(ctx, genkit.WithPlugins(&googlegenai.GoogleAI{}))
	if err != nil {
		log.Fatal(err)
	}

	// Define a simple flow that prompts an LLM to generate menu suggestions.
	genkit.DefineFlow(g, "menuSuggestionFlow", func(ctx context.Context, input string) (string, error) {
		// The Google AI API provides access to several generative models. Here,
		// we specify gemini-1.5-flash.
		m := googlegenai.GoogleAIModel(g, "gemini-1.5-flash")
		if m == nil {
			return "", errors.New("menuSuggestionFlow: failed to find model")
		}

		// Construct a request and send it to the model API (Google AI).
		resp, err := genkit.Generate(ctx, g,
			ai.WithModel(m),
			ai.WithConfig(&ai.GenerationCommonConfig{Temperature: 1}),
			ai.WithPromptText(fmt.Sprintf(`Suggest an item for the menu of a %s themed restaurant`, input)))
		if err != nil {
			return "", err
		}

		// Handle the response from the model API. In this sample, we just
		// convert it to a string. but more complicated flows might coerce the
		// response into structured output or chain the response into another
		// LLM call.
		text := resp.Text()
		return text, nil
	})

	<-ctx.Done()
}

Lorsque vous développez les fonctionnalités d'IA de votre application avec Genkit, vous allez probablement créer des flux comportant plusieurs étapes, telles que le prétraitement des entrées, la création d'invites plus sophistiquées, l'intégration de sources d'informations externes pour la génération augmentée par récupération (RAG), etc.

Vous pouvez maintenant exécuter et explorer les fonctionnalités Genkit et l'exemple de projet en local sur votre machine. Téléchargez et démarrez l'UI pour les développeurs de Genkit:
```
genkit start
```
L'interface utilisateur du développeur Genkit s'exécute désormais sur votre machine. Lorsque vous exécuterez des modèles ou des flux à l'étape suivante, votre machine effectuera les tâches d'orchestration nécessaires pour que les étapes de votre flux fonctionnent ensemble. Les appels à des services externes tels que l'API Gemini continueront d'être effectués sur des serveurs en ligne.

De plus, comme vous vous trouvez dans un environnement de développement, Genkit stocke les traces et l'état du flux dans des fichiers locaux.
L'UI du développeur Genkit se télécharge et s'ouvre automatiquement lorsque vous exécutez la commande genkit start.

L'interface utilisateur du développeur vous permet de voir les flux que vous avez définis et les modèles que vous avez configurés, de les exécuter et d'examiner les traces des exécutions précédentes. Essayez quelques-unes de ces fonctionnalités:
- Dans l'onglet Exécuter, vous trouverez la liste de tous les flux que vous avez définis et de tous les modèles configurés par des plug-ins.
  
  Cliquez sur menuSuggestionFlow et essayez de l'exécuter avec du texte saisi (par exemple, "cat"). Si tout se passe bien, vous obtiendrez une suggestion de menu pour un restaurant sur le thème des chats.
- Dans l'onglet Inspect (Examen), vous trouverez l'historique des exécutions du flux. Pour chaque flux, vous pouvez voir les paramètres qui lui ont été transmis et une trace de chaque étape au moment de son exécution.