Módulo 6: Model Context Protocol (MCP)

Progresso do Módulo 0/30 tópicos

"A verdadeira inteligência não vem apenas do modelo, mas das conexões que ele pode fazer com o mundo."

Conectando Agentes ao Mundo Real

Se os LLMs são "cérebros", o MCP é o sistema nervoso que conecta esse cérebro aos "órgãos sensoriais" e "membros" - permitindo que o agente veja (dados) e aja (ferramentas) no mundo real.

O Model Context Protocol é um protocolo aberto desenvolvido pela Anthropic que define uma maneira padronizada para que aplicações de IA se conectem a fontes de dados e ferramentas externas.

Capítulo 6.1: Introdução ao MCP

MCP é um protocolo aberto que define uma maneira padronizada para que aplicações de IA se conectem a:
- Fontes de dados externas (bancos de dados, APIs, arquivos)
- Ferramentas e serviços (cloud, automação, integração)
- Sistemas empresariais (CRM, ERP, data warehouses)
💡 ANALOGIA: Se os LLMs são "cérebros", o MCP é o "sistema nervoso" que conecta esse cérebro aos órgãos sensoriais (dados) e membros (ações), permitindo que o agente perceba e interaja com o mundo real.
❌ Problema antes do MCP:

# Cada ferramenta tinha sua própria integração chatbot.add_tool(custom_database_connector()) chatbot.add_tool(custom_api_wrapper()) chatbot.add_tool(custom_file_reader()) # Resultado: código fragmentado, difícil de manter

✅ Solução com MCP:

# Protocolo unificado mcp_client.connect_to_server("sqlite://local.db") mcp_client.connect_to_server("api://github.com") mcp_client.connect_to_server("file://~/documents") # Resultado: interface consistente e reutilizável
- ✅ Padronização: Interface única para todos os tipos de integrações
- ✅ Reutilização: Servidores MCP podem ser usados por múltiplas aplicações
- ✅ Segurança: Controle granular de permissões e autenticação
- ✅ Escalabilidade: Fácil adicionar novas fontes de dados
- ✅ Manutenibilidade: Separação clara entre cliente e servidor
1. Acesso a Dados Empresariais
- Conectar agentes a bancos de dados corporativos
- Acessar sistemas CRM, ERP
- Integração com data warehouses
2. Automação de Ferramentas
- Executar comandos no sistema operacional
- Gerenciar serviços em nuvem
- Controlar APIs de terceiros
3. Sistemas de Conhecimento
- RAG com fontes de dados dinâmicas
- Acesso a documentação técnica atualizada
- Bases de conhecimento corporativas
4. Agentes Autônomos
- Agentes que operam em ambientes reais
- Robôs de atendimento com acesso a sistemas
- Assistentes pessoais conectados

Capítulo 6.2: Arquitetura do MCP

O MCP segue uma arquitetura cliente-servidor baseada em JSON-RPC 2.0.

┌────────────────────────────────────────────────────────┐ │ MCP ECOSYSTEM │ ├────────────────────────────────────────────────────────┤ │ │ │ ┌──────────┐ MCP Protocol ┌──────────┐ │ │ │ MCP │ ◄─────────────────────►│ MCP │ │ │ │ Client │ │ Server │ │ │ │ (seu app)│ Resources, Tools, │ │ │ │ └─────┬────┘ Prompts └────┬─────┘ │ │ │ │ │ │ ▼ ▼ │ │ ┌──────────┐ ┌────────────────┐ │ │ │ LLM │ │ Data Sources │ │ │ │ (Claude) │ │ & Tools │ │ │ └──────────┘ └────────────────┘ │ │ │ └────────────────────────────────────────────────────────┘
Resources são dados que o servidor expõe ao cliente.

// Exemplo de um resource { "uri": "project://tasks/12345", "name": "Task #12345", "mimeType": "application/json", "description": "Detalhes da tarefa de desenvolvimento" }

Características:
- Representam dados que podem ser lidos
- Identificados por URIs únicas
- Podem ter diferentes formatos (JSON, texto, binário)
- Suportam versionamento
Tools são ações que o servidor pode executar.

// Exemplo de uma tool { "name": "create_task", "description": "Cria uma nova tarefa no sistema", "inputSchema": { "type": "object", "properties": { "title": {"type": "string"}, "priority": { "type": "string", "enum": ["low", "medium", "high"] } }, "required": ["title"] } }

Características:
- Representam operações que modificam estado
- Podem receber parâmetros
- Retornam resultados estruturados
- Podem ter efeitos colaterais
Prompts são templates pré-configurados que o servidor oferece.

// Exemplo de um prompt { "name": "analyze_code", "description": "Analisa código fonte", "arguments": [ { "name": "language", "description": "Linguagem de programação", "required": true } ] }

💡 DICA: Prompts são úteis para padronizar interações comuns. Por exemplo, um servidor MCP de análise de código pode oferecer prompts pré-configurados para "code review", "bug detection", "optimization suggestions".

Capítulo 6.3: Criando Servidores MCP

# Instalar o SDK do MCP pip install mcp # Ou via npm (Node.js) npm install @modelcontextprotocol/sdk
from mcp.server import Server from mcp.server.stdio import stdio_server from mcp.types import Resource, Tool # Criar servidor app = Server("meu-servidor-mcp") # Definir resources @app.list_resources() async def list_resources(): return [ Resource( uri="task://list", name="Lista de Tarefas", mimeType="application/json", description="Todas as tarefas do sistema" ) ] @app.read_resource() async def read_resource(uri: str): if uri == "task://list": return { "tasks": [ {"id": 1, "title": "Implementar MCP"}, {"id": 2, "title": "Testar integração"} ] } # Definir tools @app.list_tools() async def list_tools(): return [ Tool( name="create_task", description="Cria nova tarefa", inputSchema={ "type": "object", "properties": { "title": {"type": "string"} }, "required": ["title"] } ) ] @app.call_tool() async def call_tool(name: str, arguments: dict): if name == "create_task": # Criar tarefa return f"Tarefa '{arguments['title']}' criada!" # Rodar servidor if __name__ == "__main__": stdio_server(app)
from mcp import ClientSession, StdioServerParameters from mcp.client.stdio import stdio_client async def main(): # Conectar ao servidor server_params = StdioServerParameters( command="python", args=["meu_servidor.py"] ) async with stdio_client(server_params) as (read, write): async with ClientSession(read, write) as session: # Inicializar await session.initialize() # Listar resources resources = await session.list_resources() print(resources) # Ler resource data = await session.read_resource("task://list") print(data) # Chamar tool result = await session.call_tool( "create_task", {"title": "Nova tarefa via MCP"} ) print(result)

Capítulo 6.4: Integração com Agentes

from crewai import Agent, Task, Crew from crewai_tools import MCPTool # Criar tool MCP mcp_tool = MCPTool( server_command="python", server_args=["meu_servidor_mcp.py"] ) # Agente com acesso ao servidor MCP agent = Agent( role="Project Manager", goal="Gerenciar tarefas do projeto", tools=[mcp_tool], verbose=True ) task = Task( description="Liste todas as tarefas e crie uma nova", agent=agent ) crew = Crew(agents=[agent], tasks=[task]) result = crew.kickoff() print(result)
Principais Considerações de Segurança:
- ✓ Autenticação: Validar identidade do cliente
- ✓ Autorização: Controlar acesso a resources e tools
- ✓ Validação: Verificar inputs antes de executar
- ✓ Rate Limiting: Prevenir abuso
- ✓ Logging: Auditoria de todas as operações
🔒 SEGURANÇA: Sempre valide e sanitize inputs de tools antes de executar ações críticas. Use sandboxing quando possível e implemente rate limiting para prevenir abuso.

📝 Resumo Gráfico do Módulo 6

Componentes MCP:
- Resources: Dados expostos pelo servidor
- Tools: Ações que modificam estado
- Prompts: Templates reutilizáveis
- Client: Aplicação que consome MCP
- Server: Expõe dados e ferramentas
Vantagens:
- ✓ Padronização de integrações
- ✓ Reutilização de servidores
- ✓ Segurança e controle
- ✓ Escalabilidade

🚀 Projeto Prático do Módulo 6

Objetivo: Criar um servidor MCP completo para gestão de projetos que expõe resources e tools para agentes de IA.

Funcionalidades:
- Resources: Listar projetos, tarefas, equipes
- Tools: Criar tarefa, atualizar status, atribuir membro
- Prompts: Templates para relatórios, análises
- Segurança: Autenticação e autorização
Integração:
- Conectar com banco de dados SQLite
- Criar crew de agentes que usa o servidor MCP
- Implementar logging e auditoria
Resultado Esperado: Sistema funcional onde agentes podem gerenciar projetos via MCP.

🎯 Próximos Passos

Você agora domina o Model Context Protocol! Você aprendeu:
- ✓ O que é MCP e por que é importante
- ✓ Arquitetura cliente-servidor
- ✓ Resources, Tools e Prompts
- ✓ Criar servidores e clientes MCP
- ✓ Integração com agentes
- ✓ Segurança e boas práticas
No Módulo 7, vamos para a fase final: Deploy e Produção. Você aprenderá a levar seus agentes de IA do desenvolvimento para o mundo real com escalabilidade, monitoramento e confiabilidade.

Continue sua jornada

Você dominou o MCP. Agora é hora de colocar seus agentes em produção!

Voltar: Módulo 5 Próximo: Módulo 7 - Deploy

← Voltar para Nível Aplicação