MCP e Conectores: O Padrão Universal
Nesta página
MCP e Conectores: O Padrão Universal
O Model Context Protocol (MCP) é um padrão aberto que permite aos modelos interagir com serviços externos através de um protocolo unificado. Os Conectores da OpenAI implementam este padrão para ligar modelos diretamente a ferramentas de terceiros dentro da API de Respostas.
O Problema que o MCP Resolve
A questão central é a multiplicação de integrações: ligar N modelos a M serviços requer N×M integrações personalizadas, cada uma escrita e mantida separadamente. Cada novo serviço obriga-o a repetir o trabalho para todas as aplicações, e cada alteração na API corre o risco de quebrar múltiplas integrações.
O MCP transforma este produto numa soma: o serviço expõe as suas capacidades uma única vez utilizando o protocolo, e qualquer cliente compatível consome-as. Esta é a mesma lógica por detrás dos controladores de impressoras ou do Language Server Protocol (LSP) nos editores de código — a padronização não torna as integrações mais poderosas; torna-as economicamente sustentáveis.
# Antes do MCP: integração manual para cada serviço
tools = [
# Função para Slack
{"type": "function", "name": "slack_send_message", ...},
{"type": "function", "name": "slack_read_channel", ...},
# Função para Jira
{"type": "function", "name": "jira_create_ticket", ...},
{"type": "function", "name": "jira_list_tickets", ...},
# Função para Google Drive
{"type": "function", "name": "gdrive_list_files", ...},
# ... dezenas de funções para manter
]
Com o MCP, cada serviço expõe as suas capacidades através de um protocolo padrão, e o modelo consome-as diretamente.
Arquitetura do MCP
O protocolo define três conceitos:
- Servidor MCP: Um serviço que expõe ferramentas, recursos e prompts
- Cliente MCP: O sistema que consome as capacidades do servidor
- Transporte: O canal de comunicação entre cliente e servidor
# Um servidor MCP expõe:
# - Ferramentas: Ações que o modelo pode executar
# - Recursos: Dados que o modelo pode ler
# - Prompts: Modelos de prompt predefinidos
Utilização dos Conectores da OpenAI
Os conectores são servidores MCP que já estão alojados e mantidos: declara-os, autentica-se e consome-os. Este é o ponto de entrada natural — não há necessidade de escrever um servidor MCP para comunicar com um serviço comum que alguém já conectou.
from openai import OpenAI
client = OpenAI()
# Exemplo conceptual: conector para um serviço externo
response = client.responses.create(
model="gpt-5.6-terra",
input="Create a Jira ticket for the homepage bug",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.your-server.com/jira",
"require_approval": "always"
}
]
)
O parâmetro require_approval controla a validação humana:
"always": Cada ação requer aprovação"never": Execução automática
Criação de um Servidor MCP em Python
Escrever o seu próprio servidor torna-se vantajoso assim que um serviço interno precisar de ser acessível por múltiplas aplicações. A lógica é a mesma de uma API interna: escreve-a uma vez, de forma limpa, com as suas próprias regras de acesso — e todas as aplicações beneficiam sem reinventar a camada de integração.
from mcp.server import Server
from mcp.types import Tool, TextContent
import json
server = Server("my-crm")
@server.tool()
async def search_client(term: str, field: str = "name") -> str:
"""Pesquisar um cliente no CRM interno.
Args:
term: O termo de pesquisa (nome, email ou ID)
field: O campo onde pesquisar (name, email, id)
"""
# A sua lógica de negócio
results = await crm_database.search(term, field=field)
return json.dumps([{
"id": r.id,
"name": r.name,
"email": r.email,
"company": r.company
} for r in results])
@server.tool()
async def create_opportunity(
client_id: str,
title: str,
amount: float,
probability: int
) -> str:
"""Criar uma oportunidade de venda no CRM.
Args:
client_id: Identificador do cliente
title: Título da oportunidade
amount: Valor estimado em euros
probability: Probabilidade de fecho (0-100)
"""
opp = await crm_database.create_opportunity(
client_id=client_id,
title=title,
amount=amount,
probability=probability
)
return json.dumps({"id": opp.id, "status": "created"})
Exposição de Recursos MCP
O MCP distingue entre ferramentas, que fazem algo, e recursos, que fornecem algo para ler. Esta distinção é importante porque define o risco: um recurso é consultado sem efeitos secundários, enquanto uma ferramenta pode modificar o estado do mundo. Os controlos de aprovação focam-se naturalmente nestes últimos.
@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
"""Estado atual do pipeline de vendas."""
pipeline = await crm_database.get_pipeline()
return json.dumps({
"total_opportunities": pipeline.count,
"total_value": pipeline.total_value,
"by_stage": {
"prospecting": pipeline.prospecting,
"qualification": pipeline.qualification,
"proposal": pipeline.proposal,
"negotiation": pipeline.negotiation,
"closing": pipeline.closing
}
})
@server.resource("crm://client/{client_id}")
async def client_profile(client_id: str) -> str:
"""Perfil completo de um cliente."""
client = await crm_database.get_client(client_id)
return json.dumps({
"name": client.name,
"email": client.email,
"purchase_history": client.purchases,
"satisfaction_score": client.nps
})
Ligação de um Servidor MCP à API de Respostas
# Configuração do conector MCP na chamada à API
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the status of our sales pipeline? "
"Create an opportunity for client CLI-789: "
"cloud migration, 50000 euros, 70% probability.",
tools=[
{
"type": "mcp",
"server_label": "internal-crm",
"server_url": "https://mcp.internal.example.com/crm",
"require_approval": "never"
}
]
)
Padrão: Hub Multi-Conector
É aqui que o padrão realmente se destaca: múltiplos servidores declarados lado a lado, com o modelo a compor entre eles — lendo um ticket aqui, pesquisando um cliente ali, escrevendo uma resposta noutro lugar. Sem um protocolo comum, este mesmo fluxo exigiria três integrações específicas e a sua manutenção contínua.
response = client.responses.create(
model="gpt-5.6-terra",
input="Check open Jira tickets, send a summary to Slack, "
"and update the Notion dashboard",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.example.com/jira",
"require_approval": "always"
},
{
"type": "mcp",
"server_label": "slack",
"server_url": "https://mcp.example.com/slack",
"require_approval": "always"
},
{
"type": "mcp",
"server_label": "notion",
"server_url": "https://mcp.example.com/notion",
"require_approval": "always"
}
]
)
Segurança e Autenticação
# Os servidores MCP gerem a autenticação via cabeçalhos
# ou tokens no URL de configuração
# Melhor prática: utilizar sempre require_approval para ações de escrita
tools = [
{
"type": "mcp",
"server_label": "crm",
"server_url": "https://mcp.example.com/crm",
"require_approval": "always", # Validação humana
"allowed_tools": ["search_client", "client_profile"], # Restringir ferramentas
}
]
Pontos-chave
- O MCP é um padrão aberto para ligar modelos a serviços externos
- Os Conectores da OpenAI integram o MCP diretamente na API de Respostas
- Construa os seus próprios servidores MCP para expor serviços internos
- Utilize
require_approvalpara controlar a validação humana - Ligue múltiplos servidores MCP numa única chamada para fluxos de trabalho transversais