MCP și Conectorii: Standardul Universal
Pe această pagină
MCP și Conectorii: Standardul Universal
Model Context Protocol (MCP) este un standard deschis care permite modelelor să interacționeze cu servicii externe printr-un protocol unificat. Conectorii OpenAI implementează acest standard pentru a lega direct modelele de instrumente terțe în cadrul API-ului Responses.
Problema pe care o rezolvă MCP
Problema fundamentală este multiplicarea integrărilor: conectarea a N modele la M servicii necesită N×M integrări personalizate, fiecare scrisă și întreținută separat. Fiecare serviciu nou vă obligă să repetați munca pentru fiecare aplicație, iar fiecare modificare de API riscă să strice multiple integrări.
MCP transformă acest produs într-o sumă: serviciul își expune capacitățile o singură dată folosind protocolul, iar orice client compatibil le consumă. Aceasta este aceeași logică din spatele driverelor de imprimantă sau a Language Server Protocol (LSP) din editorii de cod—standardizarea nu face integrările mai puternice; le face durabile din punct de vedere economic.
# Înainte de MCP: integrare manuală pentru fiecare serviciu
tools = [
# Funcție pentru Slack
{"type": "function", "name": "slack_send_message", ...},
{"type": "function", "name": "slack_read_channel", ...},
# Funcție pentru Jira
{"type": "function", "name": "jira_create_ticket", ...},
{"type": "function", "name": "jira_list_tickets", ...},
# Funcție pentru Google Drive
{"type": "function", "name": "gdrive_list_files", ...},
# ... zeci de funcții de întreținut
]
Cu MCP, fiecare serviciu își expune capacitățile printr-un protocol standard, iar modelul le consumă direct.
Arhitectura MCP
Protocolul definește trei concepte:
- Server MCP: Un serviciu care expune instrumente, resurse și prompturi
- Client MCP: Sistemul care consumă capacitățile serverului
- Transport: Canalul de comunicare dintre client și server
# Un server MCP expune:
# - Instrumente: Acțiuni pe care modelul le poate executa
# - Resurse: Date pe care modelul le poate citi
# - Prompturi: Șabloane de prompturi predefinite
Utilizarea Conectorilor OpenAI
Conectorii sunt servere MCP care sunt deja găzduite și întreținute: le declarați, vă autentificați și le consumați. Acesta este punctul de intrare natural—nu este nevoie să scrieți un server MCP pentru a vorbi cu un serviciu comun pe care cineva l-a conectat deja.
from openai import OpenAI
client = OpenAI()
# Exemplu conceptual: conector la un serviciu extern
response = client.responses.create(
model="gpt-5.6-terra",
input="Creați un tichet Jira pentru eroarea de pe pagina principală",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.your-server.com/jira",
"require_approval": "always"
}
]
)
Parametrul require_approval controlează validarea umană:
"always": Fiecare acțiune necesită aprobare"never": Executare automată
Crearea unui Server MCP în Python
Scrierea propriului server devine rentabilă imediat ce un serviciu intern trebuie să fie accesibil mai multor aplicații. Logica este aceeași ca pentru un API intern: îl scrieți o singură dată, corect, cu propriile reguli de acces—și fiecare aplicație beneficiază fără a reinventa stratul de integrare.
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:
"""Caută un client în CRM-ul intern.
Args:
term: Termenul de căutare (nume, email sau ID)
field: Câmpul în care se caută (name, email, id)
"""
# Logica dvs. de business
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:
"""Creează o oportunitate de vânzare în CRM.
Args:
client_id: Identificatorul clientului
title: Titlul oportunității
amount: Valoarea estimată în euro
probability: Probabilitatea de închidere (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"})
Expunerea Resurselor MCP
MCP face distincția între instrumente, care fac ceva, și resurse, care oferă ceva de citit. Această distincție contează deoarece definește riscul: o resursă este consultată fără efecte secundare, în timp ce un instrument poate modifica starea lumii. Controalele de aprobare se concentrează în mod natural asupra acestora din urmă.
@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
"""Starea curentă a pipeline-ului de vânzări."""
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:
"""Profilul complet al unui client."""
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
})
Conectarea unui Server MCP la API-ul Responses
# Configurarea conectorului MCP în apelul API
response = client.responses.create(
model="gpt-5.6-terra",
input="Care este starea pipeline-ului nostru de vânzări? "
"Creați o oportunitate pentru clientul CLI-789: "
"migrare cloud, 50000 euro, 70% probabilitate.",
tools=[
{
"type": "mcp",
"server_label": "internal-crm",
"server_url": "https://mcp.internal.example.com/crm",
"require_approval": "never"
}
]
)
Model: Hub Multi-Conector
Aici strălucește cu adevărat standardul: multiple servere declarate alături, cu modelul compunând acțiuni între ele—citind un tichet aici, căutând un client acolo, scriind un răspuns în altă parte. Fără un protocol comun, acest același flux ar necesita trei integrări specifice și întreținerea lor continuă.
response = client.responses.create(
model="gpt-5.6-terra",
input="Verificați tichetele Jira deschise, trimiteți un rezumat pe Slack "
"și actualizați tabloul de bord Notion",
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"
}
]
)
Securitate și Autentificare
# Serverele MCP gestionează autentificarea prin antete
# sau token-uri în URL-ul de configurare
# Cea mai bună practică: folosiți întotdeauna require_approval pentru acțiuni de scriere
tools = [
{
"type": "mcp",
"server_label": "crm",
"server_url": "https://mcp.example.com/crm",
"require_approval": "always", # Validare umană
"allowed_tools": ["search_client", "client_profile"], # Restricționare instrumente
}
]
Puncte cheie
- MCP este un standard deschis pentru conectarea modelelor la servicii externe
- Conectorii OpenAI integrează MCP direct în API-ul Responses
- Construiți propriile servere MCP pentru a expune servicii interne
- Folosiți
require_approvalpentru a controla validarea umană - Conectați multiple servere MCP într-un singur apel pentru fluxuri de lucru transversale