Ir para o conteúdo principal
Português— Escolher um idioma
Menu

MCP e Conectores: O Padrão Universal

Aula 16 de 20 Programador
Nesta página
  1. MCP e Conectores: O Padrão Universal
  2. O Problema que o MCP Resolve
  3. Arquitetura do MCP
  4. Utilização dos Conectores da OpenAI
  5. Criação de um Servidor MCP em Python
  6. Exposição de Recursos MCP
  7. Ligação de um Servidor MCP à API de Respostas
  8. Padrão: Hub Multi-Conector
  9. Segurança e Autenticação
  10. Pontos-chave

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_approval para controlar a validação humana
  • Ligue múltiplos servidores MCP numa única chamada para fluxos de trabalho transversais