Cómo compilar un servidor de MCP con Gemini CLI y Go

1. Introducción

En este codelab, aprenderás a compilar e implementar un servidor de Protocolo de contexto del modelo (MCP) para ampliar las capacidades de Gemini CLI. Crearás godoctor, un servidor basado en Go que proporciona herramientas personalizadas para el desarrollo de Go, lo que transforma Gemini CLI de un asistente de programación de uso general en un experto especializado en desarrollo de Go.

En este codelab, se usa un enfoque “basado en instrucciones”. Actuarás como líder técnico y le darás instrucciones a tu asistente de IA (Gemini CLI). Tu objetivo es aprender a traducir los requisitos del proyecto en instrucciones eficaces y dejar que la IA se encargue de los detalles de implementación.

El núcleo de este proyecto es el Protocolo de contexto del modelo (MCP). MCP es un protocolo de código abierto que estandariza la forma en que los modelos de lenguaje grandes (LLM), como Gemini, se comunican con herramientas y servicios externos. Actúa como un puente, lo que permite que la IA acceda a información del mundo real y realice acciones más allá de su conocimiento integrado. Cuando creas un servidor de MCP, creas un complemento personalizado que Gemini CLI puede descubrir y usar, lo que le enseña nuevas habilidades de manera eficaz.

Qué aprenderás

• Cómo instalar y configurar Gemini CLI
• Cómo formular instrucciones eficaces para guiar a un asistente de IA en el desarrollo de software
• Cómo proporcionar contexto y lineamientos a un asistente de IA
• Cómo crear y configurar un servidor de MCP para aumentar las capacidades de Gemini CLI
• Cómo alojar en contenedores y, luego, implementar una aplicación de Go en Google Cloud Run

Requisitos

Este taller se puede realizar por completo en Google Cloud Shell, que viene con todas las dependencias necesarias (gcloud CLI, Go, Docker y Gemini CLI) preinstaladas.

Como alternativa, si prefieres trabajar en tu propia máquina, necesitarás lo siguiente:

• Node.js 20 o una versión posterior
• El SDK de Google Cloud (CLI de gcloud) instalado e inicializado
• Go 1.24 o una versión posterior instalada en tu sistema
• Docker instalado en tu sistema

Tecnologías clave

Aquí puedes encontrar más información sobre las tecnologías que utilizaremos:

• Gemini CLI: La interfaz de línea de comandos potenciada por IA que extenderemos
• Protocolo de contexto del modelo (MCP): El protocolo de código abierto que permite que Gemini CLI se comunique con nuestra herramienta personalizada
• SDK de Go para MCP: La biblioteca de Go que usaremos para implementar nuestro servidor de MCP

Sugerencias para realizar un codelab exitoso

Trabajar con un asistente de IA es una nueva forma de desarrollar software. Aquí tienes algunas sugerencias para que tu experiencia sea fluida y exitosa:

1. No tengas miedo de presionar Esc. A veces, la IA propondrá acciones o código con los que no estés de acuerdo. Usa la tecla Esc para cancelar la acción propuesta y proporciona una nueva instrucción para guiarla en la dirección correcta. Eres el piloto.
2. Fomenta el uso de herramientas. Si la IA parece perdida o inventa información, anímala a usar las herramientas disponibles. Las instrucciones como “¿Puedes usar la Búsqueda de Google para verificarlo?” o “Usa la herramienta read_file para comprender el código actual antes de hacer cambios” pueden ser muy eficaces.
3. Evita los cambios manuales. Intenta que la IA haga todo el trabajo. Esta es la habilidad principal que estás practicando. Sin embargo, si debes hacer un cambio manual, infórmale a la IA después. Una instrucción como “Actualicé manualmente el archivo README.md. Vuelve a leerlo para actualizar tus conocimientos” garantizará que la IA se mantenga sincronizada con tu proyecto.
4. ¿Ya probaste apagarla y volverla a encender? En el caso poco común de que la IA intente forzar una ruta determinada en contra de tu comando, podría deberse a la degradación del contexto (lo que a veces también se denomina “context rot”). En este caso, puedes usar el comando de Gemini CLI “/compress” para reducir el ruido del contexto o, en casos extremos, puedes usar el comando “/clear” para limpiar todo el historial de la sesión.

2. Configuración del entorno

Para obtener créditos de Google Cloud: Para ayudarte a comenzar, canjea tus créditos gratuitos de Google Cloud con este vínculo. Puedes seguir las instrucciones aquí para activar el crédito y crear un proyecto nuevo.

Elige una de las siguientes opciones: Configuración del entorno a su propio ritmo si deseas ejecutar este

codelab en tu propia máquina, o inicia Cloud Shell si deseas ejecutar este codelab por completo en la nube.

Configuración del entorno de autoaprendizaje

1. Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

• El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
• El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto.
• Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

Precaución: El ID del proyecto es único a nivel global y no lo puede usar nadie más después de que lo hayas seleccionado. Eres el único usuario de ese ID. Incluso si se borra un proyecto, no se puede volver a usar el ID.

Nota: Si usas una cuenta de Gmail, puedes dejar la ubicación predeterminada como Sin organización. Si usas una cuenta de Google Workspace, elige una ubicación adecuada para tu organización.

2. A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Inicia Cloud Shell

Si bien Google Cloud y Spanner se pueden operar de manera remota desde tu laptop, en este codelab usarás Google Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

En Google Cloud Console, haz clic en el ícono de Cloud Shell en la barra de herramientas en la parte superior derecha:

El aprovisionamiento y la conexión al entorno deberían tomar solo unos minutos. Cuando termine el proceso, debería ver algo como lo siguiente:

Esta máquina virtual está cargada con todas las herramientas de desarrollo que necesitarás. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Todo tu trabajo en este codelab se puede hacer en un navegador. No es necesario que instales nada.

3. Comienza a usar Gemini CLI

En esta sección, aprenderás sobre Gemini CLI, incluida la forma de instalarlo y configurarlo para tu entorno.

¿Qué es Gemini CLI?

Gemini CLI es una interfaz de línea de comandos potenciada por IA que puede ayudarte con una amplia variedad de tareas de desarrollo. Puede comprender el contexto de tu proyecto, responder preguntas, generar código y usar herramientas externas para ampliar sus capacidades.

Instalación

Nota: Si usas Google Cloud Shell, la CLI de Gemini ya está instalada y puedes pasar a la siguiente sección (Configuración).

Instala Gemini CLI de forma global con npm.

npm install -g @google/gemini-cli

Para confirmar que la CLI está instalada, ejecuta el siguiente comando:

gemini --version

Configuración

El comportamiento de Gemini CLI se controla con archivos de configuración y variables de entorno. Hay dos archivos de claves:

• GEMINI.md: Este archivo proporciona lineamientos y contexto a la IA. La CLI lee este archivo para comprender los estándares y las convenciones de programación de tu proyecto.
• .gemini/settings.json: Este archivo controla la configuración de la CLI, incluido cómo conectarse a herramientas externas. Usaremos este archivo más adelante para configurar la CLI para que use el servidor de MCP que estamos compilando en este lab.

Primero, configuraremos el entorno y, luego, crearemos el archivo GEMINI.md. El archivo settings.json se configurará en un paso posterior.

1. Crea e inicializa un directorio de proyecto:

mkdir godoctor && cd godoctor
go mod init godoctor

2. Autentica con las credenciales predeterminadas de la aplicación de Google Cloud:

Nota: Si usas Cloud Shell, la autenticación ya está cubierta.

Debemos acceder a una cuenta que tenga acceso al proyecto de GCP que usarás para este codelab:

• Asegúrate de tener instalado y también inicializado el SDK de Google Cloud.
• Ejecuta el siguiente comando para configurar las credenciales predeterminadas de la aplicación:

gcloud auth application-default login

4. Archivo de contexto (GEMINI.md)

Los archivos de contexto, que usan el nombre predeterminado GEMINI.md, se utilizan para proporcionar contexto instructivo al modelo de Gemini. Puedes usar estos archivos para dar instrucciones específicas del proyecto, definir un arquetipo o proporcionar guías de estilo de programación para que las respuestas de la IA sean más precisas y se adapten a tus necesidades.

Para garantizar que el asistente de IA genere código Go idiomático y de alta calidad, escribiremos un archivo GEMINI.md con algunas prácticas recomendadas comunes para los desarrolladores de Go.

Objetivo: Crear un archivo GEMINI.md que servirá como el conjunto de reglas para el asistente de IA durante este proyecto.

Abre tu IDE para crear el archivo GEMINI.md con el siguiente contenido. Si usas Cloud Shell, puedes abrir un editor con el siguiente comando:

cloudshell edit .

Tarea: Crea un archivo llamado GEMINI.md en la raíz de tu directorio godoctor y pega el siguiente contenido en él.

# 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

Ahora, tu entorno de desarrollo está completamente configurado.

5. La compilación inicial: un servidor de documentación

Tu primer objetivo es crear la versión inicial del servidor godoctor. Esta versión debería ser una aplicación mínima que proporcione una sola herramienta llamada read_docs que permita buscar documentación de Go.

Objetivo: Crear un servidor de MCP listo para producción que exponga el comando go doc, lo que permite que un LLM consulte la documentación de Go.

Ejecuta el comando de Gemini CLI en la shell:

gemini

Importante: Si necesitas instalar o actualizar Gemini CLI en Cloud Shell, puedes usar este comando: sudo env PATH=$PATH npm install -g @google/gemini-cli

Cuando ejecutes la CLI por primera vez, te pedirá que elijas un modo de autenticación y un tema.

Si ejecutas este codelab en Cloud Shell, elige la opción Usar las credenciales de usuario de Cloud Shell. De lo contrario, puedes usar la opción Acceder con Google para acceder con una Cuenta de Google personal y aprovechar el generoso nivel gratuito de Gemini CLI. La pantalla de selección de autenticación se verá similar a esta:

En caso de que necesites cambiar tu selección, puedes escribir /auth y presionar Intro para volver a abrir este menú.

A continuación, se te pedirá que elijas un tema:

Al igual que con /auth, también puedes cambiar el tema más tarde con el comando /theme.

Después de elegir el método de autenticación y tu tema preferido, se te llevará al símbolo del sistema. Aquí puedes escribir tus comandos, por ejemplo:

Write a hello world application in Go

La CLI usa una combinación de su propio razonamiento (a través de un modelo de Gemini como Gemini Flash o Gemini Pro) y herramientas para realizar las tareas. Usa herramientas cuando necesita interactuar con el sistema de archivos o servicios externos, como APIs, bases de datos, etcétera. Algunos ejemplos de las herramientas listas para usar o “herramientas internas” son read_file, write_file, web_fetch y google_search. El servidor de MCP que crearemos también se convertirá en una herramienta disponible para la CLI.

La primera vez que ejecute una herramienta, te pedirá permiso. Puedes otorgarle un permiso único (permitir una vez), darle una aprobación general para el resto de la sesión (permitir siempre) o denegar su solicitud. Si se trata de una operación de edición de archivos, también encontrarás la opción de editar el archivo con un editor externo, en caso de que quieras hacer algunos ajustes. Por ejemplo, este es el resultado de la instrucción anterior para crear un programa de Hello World:

Además de instrucciones, también puedes usar comandos de barra. Si escribes "/", la CLI te mostrará automáticamente las opciones de autocompletado. Puedes seguir escribiendo el comando completo o seleccionar una de las opciones. Los comandos /auth y /theme mencionados anteriormente son algunos de estos comandos.

Una vez que te familiarices con la interfaz, podrás comenzar la tarea principal de esta sección, que consiste en pedirle a la CLI que escriba el servidor de MCP por nosotros.

Crea un servidor de MCP de Hello World

Una de las mejores formas de garantizar que el modelo cree elementos de manera más coherente es desglosar las tareas complejas en pasos incrementales. Si bien el modelo puede ser capaz de resolver una tarea compleja por sí solo, sin la configuración adecuada tardará mucho tiempo en descubrir la implementación correcta.

Para un enfoque más coherente, primero le daremos instrucciones para crear un servidor de MCP de “Hello World” antes de implementar la funcionalidad que queremos (leer documentación de Go).

A continuación, se muestra un ejemplo de instrucción:

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!"

Ten en cuenta que la instrucción anterior se compone de tres segmentos principales:

1. La especificación del problema, que incluye lo que queremos crear y las restricciones (p.ej., usar el SDK oficial en lugar de cualquier SDK, transporte de stdio en lugar de http)
2. Desglose de las tareas que se deben realizar (TODOs)
3. Criterios de aceptación de la tarea, que funcionan como un procedimiento de prueba para que el agente sepa cuándo terminó

Tener estos tres componentes ayudará al modelo a lograr los resultados deseados de una manera más coherente.

Atención: Incluso cuando tus instrucciones son muy precisas, a veces el modelo puede desviarse de lo que le dijiste que hiciera, por lo que es importante verificar su trabajo y estar atento a posibles bucles de errores y alucinaciones. Si el modelo se estanca, consulta la sección Sugerencias útiles al final de este capítulo.

Implementación de la herramienta read_docs

Nota: La instrucción que se incluye a continuación alienta explícitamente al modelo a usar el comando de shell go doc porque el código para recuperar documentación con la biblioteca estándar es no trivial y el modelo podría tardar un tiempo en descubrirlo por sí solo. Usar la herramienta go doc integrada en el compilador ahorra mucho tiempo y nos ayuda a enfocarnos en lo importante, que es la implementación del MCP.

Una vez que tengas una implementación funcional, puedes pasar a implementar la herramienta “read_docs” real:

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

Nota: Puedes experimentar con esta instrucción o intentar crear una propia.

Sugerencias útiles

Nota: La programación con LLMs es una experiencia no determinista, por lo que no siempre se garantiza que obtendrás los mismos resultados exactos, incluso si ejecutas dos instrucciones idénticas con el mismo entorno. Por eso, es importante aprender a identificar cuándo el LLM está en un bucle o tiene un contexto degradado. Recuerda que tienes el control y puedes interrumpirlo en cualquier momento presionando ESC.

Dado que MCP es un concepto nuevo y que el SDK de Go para MCP es una biblioteca nueva, en este paso, Gemini podría tardar mucho en descubrir la implementación correcta por sí solo. Para ayudar al modelo a encontrar la solución correcta, puedes probar lo siguiente:

1. Si el modelo omitió la lectura de la documentación en algún paso, presiona ESC y recuérdale que lo haga. Si no conoces Go, ejecuta "go doc" más el nombre del paquete "go doc github.com/modelcontextprotocol/go-sdk/mcp" para obtener la documentación correcta.
2. El módulo de nivel superior "github.com/modelcontextprotocol/go-sdk" no tiene documentación (porque no tiene código Go), por lo que debes indicarle al modelo que busque la ruta completa.
3. Por el contrario, si el modelo alucina un paquete que no existe, p.ej., "go doc github.com/modelcontextprotocol/go-sdk/mcp/server", solo dirígelo hacia el paquete de nivel superior.

6. Configura godoctor como un servidor de MCP para Gemini CLI

Después de que el asistente de IA genere el código para el cliente y el servidor, puedes indicarle que ejecute algunas pruebas manuales. Por ejemplo:

retrieve the documentation for the package net/http

Asegúrate de probarlo también con una dependencia externa (no en la biblioteca estándar):

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

Cuando estés satisfecho con los resultados, dale la instrucción de escribir un README.md con instrucciones para usar y desarrollar este proyecto.

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

Ahora configuraremos el servidor para que Gemini CLI pueda usarlo durante la siguiente fase de desarrollo.

1. Pídele a la CLI que actualice GEMINI.md para usar read_docs como el método preferido para leer documentación:

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. Ahora debemos reiniciar Gemini CLI para configurar el servidor de MCP. Primero, guardemos la sesión de chat para que puedas reanudarla desde donde la dejaste una vez que se reinicie.

/chat save godoctor-workshop

3. Presiona Ctrl+D dos veces o escribe el comando /quit para salir de la CLI.
4. En los pasos anteriores, el agente debería haber compilado un archivo binario del servidor para ti, pero volveremos a compilar el servidor con un nombre diferente para que no se vea afectado cuando modifiquemos su código fuente:

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

5. Configura Gemini CLI para la herramienta local: Crea un archivo .gemini/settings.json en la raíz de tu proyecto y agrega una sección mcpServers para indicarle a Gemini CLI cómo ejecutar tu servidor compilado.

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

6. Ahora, agrega el siguiente contenido al archivo nuevo con el editor de Cloud Shell o tu IDE favorito.

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

7. Inicia Gemini CLI con el comando gemini
8. Para verificar que la herramienta se cargó, escribe el comando /mcp. También puedes mostrar la descripción completa de las herramientas con /mcp desc:

9. Prueba la integración pidiéndole a Gemini CLI que use tu herramienta con una instrucción como "Muéstrame la documentación del paquete net/http".

Debería ver algo como esto:

Nota: Si el modelo intenta leer la documentación con run_shell_command, cancélalo y redirígelo para que use la herramienta que acabamos de desarrollar.

Si la herramienta funciona correctamente, deberías ver la documentación recuperada a través de la llamada a la herramienta:

¡Felicitaciones, creaste una herramienta de MCP! Pero esto no es todo, aún podemos hacer que este servidor sea un poco más útil.

7. Cómo agregar un revisor de código potenciado por IA

Agreguemos una función más sofisticada potenciada por IA: un revisor de código que usa la API de Gemini.

Ahora puedes restablecer la sesión de chat anterior con el comando /chat resume godoctor-workshop.. Esto cargará el contexto de la sesión hasta el punto en el que terminamos de desarrollar read_docs, por lo que el modelo tendrá el conocimiento necesario para crear la nueva herramienta.

Esta herramienta necesitará acceso a Vertex AI, por lo que primero debemos habilitar la API. Puedes ejecutar comandos de shell sin salir de Gemini CLI escribiendo un signo de exclamación (!) en un mensaje vacío. Esto cambiará Gemini CLI al modo de shell.

Ejecuta el siguiente comando en el modo de shell para habilitar la API de Vertex AI:

gcloud services enable aiplatform.googleapis.com

Una vez que se complete el comando, puedes volver al modo de mensaje escribiendo la tecla de escape (Esc).

Importante: El SDK de go-genai usará las variables de entorno que definimos en el paso de configuración de este taller: GOOGLE_GENAI_USE_VERTEXAI, GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_LOCATION.. Si tienes algún problema, verifica que estas variables estén definidas correctamente en tu entorno.

No puedes cambiar las variables de entorno desde el modo de shell de Gemini CLI (los cambios no se conservarán), por lo que deberás salir de la CLI, definir las variables y volver a iniciar la CLI.

Objetivo: Agrega una nueva herramienta llamada code_review al proyecto existente. Esta herramienta usará la API de Gemini para analizar el código de Go y proporcionar comentarios.

Instrucción de ejemplo:

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

Sugerencias útiles

1. Una vez que el modelo comience a trabajar en ello, es posible que veas automáticamente que solicita llamar a la herramienta read_docs para explorar la documentación del paquete genai. Si no es así, siempre puedes interrumpir el proceso con la tecla de escape y recordarle que ahora tiene la herramienta read_docs a su disposición.
2. Si ves que intenta usar el SDK de IA generativa incorrecto (incluso si hay una lista clara de "no permitidos" en la instrucción), guíalo de nuevo al correcto.

Cómo probar el Revisor de código

1. Guarda la sesión de chat con /chat save godoctor-workshop y, luego, presiona Ctrl + D dos veces para salir de la CLI.
2. Vuelve a compilar el servidor con la nueva definición de la herramienta:

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

3. Con tu IDE, actualiza el archivo .gemini/settings.json para incluir la configuración del entorno de 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. Vuelve a iniciar Gemini CLI. Restablece la sesión de chat con /chat resume godoctor-workshop
5. Escribe el comando /mcp para confirmar que la herramienta esté habilitada. Debería ver algo como esto:

6. Ahora, probemos la herramienta code_review revisando uno de sus archivos fuente:

Use the code_review tool to review cmd/server/main.go

    You should see something like this:

Ahora que la herramienta de revisión de código funciona, puedes sugerirle al modelo que aplique algunas de las mejoras que encontró para lograr un flujo de trabajo de "mejora automática" completo.

Ahora confirmaste que la herramienta code-review funciona. En la siguiente sección, trabajarás en la implementación en la nube. Guarda tu sesión actual con /chat save godoctor-workshop y sal de la CLI.

8. Prepara tu servidor para la nube

El servidor de MCP que desarrollamos hasta ahora solo se ejecuta en la máquina local, lo que está bien si desarrollas herramientas para tu propio uso, pero, a menudo, en entornos empresariales, necesitamos implementar herramientas para que cientos o incluso miles de desarrolladores le den un uso más amplio.

Para escalar nuestro servidor de MCP, debemos convertirlo de un servidor que solo habla E/S estándar a un servidor que puede hablar HTTP y, luego, implementarlo en algún lugar donde pueda ser accesible para diferentes desarrolladores. Para este objetivo, usaremos un modo de transporte definido en la especificación de MCP como HTTP transmitible y Cloud Run como nuestro objetivo de implementación.

Objetivo: Refactorizar el servidor godoctor para usar el transporte HTTP transmitible.

Instrucción de ejemplo:

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

Sugerencias útiles

1. El modelo podría intentar usar HTTP+SSE en su lugar, que ya no se obsoleto. Si ves que sigue esta ruta, redirígelo de nuevo hacia HTTP transmitible.
2. La versión actual de Gemini CLI (0.26.0) no admite la ejecución de procesos en segundo plano (cualquier proceso que se inicie con run_shell_command se detiene una vez que se devuelve la llamada a la herramienta), por lo que le pedimos a Gemini que automatice el proceso de prueba con una secuencia de comandos. Esta función está planificada y se agregará en el futuro cercano, lo que puede simplificar el proceso de prueba.

Opcional: Cómo probar el servidor de MCP con HTTP

Si quieres configurar Gemini CLI para que use el servidor a través de HTTP, haz lo siguiente:

1. Guarda tu sesión y sal de la CLI
2. Edita el archivo .gemini/settings.json y cambia la configuración para que apunte a tu servidor local en ejecución.

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

3. En una segunda terminal, ejecuta el servidor habilitado para HTTP de forma local:

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

4. Reinicia Gemini CLI y dale una instrucción para probar la conexión, p.ej., "Usa la herramienta godoctor para obtener la documentación de fmt.Println".
5. Cuando termines de realizar las pruebas, detén el servidor con Ctrl+C.

9. Organiza la aplicación en contenedores con Docker

Ahora que nuestro servidor usa el protocolo de transporte correcto, podemos alojarlo en un contenedor para la implementación.

Objetivo: Crear un Dockerfile para empaquetar el servidor godoctor en una imagen de contenedor portátil y lista para producción.

Instrucción de ejemplo:

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

Opcional: Prueba manual de la imagen de Docker

Después de crear el Dockerfile, compila la imagen y ejecútala para asegurarte de que funcione correctamente.

1. Compila el contenedor:

docker build -t godoctor:latest .

2. Ejecuta el contenedor de forma local:

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

3. Prueba el contenedor en ejecución: En otra terminal, inicia Gemini CLI y pídele que recupere documentación.
4. Cuando termines de realizar las pruebas, detén el servidor con Ctrl+C.

10. Implementa en Cloud Run

Ahora es el momento de implementar nuestro contenedor en la nube.

Objetivo: Implementar el servidor godoctor alojado en contenedores en Google Cloud Run.

Instrucción de ejemplo:

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

Atención: Si es la primera vez que usas Cloud Run en este proyecto, se te pedirá que habilites las APIs de Artifact Registry y Cloud Run.

Una vez que finalice la implementación, configuraremos Gemini CLI para usar la herramienta que acabas de implementar.

Actualiza tu archivo .gemini/settings.json para cambiar la configuración de la herramienta de MCP y que apunte a tu servicio implementado, o pídele a Gemini CLI que lo haga por ti:

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

La sección final mcpServers debería verse así (recuerda reemplazar el marcador de posición por la URL real de tu app de Cloud Run):

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

Prueba la implementación de Cloud Run

Ahora estás listo para la prueba final de extremo a extremo.

Reinicia Gemini CLI por última vez (con /chat save y /chat resume si quieres conservar tu contexto). Ahora, CLI debería poder llamar al servidor de MCP remoto. Prueba pedir documentación para cualquier paquete.

También puedes probar la herramienta de revisión de código:

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

Limpieza

Atención: Asegúrate de borrar la implementación de Cloud Run antes de finalizar esta sesión, en especial si usas una instancia de Cloud Run no autenticada para evitar cargos inesperados en tu cuenta de facturación de GCP.

Cuando termines de realizar las pruebas, recuerda limpiar el entorno. Puedes indicarle a Gemini que borre tu proyecto o que solo quite la implementación de Cloud Run. Ejemplo de instrucción:

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. ¡Felicitaciones!

Guiaste correctamente a un asistente de IA para crear, alojar en contenedores y, luego, implementar una herramienta sofisticada y potenciada por IA. Lo que es más importante, practicaste la habilidad esencial del desarrollo de software moderno: traducir requisitos en instrucciones eficaces. Extendiste correctamente Gemini CLI con una herramienta de MCP personalizada, lo que la convierte en un asistente de desarrollo de Go más potente y especializado.

Documentos de referencia

• Blog del anuncio de Gemini CLI
• Página principal de Gemini CLI
• Documentación de Gemini CLI
• Especificación del Protocolo de contexto del modelo
• SDK de Go para MCP
• SDK de Go para IA generativa de Google