Model Context Protocol (MCP)

O que é o MCP?

Definição

O Model Context Protocol (MCP) é um padrão aberto que define como as aplicações podem interagir com modelos de linguagem de grande porte (LLMs) de maneira padronizada e eficiente.

Ele permite que os desenvolvedores forneçam contexto rico e estruturado para os LLMs, melhorando significativamente a qualidade das respostas e permitindo que os modelos acessem recursos externos.

Por que está famoso?

O MCP ganhou popularidade rapidamente porque:

Resolve problemas de interoperabilidade entre diferentes LLMs
Permite que os modelos acessem ferramentas e dados externos de forma padronizada
Melhora a transparência e a consistência das interações com IA
Tem suporte da Microsoft, Anthropic e outras empresas líderes em IA

2023

Q1 2024

Q2 2024

Hoje

Utilidade

Tool Use

Permite que LLMs acessem APIs, bancos de dados, executem código e interajam com serviços externos.

Context Management

Fornece uma estrutura para gerenciar o contexto da conversa e a memória do modelo.

Segurança

Define padrões para interações seguras e protegidas com os modelos de IA.

Interoperabilidade

Facilita a troca entre diferentes modelos e plataformas sem refatoração de código.

Componentes MCP

Tools

Funções específicas que o modelo pode chamar para realizar ações externas (como busca na web ou cálculos).

Resources

Conteúdos estáticos que o modelo pode consultar (como documentações ou dados estruturados).

Prompts

Instruções e contexto fornecidos ao modelo para guiar seu comportamento e respostas.

Transportes MCP

STDIO

Transporte baseado em entrada/saída padrão do sistema. Simples, porém síncrono e bloqueante - ideal para scripts de linha de comando.

SSE (Server-Sent Events)

Protocolo de comunicação assíncrono que permite streaming de respostas. Ideal para comunicação em tempo real e aplicações web.

Casos de Uso

Desenvolvimento de Software

Assistentes de código que podem acessar repositórios, executar testes e depurar código.

Busca Avançada

Agentes que podem pesquisar, analisar e sintetizar informações de múltiplas fontes.

Agentes Autônomos

Sistemas que podem executar tarefas complexas usando múltiplas ferramentas.

Demonstração Prática

Implementação do MCP com Python/FastAPI/Crawl4ai e Claude Desktop
para acessar documentação mais recente!

api.py

# Api para a Tool usar!
from fastapi import FastAPI
from crawl4ai import AsyncWebCrawler


app = FastAPI()

@app.get("/scrape")
async def main():
    async with AsyncWebCrawler() as crawler:
        result = await crawler.arun(url="https://crawl4ai.com")
        return result.markdown

mcp_client.py

# Cliente MCP
import httpx
from mcp.server.fastmcp import FastMCP
import json 

mcp = FastMCP("Documentacao")

async def request_api():
    async with httpx.AsyncClient() as client:
        try:
            resp = await client.get("http://127.0.0.1:8000/scrape")
            resp.raise_for_status() 
            try:
                data = resp.json()
                if isinstance(data, dict) and "detail" in data:
                    return data["detail"]
                return json.dumps(data) 
            except json.JSONDecodeError:
                return resp.text

        except httpx.HTTPStatusError as e:
            print(f"Erro na API: {e.response.status_code} - {e.response.text}")
            return f"Erro na API: Status {e.response.status_code}"
        except httpx.RequestError as e:
            print(f"Erro de conexão com a API: {e}")
            return f"Erro ao conectar com a API: {e}"
        except Exception as e:
            print(f"Erro inesperado: {e}")
            return f"Erro inesperado ao chamar a API: {e}"


@mcp.tool()
async def scrape():
    """
    Tool para Scrape de Documentacao
    """
    data = await request_api() 
    if not data:
        return "Não foi possível obter dados da API (resposta vazia)."

    if isinstance(data, str) and ("Erro na API" in data or "Erro ao conectar" in data or "Erro inesperado" in data):
         return data 
    return str(data) 

if __name__ == "__main__":
    mcp.run(transport="stdio")

Componentes do MCP

1

Definição de Ferramentas

Especificamos as ferramentas disponíveis em um formato padronizado com nome, descrição e parâmetros esperados.

2

Chamada de Ferramentas

O LLM solicita o uso de ferramentas específicas para buscar informações ou executar ações.

3

Execução

O sistema executa as ferramentas solicitadas e retorna os resultados para o LLM.

4

Resposta Aumentada

O LLM usa os dados obtidos das ferramentas para gerar uma resposta mais precisa e útil.

Exercício Prático

Implemente uma função MCP simples em Python

Desafio

Crie uma ferramenta MCP simples soma que recebe dois números e retorna a soma deles, baseando-se no código de exemplo acima.

Passos:

Implemente a função soma que recebe dois números e retorna sua soma.
Defina a descrição da ferramenta e seus parâmetros no formato MCP.
Adicione a ferramenta ao servidor MCP.
Teste o funcionamento com uma pergunta como "Qual a soma de 25 e 75 usando a ferramenta MCP?"