Cómo compilar un asistente de programación con Gemini CLI, MCP y Go

1. Introducción

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

En este codelab, se usa un enfoque "basado en instrucciones". Actuarás como líder técnico y proporcionarás instrucciones a tu asistente de IA (la propia CLI de Gemini). 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 Protocolo de contexto del modelo (MCP) es el núcleo de este proyecto. El 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 compilas un servidor de MCP, creas un complemento personalizado que la CLI de Gemini puede descubrir y usar, lo que le enseña nuevas habilidades de manera eficaz.

Qué aprenderás

• Cómo instalar y configurar la CLI de Gemini
• 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 la CLI de Gemini
• Cómo alojar en contenedores e implementar una aplicación de Go en Google Cloud Run

Requisitos

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

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

• Node.js 20 o una versión posterior
• Un proyecto de Google Cloud con la facturación habilitada.
• El SDK de Google Cloud (CLI de gcloud) instalado y, luego, 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:

• CLI de Gemini: La interfaz de línea de comandos potenciada por IA que extenderemos
• Protocolo de contexto del modelo (MCP): Es el protocolo de código abierto que permite que la CLI de Gemini 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. Estas son 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. Tú 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 verificar eso?" o "Usa la herramienta read_file para comprender el código actual antes de realizar cambios" pueden ser muy eficaces.
3. Resiste los cambios manuales. Intenta que la IA realice todo el trabajo. Esta es la habilidad principal que estás practicando. Sin embargo, si debes realizar 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 apagarlo y volverlo a encender? En el caso poco frecuente de que la IA intente forzar una ruta determinada en contra de tu comando, es posible que se deba a una degradación del contexto (a veces también denominada "pérdida de contexto"). En este caso, puedes usar el comando de la CLI de Gemini "/compress" para reducir el ruido del contexto o, en casos extremos, puedes usar el comando "/clear" para borrar todo el historial de la sesión.

2. Configuración del entorno

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. Primeros pasos con la CLI de Gemini

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

¿Qué es la CLI de Gemini?

La CLI de Gemini 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 la CLI de Gemini se controla con archivos de configuración y variables de entorno. Hay dos archivos clave:

• GEMINI.md: Este archivo proporciona contexto y lineamientos en lenguaje natural a la IA. La CLI lee este archivo para comprender los estándares y las convenciones de codificación de tu proyecto.
• .gemini/settings.json: Este archivo controla la configuración de la CLI, incluida la forma de conectarse a herramientas externas. Usaremos este archivo para configurar la CLI de modo que use el servidor de MCP que compilaremos 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

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

Si usas Cloud Shell, este paso ya está cubierto. Puedes pasar a la siguiente sección (Lineamientos de desarrollo).

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. Lineamientos de desarrollo

Para garantizar que el asistente de IA genere código Go idiomático y de alta calidad, es fundamental proporcionarle instrucciones claras. Esto se hace en el archivo GEMINI.md.

Nota: GEMINI.md puede tener muchos otros usos, como informar a la CLI sobre la estructura del proyecto, las prácticas de trabajo, las pruebas y mucho más.

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

Tarea: Crea un archivo llamado GEMINI.md en la raíz de tu directorio de 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*.

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

Ahora, tu entorno de desarrollo está completamente configurado.

5. La compilación inicial: un servidor godoc

Tu primer objetivo es crear la versión inicial del servidor godoctor. Esta versión debe ser una aplicación mínima lista para producción que proporcione una sola herramienta llamada godoc que permita buscar documentación de Go.

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

Ejecuta el comando de Gemini CLI en la shell:

gemini

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

Cuando ejecutes la CLI por primera vez, se te pedirá que elijas un modo de autenticación y un tema. En el modo de autenticación, elige "Acceder con Google" para acceder con una Cuenta de Google personal y aprovechar el generoso nivel gratuito de la CLI de Gemini. Deberías ver una opción para seleccionar tu modo de autenticación 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:

De forma similar a /auth, también puedes cambiar el tema más adelante con el comando /theme.

Después de elegir el método de autenticación y el tema que prefieras, se te dirigirá 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 estamos creando 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, una aprobación general para el resto de la sesión o rechazar su solicitud. Si se trata de una operación de edición de archivos, también encontrarás la opción para 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 las 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, puedes comenzar la tarea principal de esta sección, que consiste en pedirle a la CLI que escriba el servidor de MCP por nosotros.

Cómo crear 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 dividir las tareas complejas en pasos incrementales. Si bien el modelo puede resolver una tarea compleja por sí solo, sin la configuración adecuada, tardará mucho en descubrir la implementación correcta.

Para lograr un enfoque más coherente, primero le indicaremos que cree un servidor de MCP de "Hello World" antes de implementar la funcionalidad que queremos (leer la documentación de Go).

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

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

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

1. La especificación del problema, incluido lo que queremos compilar y las restricciones (p.ej., usar el SDK oficial en lugar de cualquier SDK)
2. Documentación de referencia para ayudar al modelo a desambiguar la solicitud
3. Un procedimiento de prueba que funciona como criterio de aceptación de la tarea

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

Atención: Aunque somos muy precisos en nuestras instrucciones, a veces el modelo puede desviarse de lo que le indicamos, por lo que es importante verificar su trabajo y estar atento a posibles bucles de errores y alucinaciones. Si el modelo se atasca, consulta la sección Recursos útiles al final de este capítulo.

Implementación de la herramienta de documentación de Go

Una vez que tengas una implementación que funcione, podemos pasar a implementar la herramienta real "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.

Puedes experimentar con esta instrucción o intentar crear una por tu cuenta.

Nota: La instrucción anterior alienta explícitamente al modelo a usar el comando de shell go doc porque el código para recuperar la documentación con la biblioteca estándar no es trivial y es posible que el modelo tarde un tiempo en resolverlo 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 interfaz de línea de comandos útil

En cuanto te decidas por una buena implementación, puedes indicarle al modelo que cree una CLI de godoctor con un cliente de MCP. Esto ayudará a optimizar las pruebas de funciones, ya que no será necesario compilar las llamadas a JSON-RPC de forma manual, como se ha hecho hasta ahora.

Ejemplo de instrucción:

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

Ahora que tienes un conjunto de cliente y servidor en funcionamiento, en la siguiente sección configurarás la CLI de Gemini con el servidor de MCP que acabas de crear para comenzar a aprovechar sus beneficios en la siguiente tarea de programación.

Recursos ú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, identificar cuándo el LLM se atasca en un bucle o tiene un contexto degradado es una habilidad importante que se debe desarrollar. Recuerda que tienes el control y puedes interrumpir el proceso en cualquier momento presionando ESC.

Dado que MCP sigue siendo un concepto nuevo y que el SDK de Go para MCP es una biblioteca nueva, en este paso, es posible que Gemini tarde mucho en descubrir la implementación correcta por su cuenta. Para ayudar al modelo a encontrar la solución correcta, puedes proporcionarle las siguientes referencias:

1. Puedes darle al modelo la siguiente instrucción para que descubra la API del SDK de manera más coherente: "usa el comando de shell go doc para descubrir la API de la biblioteca go-sdk".
2. Si el modelo intenta inspeccionar el código fuente del SDK con la herramienta read_file, fallará porque la CLI de Gemini no puede leer archivos fuera de su alcance actual. Puedes indicarle que use los comandos cat y ls en su lugar a través de la herramienta run_shell_command.
3. Si el modelo tiene problemas para depurar la aplicación, indícale que agregue un registro más detallado y mejore la información contextual en los mensajes de error.
4. Si todo lo demás falla, proporciona una implementación de referencia: https://github.com/danicat/godoctor

6. Cómo configurar godoctor como servidor de MCP para la CLI de Gemini

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 go-sdk package

Cuando estés conforme con los resultados, pídele que escriba un archivo 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 la CLI de Gemini pueda usarlo durante la siguiente fase de desarrollo.

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

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

/chat save workshop001

3. Presiona Ctrl + D dos veces para salir de la CLI.
4. Compila el archivo binario del servidor: Crea un directorio bin y compila el servidor de godoctor en él.

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

Nota: Es posible que desees usar una carpeta diferente de la que se usó para compilar el servidor durante el desarrollo, ya que queremos que este archivo binario sea estable y esté disponible para la CLI durante la siguiente fase.

5. Configura la CLI de Gemini 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 la CLI de Gemini cómo ejecutar tu servidor compilado.

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

6. Ahora, agrega el siguiente contenido al archivo nuevo con un editor de línea de comandos como vim o nano:

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

7. Ahora, inicia Gemini CLI y restablece la sesión de chat:

/chat resume workshop001

8. Para verificar que la herramienta se cargó, presiona Ctrl + T:

9. Para probar la integración, pídele a la CLI de Gemini que use tu herramienta con una instrucción como "Obtén la documentación de net/http".

Debería ver algo como esto:

Nota: Es posible que el modelo intente llamar a la herramienta a través de un comando de shell. Si esto sucede, intenta iniciar una sesión sin el contexto de la sesión anterior (p. ej., no llames a /chat resume).

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 sea un poco más útil.

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

Importante: Para realizar llamadas a la API con Gemini, debes tener un proyecto de GCP asociado a una cuenta de facturación. En el cliente, esto requiere que configures una variable de entorno llamada GEMINI_API_KEY.

La CLI de Gemini tiene un nivel gratuito generoso para las llamadas al modelo de Gemini, pero, si encuentra una clave de GEMINI_API_KEY, la CLI tendrá la opción de usar esta clave para la autenticación, lo que omitirá las cuotas del nivel gratuito.

Asegúrate de usar el modo de autenticación correcto para evitar inhabilitar el nivel gratuito. Puedes seleccionar el modo de autenticación con el comando /auth.

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

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.

Ejemplo de instrucción:

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

Sugerencias útiles

Una vez que el modelo comience a trabajar en ello, es posible que veas automáticamente que solicita llamar a la herramienta godoc 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 godoc a su disposición.

Cómo probar el Revisor de código

1. Debemos reiniciar la CLI de Gemini para compilar y volver a cargar el servidor de MCP. Guarda la sesión de chat con /chat save workshop002 y, luego, sal de la CLI presionando Ctrl + D dos veces.
2. La herramienta code_review necesita una clave de API, ya que llamamos a un modelo de Gemini para que haga las revisiones por nosotros. Puedes generar una clave de API con Google AI Studio.
3. Configura la variable de entorno GEMINI_API_KEY con la clave de API que se generó en el paso anterior:

export GEMINI_API_KEY="YOUR_API_KEY"

4. Vuelve a compilar el servidor: Después de agregar la herramienta nueva, debes volver a compilar el archivo binario del servidor para incluir los cambios.

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

5. Vuelve a iniciar la CLI de Gemini. Restablece la sesión de chat con /chat resume workshop002.
6. Importante. Asegúrate de autenticarte con tu cuenta personal de Gmail para que la CLI de Gemini no use tu cuenta de facturación. Para ello, usa el comando /auth:

7. Para confirmar que la herramienta está habilitada, presiona Ctrl + T. Debería ver algo como esto:

8. Ahora, probemos la herramienta code-review revisando uno de sus archivos fuente:

"Usa la herramienta godoctor para revisar el archivo cmd/godoctor/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.

Advertencia: Si usas el nivel gratuito de la CLI de Gemini, antes de pasar a la siguiente sección, te recomendamos que anules la configuración de GEMINI_API_KEY para evitar habilitar la facturación por error. Siempre puedes verificar que estás usando el método de autenticación correcto con el comando /auth.

Para borrar la variable GEMINI_API_KEY, haz lo siguiente:

1. Guarda tu sesión actual con /chat save workshop003 y sal de la CLI
2. Haz una copia de seguridad de la clave de API en un lugar seguro:

export | grep GEMINI_API_KEY > env.bkp

3. Anula la configuración de GEMINI_API_KEY:

export GEMINI_API_KEY=

4. Reinicia la CLI y carga la sesión con /chat resume workshop003
5. Pídele al modelo que aplique las mejoras de la revisión de código.

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 los entornos empresariales, necesitamos implementar herramientas para el uso más amplio de cientos o incluso miles de desarrolladores.

Para escalar nuestro servidor de MCP, debemos convertirlo de un servidor que solo se comunica con E/S estándar a un servidor que pueda comunicarse con HTTP y, luego, implementarlo en algún lugar donde diferentes desarrolladores puedan acceder a él. Para este objetivo, usaremos un modo de transporte definido en la especificación de MCP como HTTP transmitible y Cloud Run como nuestro destino de implementación.

Objetivo: Refactorizar el servidor de godoctor para que use el transporte HTTP transmisible.

Ejemplo de instrucción:

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.

Recursos útiles

1. Si el modelo tiene dificultades para implementar el transporte HTTP transmisible, puedes proporcionarle esta referencia: https://github.com/modelcontextprotocol/go-sdk/blob/main/design/design.md
2. Es posible que el modelo intente usar HTTP + SSE, que dejó de estar disponible. Si ves que sigue este camino, vuelve a dirigirlo hacia el HTTP de transmisión.

Cómo probar el servidor con HTTP

Pídele al modelo que actualice el cliente de godoctor para que también use HTTP transmitible, de modo que puedas probar que sigue funcionando.

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

Opcional: Si quieres configurar la CLI de Gemini 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. Ejecuta el servidor refactorizado de forma local:

go run ./cmd/godoctor/main.go

4. En una nueva terminal (ya que la operación anterior bloquea la ejecución), inicia la CLI de Gemini 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 probar, 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 contenerlo para la implementación.

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

Ejemplo de instrucción:

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

Prueba de la imagen de Docker

Después de crear el Dockerfile, compila la imagen y ejecútala para asegurarte de que funcione correctamente. Puedes indicarle a Gemini que lo haga por ti:

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

Opcional: Si quieres hacer la prueba de forma manual, sigue estos pasos:

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 la CLI de Gemini y pídele que recupere documentación.
4. Cuando termines de probar, detén el servidor con Ctrl+C.

10. Implementa en Cloud Run

Ahora es momento de implementar nuestro contenedor en la nube.

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

Orientación sobre instrucciones: Pídele a tu asistente de IA que te proporcione los comandos de gcloud para implementar tu contenedor.

Ejemplo de instrucción:

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.

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

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

Pídele a Gemini que actualice tu archivo .gemini/settings.json para cambiar la configuración de la herramienta de MCP de modo que apunte a tu servicio implementado.

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

La sección mcpServers final debería verse de la siguiente manera (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 la CLI de Gemini por última vez (con /chat save y /chat resume para conservar el contexto). Ahora la CLI debería poder llamar al servidor de MCP remoto. Intenta solicitar documentación para cualquier paquete.

Solo recuerda que, para usar la herramienta de revisión de código, el servicio necesita el GEMINI_API_KEY. Puedes pedirle a Gemini CLI que vuelva a implementarlo con el entorno correcto:

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

Reinicia la CLI y pruébala con una instrucción:

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

La CLI de Gemini ahora se conectará a tu servicio de Cloud Run implementado y ejecutará la revisión de código.

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.

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 que cree, aloje en contenedores y, luego, implemente una herramienta sofisticada potenciada por IA. Lo que es más importante, practicaste la habilidad esencial del desarrollo de software moderno: traducir los requisitos en instrucciones eficaces. Extendiste correctamente la CLI de Gemini con una herramienta personalizada, lo que la convierte en un asistente de desarrollo de Go más potente y especializado.

Documentos de referencia

• Especificación del Protocolo de contexto del modelo
• SDK de Go para MCP
• SDK de Go de IA generativa de Google
• Anuncio de la CLI de Gemini
• Página principal del proyecto de la CLI de Gemini en GitHub
• Documentación de la CLI de Gemini