Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

MCP ir jungtys: universalus standartas

Paskaita 16 iš 20 Kūrėjas
Šiame puslapyje
  1. MCP ir jungtys: universalus standartas
  2. Problema, kurią sprendžia MCP
  3. MCP architektūra
  4. „OpenAI Connectors“ naudojimas
  5. MCP serverio kūrimas naudojant „Python“
  6. MCP išteklių atskleidimas
  7. MCP serverio prijungimas prie „Responses API“
  8. Šablonas: kelių jungčių centras
  9. Saugumas ir autentifikavimas
  10. Svarbiausi punktai

MCP ir jungtys: universalus standartas

Modelio konteksto protokolas (MCP) yra atviras standartas, leidžiantis modeliams sąveikauti su išorinėmis paslaugomis per vieningą protokolą. „OpenAI Connectors“ įgyvendina šį standartą, kad tiesiogiai susietų modelius su trečiųjų šalių įrankiais „Responses API“ sąsajoje.

Problema, kurią sprendžia MCP

Pagrindinė problema – integracijų daugėjimas: norint sujungti N modelių su M paslaugų, reikia sukurti N×M individualių integracijų, kurių kiekviena rašoma ir prižiūrima atskirai. Kiekviena nauja paslauga verčia kartoti darbą kiekvienai programai, o bet koks API pakeitimas gali sugadinti kelias integracijas vienu metu.

MCP šią sandaugą paverčia suma: paslauga vieną kartą atskleidžia savo galimybes naudodama protokolą, o bet kuris suderinamas klientas jas naudoja. Tai ta pati logika, kuria grindžiami spausdintuvų tvarkyklės arba kalbų serverio protokolas (LSP) kodų redaktoriuose – standartizacija nedaro integracijų galingesnių; ji daro jas ekonomiškai tvarias.

# Prieš MCP: rankinė integracija kiekvienai paslaugai
tools = [
    # Funkcija „Slack“
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funkcija „Jira“
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funkcija „Google Drive“
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... dešimtys funkcijų, kurias reikia prižiūrėti
]

Naudojant MCP, kiekviena paslauga atskleidžia savo galimybes per standartinį protokolą, o modelis jas naudoja tiesiogiai.

MCP architektūra

Protokolas apibrėžia tris sąvokas:

  • MCP serveris: paslauga, kuri atskleidžia įrankius, išteklius ir promptus
  • MCP klientas: sistema, kuri naudoja serverio galimybes
  • Transportas: ryšio kanalas tarp kliento ir serverio
# MCP serveris atskleidžia:
# - Įrankius: veiksmai, kuriuos modelis gali vykdyti
# - Išteklius: duomenys, kuriuos modelis gali skaityti
# - Promptus: iš anksto apibrėžti promptų šablonai

„OpenAI Connectors“ naudojimas

Jungtys yra MCP serveriai, kurie jau yra talpinami ir prižiūrimi: tu juos deklaruoji, autentifikuojiesi ir naudoji. Tai natūralus įėjimo taškas – nereikia rašyti MCP serverio, norint bendrauti su įprasta paslauga, kurią jau kas nors sujungė.

from openai import OpenAI

client = OpenAI()

# Koncepcinis pavyzdys: jungtis su išorine paslauga
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Sukurk „Jira“ bilietą pagrindinio puslapio klaidai",
    tools=[
        {
            "type": "mcp",
            "server_label": "jira",
            "server_url": "https://mcp.your-server.com/jira",
            "require_approval": "always"
        }
    ]
)

Parametras require_approval valdo žmogaus patvirtinimą:

  • "always": kiekvienam veiksmui reikia patvirtinimo
  • "never": automatinis vykdymas

MCP serverio kūrimas naudojant „Python“

Savo serverio rašymas tampa prasmingas tada, kai vidinę paslaugą reikia padaryti prieinamą kelioms programoms. Logika tokia pati kaip ir kuriant vidinį API: parašai jį vieną kartą, švariai, su savo prieigos taisyklėmis – ir kiekviena programa gauna naudą, iš naujo neišradinėdama integracijos sluoksnio.

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:
    """Ieškoti kliento vidiniame CRM.

    Args:
        term: paieškos terminas (vardas, el. paštas arba ID)
        field: laukas, kuriame ieškoma (name, email, id)
    """
    # Tavo verslo 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:
    """Sukurti pardavimų prognozę CRM sistemoje.

    Args:
        client_id: kliento identifikatorius
        title: prognozės pavadinimas
        amount: numatoma suma eurais
        probability: uždarymo tikimybė (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"})

MCP išteklių atskleidimas

MCP atskiria įrankius, kurie ką nors atlieka, ir išteklius, kurie pateikia ką nors skaityti. Šis skirtumas svarbus, nes jis apibrėžia riziką: išteklius yra konsultuojamas be šalutinio poveikio, tuo tarpu įrankis gali pakeisti pasaulio būseną. Patvirtinimo kontrolės natūraliai sutelktos į pastarąjį.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Dabartinė pardavimų vamzdyno būklė."""
    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:
    """Pilnas kliento profilis."""
    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
    })

MCP serverio prijungimas prie „Responses API“

# MCP jungties konfigūracija API užklausoje
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Kokia mūsų pardavimų vamzdyno būklė? "
          "Sukurk prognozę klientui CLI-789: "
          "debesų migracija, 50000 eurų, 70% tikimybė.",
    tools=[
        {
            "type": "mcp",
            "server_label": "internal-crm",
            "server_url": "https://mcp.internal.example.com/crm",
            "require_approval": "never"
        }
    ]
)

Šablonas: kelių jungčių centras

Čia standartas tikrai atsiskleidžia: keli serveriai deklaruojami greta, o modelis komponuoja veiksmus tarp jų – čia skaito bilietą, ten ieško kliento, kitur rašo atsakymą. Be bendro protokolo, tas pats procesas reikalautų trijų specifinių integracijų ir jų nuolatinio palaikymo.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Patikrink atvirus „Jira“ bilietus, išsiųsk santrauką į „Slack“ "
          "ir atnaujink „Notion“ skydelį",
    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"
        }
    ]
)

Saugumas ir autentifikavimas

# MCP serveriai tvarko autentifikavimą per antraštes
# arba tokenus konfigūracijos URL

# Geriausia praktika: visada naudok require_approval rašymo veiksmams
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Žmogaus patvirtinimas
        "allowed_tools": ["search_client", "client_profile"],  # Apriboti įrankius
    }
]

Svarbiausi punktai

  • MCP yra atviras standartas modeliams jungti su išorinėmis paslaugomis
  • „OpenAI Connectors“ integruoja MCP tiesiogiai į „Responses API“
  • Kurk savo MCP serverius, kad atskleistum vidines paslaugas
  • Naudok require_approval žmogaus patvirtinimui valdyti
  • Vieno užklausos metu prijunk kelis MCP serverius tarpfunkciniams darbo eigoms