O Model Context Protocol (MCP) é uma estrutura poderosa e padronizada que otimiza a comunicação entre Grandes Modelos de Linguagem (LLMs) e ferramentas externas, aplicações e fontes de dados. Este guia otimizado para SEO vai te conduzir pelos conceitos essenciais do MCP, garantindo que você compreenda sua arquitetura cliente-servidor, componentes principais, mecânicas de comunicação e melhores práticas de implementação.
Esta lição explora a arquitetura fundamental e os componentes que compõem o ecossistema do Model Context Protocol (MCP). Você aprenderá sobre a arquitetura cliente-servidor, os componentes-chave e os mecanismos de comunicação que impulsionam as interações do MCP.
Ao final desta lição, você será capaz de:
- Entender a arquitetura cliente-servidor do MCP.
- Identificar os papéis e responsabilidades de Hosts, Clients e Servers.
- Analisar as características centrais que tornam o MCP uma camada de integração flexível.
- Compreender como a informação flui dentro do ecossistema MCP.
- Obter insights práticos por meio de exemplos de código em .NET, Java, Python e JavaScript.
O ecossistema MCP é construído sobre um modelo cliente-servidor. Essa estrutura modular permite que aplicações de IA interajam de forma eficiente com ferramentas, bancos de dados, APIs e recursos contextuais. Vamos detalhar essa arquitetura em seus componentes principais.
No Model Context Protocol (MCP), os Hosts desempenham um papel crucial como a interface principal pela qual os usuários interagem com o protocolo. Hosts são aplicações ou ambientes que iniciam conexões com servidores MCP para acessar dados, ferramentas e prompts. Exemplos de Hosts incluem ambientes de desenvolvimento integrados (IDEs) como Visual Studio Code, ferramentas de IA como Claude Desktop ou agentes personalizados projetados para tarefas específicas.
Hosts são aplicações LLM que iniciam conexões. Eles:
- Executam ou interagem com modelos de IA para gerar respostas.
- Iniciam conexões com servidores MCP.
- Gerenciam o fluxo da conversa e a interface do usuário.
- Controlam permissões e restrições de segurança.
- Lidam com o consentimento do usuário para compartilhamento de dados e execução de ferramentas.
Clients são componentes essenciais que facilitam a interação entre Hosts e servidores MCP. Eles atuam como intermediários, permitindo que Hosts acessem e utilizem as funcionalidades fornecidas pelos servidores MCP. Desempenham um papel fundamental para garantir uma comunicação fluida e troca eficiente de dados dentro da arquitetura MCP.
Clients são conectores dentro da aplicação host. Eles:
- Enviam solicitações aos servidores com prompts/instruções.
- Negociam capacidades com os servidores.
- Gerenciam pedidos de execução de ferramentas feitas pelos modelos.
- Processam e exibem respostas aos usuários.
Servers são responsáveis por tratar as solicitações dos clients MCP e fornecer respostas adequadas. Eles gerenciam várias operações, como recuperação de dados, execução de ferramentas e geração de prompts. Os servers garantem que a comunicação entre clients e Hosts seja eficiente e confiável, mantendo a integridade do processo de interação.
Servers são serviços que fornecem contexto e funcionalidades. Eles:
- Registram recursos disponíveis (recursos, prompts, ferramentas).
- Recebem e executam chamadas de ferramentas vindas do client.
- Fornecem informações contextuais para aprimorar as respostas do modelo.
- Retornam os resultados ao client.
- Mantêm estado ao longo das interações quando necessário.
Qualquer pessoa pode desenvolver servers para ampliar as capacidades dos modelos com funcionalidades especializadas.
Os servers no Model Context Protocol (MCP) oferecem blocos fundamentais que possibilitam interações ricas entre clients, hosts e modelos de linguagem. Essas funcionalidades são projetadas para ampliar as capacidades do MCP, oferecendo contexto estruturado, ferramentas e prompts.
Os servers MCP podem disponibilizar qualquer uma das seguintes funcionalidades:
Recursos no Model Context Protocol (MCP) abrangem diversos tipos de contexto e dados que podem ser utilizados por usuários ou modelos de IA. Isso inclui:
- Dados Contextuais: Informações e contexto que usuários ou modelos podem usar para tomada de decisão e execução de tarefas.
- Bases de Conhecimento e Repositórios de Documentos: Coleções de dados estruturados e não estruturados, como artigos, manuais e pesquisas, que fornecem insights e informações valiosas.
- Arquivos Locais e Bancos de Dados: Dados armazenados localmente em dispositivos ou dentro de bancos de dados, acessíveis para processamento e análise.
- APIs e Serviços Web: Interfaces e serviços externos que oferecem dados adicionais e funcionalidades, possibilitando integração com diversos recursos e ferramentas online.
Um exemplo de recurso pode ser um esquema de banco de dados ou um arquivo acessado da seguinte forma:
file://log.txt
database://schema
Prompts no Model Context Protocol (MCP) incluem vários templates pré-definidos e padrões de interação desenhados para agilizar fluxos de trabalho dos usuários e melhorar a comunicação. Isso inclui:
- Mensagens e Fluxos de Trabalho Modelados: Mensagens e processos pré-estruturados que guiam os usuários por tarefas e interações específicas.
- Padrões de Interação Pré-definidos: Sequências padronizadas de ações e respostas que facilitam uma comunicação consistente e eficiente.
- Templates de Conversa Especializados: Templates customizáveis para tipos específicos de conversas, garantindo interações relevantes e contextualmente adequadas.
Um template de prompt pode ser assim:
Generate a product slogan based on the following {{product}} with the following {{keywords}}Ferramentas no Model Context Protocol (MCP) são funções que o modelo de IA pode executar para realizar tarefas específicas. Essas ferramentas foram desenhadas para ampliar as capacidades do modelo, oferecendo operações estruturadas e confiáveis. Os principais aspectos incluem:
- Funções que o modelo de IA pode executar: Ferramentas são funções executáveis que o modelo pode invocar para realizar diversas tarefas.
- Nome Único e Descrição: Cada ferramenta possui um nome distinto e uma descrição detalhada que explica seu propósito e funcionalidade.
- Parâmetros e Resultados: Ferramentas aceitam parâmetros específicos e retornam resultados estruturados, garantindo resultados consistentes e previsíveis.
- Funções Discretas: Ferramentas realizam funções específicas, como buscas na web, cálculos e consultas a bancos de dados.
Um exemplo de ferramenta pode ser assim:
server.tool(
"GetProducts",
{
pageSize: z.string().optional(),
pageCount: z.string().optional()
}, () => {
// return results from API
}
)No Model Context Protocol (MCP), os clients oferecem várias funcionalidades importantes para os servers, ampliando a funcionalidade geral e a interação dentro do protocolo. Uma das funcionalidades notáveis é o Sampling.
- Comportamentos Agentes Iniciados pelo Server: Clients permitem que os servers iniciem ações ou comportamentos específicos de forma autônoma, ampliando as capacidades dinâmicas do sistema.
- Interações Recursivas com LLMs: Essa funcionalidade possibilita interações recursivas com grandes modelos de linguagem, permitindo um processamento mais complexo e iterativo de tarefas.
- Solicitação de Completions Adicionais do Modelo: Servers podem solicitar completions adicionais do modelo, garantindo que as respostas sejam completas e contextualmente relevantes.
O Model Context Protocol (MCP) define um fluxo estruturado de informações entre hosts, clients, servers e modelos. Compreender esse fluxo ajuda a esclarecer como as solicitações dos usuários são processadas e como ferramentas e dados externos são integrados às respostas do modelo.
-
Host Inicia Conexão
A aplicação host (como um IDE ou interface de chat) estabelece uma conexão com um servidor MCP, geralmente via STDIO, WebSocket ou outro transporte suportado. -
Negociação de Capacidades
O client (embutido no host) e o servidor trocam informações sobre os recursos, ferramentas, versões de protocolo e funcionalidades suportadas. Isso garante que ambos os lados entendam as capacidades disponíveis para a sessão. -
Solicitação do Usuário
O usuário interage com o host (por exemplo, inserindo um prompt ou comando). O host coleta essa entrada e a encaminha para o client processar. -
Uso de Recursos ou Ferramentas
- O client pode solicitar contexto ou recursos adicionais do servidor (como arquivos, entradas de banco de dados ou artigos de base de conhecimento) para enriquecer a compreensão do modelo.
- Se o modelo determinar que uma ferramenta é necessária (por exemplo, para buscar dados, realizar um cálculo ou chamar uma API), o client envia uma solicitação de invocação da ferramenta ao servidor, especificando o nome da ferramenta e os parâmetros.
-
Execução pelo Server
O servidor recebe a solicitação de recurso ou ferramenta, executa as operações necessárias (como rodar uma função, consultar um banco de dados ou recuperar um arquivo) e retorna os resultados ao client em formato estruturado. -
Geração da Resposta
O client integra as respostas do servidor (dados de recursos, resultados de ferramentas, etc.) na interação contínua com o modelo. O modelo usa essas informações para gerar uma resposta abrangente e contextualmente relevante. -
Apresentação do Resultado
O host recebe o resultado final do client e o apresenta ao usuário, frequentemente incluindo tanto o texto gerado pelo modelo quanto quaisquer resultados de execuções de ferramentas ou consultas a recursos.
Esse fluxo permite que o MCP suporte aplicações de IA avançadas, interativas e conscientes do contexto, conectando modelos a ferramentas e fontes de dados externas de forma fluida.
O MCP (Model Context Protocol) é construído sobre JSON-RPC 2.0, oferecendo um formato padronizado e independente de linguagem para comunicação entre hosts, clients e servers. Essa base possibilita interações confiáveis, estruturadas e extensíveis em diversas plataformas e linguagens de programação.
O MCP estende o JSON-RPC 2.0 com convenções adicionais para invocação de ferramentas, acesso a recursos e gerenciamento de prompts. Suporta múltiplas camadas de transporte (STDIO, WebSocket, SSE) e permite comunicação segura, extensível e independente de linguagem entre componentes.
- Formato de Mensagens JSON-RPC: Todas as requisições e respostas utilizam a especificação JSON-RPC 2.0, garantindo estrutura consistente para chamadas de métodos, parâmetros, resultados e tratamento de erros.
- Conexões com Estado: Sessões MCP mantêm estado entre múltiplas requisições, suportando conversas contínuas, acumulação de contexto e gerenciamento de recursos.
- Negociação de Capacidades: Durante a configuração da conexão, clients e servers trocam informações sobre recursos suportados, versões do protocolo, ferramentas e recursos disponíveis. Isso assegura que ambos os lados compreendam as capacidades um do outro e possam se adaptar.
A seguir, alguns utilitários e extensões do protocolo que o MCP oferece para melhorar a experiência do desenvolvedor e permitir cenários avançados:
- Opções de Configuração: O MCP permite configuração dinâmica de parâmetros da sessão, como permissões de ferramentas, acesso a recursos e configurações do modelo, adaptadas a cada interação.
- Monitoramento de Progresso: Operações de longa duração podem reportar atualizações de progresso, possibilitando interfaces responsivas e melhor experiência do usuário durante tarefas complexas.
- Cancelamento de Requisições: Clients podem cancelar requisições em andamento, permitindo que usuários interrompam operações que não são mais necessárias ou que estejam demorando demais.
- Relato de Erros: Mensagens e códigos de erro padronizados ajudam a diagnosticar problemas, tratar falhas de forma elegante e fornecer feedback acionável para usuários e desenvolvedores.
- Registro de Logs: Tanto clients quanto servers podem emitir logs estruturados para auditoria, depuração e monitoramento das interações do protocolo.
Ao aproveitar essas funcionalidades, o MCP garante comunicação robusta, segura e flexível entre modelos de linguagem e ferramentas ou fontes de dados externas.
Implementações do MCP devem seguir vários princípios-chave de segurança para garantir interações seguras e confiáveis:
-
Consentimento e Controle do Usuário: Os usuários devem fornecer consentimento explícito antes que qualquer dado seja acessado ou operações sejam realizadas. Eles devem ter controle claro sobre quais dados são compartilhados e quais ações são autorizadas, apoiados por interfaces intuitivas para revisão e aprovação das atividades.
-
Privacidade dos Dados: Dados do usuário só devem ser expostos com consentimento explícito e protegidos por controles de acesso adequados. Implementações MCP devem prevenir transmissões não autorizadas e garantir que a privacidade seja mantida em todas as interações.
-
Segurança das Ferramentas: Antes de invocar qualquer ferramenta, é necessário o consentimento explícito do usuário. Os usuários devem entender claramente a funcionalidade de cada ferramenta, e limites de segurança rigorosos devem ser aplicados para evitar execuções não intencionais ou inseguras.
Seguindo esses princípios, o MCP assegura que a confiança, privacidade e segurança do usuário sejam mantidas em todas as interações do protocolo.
A seguir, exemplos de código em várias linguagens populares que ilustram como implementar componentes chave de servidores MCP e ferramentas.
Aqui está um exemplo prático em .NET demonstrando como implementar um servidor MCP simples com ferramentas personalizadas. Este exemplo mostra como definir e registrar ferramentas, tratar requisições e conectar o servidor usando o Model Context Protocol.
using System;
using System.Threading.Tasks;
using ModelContextProtocol.Server;
using ModelContextProtocol.Server.Transport;
using ModelContextProtocol.Server.Tools;
public class WeatherServer
{
public static async Task Main(string[] args)
{
// Create an MCP server
var server = new McpServer(
name: "Weather MCP Server",
version: "1.0.0"
);
// Register our custom weather tool
server.AddTool<string, WeatherData>("weatherTool",
description: "Gets current weather for a location",
execute: async (location) => {
// Call weather API (simplified)
var weatherData = await GetWeatherDataAsync(location);
return weatherData;
});
// Connect the server using stdio transport
var transport = new StdioServerTransport();
await server.ConnectAsync(transport);
Console.WriteLine("Weather MCP Server started");
// Keep the server running until process is terminated
await Task.Delay(-1);
}
private static async Task<WeatherData> GetWeatherDataAsync(string location)
{
// This would normally call a weather API
// Simplified for demonstration
await Task.Delay(100); // Simulate API call
return new WeatherData {
Temperature = 72.5,
Conditions = "Sunny",
Location = location
};
}
}
public class WeatherData
{
public double Temperature { get; set; }
public string Conditions { get; set; }
public string Location { get; set; }
}Este exemplo demonstra o mesmo servidor MCP e registro de ferramentas do exemplo .NET acima, mas implementado em Java.
import io.modelcontextprotocol.server.McpServer;
import io.modelcontextprotocol.server.McpToolDefinition;
import io.modelcontextprotocol.server.transport.StdioServerTransport;
import io.modelcontextprotocol.server.tool.ToolExecutionContext;
import io.modelcontextprotocol.server.tool.ToolResponse;
public class WeatherMcpServer {
public static void main(String[] args) throws Exception {
// Create an MCP server
McpServer server = McpServer.builder()
.name("Weather MCP Server")
.version("1.0.0")
.build();
// Register a weather tool
server.registerTool(McpToolDefinition.builder("weatherTool")
.description("Gets current weather for a location")
.parameter("location", String.class)
.execute((ToolExecutionContext ctx) -> {
String location = ctx.getParameter("location", String.class);
// Get weather data (simplified)
WeatherData data = getWeatherData(location);
// Return formatted response
return ToolResponse.content(
String.format("Temperature: %.1f°F, Conditions: %s, Location: %s",
data.getTemperature(),
data.getConditions(),
data.getLocation())
);
})
.build());
// Connect the server using stdio transport
try (StdioServerTransport transport = new StdioServerTransport()) {
server.connect(transport);
System.out.println("Weather MCP Server started");
// Keep server running until process is terminated
Thread.currentThread().join();
}
}
private static WeatherData getWeatherData(String location) {
// Implementation would call a weather API
// Simplified for example purposes
return new WeatherData(72.5, "Sunny", location);
}
}
class WeatherData {
private double temperature;
private String conditions;
private String location;
public WeatherData(double temperature, String conditions, String location) {
this.temperature = temperature;
this.conditions = conditions;
this.location = location;
}
public double getTemperature() {
return temperature;
}
public String getConditions() {
return conditions;
}
public String getLocation() {
return location;
}
}Neste exemplo mostramos como construir um servidor MCP em Python. Também são apresentadas duas formas diferentes de criar ferramentas.
#!/usr/bin/env python3
import asyncio
from mcp.server.fastmcp import FastMCP
from mcp.server.transports.stdio import serve_stdio
# Create a FastMCP server
mcp = FastMCP(
name="Weather MCP Server",
version="1.0.0"
)
@mcp.tool()
def get_weather(location: str) -> dict:
"""Gets current weather for a location."""
# This would normally call a weather API
# Simplified for demonstration
return {
"temperature": 72.5,
"conditions": "Sunny",
"location": location
}
# Alternative approach using a class
class WeatherTools:
@mcp.tool()
def forecast(self, location: str, days: int = 1) -> dict:
"""Gets weather forecast for a location for the specified number of days."""
# This would normally call a weather API forecast endpoint
# Simplified for demonstration
return {
"location": location,
"forecast": [
{"day": i+1, "temperature": 70 + i, "conditions": "Partly Cloudy"}
for i in range(days)
]
}
# Instantiate the class to register its tools
weather_tools = WeatherTools()
# Start the server using stdio transport
if __name__ == "__main__":
asyncio.run(serve_stdio(mcp))Este exemplo mostra a criação de um servidor MCP em JavaScript e como registrar duas ferramentas relacionadas ao clima.
// Using the official Model Context Protocol SDK
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod"; // For parameter validation
// Create an MCP server
const server = new McpServer({
name: "Weather MCP Server",
version: "1.0.0"
});
// Define a weather tool
server.tool(
"weatherTool",
{
location: z.string().describe("The location to get weather for")
},
async ({ location }) => {
// This would normally call a weather API
// Simplified for demonstration
const weatherData = await getWeatherData(location);
return {
content: [
{
type: "text",
text: `Temperature: ${weatherData.temperature}°F, Conditions: ${weatherData.conditions}, Location: ${weatherData.location}`
}
]
};
}
);
// Define a forecast tool
server.tool(
"forecastTool",
{
location: z.string(),
days: z.number().default(3).describe("Number of days for forecast")
},
async ({ location, days }) => {
// This would normally call a weather API
// Simplified for demonstration
const forecast = await getForecastData(location, days);
return {
content: [
{
type: "text",
text: `${days}-day forecast for ${location}: ${JSON.stringify(forecast)}`
}
]
};
}
);
// Helper functions
async function getWeatherData(location) {
// Simulate API call
return {
temperature: 72.5,
conditions: "Sunny",
location: location
};
}
async function getForecastData(location, days) {
// Simulate API call
return Array.from({ length: days }, (_, i) => ({
day: i + 1,
temperature: 70 + Math.floor(Math.random() * 10),
conditions: i % 2 === 0 ? "Sunny" : "Partly Cloudy"
}));
}
// Connect the server using stdio transport
const transport = new StdioServerTransport();
server.connect(transport).catch(console.error);
console.log("Weather MCP Server started");Este exemplo em JavaScript demonstra como criar um client MCP que conecta a um servidor, envia um prompt e processa a resposta, incluindo quaisquer chamadas de ferramentas feitas.
O MCP inclui vários conceitos e mecanismos embutidos para gerenciar segurança e autorização ao longo do protocolo:
-
Controle de Permissão de Ferramentas:
Clients podem especificar quais ferramentas um modelo está autorizado a usar durante uma sessão. Isso garante que apenas ferramentas explicitamente autorizadas estejam acessíveis, reduzindo riscos de operações não intencionais ou inseguras. Permissões podem ser configuradas dinamicamente com base em preferências do usuário, políticas organizacionais ou contexto da interação. -
Autenticação:
Servers podem exigir autenticação antes de conceder acesso a ferramentas, recursos ou operações sensíveis. Isso pode envolver chaves de API, tokens OAuth ou outros esquemas de autenticação. A autenticação adequada assegura que apenas clients e usuários confiáveis possam invocar capacidades do servidor. -
Validação:
Validação de parâmetros é aplicada a todas as invocações de ferramentas. Cada ferramenta define os tipos, formatos e restrições esperados para seus parâmetros, e o servidor valida as requisições recebidas conforme essas regras. Isso evita que entradas malformadas ou maliciosas alcancem as implementações das ferramentas e ajuda a manter a integridade das operações. -
Limitação de Taxa (Rate Limiting):
Para prevenir abusos e garantir uso justo dos recursos do servidor, servers MCP podem implementar limitação de taxa para chamadas de ferramentas e acesso a recursos. Limites podem ser aplicados por usuário, por sessão ou globalmente, protegendo contra ataques de negação de serviço ou consumo excessivo de recursos.
Combinando esses mecanismos, o MCP oferece uma base segura para integrar modelos de linguagem com ferramentas e fontes de dados externas, ao mesmo tempo em que dá a usuários e desenvolvedores controle detalhado sobre acesso e uso.
A comunicação MCP utiliza mensagens JSON estruturadas para facilitar interações claras e confiáveis entre clients, servers e modelos. Os principais tipos de mensagem incluem:
-
Solicitação do Client
Enviada do client para o servidor, essa mensagem geralmente inclui:- O prompt ou comando do usuário
- Histórico da conversa para contexto
- Configuração e permissões de ferramentas
- Qualquer metadado adicional ou informação da sessão
-
Resposta do Modelo
Retornada pelo modelo (via client), essa mensagem contém:- Texto gerado ou completions baseados no prompt e contexto
- Instruções opcionais para chamada de ferramentas caso o modelo determine que deve invocar alguma
- Referências a recursos ou contexto adicional conforme necessário
-
Solicitação de Ferramenta
Enviada do client para o servidor quando uma ferramenta precisa ser executada. Essa mensagem inclui:- O nome da ferramenta a ser invocada
- Parâmetros exigidos pela ferramenta (validados contra o esquema da ferramenta)
- Informações contextuais ou identificadores para rastreamento da solicitação
-
Resposta da Ferramenta
Retornada pelo servidor após executar uma ferramenta. Essa mensagem fornece:- Resultados da execução da ferramenta (dados estruturados ou conteúdo)
- Qualquer erro ou informação de status caso a chamada da ferramenta tenha falhado
- Opcionalmente, metadados adicionais ou logs relacionados à execução
Essas mensagens estruturadas garantem que cada etapa do fluxo MCP seja explícita, rastreável e extensível, suportando cenários avançados como conversas multi-turno, encadeamento de ferramentas e tratamento robusto de erros.
- MCP utiliza arquitetura cliente-servidor para conectar modelos a capacidades externas
- O ecossistema é composto por clients, hosts, servers, ferramentas e fontes de dados
- A comunicação pode ocorrer via STDIO, SSE ou WebSockets
- Ferramentas são as unidades fundamentais de funcionalidade expostas aos modelos
- Protocolos de comunicação estruturada garantem interações consistentes
Projete uma ferramenta MCP simples que seria útil na sua área de atuação. Defina:
- Qual seria o nome da ferramenta
- Quais parâmetros ela aceitaria
- Qual saída ela retornaria
- Como um modelo poderia usar essa ferramenta para resolver problemas do usuário
Próximo: Capítulo 2: Segurança
Aviso Legal:
Este documento foi traduzido utilizando o serviço de tradução por IA Co-op Translator. Embora nos esforcemos para garantir a precisão, por favor, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original em seu idioma nativo deve ser considerado a fonte autorizada. Para informações críticas, recomenda-se tradução profissional feita por humanos. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações equivocadas decorrentes do uso desta tradução.