Pular para o conteudo
MODULO 3.1

๐Ÿ”Œ O que sao MCP Servers

MCP e o protocolo que transforma o Claude Code de "leitor de arquivos" em "operador de sistemas". Aqui voce entende a arquitetura, o schema de tools, e por que MCP e o padrao que conecta agentes ao mundo real. Cada termo novo e explicado na hora.

6
Topicos
~40
Minutos
T1-T2
Pre-requisito
Teoria
Tipo
Progresso: 0% 0 de 6

๐Ÿ“– Glossario vivo

Termos-chave desta trilha. Volte aqui sempre que precisar.

MCP (Model Context Protocol) โ€” protocolo aberto que permite a agentes de IA (como o Claude Code) descobrir e usar ferramentas externas de forma padronizada, via JSON-RPC.
Tool โ€” uma funcao que o MCP server expoe ao agente. Tem nome, descricao e um schema de entrada. Ex.: read_file, query_db.
Schema (inputSchema) โ€” a descricao JSON Schema dos parametros que uma tool aceita. O agente usa isso para saber o que mandar.
Protocol โ€” um conjunto de regras que define como dois programas se comunicam. MCP usa JSON-RPC sobre stdio ou HTTP.
Server โ€” o processo que expoe tools via MCP. Pode ser um script Node.js, um binario, um container Docker.
Client โ€” quem consome as tools do server. No nosso caso, o Claude Code e o client MCP.
1

๐Ÿ“ก O protocolo MCP explicado

Imagine assim: voce contrata um assistente que fala 10 idiomas. Mas se cada fornecedor inventar um idioma proprio, o assistente precisa aprender 10 gramaticas. MCP e o "idioma unico" que todos os fornecedores usam para falar com agentes de IA.

MCP significa Model Context Protocol. E um protocolo aberto, criado pela Anthropic e liberado para toda a comunidade, que padroniza como agentes de IA descobrem e usam ferramentas externas. Antes do MCP, cada ferramenta tinha sua propria integracao. Agora, um unico protocolo conecta o agente a qualquer servico que implemente o padrao.

Na pratica, MCP usa JSON-RPC 2.0 sobre um canal de comunicacao (normalmente stdio para processos locais, ou HTTP com SSE para servidores remotos). O agente manda uma mensagem JSON dizendo "quero chamar a tool X com esses parametros" e o server responde com o resultado, tambem em JSON. Simples, previsivel e extensivel.

CLIENT (Claude Code) SERVER (MCP Server) tools/call { name, args } { content: [resultado] }

O client (Claude Code) manda um request JSON-RPC; o server executa e devolve o resultado.

Em 1 frase: MCP e o JSON-RPC padronizado que permite ao agente chamar qualquer ferramenta externa com um unico protocolo.

2

๐Ÿ—๏ธ Arquitetura client-server

Imagine assim: um restaurante. O garcom (client) anota o pedido e leva para a cozinha (server). A cozinha prepara e devolve o prato. O garcom nao precisa saber cozinhar; a cozinha nao precisa saber servir. Cada um faz sua parte.

No MCP, o client e o Claude Code. Ele sabe como conversar com o usuario, planejar tarefas, e decidir quando precisa de uma ferramenta. O server e um processo separado que sabe fazer algo especifico: ler arquivos, consultar um banco, mandar um email. O client descobre o que o server oferece (via tools/list), e depois chama a tool que precisa (via tools/call).

O canal entre eles pode ser stdio (o client inicia o server como processo filho e conversa via stdin/stdout) ou HTTP + SSE (o server roda remoto e aceita conexoes). No dia a dia com Claude Code, voce quase sempre usa stdio: o agente spawna o processo MCP, conversa, e mata quando termina a sessao.

1. initialize 2. tools/list 3. tools/call 4. shutdown repete N vezes Handshake decapabilities Client descobretools disponiveis Client invocaa tool necessaria Encerra processodo server

Quem e o "client" no ecossistema MCP do Claude Code?

Em 1 frase: o Claude Code (client) inicia o MCP server, descobre as tools, chama o que precisa, e encerra.

3

๐Ÿ“‹ Tool discovery e schemas

Quando o client conecta a um MCP server, a primeira coisa que faz (apos o handshake) e pedir a lista de tools disponiveis via tools/list. Cada tool vem com tres coisas: um nome (ex.: read_query), uma descricao (texto que explica o que faz), e um inputSchema (JSON Schema dizendo quais parametros aceita).

O agente le o schema e "entende" que parametros precisa fornecer. E como se cada tool viesse com um manual embutido. Quanto melhor a descricao e o schema, mais o agente acerta de primeira. Um schema ruim e como dar um formulario sem rotulos: o agente vai chutar.

exemplo-tool-schema.json
{
  "name": "read_query",
  "description": "Execute a SELECT query against the database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "The SQL SELECT query to execute"
      }
    },
    "required": ["query"]
  }
}

O schema e o contrato

O inputSchema funciona exatamente como um JSON Schema da OpenAPI. Se voce ja trabalhou com APIs REST documentadas via Swagger/OpenAPI, o mecanismo e identico: o schema descreve tipos, campos obrigatorios, e descricoes. A diferenca e que quem le o schema nao e um dev humano, mas o proprio agente de IA.

Em 1 frase: cada tool tem um schema JSON que o agente le para saber exatamente o que mandar.

4

๐Ÿ’ก Por que MCP importa

Imagine assim: antes do USB, cada dispositivo tinha um conector diferente. O USB padronizou a conexao e o ecossistema de perifericos explodiu. MCP e o "USB dos agentes de IA".

Sem MCP, o Claude Code so tem as ferramentas built-in: ler/escrever arquivos, rodar bash, buscar na web. Funciona, mas e como um computador sem portas USB: faz o basico e para por ai. Com MCP, voce pluga quantos "perifericos" quiser: banco de dados, Slack, email, calendario, qualquer API.

O impacto pratico e enorme. Em vez de escrever scripts glue para cada integracao, voce configura um MCP server e o agente descobre sozinho o que pode fazer. A padronizacao significa que qualquer MCP server feito por qualquer pessoa funciona com qualquer client MCP. Composicao sem limites.

Sem MCP

  • * So ferramentas built-in (file, bash, web)
  • * Cada integracao = script custom
  • * Nao escala: 5 integracoes = 5 scripts
  • * Agente limitado ao filesystem

Com MCP

  • * Centenas de tools via protocolo padrao
  • * Config unica no settings.json
  • * Escala: 50 tools = mesmo pattern
  • * Agente opera DBs, APIs, SaaS, tudo

Em 1 frase: MCP transforma o Claude Code de "editor de arquivos" em "operador de sistemas conectado a tudo".

5

๐ŸŒ Ecossistema atual

O ecossistema MCP ja e vasto. Existem mais de 200 servers open source cobrindo categorias como: DevOps (Git, Docker, Kubernetes), Database (Postgres, SQLite, Redis, MongoDB), SaaS (Slack, Notion, Linear, Gmail, Calendar), Cloud (AWS, GCP, Cloudflare), e Utilitarios (browser automation, web search, file conversion).

Os servers oficiais da Anthropic cobrem o basico: filesystem, git, SQLite, Postgres, puppeteer, brave-search. A comunidade contribui o resto. Repositorios como awesome-mcp-servers no GitHub e o marketplace Smithery.ai sao os melhores pontos de partida para descobrir o que existe.

Categorias principais do ecossistema

๐Ÿ“
DevOps

Git, Docker, K8s, CI/CD

๐Ÿ—„๏ธ
Database

Postgres, SQLite, Redis, Mongo

๐Ÿ’ฌ
SaaS

Slack, Notion, Linear, Gmail

โ˜๏ธ
Cloud

AWS, GCP, Cloudflare

๐ŸŒ
Web

Browser, search, scraping

๐Ÿ› ๏ธ
Util

PDF, imagem, email, calendar

Em 1 frase: 200+ servers open source, de Git a Slack, prontos para plugar no Claude Code.

6

๐Ÿ”„ Analogia com APIs REST

Se voce ja trabalhou com APIs REST, MCP vai parecer familiar. Em REST, voce tem endpoints (GET /users, POST /orders). Em MCP, voce tem tools (list_users, create_order). Em REST, a documentacao vem num OpenAPI spec. Em MCP, vem no inputSchema.

A diferenca fundamental: REST foi feito para devs humanos chamarem via codigo. MCP foi feito para agentes de IA chamarem automaticamente. Por isso o schema e mais descritivo (o agente precisa "entender" o que a tool faz so lendo a descricao) e o discovery e automatico (o agente lista as tools em runtime, sem ler documentacao).

AspectoREST APIMCP
UnidadeEndpoint (URL + metodo)Tool (nome + schema)
DocumentacaoOpenAPI / SwaggerinputSchema (JSON Schema)
DiscoveryManual (ler docs)Automatico (tools/list)
ConsumidorCodigo escrito por humanoAgente de IA (automatico)
TransporteHTTPstdio ou HTTP+SSE

Em 1 frase: MCP e como uma API REST, mas com discovery automatico e otimizada para agentes (nao humanos).

๐Ÿงพ Resumo do Modulo

โœ“
MCP = protocolo padrao โ€” JSON-RPC que conecta agentes a ferramentas externas.
โœ“
Client-Server โ€” Claude Code (client) descobre e chama tools de cada server.
โœ“
Schema = contrato โ€” cada tool declara o que aceita via JSON Schema.
โœ“
Ecossistema vasto โ€” 200+ servers open source, de Git a Slack.

Proximo modulo:

3.2 โ€” Seus Primeiros MCPs: mao na massa com Filesystem, Git e SQLite.