Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

MCP in konektorji: univerzalni standard

Lekcija 16 od 20 Razvijalec
Na tej strani
  1. MCP in konektorji: univerzalni standard
  2. Težava, ki jo rešuje MCP
  3. Arhitektura MCP
  4. Uporaba konektorjev OpenAI
  5. Ustvarjanje strežnika MCP v Pythonu
  6. Izpostavljanje virov MCP
  7. Povezava strežnika MCP z API-jem Responses
  8. Vzorec: Središče z več konektorji
  9. Varnost in avtentikacija
  10. Ključne ugotovitve

MCP in konektorji: univerzalni standard

Protokol Model Context Protocol (MCP) je odprt standard, ki modelom omogoča interakcijo z zunanjimi storitvami prek enotnega protokola. Konektorji OpenAI ta standard implementirajo, da povežejo modele neposredno z orodji tretjih strani znotraj API-ja Responses.

Težava, ki jo rešuje MCP

Ključna težava je množenje integracij: povezava N modelov z M storitvami zahteva N×M prilagojenih integracij, od katerih je vsaka napisana in vzdrževana ločeno. Vsaka nova storitev te prisili, da delo ponoviš za vsako aplikacijo, vsaka sprememba API-ja pa tvega okvaro več integracij hkrati.

MCP to množenie spremeni v seštevek: storitev svoje zmogljivosti izpostavi enkrat s pomočjo protokola, kateri koli združljiv odjemalec pa jih porabi. To je ista logika kot pri gonilnikih za tiskalnike ali protokolu Language Server Protocol (LSP) v urejevalnikih kode – standardizacija integracij ne naredi zmogljivejših, temveč ekonomsko vzdržne.

# Pred MCP: ročna integracija za vsako storitev
tools = [
    # Funkcija za Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funkcija za Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funkcija za Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... ducat funkcij za vzdrževanje
]

Z MCP vsaka storitev svoje zmogljivosti izpostavi prek standardnega protokola, model pa jih porabi neposredno.

Arhitektura MCP

Protokol opredeljuje tri koncepte:

  • Strežnik MCP: Storitev, ki izpostavlja orodja, vire in pozive
  • Odjemalec MCP: Sistem, ki porablja zmogljivosti strežnika
  • Prenos: Komunikacijski kanal med odjemalcem in strežnikom
# Strežnik MCP izpostavlja:
# - Orodja: Dejanja, ki jih model lahko izvrši
# - Vire: Podatke, ki jih model lahko prebere
# - Pozive: Vnaprej določene predloge pozivov

Uporaba konektorjev OpenAI

Konektorji so strežniki MCP, ki so že gostovani in vzdrževani: jih deklariraš, avtenticiraš in porabiš. To je naravna vstopna točka – ni treba pisati strežnika MCP za komunikacijo s pogosto storitvijo, ki jo je nekdo že povezal.

from openai import OpenAI

client = OpenAI()

# Konceptualni primer: konektor do zunanje storitve
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Create a Jira ticket for the homepage bug",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Parameter require_approval nadzira človeško validacijo:

  • "always": Vsako dejanje zahteva odobritev
  • "never": Samodejna izvršitev

Ustvarjanje strežnika MCP v Pythonu

Pisanje lastnega strežnika postane smiselno takoj, ko mora biti notranja storitev dosegljiva za več aplikacij. Logika je enaka kot pri notranjem API-ju: napišeš ga enkrat, čisto, z lastnimi pravili dostopa – in vsaka aplikacija ima korist, ne da bi znova izumljala integracijski sloj.

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:
    """Iskanje stranke v internem CRM-u.

    Args:
        term: Iskalni niz (ime, e-pošta ali ID)
        field: Polje za iskanje (name, email, id)
    """
    # Tvoja poslovna 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:
    """Ustvarjanje prodajne priložnosti v CRM-u.

    Args:
        client_id: Identifikator stranke
        title: Naslov priložnosti
        amount: Ocenjeni znesek v evrih
        probability: Verjetnost zaključka (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"})

Izpostavljanje virov MCP

MCP razlikuje med orodji, ki nekaj naredijo, in viri, ki zagotavljajo nekaj za branje. Ta razlika je pomembna, ker opredeljuje tveganje: vir se posvetuje brez stranskih učinkov, medtem ko orodje lahko spremeni stanje sveta. Nadzor odobritev se naravno osredotoča na slednje.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Trenutno stanje prodajnega lijaka."""
    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:
    """Celoten profil stranke."""
    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
    })

Povezava strežnika MCP z API-jem Responses

# Konfiguracija konektorja MCP v klicu API-ja
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the status of our sales pipeline? "
          "Create an opportunity for client CLI-789: "
          "cloud migration, 50000 euros, 70% probability.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Vzorec: Središče z več konektorji

Tu standard resnično blesti: več strežnikov, deklariranih drug ob drugem, pri čemer model sestavlja delo med njimi – tu prebere listek, tam poišče stranko, drugje zapiše odgovor. Brez skupnega protokola bi ta isti tok zahteval tri specifične integracije in njihovo stalno vzdrževanje.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Check open Jira tickets, send a summary to Slack, "
          "and update the Notion dashboard",
    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"
        }
    ]
)

Varnost in avtentikacija

# Strežniki MCP upravljajo avtentikacijo prek glav
# ali žetonov v konfiguracijskem URL-ju

# Najboljša praksa: za dejanja zapisovanja vedno uporabi require_approval
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Človeška validacija
        "allowed_tools": ["search_client", "client_profile"],  # Omejitev orodij
    }
]

Ključne ugotovitve

  • MCP je odprt standard za povezovanje modelov z zunanjimi storitvami
  • Konektorji OpenAI integrirajo MCP neposredno v API Responses
  • Zgradi lastne strežnike MCP za izpostavljanje notranjih storitev
  • Uporabi require_approval za nadzor človeške validacije
  • Poveži več strežnikov MCP v enem klicu za medfunkcijske delovne tokove