MCP a konektory: Univerzálny štandard
Na tejto strane
MCP a konektory: Univerzálny štandard
Model Context Protocol (MCP) je otvorený štandard, ktorý umožňuje modelom komunikovať s externými službami prostredníctvom jednotného protokolu. Konektory OpenAI tento štandard implementujú, aby priamo prepojili modely s nástrojmi tretích strán v rámci Responses API.
Problém, ktorý MCP rieši
Základným problémom je násobenie integrácií: prepojenie N modelov s M službami si vyžaduje N×M vlastných integrácií, pričom každá sa píše a udržiava samostatne. Každá nová služba ťa núti opakovať prácu pre každú aplikáciu a každá zmena API hrozí rozbitím viacerých integrácií.
MCP mení tento súčin na súčet: služba raz exponuje svoje možnosti pomocou protokolu a akýkoľvek kompatibilný klient ich môže využiť. Je to rovnaká logika ako pri ovládačoch tlačiarní alebo protokole Language Server Protocol (LSP) v kódových editoroch – štandardizácia nerobí integrácie výkonnejšími, robí ich ekonomicky udržateľnými.
# Pred MCP: manuálna integrácia pre každú službu
tools = [
# Funkcia pre Slack
{"type": "function", "name": "slack_send_message", ...},
{"type": "function", "name": "slack_read_channel", ...},
# Funkcia pre Jira
{"type": "function", "name": "jira_create_ticket", ...},
{"type": "function", "name": "jira_list_tickets", ...},
# Funkcia pre Google Drive
{"type": "function", "name": "gdrive_list_files", ...},
# ... desiatky funkcií na údržbu
]
Vďaka MCP každá služba exponuje svoje možnosti cez štandardný protokol a model ich spotrebúva priamo.
Architektúra MCP
Protokol definuje tri koncepty:
- MCP Server: Služba, ktorá exponuje nástroje, zdroje a výzvy (prompty)
- MCP Client: Systém, ktorý využíva možnosti servera
- Transport: Komunikačný kanál medzi klientom a serverom
# MCP server exponuje:
# - Nástroje: Akcie, ktoré môže model vykonať
# - Zdroje: Údaje, ktoré môže model čítať
# - Výzvy: Preddefinované šablóny výziev
Používanie konektorov OpenAI
Konektory sú MCP servery, ktoré sú už hostované a udržiavané: iba ich deklarujete, overíte sa a využívate. Toto je prirodzený vstupný bod – nemusíš písať MCP server, aby si komunikoval so bežnou službou, ktorú už niekto pripojil.
from openai import OpenAI
client = OpenAI()
# Konceptuálny príklad: konektor k externej službe
response = client.responses.create(
model="gpt-5.6-terra",
input="Vytvor ticket v Jire pre chybu na domovskej stránke",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.your-server.com/jira",
"require_approval": "always"
}
]
)
Parameter require_approval riadi ľudské schvaľovanie:
"always": Každá akcia vyžaduje schválenie"never": Automatické vykonanie
Vytvorenie MCP servera v Pythone
Písanie vlastného servera sa oplatí hneď, ako potrebuješ, aby bola interná služba dostupná pre viacero aplikácií. Logika je rovnaká ako pri internom API: napíšeš ju raz, čisto, s vlastnými pravidlami prístupu – a každá aplikácia z toho ťaží bez nutnosti znovu vymýšľať integračnú vrstvu.
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:
"""Vyhľadaj klienta v internom CRM.
Args:
term: Hľadaný výraz (meno, e-mail alebo ID)
field: Pole, v ktorom sa hľadá (name, email, id)
"""
# Tvoja business logika
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:
"""Vytvor obchodnú príležitosť v CRM.
Args:
client_id: Identifikátor klienta
title: Názov príležitosti
amount: Odhadovaná suma v eurách
probability: Pravdepodobnosť uzavretia (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"})
Exponovanie zdrojov MCP
MCP rozlišuje medzi nástrojmi, ktoré niečo robia, a zdrojmi, ktoré poskytujú niečo na čítanie. Toto rozlíšenie je dôležité, pretože definuje riziko: zdroj sa konzultuje bez vedľajších účinkov, zatiaľ čo nástroj môže meniť stav sveta. Kontrola schvaľovania sa prirodzene zameriava na to druhé.
@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
"""Aktuálny stav obchodného lievika."""
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:
"""Kompletný profil klienta."""
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
})
Pripojenie MCP servera k Responses API
# Konfigurácia MCP konektora v API volaní
response = client.responses.create(
model="gpt-5.6-terra",
input="Aký je stav nášho obchodného lievika? "
"Vytvor príležitosť pre klienta CLI-789: "
"migrácia do cloudu, 50000 eur, 70% pravdepodobnosť.",
tools=[
{
"type": "mcp",
"server_label": "internal-crm",
"server_url": "https://mcp.internal.example.com/crm",
"require_approval": "never"
}
]
)
Vzorec: Hub s viacerými konektormi
Tu štandard skutočne žiari: viacero serverov deklarovaných vedľa seba, pričom model komponuje naprieč nimi – číta ticket tu, hľadá klienta tam, zapisuje odpoveď inde. Bez spoločného protokolu by tento istý tok vyžadoval tri špecifické integrácie a ich neustálu údržbu.
response = client.responses.create(
model="gpt-5.6-terra",
input="Skontroluj otvorené tickety v Jire, pošli zhrnutie na Slack "
"a aktualizuj dashboard v Notione",
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"
}
]
)
Bezpečnosť a autentifikácia
# MCP servery vybavujú autentifikáciu cez hlavičky
# alebo tokeny v konfiguračnej URL
# Najlepšia prax: pre akcie zápisu vždy používaj require_approval
tools = [
{
"type": "mcp",
"server_label": "crm",
"server_url": "https://mcp.example.com/crm",
"require_approval": "always", # Ľudské overenie
"allowed_tools": ["search_client", "client_profile"], # Obmedzenie nástrojov
}
]
Kľúčové poznatky
- MCP je otvorený štandard na prepojenie modelov s externými službami
- Konektory OpenAI integrujú MCP priamo do Responses API
- Vytváraj vlastné MCP servery na exponovanie interných služieb
- Použi
require_approvalna kontrolu ľudského schvaľovania - Pripoj viacero MCP serverov v jednom volaní pre medzifunkčné pracovné postupy