Como criar um assistente de programação com a CLI do Gemini, o MCP e o Go

1. Introdução

Neste codelab, você vai aprender a criar e implantar um servidor do Protocolo de contexto de modelo (MCP) para ampliar os recursos da CLI do Gemini. Você vai criar o godoctor, um servidor baseado em Go que oferece ferramentas personalizadas para desenvolvimento em Go, transformando a CLI do Gemini de um assistente de programação de uso geral em um especialista em desenvolvimento em Go.

Este codelab usa uma abordagem "orientada por comandos". Você vai atuar como líder técnico, fornecendo comandos para seu assistente de IA (a própria CLI do Gemini). Seu objetivo é aprender a traduzir os requisitos do projeto em comandos eficazes e deixar que a IA cuide dos detalhes da implementação.

O Protocolo de Contexto de Modelo (MCP) é a base desse projeto. O MCP é um protocolo de código aberto que padroniza a forma como modelos de linguagem grandes (LLMs), como o Gemini, se comunicam com ferramentas e serviços externos. Ele atua como uma ponte, permitindo que a IA acesse informações do mundo real e realize ações além do conhecimento integrado. Ao criar um servidor MCP, você cria um plug-in personalizado que a CLI do Gemini pode descobrir e usar, ensinando novas habilidades a ela.

O que você vai aprender

• Como instalar e configurar a CLI do Gemini
• Como formular comandos eficazes para orientar um assistente de IA no desenvolvimento de software
• Como fornecer contexto e diretrizes a um assistente de IA
• Como criar e configurar um servidor MCP para aumentar os recursos da CLI do Gemini
• Como conteinerizar e implantar um aplicativo Go no Google Cloud Run

O que é necessário

Este workshop pode ser realizado totalmente no Google Cloud Shell, que vem pré-instalado com todas as dependências necessárias (CLI gcloud, Go, Docker, CLI Gemini).

Se você preferir trabalhar na sua própria máquina, vai precisar do seguinte:

• Node.js 20 ou mais recente
• Tenha um projeto do Google Cloud com o faturamento ativado.
• O SDK do Google Cloud (CLI gcloud) instalado e inicializado
• Go 1.24 ou mais recente instalado no seu sistema
• O Docker está instalado no seu sistema

Principais tecnologias

Confira mais informações sobre as tecnologias que vamos usar:

• CLI do Gemini: a interface de linha de comando com tecnologia de IA que vamos estender
• Protocolo de Contexto de Modelo (MCP): o protocolo de código aberto que permite que a CLI do Gemini se comunique com nossa ferramenta personalizada
• SDK Go para MCP: a biblioteca Go que vamos usar para implementar nosso servidor MCP.

Dicas para um codelab de sucesso

Trabalhar com um assistente de IA é uma nova maneira de desenvolver software. Confira algumas dicas para ter uma experiência tranquila e bem-sucedida:

1. Não tenha medo de pressionar ESC. Às vezes, a IA vai propor ações ou códigos com que você não concorda. Use a tecla ESC para cancelar a ação proposta e fornecer um novo comando para orientar o modelo na direção certa. Você é o piloto.
2. Incentive o uso de ferramentas. Se a IA parecer perdida ou estiver inventando informações, incentive-a a usar as ferramentas disponíveis. Comandos como "Você pode usar a Pesquisa Google para verificar isso?" ou "Use a ferramenta read_file para entender o código atual antes de fazer mudanças" podem ser muito eficazes.
3. Resista a mudanças manuais. Tente fazer com que a IA realize todo o trabalho. Essa é a habilidade principal que você está praticando. No entanto, se você precisar fazer uma mudança manual, informe a IA depois. Um comando como "Atualizei manualmente o arquivo README.md. Leia de novo para atualizar seu conhecimento" vai garantir que a IA permaneça sincronizada com seu projeto.
4. Você já tentou desligar e ligar de novo? Em casos raros, se a IA tentar forçar um determinado caminho contra seu comando, isso pode ser devido à degradação do contexto (às vezes também chamada de "deterioração do contexto"). Nesse caso, use o comando "/compress" da CLI do Gemini para reduzir o ruído de contexto ou, em casos extremos, use o comando "/clear" para limpar todo o histórico da sessão.

2. Configuração do ambiente

Configuração de ambiente autoguiada

1. Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

• O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
• O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
• Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Atenção: o ID do projeto é globalmente exclusivo e não pode ser usado por outras pessoas após a seleção. Você é o único usuário com esse ID. Mesmo que um projeto seja excluído, o ID não poderá ser usado novamente.

Observação: se você usa uma conta do Gmail, defina o local padrão como Sem organização. Se você usa uma conta do Google Workspace, escolha um local adequado para a organização.

2. Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud e o Spanner possam ser operados remotamente do seu laptop, neste codelab usaremos o Google Cloud Shell, um ambiente de linha de comando executado no Cloud.

No Console do Google Cloud, clique no ícone do Cloud Shell na barra de ferramentas superior à direita:

O provisionamento e a conexão com o ambiente levarão apenas alguns instantes para serem concluídos: Quando o processamento for concluído, você verá algo como:

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, todo o trabalho pode ser feito com um navegador. Você não precisa instalar nada.

3. Como começar a usar a CLI do Gemini

Nesta seção, você vai aprender sobre a CLI do Gemini, incluindo como instalar e configurar para seu ambiente.

O que é a CLI do Gemini?

A CLI do Gemini é uma interface de linha de comando com tecnologia de IA que pode ajudar você em uma ampla variedade de tarefas de desenvolvimento. Ele pode entender o contexto do seu projeto, responder a perguntas, gerar código e usar ferramentas externas para ampliar os recursos.

Instalação

Observação:se você estiver usando o Google Cloud Shell, a CLI do Gemini já estará instalada. Você pode pular para a próxima seção (Configuração).

Instale a CLI do Gemini globalmente usando o npm.

npm install -g @google/gemini-cli

Para confirmar se a CLI está instalada, execute:

gemini --version

Configuração

O comportamento da CLI Gemini é controlado por arquivos de configuração e variáveis de ambiente. Há dois arquivos principais:

• GEMINI.md: esse arquivo fornece diretrizes e contexto em linguagem natural para a IA. A CLI lê esse arquivo para entender os padrões e convenções de programação do projeto.
• .gemini/settings.json: esse arquivo controla a configuração da CLI, incluindo como se conectar a ferramentas externas. Vamos usar esse arquivo para configurar a CLI e usar o servidor MCP que estamos criando neste laboratório.

Primeiro, vamos configurar o ambiente e depois criar o arquivo GEMINI.md. O arquivo settings.json será configurado em uma etapa posterior.

1. Crie e inicialize um diretório de projeto:

mkdir godoctor
cd godoctor
go mod init godoctor

1. Faça a autenticação com as credenciais padrão do aplicativo do Google Cloud:

Se você estiver usando o Cloud Shell, esta etapa já foi concluída. Você pode pular para a próxima seção (Diretrizes de desenvolvimento).

Faça login em uma conta que tenha acesso ao projeto do GCP que você vai usar neste codelab:

• Verifique se o SDK do Google Cloud está instalado e inicializado.
• Execute o comando a seguir para configurar as credenciais padrão do aplicativo:

gcloud auth application-default login

4. Diretrizes de desenvolvimento

Para garantir que o assistente de IA gere código Go idiomático e de alta qualidade, é essencial fornecer diretrizes claras. Isso é feito no arquivo GEMINI.md.

Observação:o GEMINI.md pode ter muitos outros usos, como informar à CLI sobre a estrutura do projeto, práticas de trabalho, testes e muito mais.

Objetivo: criar um arquivo GEMINI.md que sirva como o conjunto de regras para o assistente de IA durante este projeto.

Tarefa: crie um arquivo chamado GEMINI.md na raiz do diretório godoctor e cole o seguinte conteúdo nele.

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

Agora seu ambiente de desenvolvimento está totalmente configurado.

5. O build inicial: um servidor godoc

Sua primeira meta é criar a versão inicial do servidor godoctor. Essa versão precisa ser um aplicativo mínimo pronto para produção que forneça uma única ferramenta chamada godoc, que permite pesquisar a documentação do Go.

Objetivo: criar um servidor MCP pronto para produção que exponha o comando go doc, permitindo que um LLM consulte a documentação do Go.

Execute o comando da CLI do Gemini no shell:

gemini

Observação:se você precisar instalar ou atualizar a CLI Gemini no Cloud Shell, use este comando: sudo env PATH=$PATH npm install -g @google/gemini-cli

Quando você executar a CLI pela primeira vez, será necessário escolher um modo de autenticação e um tema. No modo de autenticação, escolha "Fazer login com o Google" para usar uma Conta do Google pessoal e aproveitar o nível sem custo financeiro generoso da CLI Gemini. Você vai encontrar uma opção para selecionar seu modo de autenticação semelhante a esta:

Se precisar mudar sua seleção, digite /auth e pressione "Enter" para abrir o menu novamente.

Em seguida, você vai precisar escolher um tema:

Assim como /auth, você também pode mudar o tema depois com o comando /theme.

Depois de escolher o método de autenticação e o tema preferido, você vai acessar o prompt de comando. Aqui você pode digitar seus comandos, por exemplo:

Write a hello world application in Go.

A CLI usa uma combinação de raciocínio próprio (com um modelo do Gemini, como o Gemini Flash ou o Gemini Pro) e ferramentas para realizar as tarefas. Ele usa ferramentas sempre que precisa interagir com o sistema de arquivos ou serviços externos, como APIs, bancos de dados etc. Exemplos de ferramentas prontas para uso, ou "ferramentas internas", são read_file, write_file, web_fetch e google_search. O servidor MCP que estamos criando também vai se tornar uma ferramenta disponível para a CLI.

Na primeira vez que ele executar uma ferramenta, vai pedir sua permissão. Você pode dar uma permissão única, uma aprovação geral para o restante da sessão ou negar a solicitação. Se for uma operação de edição de arquivo, você também vai encontrar a opção de editar o arquivo usando um editor externo, caso queira fazer alguns ajustes. Por exemplo, esta é a saída da instrução acima para criar um programa "Hello World":

Além dos comandos, você também pode usar comandos de barra. Se você digitar "/", a CLI vai mostrar automaticamente as opções de preenchimento automático. Você pode continuar digitando o comando completo ou selecionar uma das opções. Os comandos /auth e /theme mencionados acima são alguns exemplos.

Depois de se familiarizar com a interface, você pode iniciar a principal tarefa desta seção, que é pedir à CLI para escrever o servidor MCP.

Como criar um servidor MCP Hello World

Uma das melhores maneiras de garantir que o modelo crie coisas de forma mais consistente é dividir tarefas complexas em etapas incrementais. Embora o modelo possa resolver uma tarefa complexa sozinho, sem a configuração certa, ele vai levar muito tempo para descobrir a implementação correta.

Para uma abordagem mais consistente, vamos primeiro instruir a criar um servidor MCP "Hello World" antes de implementar a funcionalidade desejada (leitura da documentação do Go).

Confira um exemplo de comando abaixo:

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

A instrução acima é composta por três segmentos principais:

1. A especificação do problema, incluindo o que queremos criar e as restrições (por exemplo, usar o SDK oficial em vez de qualquer SDK)
2. Documentação de referência para ajudar o modelo a esclarecer a solicitação
3. Um procedimento de teste, que funciona como critério de aceitação da tarefa

Ter esses três componentes ajuda o modelo a alcançar os resultados desejados de maneira mais consistente.

Atenção:mesmo que as instruções sejam muito precisas, às vezes o modelo pode se desviar do que foi solicitado. Por isso, é importante verificar o trabalho dele e ficar atento a possíveis loops de erros e alucinações. Se o modelo ficar travado, consulte a seção "Recursos úteis" no final deste capítulo.

Implementação da ferramenta Go doc

Depois de ter uma implementação funcional, podemos passar para a implementação da ferramenta "go doc" real:

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.

Fique à vontade para testar esse comando ou criar o seu.

Observação:o comando acima incentiva explicitamente o modelo a usar o comando de shell go doc porque o código para recuperar a documentação usando a biblioteca padrão não é trivial e pode levar um tempo para o modelo descobrir por conta própria. Usar a ferramenta go doc integrada ao compilador economiza muito tempo e ajuda a focar no que é importante, ou seja, a implementação do MCP.

Uma interface de linha de comando útil

Assim que você se decidir por uma boa implementação, instrua o modelo a criar uma CLI godoctor usando um cliente MCP. Isso ajuda a simplificar o teste de recursos, evitando a criação manual de chamadas JSON-RPC, como tem sido feito até agora.

Exemplo de comando:

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

Agora que você tem um conjunto funcional de cliente e servidor, na próxima seção, configure a CLI Gemini com o servidor MCP que acabou de criar para começar a aproveitar os benefícios dele na próxima tarefa de programação.

Recursos úteis

Observação:a programação com LLMs não é determinista. Portanto, não há garantia de que você terá os mesmos resultados exatos mesmo se executar dois comandos idênticos com o mesmo ambiente. Por isso, é importante saber identificar quando o LLM está preso em um loop ou tem um contexto degradado. Você está no controle e pode interromper o processo a qualquer momento pressionando ESC.

Como o MCP ainda é um conceito novo e o SDK Go para MCP é uma biblioteca nova, nesta etapa, o Gemini pode levar muito tempo para descobrir a implementação certa por conta própria. Para ajudar o modelo a encontrar a solução certa, você pode dar as seguintes referências:

1. Você pode dar ao modelo o seguinte comando para que ele descubra a API do SDK de maneira mais consistente: "use o comando do shell go doc para descobrir a API da biblioteca go-sdk"
2. Se o modelo tentar inspecionar o código-fonte do SDK com a ferramenta read_file, a ação vai falhar porque a CLI Gemini não consegue ler arquivos fora do escopo atual. Você pode instruir o uso dos comandos cat e ls usando a ferramenta run_shell_command.
3. Se o modelo tiver dificuldade em depurar o aplicativo, instrua-o a adicionar um registro mais detalhado e melhorar as informações contextuais nas mensagens de erro.
4. Se tudo mais falhar, use uma implementação de referência: https://github.com/danicat/godoctor

6. Configurar o godoctor como um servidor MCP para a CLI do Gemini

Depois que o assistente de IA gerar o código para o cliente e o servidor, você pode pedir que ele execute alguns testes manuais. Exemplo:

retrieve the documentation for the package net/http

Teste também com uma dependência externa (não na biblioteca padrão):

retrieve the documentation for the go-sdk package

Quando estiver satisfeito com os resultados, peça para ele escrever um README.md com instruções sobre como usar e desenvolver esse projeto.

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

Agora vamos configurar o servidor para que a CLI do Gemini possa usá-lo na próxima fase de desenvolvimento.

1. Peça à CLI para atualizar o GEMINI.md e usar godoc como o método preferido para ler a documentação:

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. Agora, precisamos reiniciar a CLI do Gemini para configurá-la. Primeiro, vamos salvar a sessão de chat para que você possa retomar de onde parou quando ela for reiniciada.

/chat save workshop001

3. Para sair da CLI, pressione Ctrl+D duas vezes.
4. Compile o binário do servidor: crie um diretório bin e compile o servidor godoctor nele.

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

Observação: talvez seja melhor usar uma pasta diferente da usada para criar o servidor durante o desenvolvimento, já que queremos que esse binário seja estável e esteja disponível para a CLI na próxima fase.

5. Configure a CLI do Gemini para a ferramenta local: crie um arquivo .gemini/settings.json na raiz do projeto e adicione uma seção mcpServers para informar à CLI do Gemini como executar o servidor compilado.

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

6. Agora, adicione o seguinte conteúdo ao novo arquivo usando um editor de linha de comando como vim ou nano:

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

7. Agora inicie a CLI do Gemini e restaure a sessão de chat:

/chat resume workshop001

8. Para verificar se a ferramenta foi carregada, pressione Ctrl+T:

9. Teste a integração pedindo à CLI do Gemini para usar sua ferramenta com um comando como "Get the documentation for net/http"

Você verá algo como:

Observação: é possível que o modelo tente chamar a ferramenta usando um comando de shell. Se isso acontecer, tente iniciar uma sessão sem o contexto da sessão anterior (por exemplo, não chamando /chat resume).

Se a ferramenta estiver funcionando corretamente, você vai ver a documentação recuperada pela chamada de função:

Parabéns, você criou uma ferramenta do MCP! Mas isso não é tudo. Ainda podemos deixar o texto um pouco mais útil.

7. Adicionar um revisor de código com tecnologia de IA

Importante:para fazer chamadas de API com o Gemini, você precisa ter um projeto do GCP associado a uma conta de faturamento. No lado do cliente, isso exige que você configure uma variável de ambiente chamada GEMINI_API_KEY.

A CLI do Gemini tem um nível sem custo financeiro generoso para chamadas de modelo do Gemini, mas, se encontrar uma GEMINI_API_KEY, ela terá a opção de usar essa chave para autenticação, o que ignora as cotas do nível sem custo financeiro.

Use o modo de autenticação correto para evitar a desativação do nível sem custo financeiro. É possível selecionar o modo de autenticação usando o comando /auth.

Vamos adicionar um recurso mais sofisticado com tecnologia de IA: um revisor de código que usa a API Gemini.

Objetivo: adicionar uma nova ferramenta chamada code_review ao projeto atual. Essa ferramenta usa a API Gemini para analisar o código Go e fornecer feedback.

Exemplo de comando:

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

Dicas úteis

Assim que o modelo começar a trabalhar nele, você poderá ver automaticamente uma solicitação para chamar a ferramenta godoc e navegar pela documentação do pacote genai. Se não for, você sempre pode interromper o processo com a tecla "Esc" e lembrar que agora ele tem a ferramenta godoc à disposição.

Testar o revisor de código

1. É necessário reiniciar a CLI do Gemini para criar e recarregar o servidor MCP. Salve a sessão de chat com /chat save workshop002 e saia da CLI pressionando Ctrl+D duas vezes.
2. A ferramenta code_review precisa de uma chave de API porque estamos chamando um modelo do Gemini para fazer as análises. Você pode gerar uma chave de API usando o Google AI Studio.
3. Configure a variável de ambiente GEMINI_API_KEY com a chave de API gerada na etapa acima:

export GEMINI_API_KEY="YOUR_API_KEY"

4. Recompile o servidor: depois de adicionar a nova ferramenta, é necessário recompilar o binário do servidor para incluir as mudanças.

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

5. Inicie a CLI do Gemini novamente. Restaure a sessão de chat com /chat resume workshop002.
6. Importante. Confira se você fez a autenticação com sua conta pessoal do Gmail para que a CLI do Gemini não use sua conta de faturamento. Para isso, use o comando /auth:

7. Confirme se a ferramenta está ativada pressionando Ctrl+T. Você verá algo como:

8. Agora vamos testar a ferramenta code-review analisando um dos arquivos de origem dela:

"Use a ferramenta godoctor para revisar o arquivo cmd/godoctor/main.go."

    You should see something like this:

Com a ferramenta de análise de código funcionando, agora você pode sugerir que o modelo aplique algumas das melhorias encontradas, para um fluxo de trabalho completo de "autoaprimoramento".

Agora você confirmou que a ferramenta code-review funciona. Na próxima seção, você vai trabalhar na implantação na nuvem.

Aviso:se você estiver usando o nível sem custo financeiro da CLI Gemini, antes de passar para a próxima seção, é recomendável remover a definição de GEMINI_API_KEY para evitar a ativação do faturamento por engano. Você pode sempre verificar se está usando o método de autenticação correto com o comando /auth.

Para limpar a GEMINI_API_KEY:

1. Salve a sessão atual com /chat save workshop003 e saia da CLI.
2. Faça backup da chave de API em um lugar seguro:

export | grep GEMINI_API_KEY > env.bkp

3. Desmarque o GEMINI_API_KEY:

export GEMINI_API_KEY=

4. Reinicie a CLI e carregue a sessão com /chat resume workshop003
5. Peça ao modelo para aplicar as melhorias da revisão de código.

8. Preparar seu servidor para a nuvem

O servidor MCP que desenvolvemos até agora só é executado na máquina local, o que é bom se você estiver desenvolvendo ferramentas para uso próprio. No entanto, em ambientes empresariais, geralmente precisamos implantar ferramentas para uso mais amplo de centenas ou até milhares de desenvolvedores.

Para escalonar nosso servidor MCP, precisamos convertê-lo de um servidor que só usa E/S padrão para um servidor que pode usar HTTP e implantá-lo em algum lugar onde possa ser acessado por diferentes desenvolvedores. Para isso, vamos usar um modo de transporte definido na especificação do MCP como HTTP transmitível e usar o Cloud Run como nosso destino de implantação.

Objetivo: refatorar o servidor godoctor para usar o transporte HTTP transmitível.

Exemplo de comando:

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 úteis

1. Se o modelo tiver dificuldades para implementar o transporte HTTP transmitível, você pode dar esta referência: https://github.com/modelcontextprotocol/go-sdk/blob/main/design/design.md
2. O modelo pode tentar usar HTTP+SSE, que foi descontinuado. Se você perceber que ele está seguindo esse caminho, direcione-o de volta para o HTTP de streaming.

Como testar o servidor usando HTTP

Peça ao modelo para atualizar o cliente godoctor e usar HTTP transmitível para que você possa testar se ele ainda está funcionando.

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

Opcional:se você quiser configurar a CLI do Gemini para usar o servidor via HTTP:

1. Salve a sessão e saia da CLI
2. Edite o arquivo .gemini/settings.json e mude a configuração para apontar para o servidor local em execução.

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

3. Execute o servidor refatorado localmente:

go run ./cmd/godoctor/main.go

4. Em um novo terminal (já que a operação acima está bloqueando), inicie a CLI do Gemini e dê um comando para testar a conexão, por exemplo: "Use a ferramenta godoctor para acessar a documentação de fmt.Println."
5. Pare o servidor com Ctrl+C quando terminar de testar.

9. Como inserir o aplicativo em um contêiner com o Docker

Agora que nosso servidor está usando o protocolo de transporte correto, podemos contêinerizar para implantação.

Objetivo: criar um Dockerfile para empacotar o servidor godoctor em uma imagem de contêiner portátil e pronta para produção.

Exemplo de comando:

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

Teste da imagem do Docker

Depois que o Dockerfile for criado, crie e execute a imagem para garantir que ela funcione corretamente. Você pode instruir o Gemini a fazer isso por você:

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

Opcional:se você quiser fazer o teste manualmente:

1. Criar o contêiner:

docker build -t godoctor:latest .

2. Execute o contêiner localmente:

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

3. Teste o contêiner em execução: em outro terminal, inicie a CLI do Gemini e peça para ela buscar a documentação.
4. Pare o servidor com Ctrl+C quando terminar de testar.

10. Como implantar no Cloud Run

Agora é hora de implantar nosso contêiner na nuvem.

Objetivo: implantar o servidor godoctor conteinerizado no Google Cloud Run.

Orientação de comando: peça ao seu assistente de IA para fornecer os comandos gcloud para implantar o contêiner.

Exemplo de comando:

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.

Atenção:se este for um projeto novo ou se você estiver usando o Cloud Run pela primeira vez nele, será necessário ativar as APIs Artifact Registry e Cloud Run.

Depois que a implantação for concluída, vamos configurar a CLI Gemini para usar a ferramenta que você acabou de implantar.

Peça ao Gemini para atualizar o arquivo .gemini/settings.json e mudar a configuração da ferramenta MCP para apontar para o serviço implantado.

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

A seção mcpServers final vai ficar assim. Não se esqueça de substituir o marcador de posição pelo URL real do app do Cloud Run:

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

Como testar a implantação do Cloud Run

Agora você está pronto para o teste final de ponta a ponta.

Reinicie a CLI Gemini pela última vez (usando /chat save e /chat resume para preservar o contexto). Agora, a CLI poderá chamar o servidor MCP remoto. Tente pedir a documentação de qualquer pacote.

Lembre-se de que, para usar a ferramenta de revisão de código, o serviço precisa do GEMINI_API_KEY. Você pode pedir à CLI do Gemini para reimplantar com o ambiente certo:

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

Reinicie a CLI e teste com um comando:

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

A CLI do Gemini vai se conectar ao serviço implantado do Cloud Run e executar a revisão de código.

Atenção:exclua a implantação do Cloud Run antes de encerrar esta sessão, principalmente se você estiver usando uma instância não autenticada do Cloud Run para evitar cobranças inesperadas na sua conta de faturamento do GCP.

Exemplo de comando:

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. Parabéns!

Você orientou um assistente de IA a criar, colocar em contêineres e implantar uma ferramenta sofisticada com tecnologia de IA. E o mais importante: você praticou a habilidade essencial do desenvolvimento de software moderno: traduzir requisitos em comandos eficazes. Você estendeu a CLI do Gemini com uma ferramenta personalizada, tornando-a um assistente de desenvolvimento em Go mais eficiente e especializado.

Documentos de referência

• Especificação do Protocolo de Contexto de Modelo
• Go SDK para MCP
• SDK do Google Gen AI para Go
• Anúncio da CLI Gemini
• Página inicial do projeto da CLI do Gemini no GitHub
• Documentação da CLI do Gemini