MCP a konektory: Univerzální standard
Na této stránce
MCP a konektory: Univerzální standard
Model Context Protocol (MCP) je otevřený standard, který umožňuje modelům komunikovat s externími službami prostřednictvím jednotného protokolu. Konektory OpenAI tento standard implementují, aby přímo propojily modely se službami třetích stran v rámci Responses API.
Problém, který MCP řeší
Základním problémem je násobení integrací: propojení N modelů s M službami vyžaduje N×M vlastních integrací, z nichž každá se píše a udržuje samostatně. Každá nová služba tě nutí opakovat práci pro každou aplikaci a každá změna API hrozí rozbitím více integrací najednou.
MCP mění tento součin na součet: služba jednou zpřístupní své možnosti pomocí protokolu a jakýkoli kompatibilní klient je může využít. Je to stejná logika jako u ovladačů tiskáren nebo Language Server Protocol (LSP) v code editorech – standardizace nedělá integrace výkonnějšími, ale činí je ekonomicky udržitelnými.
# Před MCP: ruční integrace pro každou službu
tools = [
# Funkce pro Slack
{"type": "function", "name": "slack_send_message", ...},
{"type": "function", "name": "slack_read_channel", ...},
# Funkce pro Jira
{"type": "function", "name": "jira_create_ticket", ...},
{"type": "function", "name": "jira_list_tickets", ...},
# Funkce pro Google Drive
{"type": "function", "name": "gdrive_list_files", ...},
# ... desítky funkcí k udržování
]
Díky MCP každá služba zpřístupní své možnosti prostřednictvím standardního protokolu a model je přímo využívá.
Architektura MCP
Protokol definuje tři koncepty:
- MCP Server: Služba, která zpřístupňuje nástroje, zdroje a prompty
- MCP Klient: Systém, který využívá možnosti serveru
- Transport: Komunikační kanál mezi klientem a serverem
# MCP server zpřístupňuje:
# - Nástroje: Akce, které může model执行ovat
# - Zdroje: Data, která může model číst
# - Prompty: Předdefinované šablony promptů
Používání konektorů OpenAI
Konektory jsou MCP servery, které jsou již hostovány a udržovány: pouze je deklarujete, autentizujete se a využíváte. Je to přirozený vstupní bod – nemusíš psát vlastní MCP server pro komunikaci s běžnou službou, kterou již někdo připojil.
from openai import OpenAI
client = OpenAI()
# Konceptuální příklad: konektor k externí službě
response = client.responses.create(
model="gpt-5.6-terra",
input="Vytvoř ticket v Jiře pro chybu na homepage",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.your-server.com/jira",
"require_approval": "always"
}
]
)
Parametr require_approval řídí lidskou validaci:
"always": Každá akce vyžaduje schválení"never": Automatické执行ování
Vytvoření MCP serveru v Pythonu
Psaní vlastního serveru dává smysl hned, jakmile potřebuješ, aby byla vnitřní služba dostupná pro více aplikací. Logika je stejná jako u vnitřního API: napíšeš ji jednou, čistě, s vlastními pravidly přístupu – a každá aplikace z toho těží, aniž by musela znovu vymýšlet 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:
"""Vyhledat klienta v interním CRM.
Args:
term: Vyhledávací výraz (jméno, e-mail nebo ID)
field: Pole, ve kterém hledat (name, email, id)
"""
# Tvá 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:
"""Vytvořit obchodní příležitost v CRM.
Args:
client_id: Identifikátor klienta
title: Název příležitosti
amount: Odhadovaná částka v eurech
probability: Pravděpodobnost uzavření (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"})
Zpřístupnění zdrojů MCP
MCP rozlišuje mezi nástroji, které něco dělají, a zdroji, které poskytují data ke čtení. Toto rozlišení je důležité, protože definuje riziko: zdroj se konzultuje bez vedlejších účinků, zatímco nástroj může měnit stav světa. Řízení schvalování se přirozeně zaměřuje na to druhé.
@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
"""Aktuální stav prodejního pipeline."""
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
})
Připojení MCP serveru k Responses API
# Konfigurace MCP konektoru v API volání
response = client.responses.create(
model="gpt-5.6-terra",
input="Jaký je stav našeho prodejního pipeline? "
"Vytvoř příležitost pro klienta CLI-789: "
"migrace do cloudu, 50000 eur, 70% pravděpodobnost.",
tools=[
{
"type": "mcp",
"server_label": "internal-crm",
"server_url": "https://mcp.internal.example.com/crm",
"require_approval": "never"
}
]
)
Vzor: Hub s více konektory
Zde standard skutečně vyniká: více serverů deklarovaných vedle sebe, přičemž model mezi nimi komponuje – čte ticket zde, hledá klienta tam, zapisuje odpověď jinam. Bez společného protokolu by tento stejný tok vyžadoval tři specifické integrace a jejich neustálou údržbu.
response = client.responses.create(
model="gpt-5.6-terra",
input="Zkontroluj otevřené tickety v Jiře, pošli shrnutí na Slack "
"a aktualizuj dashboard v Notionu",
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čnost a autentizace
# MCP servery řeší autentizaci přes hlavičky
# nebo tokeny v konfiguračním URL
# Nejlepší praxe: pro akce zápisu vždy používej require_approval
tools = [
{
"type": "mcp",
"server_label": "crm",
"server_url": "https://mcp.example.com/crm",
"require_approval": "always", # Lidská validace
"allowed_tools": ["search_client", "client_profile"], # Omezení nástrojů
}
]
Klíčové poznatky
- MCP je otevřený standard pro propojení modelů s externími službami
- Konektory OpenAI integrují MCP přímo do Responses API
- Vytvářej vlastní MCP servery pro zpřístupnění vnitřních služeb
- Používej
require_approvalpro řízení lidské validace - Propoj více MCP serverů v jediném volání pro cross-funkční workflow