Créer un serveur MCP avec la CLI Gemini et Go

1. Introduction

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

Cet atelier de programmation adopte une approche "pilotée par des prompts". Vous jouerez le rôle d'un responsable technique qui envoie des requêtes à son assistant IA (Gemini CLI). Votre objectif est d'apprendre à traduire les exigences d'un projet en prompts efficaces et à laisser l'IA gérer les détails de l'implémentation.

Le Model Context Protocol (MCP) est au cœur de ce projet. MCP est un protocole Open Source qui standardise la façon dont les grands modèles de langage (LLM) comme Gemini communiquent avec des outils et des 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 Gemini CLI peut découvrir et utiliser, ce qui lui permet d'acquérir de nouvelles compétences.

Points abordés

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

Prérequis

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

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

• Node.js 20 ou version ultérieure
• Google Cloud SDK (CLI gcloud) 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 ici plus d'informations sur les technologies que nous allons utiliser :

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

Conseils pour réussir un atelier de programmation

Une nouvelle façon de développer des logiciels consiste à utiliser un assistant IA. Voici quelques conseils pour que votre expérience se déroule au mieux :

1. N'hésitez pas à appuyer sur Échap. L'IA peut parfois proposer des actions ou du code qui ne vous conviennent pas. Utilisez la touche Échap pour annuler l'action proposée et fournir un nouveau prompt pour l'orienter dans la bonne direction. Vous décidez.
2. Encouragez l'utilisation des outils. Si l'IA semble perdue ou invente des informations, encouragez-la à utiliser les outils dont elle dispose. Des prompts tels que "Peux-tu utiliser la recherche Google pour vérifier cela ?" ou "Utilise l'outil read_file pour comprendre le code actuel avant d'y apporter des modifications" peuvent être très efficaces.
3. Résistez à la tentation d'apporter des modifications manuelles. Essayez de confier tout le travail à l'IA. C'est la compétence essentielle que vous êtes en train de développer. Toutefois, si vous devez effectuer une modification manuelle, signalez-la à l'IA par la suite. Un prompt du type "J'ai modifié manuellement le fichier README.md. Relis-le pour rafraîchir tes connaissances" permet de s'assurer que l'IA reste en phase avec votre projet.
4. Avez-vous essayé de l'éteindre et de le redémarrer ? Dans les rares cas où l'IA tenterait d'imposer une direction contraire à vos instructions, cela peut être dû à une dégradation du contexte (parfois appelée "context rot"). Dans ce cas, vous pouvez utiliser la commande "/compress" de Gemini CLI pour réduire le bruit contextuel ou, dans les cas extrêmes, la commande "/clear" pour effacer l'historique de la session.

2. Configuration de l'environnement

Pour les crédits Google Cloud : pour vous aider à démarrer, utilisez ce lien pour profiter de vos crédits Google Cloud sans frais. Pour activer le crédit et créer un projet, suivez ces instructions.

Choisissez l'une des options suivantes : Configuration de l'environnement à votre rythme si vous souhaitez exécuter cette

l'atelier de programmation sur votre propre machine, ou démarrer Cloud Shell si vous souhaitez exécuter cet atelier de programmation entièrement dans le cloud.

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 ne possédez 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 Gemini CLI

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

Qu'est-ce que Gemini CLI ?

Gemini CLI 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. Elle 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, Gemini CLI est déjà installé. Vous pouvez passer à la section suivante (Configuration).

Installez Gemini CLI 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 Gemini CLI est contrôlé par des fichiers de configuration et des variables d'environnement. Il existe deux fichiers clés :

• GEMINI.md : ce fichier fournit des instructions et un contexte à 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 méthode de connexion à des outils externes. Nous utiliserons ce fichier plus tard 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

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

Remarque : Si vous utilisez Cloud Shell, l'authentification est déjà effectuée pour vous.

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. Fichier de contexte (GEMINI.md)

Les fichiers de contexte, qui utilisent le nom par défaut GEMINI.md, servent à fournir un contexte d'instructions au modèle Gemini. Vous pouvez utiliser ces fichiers pour fournir des instructions spécifiques à un projet, définir un persona ou fournir des guides de style de codage afin de rendre les réponses de l'IA plus précises et adaptées à vos besoins.

Pour que l'assistant IA génère du code Go idiomatique de haute qualité, nous allons écrire un fichier GEMINI.md contenant quelques bonnes pratiques courantes pour les développeurs Go.

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

Ouvrez votre IDE pour créer le fichier GEMINI.md avec le contenu ci-dessous. Si vous utilisez Cloud Shell, vous pouvez ouvrir un éditeur à l'aide de la commande ci-dessous :

cloudshell edit .

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*.

## 6. Project structure
- cmd/ contains source code for target binaries (e.g. server, client)
- internal/ contains source code for packages not meant to be exported (e.g. internal/tools/hello)
- bin/ contains the compiled binaries
- At the root place README.md, go.mod and go.sum

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

5. Première compilation : un serveur de documentation

Votre premier objectif est de créer la version initiale du serveur godoctor. Cette version doit être une application minimale qui fournit un seul outil appelé read_docs, permettant de consulter 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

Important : 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 la CLI pour la première fois, il vous est demandé de choisir un mode d'authentification et un thème.

Si vous exécutez cet atelier de programmation dans Cloud Shell, sélectionnez l'option Utiliser les identifiants utilisateur Cloud Shell. Si ce n'est pas le cas, vous pouvez utiliser Se connecter avec Google pour vous connecter avec un compte Google personnel et profiter du généreux forfait sans frais de Gemini CLI. L'écran de sélection de l'authentification ressemblera à ceci :

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 aussi changer de thème plus tard avec la commande /theme.

Après avoir choisi la méthode d'authentification et votre thème préféré, vous êtes redirigé vers l'invite de commande. C'est ici que vous pouvez saisir vos commandes, par exemple :

Write a hello world application in Go

La CLI utilise une combinaison de son propre raisonnement (à l'aide d'un modèle Gemini tel que Gemini Flash ou Gemini Pro) et d'outils pour effectuer les tâches. Elle utilise des outils chaque fois qu'elle doit communiquer avec le système de fichiers ou des services externes, comme des API, des bases de données, etc. Les outils internes incluent read_file, write_file, web_fetch et google_search. Le serveur MCP que nous allons créer deviendra également un outil disponible dans la CLI.

La première fois qu'il exécute un outil, il vous demande votre autorisation. Vous pouvez lui accorder une autorisation ponctuelle (autoriser une seule fois), une autorisation globale pour le reste de la session (autoriser toujours) 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 effectuer des ajustements. Par exemple, voici le résultat de la requête ci-dessus, pour créer un programme Hello World :

En plus des prompts, vous pouvez utiliser des commandes à barre oblique. Si vous saisissez "/", la CLI affiche automatiquement les options de saisie semi-automatique. Vous pouvez continuer à saisir la commande complète ou sélectionner l'une des 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 génère des éléments de façon plus cohérente consiste à décomposer les tâches complexes en étapes incrémentales. Même si le modèle est capable de résoudre une tâche complexe par lui-même, sans la bonne configuration, il mettra beaucoup de temps à 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 :

Create a Model Context Protocol (MCP) server that exposes a "hello_world" tool. This tool, when called, should return the message "Hello, MCP world!"

For the MCP implementation, you should use the official Go SDK for MCP (github.com/modelcontextprotocol/go-sdk/mcp) and use the stdio transport.

TODO:
- Download the dependency: `go get github.com/modelcontextprotocol/go-sdk/mcp`
- Inspect the documentation of the SDK: `go doc github.com/modelcontextprotocol/go-sdk/mcp`
- Build a `server` command that supports stdio transport only
- Build a `client` command that connects to the server over command transport to test the server

Acceptance Criteria:
- `./bin/client --list-tools` returns the list of server tools including "hello_world"
- `./bin/client --call-tool` "hello_world" returns the output "Hello, MCP world!"

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, le transport stdio au lieu de http)
2. Décomposition des tâches à effectuer (TODO)
3. Critères d'acceptation pour la tâche, qui servent de procédure de test pour que l'agent sache quand il a terminé

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

Attention : Même si vous êtes très précis dans vos instructions, il arrive que le modèle s'écarte de ce que vous lui avez 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 se bloque, veuillez consulter la section "Conseils utiles" à la fin de ce chapitre.

Implémentation de l'outil read_docs

Remarque : Le prompt ci-dessous 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'outil go doc intégré au compilateur permet de gagner beaucoup de temps et de se concentrer sur l'essentiel, à savoir l'implémentation de MCP.

Une fois que vous disposez d'une implémentation fonctionnelle, vous pouvez passer à l'implémentation du véritable outil "read_docs" :

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

TODO:
- create a package `./internal/tools/docs`
- register the tool with the MCP server
- update the client to support the "read_docs" tool by providing arguments to the tool call

Acceptance Criteria:
- `./bin/client --tools-list` show both hello_world and read_docs
- `./bin/client --tool-call read_docs fmt` returns the documentation for the `fmt` package
- `./bin/client --tool-call read_docs fmt.Println` returns the documentation for the `fmt.Println` function
- `./bin/client --tool-call read_docs github.com/modelcontextprotocol/go-sdk/mcp` returns documentation for the `mcp` package

Remarque : N'hésitez pas à tester ce prompt ou à en créer un autre.

Conseils 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 dans le même environnement. C'est pourquoi il est important d'apprendre à identifier les cas où le LLM est bloqué dans une boucle ou a dégradé le contexte. N'oubliez pas que vous gardez le contrôle et que vous pouvez interrompre le processus à tout moment en appuyant sur Échap.

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

1. Si le modèle a ignoré la lecture de la documentation à une étape quelconque, appuyez sur ÉCHAP et rappelez-lui de le faire. Si vous ne connaissez pas Go, exécutez "go doc" suivi du nom du package "go doc github.com/modelcontextprotocol/go-sdk/mcp" pour obtenir la documentation appropriée.
2. Le module de premier niveau github.com/modelcontextprotocol/go-sdk ne contient pas de documentation (car il ne contient pas de code Go). Vous devez indiquer au modèle de rechercher le chemin d'accès complet.
3. À l'inverse, si le modèle hallucine un package qui n'existe pas, par exemple "go doc github.com/modelcontextprotocol/go-sdk/mcp/server", il suffit de l'orienter vers le package de premier niveau.

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 d'effectuer un test avec une dépendance externe (qui ne fait pas partie de la bibliothèque standard) :

retrieve the documentation for the github.com/modelcontextprotocol/go-sdk/mcp package

Une fois que vous êtes satisfait des résultats, demandez-lui de rédiger 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 Gemini CLI puisse l'utiliser lors de la prochaine phase de développement.

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

update the GEMINI.md file to include instructions to always use the read_docs tool to retrieve documentation about Go packages or symbols. This should be done whenever seeing an import for the first time in a session or after a new dependency is installed to the project (e.g. via `go get`)

2. Nous devons maintenant redémarrer Gemini CLI pour configurer le serveur MCP. Tout d'abord, enregistrons la session de chat pour que vous puissiez la reprendre là où vous l'avez laissée après un redémarrage.

/chat save godoctor-workshop

3. Quittez la CLI en appuyant deux fois sur Ctrl+D ou en saisissant la commande /quit.
4. Lors des étapes précédentes, l'agent aurait dû compiler un binaire de serveur pour vous. Toutefois, nous compilons à nouveau le serveur avec un nom différent afin qu'il ne soit pas affecté lorsque nous modifierons son code source :

mkdir -p bin && go build -o ./bin/godoctor ./cmd/server

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

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

6. Ajoutez maintenant le contenu suivant au nouveau fichier à l'aide de l'éditeur Cloud Shell ou de votre IDE préféré.

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

7. Lancer Gemini CLI avec la commande gemini
8. Vous devriez pouvoir voir que l'outil est chargé en saisissant la commande /mcp. Vous pouvez également afficher la description complète des outils à l'aide de /mcp desc :

9. Testez l'intégration en demandant à Gemini CLI d'utiliser votre outil avec un prompt tel que "Affiche-moi la documentation du package net/http".

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

Remarque : Si le modèle tente de lire la documentation à l'aide de run_shell_command, annulez l'opération et redirigez-le pour qu'il utilise l'outil que nous venons de développer.

Si l'outil fonctionne correctement, vous devriez voir la documentation récupérée par l'appel de l'outil :

Félicitations, vous avez créé un outil MCP ! Mais ce n'est pas tout, nous pouvons encore rendre ce serveur un peu plus utile.

7. Ajouter un outil d'examen du code optimisé par l'IA

Ajoutons une fonctionnalité plus sophistiquée, optimisée par l'IA : un outil de révision de code qui utilise l'API Gemini.

Vous pouvez maintenant restaurer la session de chat précédente avec la commande /chat resume godoctor-workshop.. Le contexte de la session sera chargé jusqu'au point où nous avons terminé de développer read_docs. Le modèle disposera donc des connaissances nécessaires pour créer le nouvel outil.

Cet outil aura besoin d'accéder à Vertex AI. Nous devons donc d'abord activer l'API. Vous pouvez exécuter des commandes shell sans quitter Gemini CLI en saisissant un point d'exclamation (!) dans une invite vide. Gemini CLI passe alors en mode shell.

Exécutez la commande suivante en mode Shell pour activer l'API Vertex AI :

gcloud services enable aiplatform.googleapis.com

Une fois la commande exécutée, vous pouvez revenir au mode requête en appuyant sur la touche Échap.

Important : Le SDK go-genai utilisera les variables d'environnement que nous avons définies lors de l'étape de configuration de cet atelier : GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_LOCATION.. En cas de problème, vérifiez que ces variables sont correctement définies dans votre environnement.

Vous ne pouvez pas modifier les variables d'environnement en mode shell Gemini CLI (les modifications ne seront pas conservées). Vous devrez donc quitter la CLI, définir les variables et redémarrer la CLI.

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 :

Add a new tool to my project called code_review. This tool should use the Gemini API on Vertex AI (with model id gemini-2.5-pro) to analyze Go code and provide a list of improvements 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".

The tool output should be text in Markdown format.

TODO:
- add the genai SDK dependency with `go get import google.golang.org/genai`
- create the tool code in ./internal/tools/code/review.go
- create a code review prompt to be used by the tool
- use go-genai with Vertex AI authentication to call gemini-2.5-pro
- register the tool with the server
- add a flag to the server to set the Google Cloud Project ID: --project
- add a flag to the server to set the Google Cloud Location: --location
- add support to the review tool in the client CLI

NOT TO DO:
- DO NOT use the package github.com/google/generative-ai-go/genai as it is DEPRECATED
- DO NOT use the package cloud.google.com/go/vertexai/genai as it has been superseded by google.golang.org/genai

Acceptance Criteria:
- `./bin/client --tools-list` show all tools including `code_review`
- `./bin/client --tool-call code_review internal/tools/code/review.go` returns the code review for the "review.go" file

Conseils utiles

1. Une fois que le modèle commence à travailler dessus, il peut automatiquement demander à appeler l'outil read_docs 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 read_docs.
2. Si vous constatez qu'il essaie d'utiliser le mauvais SDK d'IA générative (même s'il existe une liste claire des SDK "non autorisés" dans l'invite), redirigez-le vers le bon.

Tester le vérificateur de code

1. Enregistrez la session de chat avec /chat save godoctor-workshop, puis quittez la CLI en appuyant deux fois sur Ctrl+D.
2. Recompilez le serveur avec la nouvelle définition d'outil :

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

3. À l'aide de votre IDE, mettez à jour le fichier .gemini/settings.json pour inclure la configuration de l'environnement pour Vertex AI :

{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor",
      "env": {
        "GOOGLE_CLOUD_USE_VERTEXAI": "true",
        "GOOGLE_CLOUD_PROJECT": "<your-project-id>",
        "GOOGLE_CLOUD_LOCATION": "<your-preferred-region>"
      }
    }
  }
}

4. Relancez Gemini CLI. Restaurer la session de chat avec /chat resume godoctor-workshop
5. Vérifiez que l'outil est activé en saisissant la commande /mcp. L'écran qui s'affiche devrait ressembler à ce qui suit :

6. Testons maintenant l'outil code_review en examinant l'un de ses fichiers sources :

Use the code_review tool to review cmd/server/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. Enregistrez votre session actuelle avec /chat save godoctor-workshop et quittez la CLI.

8. Préparez 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 convient si vous développez des outils pour votre propre usage. Cependant, dans les environnements d'entreprise, il est souvent nécessaire de 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 faire passer d'un serveur qui ne communique qu'avec des E/S standards à un serveur qui peut communiquer en HTTP, et le déployer dans un emplacement où il est 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 transmissible en flux, et utiliser Cloud Run comme cible de déploiement.

Objectif : refactoriser le serveur godoctor pour qu'il utilise le transport HTTP en flux.

Exemple de requête :

The godoctor server is currently using the stdio transport. I want to prepare it to be deployed to Cloud Run, so we need to add support to use the Streamable HTTP transport.

TODO:
- Update server to enable Streamable HTTP via the -http flag.
- An optional -listen flag can be specified to set the port to listen
- If no -http flag is specified, the server defaults to stdio transport and -listen is ignored
- Update client to use Streamable HTTP via the -addr flag
- If no flag is specified, the client defaults to command transport
- Create a shell script test_server.sh to support testing

NOT TO DO:
- DO NOT use the HTTP+SSE protocol as it has been deprecated by the MCP specification

Acceptance Criteria
- Create a shell script that:
  - Runs the server in the background;
  - Runs the client connecting over HTTP and call list tools
  - Kills the background process
- The shell script should run without failures

Conseils utiles

1. Le modèle peut essayer d'utiliser HTTP+SSE, qui est obsolète. Si vous voyez que le contenu emprunte ce chemin, redirigez-le vers le protocole HTTP en flux continu.
2. La version actuelle de Gemini CLI (0.26.0) ne permet pas d'exécuter des processus en arrière-plan (tout processus lancé avec run_shell_command est arrêté une fois l'appel d'outil renvoyé). Nous demandons donc à Gemini d'automatiser le processus de test à l'aide d'un script. Cette fonctionnalité est prévue et sera ajoutée prochainement. Elle permettra de simplifier le processus de test.

Facultatif : Tester le serveur MCP à l'aide du protocole HTTP

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. Dans un deuxième terminal, exécutez le serveur HTTP activé localement :

go build -o ./bin/godoctor ./cmd/server && ./bin/godoctor -listen=:8080

4. Redémarrez Gemini CLI et saisissez un prompt 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 protocole de transport approprié, 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.25.6-alpine. The image should support the following environment variables:
- GOOGLE_CLOUD_USE_VERTEXAI
- GOOGLE_CLOUD_PROJECT
- GOOGLE_CLOUD_LOCATION

Acceptance Criteria:
- The image builds successfully
- Create a script test_docker.sh to launch the docker image in background and test the connectivity with the client:
    - Call list_tools on the client pointing to the server running on Docker
    - Call read_docs for fmt.Println
    - Stop the server
- The script should run without failures

Facultatif : Tester manuellement l'image Docker

Une fois le Dockerfile créé, concevez l'image et exécutez-la pour vous assurer qu'elle fonctionne correctement.

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.

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. Configure Cloud Run to use the following environment variables:
- GOOGLE_CLOUD_USE_VERTEXAI: true,
- GOOGLE_CLOUD_PROJECT: <your-project-id>
- GOOGLE_CLOUD_LOCATION: <your-preferred-region>

TODO:
- Run `docker build -t gcr.io/daniela-genai-sandbox/godoctor .`
- Run `gcloud run deploy godoctor --image` with the image created above

Acceptance Criteria:
- Call list-tools with the client pointing to the CloudRun endpoint

Attention : 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 Gemini CLI pour qu'il utilise l'outil que vous venez de déployer.

Mettez à jour votre fichier .gemini/settings.json pour que la configuration de l'outil MCP pointe vers votre service déployé, ou demandez à Gemini CLI de le faire pour vous :

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

La section mcpServers finale doit ressembler à ceci (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 à effectuer le test de bout en bout final.

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

Vous pouvez également tester l'outil d'examen du code :

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

Nettoyage

Attention : Assurez-vous de 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.

Une fois les tests terminés, n'oubliez pas de nettoyer l'environnement. Vous pouvez demander à Gemini de supprimer votre projet ou de simplement supprimer le déploiement Cloud Run. 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 guidé un assistant IA pour créer, conteneuriser et déployer un outil sophistiqué optimisé par l'IA. Plus important encore, vous avez exercé une compétence essentielle du développement logiciel moderne : traduire des exigences en prompts efficaces. Vous avez étendu Gemini CLI avec un outil MCP personnalisé, ce qui en fait un assistant de développement Go plus puissant et spécialisé.

Documentation de référence

• Blog annonçant le lancement de Gemini CLI
• Page d'accueil de Gemini CLI
• Documentation Gemini CLI
• Spécification du protocole MCP (Model Context Protocol)
• SDK Go pour MCP
• SDK Go pour l'IA générative Google