# MCP Server — Projeto de Estudos

## Sobre este projeto

Este repositório tem como objetivo **praticar e entender na prática os conceitos do Model Context Protocol (MCP)** — como criar servidores, expor ferramentas, conectar clientes e fazer a comunicação entre eles funcionar. Os exemplos aqui são intencionalmente simples para focar no aprendizado do protocolo em si, não na complexidade do domínio.

---

## O que é o MCP

MCP (Model Context Protocol) é um **protocolo aberto criado pela Anthropic** (lançado em novembro de 2024) que padroniza a forma como modelos de linguagem (LLMs) se comunicam com ferramentas, dados e serviços externos.

A ideia central é simples: em vez de cada aplicação de IA ter sua própria forma proprietária de conectar o modelo a ferramentas, o MCP define um contrato universal — um "USB para IA".

```
Sem MCP:                          Com MCP:
Claude  ── integração custom       Claude  ──┐
GPT     ── integração custom       GPT     ──┼──► Servidor MCP ──► sua ferramenta
Cursor  ── integração custom       Cursor  ──┘
```

---

## Para que serve

Com o MCP, você cria **um servidor MCP** para o seu serviço uma única vez, e qualquer cliente MCP (Claude, Cursor, VS Code, sua própria aplicação) consegue se conectar e usar suas ferramentas automaticamente — sem reimplementar integrações para cada modelo ou produto.

---

## Como funciona

O protocolo define três primitivas principais:

| Primitiva | O que é |
|---|---|
| **Tools** | Funções que o modelo pode chamar (ex: buscar notícias, executar SQL) |
| **Resources** | Dados que o modelo pode ler (ex: arquivos, registros de banco) |
| **Prompts** | Templates de prompt reutilizáveis expostos pelo servidor |

### Fluxo básico

1. Cliente conecta ao servidor MCP
2. Cliente pergunta quais ferramentas estão disponíveis (`list_tools`)
3. O LLM decide chamar uma ferramenta (`call_tool`)
4. O servidor executa e devolve o resultado
5. O resultado vira contexto para o LLM continuar o raciocínio

---

## Transportes: stdio vs SSE

Esses são os dois principais meios de comunicação entre cliente e servidor.

### stdio (Standard Input/Output)

O cliente **inicia o servidor como um subprocesso** e a comunicação acontece via stdin/stdout.

```
Cliente
  └── spawn → server.py (processo filho)
        ├── stdin  ← mensagens do cliente
        └── stdout → respostas ao cliente
```

**Quando usar:**
- Ferramentas locais (acesso a arquivos, comandos do sistema, banco de dados local)
- Integrações em IDEs como Cursor e VS Code
- Quando cliente e servidor estão na mesma máquina
- Configuração mais simples, sem necessidade de rede

### SSE (Server-Sent Events)

O servidor roda de forma **independente** como um processo HTTP. O cliente se conecta via URL. A comunicação usa HTTP — o cliente envia requests POST e recebe eventos via SSE (conexão persistente).

```
Cliente ──── HTTP POST ────► Servidor (http://localhost:8000/sse)
        ◄─── SSE events ────
```

**Quando usar:**
- Servidor precisa ser acessado por múltiplos clientes simultaneamente
- Servidor remoto (cloud, outro host)
- Integração com aplicações web
- Quando o servidor precisa ficar sempre disponível, independente do cliente

### Comparativo

| | stdio | SSE |
|---|---|---|
| Onde roda | mesmo processo/máquina | processo independente, pode ser remoto |
| Ciclo de vida | nasce e morre com o cliente | roda continuamente |
| Múltiplos clientes | não | sim |
| Complexidade | menor | maior |
| Caso de uso típico | ferramentas locais, IDEs | serviços, APIs, produção |

---

## Por que o MCP está tão em alta

**1. Agentes de IA viraram realidade prática**
LLMs bons o suficiente para usar ferramentas de forma confiável só apareceram nos últimos 1-2 anos. O problema de "como conectar o modelo ao mundo real" deixou de ser teórico e virou urgente.

**2. Fragmentação estava ficando insustentável**
Cada provedor (OpenAI, Anthropic, Google) tinha sua própria forma de function calling. Cada IDE, cada produto de IA reimplementava as mesmas integrações. O MCP veio resolver exatamente essa dor.

**3. Adoção em cascata**
Cursor, VS Code (Copilot), Zed, Windsurf e outros editores adotaram MCP em poucos meses. Isso criou um ecossistema de servidores reutilizáveis — hoje existem centenas de servidores MCP públicos (GitHub, Slack, Postgres, etc.).

**4. Baixa barreira de entrada**
Com bibliotecas como `fastmcp`, criar um servidor MCP funcional é questão de minutos. Isso democratizou o acesso ao protocolo.

**5. Definição de padrão da indústria**
Estamos na fase em que a indústria está definindo os protocolos que vão durar anos. O MCP tem chance real de se tornar o padrão de fato para integração de ferramentas com LLMs.