Como Criar Serviços MCP com Go: Guia Completo para Agentes de IA

O Model Context Protocol (MCP) é um padrão aberto que permite conectar aplicações de IA (como Claude e ChatGPT) a fontes de dados externas, ferramentas e fluxos de trabalho. Imagine o MCP como o "USB-C para IAs": um padrão único que permite que qualquer agente se conecte a qualquer servidor de contexto sem a necessidade de integrações customizadas para cada nova ferramenta.

Neste guia, vamos explorar por que a linguagem Go (Golang) é uma escolha excepcional para construir esses serviços e forneceremos um passo a passo detalhado para você criar o seu primeiro servidor MCP.

Por que usar Go para Serviços MCP?

A escolha da linguagem impacta diretamente a performance e a facilidade de deploy do seu agente. Go se destaca por vários motivos:

1. Performance e Eficiência: Go oferece a performance de linguagens compiladas com a simplicidade de linguagens de alto nível. Para serviços que precisam de baixa latência ao responder a um agente, Go é ideal.
2. Binários Estáticos: Go compila tudo em um único arquivo binário. Isso simplifica absurdamente o deploy em containers ou servidores, eliminando a necessidade de instalar runtimes pesados (como Node.js ou Python) no ambiente de produção.
3. Concorrência Nativa: Com Goroutines e Channels, Go lida com múltiplas requisições de agentes simultaneamente de forma extremamente eficiente.
4. Tipagem Forte: O sistema de tipos de Go ajuda a evitar erros comuns em tempo de execução, algo crítico quando você está definindo esquemas de ferramentas que a IA deve seguir rigorosamente.

---

Passo a Passo: Criando seu Servidor MCP em Go

Para este exemplo, vamos criar um servidor simples de "Saudações" que expõe uma ferramenta para o agente.

1. Pré-requisitos

• Go instalado (versão 1.21 ou superior).
• Um editor de código (VS Code, GoLand, etc.).

2. Inicializando o Projeto

Crie uma nova pasta para o seu projeto e inicialize o módulo Go:

mkdir mcp-go-server
cd mcp-go-server
go mod init mcp-go-server

3. Instalando o SDK Oficial

O MCP possui um SDK oficial para Go que simplifica a implementação do protocolo. Instale-o com:

go get github.com/modelcontextprotocol/go-sdk/mcp

4. Codificando o Servidor

Crie um arquivo chamado main.go e adicione o seguinte código:

package main

import (
    "context"
    "log"

    "github.com/modelcontextprotocol/go-sdk/mcp"
)

// Input define os parâmetros que a IA deve enviar para a ferramenta
type Input struct {
    Name string `json:"name" jsonschema:"o nome da pessoa a ser saudada"`
}

// Output define a estrutura de resposta da ferramenta
type Output struct {
    Greeting string `json:"greeting" jsonschema:"a saudação a ser entregue ao usuário"`
}

// SayHi é a função lógica da nossa ferramenta
func SayHi(ctx context.Context, req *mcp.CallToolRequest, input Input) (*mcp.CallToolResult, Output, error) {
    return nil, Output{Greeting: "Olá, " + input.Name + "! Bem-vindo ao mundo do MCP com Go!"}, nil
}

func main() {
    // 1. Criar a instância do servidor com nome e versão
    server := mcp.NewServer(&mcp.Implementation{
        Name:    "GreeterServer",
        Version: "v1.0.0",
    }, nil)

    // 2. Adicionar a ferramenta ao servidor
    mcp.AddTool(server, &mcp.Tool{
        Name:        "greet",
        Description: "Envia uma saudação personalizada para o usuário",
    }, SayHi)

    // 3. Executar o servidor via Stdio (entrada/saída padrão)
    // Este é o transporte mais comum para agentes locais
    if err := server.Run(context.Background(), &mcp.StdioTransport{}); err != nil {
        log.Fatal(err)
    }
}

5. Compilando e Executando

Compile o seu servidor para gerar o binário:

go build -o mcp-server main.go

6. Integrando com o Agente (Ex: Claude Desktop)

Para testar, você deve configurar o seu cliente de IA para usar este binário. No arquivo de configuração do Claude Desktop (claude_desktop_config.json), adicione:

{
  "mcpServers": {
    "go-greeter": {
      "command": "/caminho/para/seu/projeto/mcp-server",
      "args": []
    }
  }
}

---

Considerações Finais

Agora você tem um servidor MCP funcional escrito em Go! A partir daqui, você pode expandir seu serviço para:

• Conectar-se a bancos de dados SQL.
• Consumir APIs externas de terceiros.
• Ler e manipular arquivos locais para fornecer contexto ao agente.

A combinação de Go com MCP permite que você crie ecossistemas de agentes robustos, rápidos e extremamente fáceis de distribuir. Bons códigos!