(Clique na imagem acima para assistir ao vídeo desta lição)
O Model Context Protocol (MCP) é uma estrutura padronizada e poderosa que otimiza a comunicação entre Modelos de Linguagem de Grande Escala (LLMs) e ferramentas, aplicações e fontes de dados externas.
Este guia irá apresentar os conceitos fundamentais do MCP. Você aprenderá sobre sua arquitetura cliente-servidor, componentes essenciais, mecânica de comunicação e melhores práticas de implementação.
-
Consentimento Explícito do Utilizador: Todo acesso a dados e operações requer aprovação explícita do utilizador antes da execução. Os utilizadores devem compreender claramente quais dados serão acessados e quais ações serão realizadas, com controle detalhado sobre permissões e autorizações.
-
Proteção da Privacidade dos Dados: Os dados do utilizador só podem ser expostos com consentimento explícito e devem ser protegidos por controles de acesso robustos durante todo o ciclo de interação. As implementações devem prevenir transmissões não autorizadas de dados e manter limites rigorosos de privacidade.
-
Segurança na Execução de Ferramentas: Cada invocação de ferramenta requer consentimento explícito do utilizador, com compreensão clara da funcionalidade, parâmetros e impacto potencial da ferramenta. Limites de segurança robustos devem prevenir execuções de ferramentas não intencionais, inseguras ou maliciosas.
-
Segurança na Camada de Transporte: Todos os canais de comunicação devem utilizar mecanismos apropriados de encriptação e autenticação. Conexões remotas devem implementar protocolos de transporte seguros e gestão adequada de credenciais.
- Gestão de Permissões: Implementar sistemas de permissão detalhados que permitam aos utilizadores controlar quais servidores, ferramentas e recursos são acessíveis
- Autenticação e Autorização: Utilizar métodos seguros de autenticação (OAuth, chaves de API) com gestão adequada de tokens e expiração
- Validação de Entrada: Validar todos os parâmetros e entradas de dados de acordo com esquemas definidos para prevenir ataques de injeção
- Registo de Auditoria: Manter registos abrangentes de todas as operações para monitorização de segurança e conformidade
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 principais e os mecanismos de comunicação que impulsionam as interações do MCP.
Ao final desta lição, você será capaz de:
- Compreender a arquitetura cliente-servidor do MCP.
- Identificar os papéis e responsabilidades de Hosts, Clientes e Servidores.
- Analisar os recursos principais que tornam o MCP uma camada de integração flexível.
- Aprender como a informação flui dentro do ecossistema MCP.
- Obter insights práticos através de exemplos de código em .NET, Java, Python e JavaScript.
O ecossistema MCP é construído com base em um modelo cliente-servidor. Esta estrutura modular permite que aplicações de IA interajam com ferramentas, bases de dados, APIs e recursos contextuais de forma eficiente. Vamos detalhar esta arquitetura em seus componentes principais.
No núcleo, o MCP segue uma arquitetura cliente-servidor onde uma aplicação host pode conectar-se a múltiplos servidores:
flowchart LR
subgraph "Your Computer"
Host["Host with MCP (Visual Studio, VS Code, IDEs, Tools)"]
S1["MCP Server A"]
S2["MCP Server B"]
S3["MCP Server C"]
Host <-->|"MCP Protocol"| S1
Host <-->|"MCP Protocol"| S2
Host <-->|"MCP Protocol"| S3
S1 <--> D1[("Local\Data Source A")]
S2 <--> D2[("Local\Data Source B")]
end
subgraph "Internet"
S3 <-->|"Web APIs"| D3[("Remote\Services")]
end
- Hosts MCP: Programas como VSCode, Claude Desktop, IDEs ou ferramentas de IA que desejam acessar dados através do MCP
- Clientes MCP: Clientes de protocolo que mantêm conexões 1:1 com servidores
- Servidores MCP: Programas leves que expõem capacidades específicas através do Protocolo de Contexto de Modelo padronizado
- Fontes de Dados Locais: Arquivos, bases de dados e serviços do seu computador que os servidores MCP podem acessar de forma segura
- Serviços Remotos: Sistemas externos disponíveis na internet que os servidores MCP podem conectar através de APIs
O Protocolo MCP é um padrão em evolução que utiliza versionamento baseado em datas (formato YYYY-MM-DD). A versão atual do protocolo é 2025-06-18. Você pode ver as atualizações mais recentes na especificação do protocolo.
No Model Context Protocol (MCP), Hosts são aplicações de IA que servem como a interface principal através da qual os utilizadores interagem com o protocolo. Os Hosts coordenam e gerem conexões com múltiplos servidores MCP, criando clientes MCP dedicados para cada conexão de servidor. Exemplos de Hosts incluem:
- Aplicações de IA: Claude Desktop, Visual Studio Code, Claude Code
- Ambientes de Desenvolvimento: IDEs e editores de código com integração MCP
- Aplicações Personalizadas: Agentes e ferramentas de IA desenvolvidos para propósitos específicos
Hosts são aplicações que coordenam interações com modelos de IA. Eles:
- Orquestram Modelos de IA: Executam ou interagem com LLMs para gerar respostas e coordenar fluxos de trabalho de IA
- Gerem Conexões de Clientes: Criam e mantêm um cliente MCP por conexão de servidor MCP
- Controlam a Interface do Utilizador: Gerem o fluxo de conversação, interações com o utilizador e apresentação de respostas
- Aplicam Segurança: Controlam permissões, restrições de segurança e autenticação
- Gerem Consentimento do Utilizador: Administram a aprovação do utilizador para compartilhamento de dados e execução de ferramentas
Clientes são componentes essenciais que mantêm conexões dedicadas um-a-um entre Hosts e servidores MCP. Cada cliente MCP é instanciado pelo Host para conectar-se a um servidor MCP específico, garantindo canais de comunicação organizados e seguros. Múltiplos clientes permitem que Hosts conectem-se a vários servidores simultaneamente.
Clientes são componentes conectores dentro da aplicação host. Eles:
- Comunicação de Protocolo: Enviam solicitações JSON-RPC 2.0 para servidores com instruções e prompts
- Negociação de Capacidades: Negociam recursos suportados e versões de protocolo com servidores durante a inicialização
- Execução de Ferramentas: Gerem solicitações de execução de ferramentas feitas por modelos e processam respostas
- Atualizações em Tempo Real: Lidam com notificações e atualizações em tempo real dos servidores
- Processamento de Respostas: Processam e formatam respostas dos servidores para exibição aos utilizadores
Servidores são programas que fornecem contexto, ferramentas e capacidades aos clientes MCP. Eles podem ser executados localmente (na mesma máquina que o Host) ou remotamente (em plataformas externas) e são responsáveis por lidar com solicitações de clientes e fornecer respostas estruturadas. Servidores expõem funcionalidades específicas através do Protocolo de Contexto de Modelo padronizado.
Servidores são serviços que fornecem contexto e capacidades. Eles:
- Registo de Recursos: Registram e expõem primitivas disponíveis (recursos, prompts, ferramentas) para os clientes
- Processamento de Solicitações: Recebem e executam chamadas de ferramentas, solicitações de recursos e prompts dos clientes
- Provisão de Contexto: Fornecem informações contextuais e dados para melhorar as respostas dos modelos
- Gestão de Estado: Mantêm o estado da sessão e lidam com interações com estado quando necessário
- Notificações em Tempo Real: Enviam notificações sobre mudanças de capacidades e atualizações para clientes conectados
Os servidores podem ser desenvolvidos por qualquer pessoa para estender as capacidades dos modelos com funcionalidades especializadas, e suportam cenários de implantação local e remota.
Os servidores no Model Context Protocol (MCP) fornecem três primitivas principais que definem os blocos fundamentais para interações ricas entre clientes, hosts e modelos de linguagem. Estas primitivas especificam os tipos de informações contextuais e ações disponíveis através do protocolo.
Os servidores MCP podem expor qualquer combinação das três primitivas principais:
Recursos são fontes de dados que fornecem informações contextuais para aplicações de IA. Eles representam conteúdo estático ou dinâmico que pode melhorar a compreensão e tomada de decisão dos modelos:
- Dados Contextuais: Informações estruturadas e contexto para consumo por modelos de IA
- Bases de Conhecimento: Repositórios de documentos, artigos, manuais e trabalhos de pesquisa
- Fontes de Dados Locais: Arquivos, bases de dados e informações do sistema local
- Dados Externos: Respostas de APIs, serviços web e dados de sistemas remotos
- Conteúdo Dinâmico: Dados em tempo real que se atualizam com base em condições externas
Os recursos são identificados por URIs e suportam descoberta através dos métodos resources/list e recuperação através de resources/read:
file://documents/project-spec.md
database://production/users/schema
api://weather/current
Prompts são modelos reutilizáveis que ajudam a estruturar interações com modelos de linguagem. Eles fornecem padrões de interação padronizados e fluxos de trabalho modelados:
- Interações Baseadas em Modelos: Mensagens pré-estruturadas e iniciadores de conversação
- Modelos de Fluxo de Trabalho: Sequências padronizadas para tarefas e interações comuns
- Exemplos Few-shot: Modelos baseados em exemplos para instrução de modelos
- Prompts de Sistema: Prompts fundamentais que definem o comportamento e contexto do modelo
- Modelos Dinâmicos: Prompts parametrizados que se adaptam a contextos específicos
Os prompts suportam substituição de variáveis e podem ser descobertos via prompts/list e recuperados com prompts/get:
Generate a {{task_type}} for {{product}} targeting {{audience}} with the following requirements: {{requirements}}Ferramentas são funções executáveis que modelos de IA podem invocar para realizar ações específicas. Elas representam os "verbos" do ecossistema MCP, permitindo que modelos interajam com sistemas externos:
- Funções Executáveis: Operações discretas que modelos podem invocar com parâmetros específicos
- Integração com Sistemas Externos: Chamadas de API, consultas a bases de dados, operações em arquivos, cálculos
- Identidade Única: Cada ferramenta possui um nome distinto, descrição e esquema de parâmetros
- Entrada/Saída Estruturada: Ferramentas aceitam parâmetros validados e retornam respostas estruturadas e tipadas
- Capacidades de Ação: Permitem que modelos realizem ações no mundo real e obtenham dados em tempo real
As ferramentas são definidas com JSON Schema para validação de parâmetros e descobertas através de tools/list e executadas via tools/call:
server.tool(
"search_products",
{
query: z.string().describe("Search query for products"),
category: z.string().optional().describe("Product category filter"),
max_results: z.number().default(10).describe("Maximum results to return")
},
async (params) => {
// Execute search and return structured results
return await productService.search(params);
}
);No Model Context Protocol (MCP), clientes podem expor primitivas que permitem que servidores solicitem capacidades adicionais da aplicação host. Estas primitivas do lado do cliente possibilitam implementações de servidores mais ricas e interativas, que podem acessar capacidades de modelos de IA e interações com utilizadores.
Amostragem permite que servidores solicitem completions de modelos de linguagem da aplicação de IA do cliente. Esta primitiva possibilita que servidores acessem capacidades de LLM sem depender de suas próprias dependências de modelo:
- Acesso Independente de Modelo: Servidores podem solicitar completions sem incluir SDKs de LLM ou gerir acesso a modelos
- IA Iniciada pelo Servidor: Permite que servidores gerem conteúdo autonomamente usando o modelo de IA do cliente
- Interações Recursivas com LLM: Suporta cenários complexos onde servidores precisam de assistência de IA para processamento
- Geração Dinâmica de Conteúdo: Permite que servidores criem respostas contextuais usando o modelo do host
A amostragem é iniciada através do método sampling/complete, onde servidores enviam solicitações de completions para clientes.
Elicitação permite que servidores solicitem informações adicionais ou confirmação de utilizadores através da interface do cliente:
- Solicitações de Entrada do Utilizador: Servidores podem pedir informações adicionais quando necessário para execução de ferramentas
- Diálogos de Confirmação: Solicitar aprovação do utilizador para operações sensíveis ou impactantes
- Fluxos de Trabalho Interativos: Permitir que servidores criem interações passo-a-passo com utilizadores
- Coleta Dinâmica de Parâmetros: Recolher parâmetros ausentes ou opcionais durante a execução de ferramentas
Solicitações de elicitação são feitas usando o método elicitation/request para coletar entrada do utilizador através da interface do cliente.
Registo permite que servidores enviem mensagens de log estruturadas para clientes, para depuração, monitorização e visibilidade operacional:
- Suporte à Depuração: Permitir que servidores forneçam logs detalhados de execução para resolução de problemas
- Monitorização Operacional: Enviar atualizações de status e métricas de desempenho para clientes
- Relatórios de Erros: Fornecer contexto detalhado de erros e informações de diagnóstico
- Trilhas de Auditoria: Criar registos abrangentes de operações e decisões dos servidores
Mensagens de registo são enviadas aos clientes para fornecer transparência nas operações dos servidores e facilitar a depuração.
O Model Context Protocol (MCP) define um fluxo estruturado de informações entre hosts, clientes, servidores e modelos. Compreender este fluxo ajuda a esclarecer como solicitações de utilizadores são processadas e como ferramentas e dados externos são integrados nas respostas dos modelos.
-
Host Inicia Conexão
A aplicação host (como um IDE ou interface de chat) estabelece uma conexão com um servidor MCP, tipicamente via STDIO, WebSocket ou outro transporte suportado. -
Negociação de Capacidades
O cliente (embutido no host) e o servidor trocam informações sobre os recursos suportados, ferramentas, recursos e versões de protocolo. Isso garante que ambos os lados compreendam as capacidades disponíveis para a sessão. -
Solicitação do Utilizador
O utilizador interage com o host (por exemplo, insere um prompt ou comando). O host coleta esta entrada e a passa para o cliente para processamento. -
Uso de Recursos ou Ferramentas
- O cliente pode solicitar contexto adicional ou recursos do servidor (como arquivos, entradas de bases de dados ou artigos de bases 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 cliente envia uma solicitação de invocação de ferramenta ao servidor, especificando o nome da ferramenta e os parâmetros.
-
Execução pelo Servidor
O servidor recebe a solicitação de recurso ou ferramenta, executa as operações necessárias (como executar uma função, consultar uma base de dados ou recuperar um arquivo) e retorna os resultados ao cliente em um formato estruturado. -
Geração de Resposta
O cliente integra as respostas do servidor (dados de recursos, saídas de ferramentas, etc.) na interação contínua do modelo. O modelo usa estas informações para gerar uma resposta abrangente e contextualmente relevante. -
Apresentação do Resultado
O host recebe a saída final do cliente e a apresenta ao utilizador, frequentemente incluindo tanto o texto gerado pelo modelo quanto quaisquer resultados de execuções de ferramentas ou consultas de recursos.
Este fluxo permite que o MCP suporte aplicações de IA avançadas, interativas e conscientes do contexto, conectando modelos de forma transparente a ferramentas e fontes de dados externas.
O MCP consiste em duas camadas arquiteturais distintas que trabalham juntas para fornecer uma estrutura completa de comunicação:
A Camada de Dados implementa o protocolo MCP central usando JSON-RPC 2.0 como base. Esta camada define a estrutura de mensagens, semântica e padrões de interação:
- Protocolo JSON-RPC 2.0: Toda a comunicação utiliza o formato de mensagem padronizado JSON-RPC 2.0 para chamadas de método, respostas e notificações.
- Gestão do Ciclo de Vida: Gere a inicialização da conexão, negociação de capacidades e terminação da sessão entre clientes e servidores.
- Primitivas do Servidor: Permite que os servidores forneçam funcionalidades principais através de ferramentas, recursos e prompts.
- Primitivas do Cliente: Permite que os servidores solicitem amostragens de LLMs, obtenham input do utilizador e enviem mensagens de log.
- Notificações em Tempo Real: Suporta notificações assíncronas para atualizações dinâmicas sem necessidade de polling.
- Negociação da Versão do Protocolo: Utiliza versionamento baseado em datas (AAAA-MM-DD) para garantir compatibilidade.
- Descoberta de Capacidades: Clientes e servidores trocam informações sobre funcionalidades suportadas durante a inicialização.
- Sessões com Estado: Mantém o estado da conexão em múltiplas interações para continuidade de contexto.
A Camada de Transporte gere os canais de comunicação, enquadramento de mensagens e autenticação entre os participantes do MCP:
-
Transporte STDIO:
- Utiliza fluxos de entrada/saída padrão para comunicação direta entre processos.
- Ideal para processos locais na mesma máquina, sem sobrecarga de rede.
- Comumente usado para implementações locais de servidores MCP.
-
Transporte HTTP com Streaming:
- Utiliza HTTP POST para mensagens de cliente para servidor.
- Eventos Enviados pelo Servidor (SSE) opcionais para streaming de servidor para cliente.
- Permite comunicação com servidores remotos através de redes.
- Suporta autenticação HTTP padrão (tokens bearer, chaves API, cabeçalhos personalizados).
- O MCP recomenda OAuth para autenticação segura baseada em tokens.
A camada de transporte abstrai os detalhes de comunicação da camada de dados, permitindo o mesmo formato de mensagem JSON-RPC 2.0 em todos os mecanismos de transporte. Esta abstração permite que as aplicações alternem entre servidores locais e remotos de forma transparente.
As implementações do MCP devem aderir a vários princípios de segurança críticos para garantir interações seguras, confiáveis e protegidas em todas as operações do protocolo:
-
Consentimento e Controlo do Utilizador: Os utilizadores devem fornecer consentimento explícito antes de qualquer dado ser acedido ou operações serem realizadas. Devem ter controlo claro sobre quais dados são partilhados e quais ações são autorizadas, suportado por interfaces intuitivas para revisão e aprovação de atividades.
-
Privacidade dos Dados: Os dados do utilizador só devem ser expostos com consentimento explícito e devem ser protegidos por controlos de acesso apropriados. As implementações do MCP devem proteger contra transmissões não autorizadas de dados e garantir que a privacidade seja mantida em todas as interações.
-
Segurança das Ferramentas: Antes de invocar qualquer ferramenta, é necessário obter consentimento explícito do utilizador. Os utilizadores devem compreender claramente a funcionalidade de cada ferramenta, e limites de segurança robustos devem ser aplicados para evitar execuções não intencionais ou inseguras.
Ao seguir estes princípios de segurança, o MCP garante que a confiança, privacidade e segurança dos utilizadores sejam mantidas em todas as interações do protocolo, enquanto permite integrações poderosas com IA.
Abaixo estão exemplos de código em várias linguagens de programação populares que ilustram como implementar componentes principais de servidores MCP e ferramentas.
Aqui está um exemplo prático em .NET que demonstra como implementar um servidor MCP simples com ferramentas personalizadas. Este exemplo mostra como definir e registar ferramentas, lidar com pedidos e conectar o servidor utilizando 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 registo de ferramentas do exemplo em .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 registar duas ferramentas relacionadas com meteorologia.
// 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 cliente MCP que se conecta a um servidor, envia um prompt e processa a resposta, incluindo quaisquer chamadas de ferramentas realizadas.
O MCP inclui vários conceitos e mecanismos integrados para gerir segurança e autorização em todo o protocolo:
-
Controlo de Permissões de Ferramentas:
Os clientes podem especificar quais ferramentas um modelo está autorizado a usar durante uma sessão. Isto garante que apenas ferramentas explicitamente autorizadas estejam acessíveis, reduzindo o risco de operações não intencionais ou inseguras. As permissões podem ser configuradas dinamicamente com base nas preferências do utilizador, políticas organizacionais ou no contexto da interação. -
Autenticação:
Os servidores podem exigir autenticação antes de conceder acesso a ferramentas, recursos ou operações sensíveis. Isto pode envolver chaves API, tokens OAuth ou outros esquemas de autenticação. A autenticação adequada garante que apenas clientes e utilizadores confiáveis possam invocar capacidades do lado do servidor. -
Validação:
A validação de parâmetros é aplicada a todas as invocações de ferramentas. Cada ferramenta define os tipos, formatos e restrições esperados para os seus parâmetros, e o servidor valida os pedidos recebidos de acordo. Isto previne entradas malformadas ou maliciosas de alcançarem as implementações das ferramentas e ajuda a manter a integridade das operações. -
Limitação de Taxa:
Para prevenir abusos e garantir o uso justo dos recursos do servidor, os servidores MCP podem implementar limitação de taxa para chamadas de ferramentas e acesso a recursos. Os limites de taxa podem ser aplicados por utilizador, por sessão ou globalmente, ajudando a proteger contra ataques de negação de serviço ou consumo excessivo de recursos.
Combinando estes mecanismos, o MCP fornece uma base segura para integrar modelos de linguagem com ferramentas e fontes de dados externas, enquanto oferece aos utilizadores e desenvolvedores controlo detalhado sobre acesso e utilização.
A comunicação do MCP utiliza mensagens estruturadas JSON-RPC 2.0 para facilitar interações claras e confiáveis entre hosts, clientes e servidores. O protocolo define padrões específicos de mensagens para diferentes tipos de operações:
- Pedido
initialize: Estabelece a conexão e negocia a versão do protocolo e capacidades. - Resposta
initialize: Confirma as funcionalidades suportadas e informações do servidor. notifications/initialized: Sinaliza que a inicialização está completa e a sessão está pronta.
- Pedido
tools/list: Descobre ferramentas disponíveis no servidor. - Pedido
resources/list: Lista os recursos disponíveis (fontes de dados). - Pedido
prompts/list: Recupera templates de prompts disponíveis.
- Pedido
tools/call: Executa uma ferramenta específica com os parâmetros fornecidos. - Pedido
resources/read: Recupera conteúdo de um recurso específico. - Pedido
prompts/get: Obtém um template de prompt com parâmetros opcionais.
- Pedido
sampling/complete: O servidor solicita uma conclusão de LLM ao cliente. elicitation/request: O servidor solicita input do utilizador através da interface do cliente.- Mensagens de Log: O servidor envia mensagens de log estruturadas ao cliente.
notifications/tools/list_changed: O servidor notifica o cliente sobre alterações nas ferramentas.notifications/resources/list_changed: O servidor notifica o cliente sobre alterações nos recursos.notifications/prompts/list_changed: O servidor notifica o cliente sobre alterações nos prompts.
Todas as mensagens MCP seguem o formato JSON-RPC 2.0 com:
- Mensagens de Pedido: Incluem
id,methodeparamsopcionais. - Mensagens de Resposta: Incluem
ideresultouerror. - Mensagens de Notificação: Incluem
methodeparamsopcionais (semidou resposta esperada).
Esta comunicação estruturada garante interações confiáveis, rastreáveis e extensíveis, suportando cenários avançados como atualizações em tempo real, encadeamento de ferramentas e tratamento robusto de erros.
- Arquitetura: O MCP utiliza uma arquitetura cliente-servidor onde hosts gerem múltiplas conexões de clientes para servidores.
- Participantes: O ecossistema inclui hosts (aplicações de IA), clientes (conectores do protocolo) e servidores (fornecedores de capacidades).
- Mecanismos de Transporte: A comunicação suporta STDIO (local) e HTTP com Streaming opcional SSE (remoto).
- Primitivas Centrais: Os servidores expõem ferramentas (funções executáveis), recursos (fontes de dados) e prompts (templates).
- Primitivas do Cliente: Os servidores podem solicitar amostragens (conclusões de LLM), elicitação (input do utilizador) e logging aos clientes.
- Fundação do Protocolo: Baseado em JSON-RPC 2.0 com versionamento baseado em datas (atual: 2025-06-18).
- Capacidades em Tempo Real: Suporta notificações para atualizações dinâmicas e sincronização em tempo real.
- Segurança em Primeiro Lugar: Consentimento explícito do utilizador, proteção da privacidade dos dados e transporte seguro são requisitos fundamentais.
Desenhe uma ferramenta MCP simples que seria útil na sua área. Defina:
- O nome da ferramenta.
- Os parâmetros que aceitaria.
- A saída que retornaria.
- Como um modelo poderia usar esta ferramenta para resolver problemas dos utilizadores.
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, esteja ciente de que traduções automáticas podem conter erros ou imprecisões. O documento original na sua língua nativa deve ser considerado a fonte oficial. Para informações críticas, recomenda-se a tradução profissional humana. Não nos responsabilizamos por quaisquer mal-entendidos ou interpretações incorretas resultantes do uso desta tradução.