Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

MCP a konektory: Univerzálny štandard

Lekcia 16 z 20 Vývojár
Na tejto strane
  1. MCP a konektory: Univerzálny štandard
  2. Problém, ktorý MCP rieši
  3. Architektúra MCP
  4. Používanie konektorov OpenAI
  5. Vytvorenie MCP servera v Pythone
  6. Exponovanie zdrojov MCP
  7. Pripojenie MCP servera k Responses API
  8. Vzorec: Hub s viacerými konektormi
  9. Bezpečnosť a autentifikácia
  10. Kľúčové poznatky

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_approval na kontrolu ľudského schvaľovania
  • Pripoj viacero MCP serverov v jednom volaní pre medzifunkčné pracovné postupy