Créer un assistant de programmation avec la CLI Gemini, MCP et Go

1. Introduction

Dans cet atelier de programmation, vous allez apprendre à créer et à déployer un serveur MCP (Model Context Protocol) pour étendre les capacités de la CLI Gemini. Vous allez créer godoctor, un serveur basé sur Go qui fournit des outils personnalisés pour le développement Go, transformant Gemini CLI d'un assistant de codage à usage général en un expert spécialisé dans le développement Go.

Cet atelier de programmation utilise une approche "axée sur les requêtes". Vous agirez en tant que responsable technique et fournirez des requêtes à votre assistant IA (l'interface de ligne de commande Gemini elle-même). Votre objectif est d'apprendre à traduire les exigences du projet en requêtes efficaces et de laisser l'IA s'occuper des détails de l'implémentation.

Le protocole MCP (Model Context Protocol) est au cœur de ce projet. Le protocole MCP est un protocole Open Source qui standardise la façon dont les grands modèles de langage (LLM) comme Gemini communiquent avec les outils et services externes. Il sert de passerelle, permettant à l'IA d'accéder à des informations réelles et d'effectuer des actions au-delà de ses connaissances intégrées. En créant un serveur MCP, vous créez un plug-in personnalisé que la CLI Gemini peut découvrir et utiliser, ce qui lui permet d'acquérir de nouvelles compétences.

Points abordés

• Installer et configurer la CLI Gemini
• Formuler des requêtes efficaces pour guider un assistant IA dans le développement de logiciels
• Fournir du contexte et des consignes à un assistant IA
• Créer et configurer un serveur MCP pour augmenter les capacités de l'interface de ligne de commande Gemini
• Conteneuriser et déployer une application Go sur Google Cloud Run

Prérequis

Cet atelier peut être exécuté entièrement dans Google Cloud Shell, qui est préinstallé avec toutes les dépendances nécessaires (gcloud CLI, Go, Docker, Gemini CLI).

Si vous préférez travailler sur votre propre machine, vous aurez besoin des éléments suivants :

• Node.js 20 ou version ultérieure
• Un projet Google Cloud avec facturation activée
• Le SDK Google Cloud (CLI gcloud) est installé et initialisé.
• Go 1.24 ou version ultérieure installé sur votre système
• Docker installé sur votre système

Technologies clés

Vous trouverez ci-dessous plus d'informations sur les technologies que nous allons utiliser :

• Gemini CLI : interface de ligne de commande optimisée par l'IA que nous allons étendre
• Protocole MCP (Model Context Protocol) : protocole Open Source qui permet à l'interface de ligne de commande Gemini de communiquer avec notre outil personnalisé
• Go SDK pour MCP : bibliothèque Go que nous utiliserons pour implémenter notre serveur MCP.

Conseils pour réussir un atelier

Travailler avec un assistant IA est une nouvelle façon de développer des logiciels. Voici quelques conseils pour que votre expérience soit fluide et réussie :

1. N'hésitez pas à appuyer sur Échap. L'IA proposera parfois des actions ou du code avec lesquels vous ne serez pas d'accord. Utilisez la touche Échap pour annuler l'action proposée et fournir une nouvelle requête afin de l'orienter dans la bonne direction. Vous êtes le pilote.
2. Encouragez l'utilisation des outils. Si l'IA semble perdue ou invente des informations, encouragez-la à utiliser les outils à sa disposition. Les requêtes telles que "Peux-tu utiliser la recherche Google pour vérifier cela ?" ou "Utilise l'outil read_file pour comprendre le code actuel avant d'apporter des modifications" peuvent être très efficaces.
3. Résistez aux modifications manuelles. Essayez de laisser l'IA faire tout le travail. Il s'agit de la compétence de base que vous pratiquez. Toutefois, si vous devez apporter une modification manuellement, informez-en l'IA par la suite. Une requête telle que "J'ai mis à jour manuellement le fichier README.md. Veuillez le relire pour actualiser vos connaissances" permettra à l'IA de rester en phase avec votre projet.
4. Avez-vous essayé de l'éteindre et de le rallumer ? Dans le rare cas où l'IA tente d'imposer un chemin donné à l'encontre de votre commande, cela peut être dû à une dégradation du contexte (parfois appelée "perte de contexte"). Dans ce cas, vous pouvez utiliser la commande Gemini CLI "/compress" pour réduire le bruit du contexte ou, dans les cas extrêmes, la commande "/clear" pour effacer l'intégralité de l'historique des sessions.

2. Configuration de l'environnement

Configuration de l'environnement au rythme de chacun

1. Connectez-vous à la console Google Cloud, puis créez un projet ou réutilisez un projet existant. Si vous n'avez pas encore de compte Gmail ou Google Workspace, vous devez en créer un.

• Le nom du projet est le nom à afficher pour les participants au projet. Il s'agit d'une chaîne de caractères non utilisée par les API Google. Vous pourrez toujours le modifier.
• L'ID du projet est unique parmi tous les projets Google Cloud et non modifiable une fois défini. La console Cloud génère automatiquement une chaîne unique (en général, vous n'y accordez d'importance particulière). Dans la plupart des ateliers de programmation, vous devrez indiquer l'ID de votre projet (généralement identifié par PROJECT_ID). Si l'ID généré ne vous convient pas, vous pouvez en générer un autre de manière aléatoire. Vous pouvez également en spécifier un et voir s'il est disponible. Après cette étape, l'ID n'est plus modifiable et restera donc le même pour toute la durée du projet.
• Pour information, il existe une troisième valeur (le numéro de projet) que certaines API utilisent. Pour en savoir plus sur ces trois valeurs, consultez la documentation.

Attention : Un ID de projet est unique. Une fois que vous l'avez choisi, personne d'autre ne peut l'employer. Vous en êtes le seul utilisateur. Même si un projet est supprimé, son ID ne peut pas être réutilisé.

Remarque : Si vous utilisez un compte Gmail, vous pouvez conserver l'emplacement par défaut défini sur Aucune organisation. Si vous utilisez un compte Google Workspace, choisissez un emplacement qui ait du sens pour votre organisation.

2. Vous devez ensuite activer la facturation dans la console Cloud pour utiliser les ressources/API Cloud. L'exécution de cet atelier de programmation est très peu coûteuse, voire sans frais. Pour désactiver les ressources et éviter ainsi que des frais ne vous soient facturés après ce tutoriel, vous pouvez supprimer le projet ou les ressources que vous avez créées. Les nouveaux utilisateurs de Google Cloud peuvent participer au programme d'essai sans frais pour bénéficier d'un crédit de 300 $.

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

3. Premiers pas avec la CLI Gemini

Dans cette section, vous allez découvrir la CLI Gemini, y compris comment l'installer et la configurer pour votre environnement.

Qu'est-ce que Gemini CLI ?

La CLI Gemini est une interface de ligne de commande optimisée par l'IA qui peut vous aider à effectuer un large éventail de tâches de développement. Il peut comprendre le contexte de votre projet, répondre à des questions, générer du code et utiliser des outils externes pour étendre ses capacités.

Installation

Remarque : Si vous utilisez Google Cloud Shell, la Gemini CLI est déjà installée. Vous pouvez passer à la section suivante (Configuration).

Installez la CLI Gemini au niveau global à l'aide de npm.

npm install -g @google/gemini-cli

Pour vérifier que la CLI est installée, exécutez la commande suivante :

gemini --version

Configuration

Le comportement de l'interface de ligne de commande Gemini est contrôlé par des fichiers de configuration et des variables d'environnement. Deux fichiers clés sont à prendre en compte :

• GEMINI.md : ce fichier fournit des consignes et un contexte en langage naturel à l'IA. La CLI lit ce fichier pour comprendre les normes et conventions de codage de votre projet.
• .gemini/settings.json : ce fichier contrôle la configuration de la CLI, y compris la façon de se connecter à des outils externes. Nous allons utiliser ce fichier pour configurer la CLI afin qu'elle utilise le serveur MCP que nous allons créer dans cet atelier.

Nous allons d'abord configurer l'environnement, puis créer le fichier GEMINI.md. Le fichier settings.json sera configuré lors d'une étape ultérieure.

1. Créez et initialisez un répertoire de projet :

mkdir godoctor
cd godoctor
go mod init godoctor

1. Authentifiez-vous avec les identifiants par défaut de l'application Google Cloud :

Si vous utilisez Cloud Shell, cette étape est déjà effectuée pour vous. Vous pouvez passer à la section suivante (Consignes de développement).

Nous devons nous connecter à un compte ayant accès au projet GCP que vous allez utiliser pour cet atelier de programmation :

• Assurez-vous d'avoir installé et initialisé le SDK Google Cloud.
• Exécutez la commande suivante pour configurer les identifiants par défaut de l'application :

gcloud auth application-default login

4. Consignes de développement

Pour que l'assistant IA génère du code Go idiomatique et de haute qualité, il est essentiel de lui fournir des consignes claires. Cette opération est effectuée dans le fichier GEMINI.md.

Remarque : GEMINI.md peut avoir de nombreuses autres utilisations, comme informer la CLI sur la structure du projet, les pratiques de travail, les tests, etc.

Objectif : créer un fichier GEMINI.md qui servira d'ensemble de règles pour l'assistant IA pendant ce projet.

Tâche : Créez un fichier nommé GEMINI.md à la racine de votre répertoire godoctor et collez-y le contenu suivant.

# Go Development Guidelines
All code contributed to this project must adhere to the following principles.

### 1. Formatting
All Go code **must** be formatted with `gofmt` before being submitted.

### 2. Naming Conventions
- **Packages:** Use short, concise, all-lowercase names.
- **Variables, Functions, and Methods:** Use `camelCase` for unexported identifiers and `PascalCase` for exported identifiers.
- **Interfaces:** Name interfaces for what they do (e.g., `io.Reader`), not with a prefix like `I`.

### 3. Error Handling
- Errors are values. Do not discard them.
- Handle errors explicitly using the `if err != nil` pattern.
- Provide context to errors using `fmt.Errorf("context: %w", err)`.

### 4. Simplicity and Clarity
- "Clear is better than clever." Write code that is easy to understand.
- Avoid unnecessary complexity and abstractions.
- Prefer returning concrete types, not interfaces.

### 5. Documentation
- All exported identifiers (`PascalCase`) **must** have a doc comment.
- Comments should explain the *why*, not the *what*.

# Agent Guidelines
- **Reading URLs:** ALWAYS read URLs provided by the user. They are not optional.

Votre environnement de développement est désormais entièrement configuré.

5. Première compilation : un serveur godoc

Votre premier objectif est de créer la version initiale du serveur godoctor. Cette version doit être une application minimale, prête pour la production, qui fournit un outil unique appelé godoc permettant de rechercher la documentation Go.

Objectif : créer un serveur MCP prêt pour la production qui expose la commande go doc, permettant à un LLM d'interroger la documentation Go.

Exécutez la commande Gemini CLI dans le shell :

gemini

Remarque : Si vous devez installer ou mettre à jour Gemini CLI sur Cloud Shell, vous pouvez utiliser la commande suivante : sudo env PATH=$PATH npm install -g @google/gemini-cli

Lorsque vous exécutez l'interface de ligne de commande pour la première fois, vous êtes invité à choisir un mode d'authentification et un thème. Pour le mode d'authentification, choisissez"Se connecter avec Google" pour vous connecter avec un compte Google personnel et profiter du généreux forfait sans frais de Gemini CLI. Une option permettant de sélectionner votre mode d'authentification devrait s'afficher, comme suit :

Si vous devez modifier votre sélection, vous pouvez saisir /auth et appuyer sur Entrée pour rouvrir ce menu.

Vous serez ensuite invité à choisir un thème :

Comme pour /auth, vous pouvez également modifier le thème ultérieurement à l'aide de la commande /theme.

Après avoir choisi la méthode d'authentification et votre thème préféré, vous serez redirigé vers l'invite de commande. Vous pouvez y saisir vos commandes, par exemple :

Write a hello world application in Go.

La CLI utilise une combinaison de son propre raisonnement (via un modèle Gemini comme Gemini Flash ou Gemini Pro) et d'outils pour effectuer les tâches. Il utilise des outils chaque fois qu'il doit interagir avec le système de fichiers ou des services externes, comme des API, des bases de données, etc. Les outils intégrés, ou "outils internes", sont par exemple read_file, write_file, web_fetch et google_search. Le serveur MCP que nous allons créer deviendra également un outil disponible pour la CLI.

La première fois qu'il exécute un outil, il vous demande votre autorisation. Vous pouvez lui accorder une autorisation ponctuelle, une autorisation globale pour le reste de la session ou refuser sa demande. S'il s'agit d'une opération de modification de fichier, vous trouverez également l'option permettant de modifier le fichier à l'aide d'un éditeur externe, au cas où vous souhaiteriez apporter des ajustements. Par exemple, voici le résultat de la requête ci-dessus, pour créer un programme Hello World :

En plus des requêtes, vous pouvez également utiliser des commandes à barre oblique. Si vous saisissez "/", l'interface CLI vous affichera automatiquement les options de saisie semi-automatique. Vous pouvez continuer à saisir la commande complète ou en sélectionner une parmi les options. Les commandes /auth et /theme mentionnées ci-dessus en sont des exemples.

Une fois que vous vous êtes familiarisé avec l'interface, vous pouvez commencer la tâche principale de cette section, qui consiste à demander à la CLI d'écrire le serveur MCP pour nous.

Créer un serveur MCP Hello World

L'un des meilleurs moyens de s'assurer que le modèle crée des éléments de manière plus cohérente consiste à décomposer les tâches complexes en étapes incrémentales. Bien que le modèle puisse être en mesure de résoudre une tâche complexe par lui-même, sans la configuration appropriée, il lui faudra beaucoup de temps pour trouver la bonne implémentation.

Pour une approche plus cohérente, nous allons d'abord lui demander de créer un serveur MCP "Hello World" avant d'implémenter la fonctionnalité souhaitée (lecture de la documentation Go).

Voici un exemple de requête :

Your task is to create a Model Context Protocol (MCP) server to expose a "hello world" tool. For the MCP implementation, you should use the official Go SDK for MCP and use the stdio transport.

Read these references to gather information about the technology and project structure before writing any code:
- https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md
- https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle
- https://go.dev/doc/modules/layout

To test the server, use shell commands like these:
(
  echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}';
  echo '{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}';
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}';
) | ./bin/godoctor

Notez que la requête ci-dessus se compose de trois segments principaux :

1. La spécification du problème, y compris ce que nous voulons créer et les contraintes (par exemple, utiliser le SDK officiel au lieu de n'importe quel SDK)
2. Documentation de référence pour le modèle afin de l'aider à lever toute ambiguïté dans la demande
3. Une procédure de test, qui sert de critère d'acceptation pour la tâche

Ces trois composants aideront le modèle à obtenir les résultats souhaités de manière plus cohérente.

Attention : même si nous sommes très précis dans nos instructions, il arrive que le modèle s'écarte de ce que nous lui avons demandé. Il est donc important de vérifier son travail et de rester attentif aux éventuelles boucles d'erreur et hallucinations. Si le modèle est bloqué, veuillez consulter la section "Ressources utiles" à la fin de ce chapitre.

Implémentation de l'outil Go doc

Une fois que vous avez une implémentation fonctionnelle, nous pouvons passer à l'implémentation du véritable outil "go doc" :

Add a new tool to our MCP server called "godoc" that invokes the "go doc" shell command. The tool will take a mandatory "package" argument and an optional "symbol" argument.

Read the reference for the go doc command to understand its API: https://pkg.go.dev/golang.org/x/tools/cmd/godoc

Test it by executing the call with:
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name": "godoc", "arguments": {"package": "fmt"} } }'
 | ./bin/godoctor

Test it using both a standard library package and an external package like "github.com/modelcontextprotocol/go-sdk/mcp", both with and without symbols.

N'hésitez pas à tester cette requête ou à en créer une.

Remarque : La requête ci-dessus encourage explicitement le modèle à utiliser la commande shell go doc, car le code permettant de récupérer la documentation à l'aide de la bibliothèque standard n'est pas simple et le modèle peut mettre du temps à le trouver par lui-même. L'utilisation de l'outil go doc intégré au compilateur permet de gagner beaucoup de temps et de se concentrer sur l'essentiel, à savoir l'implémentation du MCP.

Une interface de ligne de commande utile

Dès que vous avez trouvé une bonne implémentation, vous pouvez demander au modèle de créer une CLI godoctor à l'aide d'un client MCP. Cela permettra de simplifier le test des fonctionnalités en évitant de créer manuellement les appels JSON-RPC comme cela a été fait jusqu'à présent.

Exemple de requête :

Now create a godoctor-cli component that will call the MCP server using command transport. This CLI will expose all tools using subcommands and allow us to test the MCP server implementation without needing to build the JSON-RPC calls manually.

Use the reference implementation at https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md to build the client.

Test it by calling from the command line:
- the hello_world tool 
- the godoc tool with a local package
- the godoc tool with a local package and symbol
- the godoc tool with an external package
- the godoc tool with an external package and symbol

Maintenant que vous disposez d'un ensemble fonctionnel de client et de serveur, vous allez configurer l'interface de ligne de commande Gemini avec le serveur MCP que vous venez de créer pour commencer à profiter de ses avantages lors de la prochaine tâche de programmation.

Ressources utiles

Remarque : Le codage avec des LLM est une expérience non déterministe. Vous n'êtes donc pas toujours assuré d'obtenir exactement les mêmes résultats, même si vous exécutez deux requêtes identiques avec le même environnement. C'est pourquoi il est important de savoir identifier quand le LLM est bloqué dans une boucle ou que son contexte est dégradé. N'oubliez pas que vous gardez le contrôle et que vous pouvez l'interrompre à tout moment en appuyant sur Échap.

Étant donné que MCP est un concept nouveau et que le SDK Go pour MCP est une nouvelle bibliothèque, Gemini peut mettre beaucoup de temps à découvrir la bonne implémentation par lui-même lors de cette étape. Pour aider le modèle à trouver la bonne solution, vous pouvez lui fournir les références suivantes :

1. Vous pouvez donner au modèle la requête suivante pour qu'il découvre l'API du SDK de manière plus cohérente : "use the go doc shell command to discover the api for the go-sdk library" (utiliser la commande shell go doc pour découvrir l'API de la bibliothèque go-sdk).
2. Si le modèle tente d'inspecter le code source du SDK avec l'outil read_file, il échouera, car la Gemini CLI ne peut pas lire les fichiers en dehors de sa portée actuelle. Vous pouvez lui demander d'utiliser les commandes cat et ls à la place, via l'outil run_shell_command.
3. Si le modèle a du mal à déboguer l'application, demandez-lui d'ajouter une journalisation plus détaillée et d'améliorer les informations contextuelles dans les messages d'erreur.
4. Si tout le reste échoue, donnez-lui une implémentation de référence : https://github.com/danicat/godoctor.

6. Configurer godoctor en tant que serveur MCP pour Gemini CLI

Une fois que l'assistant IA a généré le code pour le client et le serveur, vous pouvez lui demander d'exécuter quelques tests manuels. Exemple :

retrieve the documentation for the package net/http

Assurez-vous également de le tester avec une dépendance externe (pas dans la bibliothèque standard) :

retrieve the documentation for the go-sdk package

Une fois que vous êtes satisfait des résultats, demandez-lui d'écrire un fichier README.md contenant des instructions sur l'utilisation et le développement de ce projet.

Now write a detailed README.md file explaining both from a user and a developer perspective how to use and to build this project.

Nous allons maintenant configurer le serveur pour que la CLI Gemini puisse l'utiliser lors de la prochaine phase de développement.

1. Demandez à la CLI de mettre à jour GEMINI.md pour utiliser godoc comme méthode privilégiée pour lire la documentation :

update the GEMINI.md file to use the godoc tool to retrieve documentation about Go packages or symbols. Always prefer to use godoc over WebFetch and GoogleSearch, and only use those when godoc doesn't give a clear answer.

2. Nous devons maintenant redémarrer Gemini CLI pour le configurer. Commençons par enregistrer la session de chat pour que vous puissiez la reprendre là où vous l'avez laissée une fois qu'elle aura redémarré.

/chat save workshop001

3. Quittez l'interface de ligne de commande en appuyant deux fois sur Ctrl+D.
4. Compilez le binaire du serveur : créez un répertoire bin et compilez-y le serveur godoctor.

mkdir -p bin
go build -o ./bin/godoctor ./cmd/godoctor # adjust paths as needed

Remarque : Vous pouvez utiliser un dossier différent de celui utilisé pour créer le serveur pendant le développement, car nous voulons que ce binaire soit stable et disponible pour la CLI lors de la prochaine phase.

5. Configurez la CLI Gemini pour l'outil local : créez un fichier .gemini/settings.json à la racine de votre projet et ajoutez une section mcpServers pour indiquer à la CLI Gemini comment exécuter votre serveur compilé.

mkdir -p .gemini
touch .gemini/settings.json

6. Ajoutez maintenant le contenu suivant au nouveau fichier à l'aide d'un éditeur de ligne de commande tel que vim ou nano :

{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor"
    }
  }
}

7. Lancez maintenant Gemini CLI et restaurez la session de discussion :

/chat resume workshop001

8. Vous devriez pouvoir voir que l'outil est chargé en appuyant sur Ctrl+T :

9. Testez l'intégration en demandant à Gemini CLI d'utiliser votre outil avec une invite telle que "Obtiens la documentation pour net/http".

L'écran qui s'affiche devrait ressembler à ce qui suit :

Remarque : Il est possible que le modèle tente d'appeler l'outil via une commande shell. Si cela se produit, essayez de démarrer une session sans le contexte de la session précédente (par exemple, sans appeler /chat resume).

Si l'outil fonctionne correctement, la documentation récupérée via l'appel d'outil devrait s'afficher :

Félicitations, vous avez créé un outil MCP ! Mais ce n'est pas tout, nous pouvons encore l'améliorer.

7. Ajouter un outil d'examen du code basé sur l'IA

Important : Pour effectuer des appels d'API avec Gemini, vous devez disposer d'un projet GCP associé à un compte de facturation. Côté client, vous devez configurer une variable d'environnement appelée GEMINI_API_KEY.

La CLI Gemini dispose d'un niveau sans frais généreux pour les appels de modèles Gemini. Toutefois, si elle trouve une clé GEMINI_API_KEY, elle aura la possibilité de l'utiliser pour l'authentification à la place, ce qui contournera les quotas du niveau sans frais.

Veillez à utiliser le bon mode d'authentification pour éviter de désactiver le niveau sans frais. Vous pouvez sélectionner le mode d'authentification à l'aide de la commande /auth.

Ajoutons une fonctionnalité plus sophistiquée, optimisée par l'IA : un outil d'examen du code qui utilise l'API Gemini.

Objectif : Ajouter un nouvel outil nommé code_review au projet existant. Cet outil utilisera l'API Gemini pour analyser le code Go et fournir des commentaires.

Exemple de requête :

I want to add a new tool to my project called code_review. This tool should use the Gemini API to analyze Go code and provide a list of improvements in json format according to the best practices accepted by the Go community. The tool should take the Go code content and an optional hint as input. The hint will be used to provide additional guidance for the AI reviewer, like "focus on security" or "help me simplify this code". Please update the server to include this new tool and modify the CLI client to add a review command to use it.

Use this SDK to call Gemini: https://github.com/googleapis/go-genai

Conseils utiles

Une fois que le modèle commence à travailler dessus, il peut automatiquement demander à appeler l'outil godoc pour parcourir la documentation du package genai. Si ce n'est pas le cas, vous pouvez toujours interrompre le processus avec la touche Échap et lui rappeler qu'il dispose désormais de l'outil godoc.

Tester le vérificateur de code

1. Nous devons redémarrer Gemini CLI pour créer et recharger le serveur MCP. Enregistrez la session de chat avec /chat save workshop002, puis quittez l'interface de ligne de commande en appuyant deux fois sur Ctrl+D.
2. L'outil code_review a besoin d'une clé API, car nous appelons un modèle Gemini pour qu'il effectue les révisions pour nous. Vous pouvez générer une clé API à l'aide de Google AI Studio.
3. Configurez la variable d'environnement GEMINI_API_KEY avec la clé API générée à l'étape ci-dessus :

export GEMINI_API_KEY="YOUR_API_KEY"

4. Recompilez le serveur : après avoir ajouté le nouvel outil, vous devez recompiler le binaire du serveur pour inclure les modifications.

go build -o ./bin/godoctor ./cmd/godoctor

5. Relancez la CLI Gemini. Restaurez la session de chat avec /chat resume workshop002.
6. Important : Assurez-vous d'être authentifié avec votre compte Gmail personnel afin que la CLI Gemini elle-même n'utilise pas votre compte de facturation. Pour ce faire, exécutez la commande /auth :

7. Vérifiez que l'outil est activé en appuyant sur Ctrl+T. L'écran qui s'affiche devrait ressembler à ce qui suit :

8. Testons maintenant l'outil code-review en examinant l'un de ses fichiers sources :

"Utilisez l'outil godoctor pour examiner le fichier cmd/godoctor/main.go."

    You should see something like this:

Maintenant que l'outil de révision du code fonctionne, vous pouvez suggérer au modèle d'appliquer certaines des améliorations qu'il a trouvées, pour un workflow d'amélioration automatique complet.

Vous avez maintenant confirmé que l'outil code-review fonctionne. Dans la section suivante, vous allez déployer l'application dans le cloud.

Avertissement : Si vous utilisez le niveau sans frais de la CLI Gemini, il est recommandé de désactiver GEMINI_API_KEY avant de passer à la section suivante pour éviter d'activer la facturation par erreur. Vous pouvez toujours vérifier que vous utilisez la bonne méthode d'authentification avec la commande /auth.

Pour effacer la clé GEMINI_API_KEY :

1. Enregistrez votre session actuelle avec /chat save workshop003 et quittez la CLI.
2. Sauvegardez la clé API dans un endroit sûr :

export | grep GEMINI_API_KEY > env.bkp

3. Désactivez GEMINI_API_KEY :

export GEMINI_API_KEY=

4. Redémarrez la CLI et chargez la session avec /chat resume workshop003.
5. Demandez au modèle d'appliquer les améliorations de la revue de code.

8. Préparer votre serveur pour le cloud

Le serveur MCP que nous avons développé jusqu'à présent ne s'exécute que sur la machine locale, ce qui est acceptable si vous développez des outils pour votre propre usage. Toutefois, dans les environnements d'entreprise, nous devons souvent déployer des outils pour une utilisation plus large par des centaines, voire des milliers de développeurs.

Pour faire évoluer notre serveur MCP, nous devons le convertir d'un serveur qui ne parle que d'E/S standard à un serveur qui peut communiquer en HTTP, et le déployer quelque part où il peut être accessible par différents développeurs. Pour atteindre cet objectif, nous allons utiliser un mode de transport défini dans la spécification MCP comme HTTP diffusable et utiliser Cloud Run comme cible de déploiement.

Objectif : refactoriser le serveur godoctor pour utiliser le transport HTTP streamable.

Exemple de requête :

The godoctor server is currently using the stdio transport. I want to deploy it to Cloud Run, so I need to refactor it to use the streamable HTTP transport instead. Please modify the server to comply with the streamable HTTP specification.

Ressources utiles

1. Si le modèle a du mal à implémenter le transport HTTP en flux, vous pouvez lui fournir cette référence : https://github.com/modelcontextprotocol/go-sdk/blob/main/design/design.md.
2. Le modèle peut essayer d'utiliser HTTP+SSE, qui est obsolète. Si vous constatez qu'il emprunte ce chemin, redirigez-le vers le protocole HTTP de diffusion en continu.

Tester le serveur à l'aide de HTTP

Demandez au modèle de mettre à jour le client godoctor pour qu'il utilise également le protocole HTTP transmissible en flux afin de pouvoir tester son fonctionnement.

Now update the client to use streamable HTTP and run a test by retrieving documentation from one package

Facultatif : Si vous souhaitez configurer Gemini CLI pour qu'il utilise le serveur via HTTP :

1. Enregistrer votre session et quitter la CLI
2. Modifiez votre fichier .gemini/settings.json et changez la configuration pour qu'elle pointe vers votre serveur local en cours d'exécution.

"mcpServers": {
  "godoctor": {
    "httpUrl": "http://localhost:8080"
  }
}

3. Exécutez le serveur refactorisé localement :

go run ./cmd/godoctor/main.go

4. Dans un nouveau terminal (puisque l'opération ci-dessus est bloquante), démarrez la CLI Gemini et envoyez-lui une requête pour tester la connexion, par exemple : "Utilise l'outil godoctor pour obtenir la documentation de fmt.Println."
5. Arrêtez le serveur avec Ctrl+C lorsque vous avez terminé de tester.

9. Conteneuriser l'application avec Docker

Maintenant que notre serveur utilise le bon protocole de transport, nous pouvons le conteneuriser pour le déploiement.

Objectif : créer un fichier Dockerfile pour empaqueter le serveur godoctor dans une image de conteneur portable et prête pour la production.

Exemple de requête :

Please create a multi-stage Dockerfile that compiles the Go binary and copies it into a minimal golang image like golang:1.24-alpine.

Tester l'image Docker

Une fois le Dockerfile créé, créez l'image et exécutez-la pour vous assurer qu'elle fonctionne correctement. Vous pouvez demander à Gemini de le faire pour vous :

build the image and test the connectivity to the server using the godoctor client

Facultatif : si vous souhaitez effectuer le test manuellement :

1. Créez le conteneur :

docker build -t godoctor:latest .

2. Exécutez le conteneur localement :

docker run -p 8080:8080 -e PORT=8080 godoctor:latest

3. Testez le conteneur en cours d'exécution : dans un autre terminal, démarrez Gemini CLI et demandez-lui d'extraire la documentation.
4. Arrêtez le serveur avec Ctrl+C lorsque vous avez terminé de tester.

10. Déployer sur Cloud Run

Il est maintenant temps de déployer notre conteneur dans le cloud.

Objectif : déployer le serveur godoctor conteneurisé sur Google Cloud Run.

Conseils pour les requêtes : demandez à votre assistant IA de fournir les commandes gcloud permettant de déployer votre conteneur.

Exemple de requête :

Now please deploy this image to Cloud Run and return me an URL I can use to call the MCP tool. Deploy it to us-central1 and use the project currently configured in the environment.

Attention : Si ce projet est nouveau ou si vous utilisez Cloud Run pour la première fois dans ce projet, vous serez invité à activer les API Artifact Registry et Cloud Run.

Une fois le déploiement terminé, nous allons configurer la CLI Gemini pour qu'elle utilise l'outil que vous venez de déployer.

Demandez à Gemini de mettre à jour votre fichier .gemini/settings.json pour modifier la configuration de l'outil MCP afin qu'il pointe vers votre service déployé.

now update the .gemini/settings.json file to use this URL for the godoctor server

La section mcpServers finale doit se présenter comme suit (n'oubliez pas de remplacer l'espace réservé par l'URL réelle de votre application Cloud Run) :

"mcpServers": {
  "godoctor": {
    "httpUrl": "https://<your-cloud-run-id>.us-central1.run.app"
  }
}

Tester le déploiement Cloud Run

Vous êtes maintenant prêt pour le test de bout en bout final.

Redémarrez la Gemini CLI une dernière fois (en utilisant /chat save et /chat resume pour conserver votre contexte). L'interface CLI devrait maintenant pouvoir appeler le serveur MCP distant. Essayez de demander la documentation de n'importe quel package.

N'oubliez pas que pour utiliser l'outil d'examen du code, le service a besoin de GEMINI_API_KEY. Vous pouvez demander à la CLI Gemini de le redéployer avec le bon environnement :

update the cloud run environment to add a GEMINI_API_KEY and use the value in @env.bkp. Then update the .gemini/settings.json file with the correct service URL

Redémarrez la CLI et testez-la avec une requête :

Use the godoctor tool to review the cmd/godoctor/main.go file

La CLI Gemini se connecte maintenant à votre service Cloud Run déployé et exécute la revue du code.

Attention : Veillez à supprimer le déploiement Cloud Run avant de terminer cette session, en particulier si vous utilisez une instance Cloud Run non authentifiée, afin d'éviter des frais inattendus sur votre compte de facturation GCP.

Exemple de requête :

I'm done with my tests on the CloudRun server, please delete this deployment for me and revert my .gemini/settings.json to use the local version.

11. Félicitations !

Vous avez réussi à guider un assistant IA pour créer, conteneuriser et déployer un outil sophistiqué basé sur l'IA. Plus important encore, vous avez pratiqué la compétence essentielle du développement logiciel moderne : traduire les exigences en requêtes efficaces. Vous avez étendu la CLI Gemini avec un outil personnalisé, ce qui en fait un assistant de développement Go plus puissant et spécialisé.

Documentation de référence

• Spécifications du protocole MCP (Model Context Protocol)
• SDK Go pour MCP
• SDK Google Gen AI pour Go
• Annonce concernant la CLI Gemini
• Page d'accueil du projet Gemini CLI sur GitHub
• Documentation de la CLI Gemini