Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

MCP a konektory: Univerzální standard

Lekce 16 z 20 Vývojář
Na této stránce
  1. MCP a konektory: Univerzální standard
  2. Problém, který MCP řeší
  3. Architektura MCP
  4. Používání konektorů OpenAI
  5. Vytvoření MCP serveru v Pythonu
  6. Zpřístupnění zdrojů MCP
  7. Připojení MCP serveru k Responses API
  8. Vzor: Hub s více konektory
  9. Bezpečnost a autentizace
  10. Klíčové poznatky

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_approval pro řízení lidské validace
  • Propoj více MCP serverů v jediném volání pro cross-funkční workflow