Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

MCP un savienotāji: universālais standarts

Nodarbība 16 no 20 Programmētājs
Šajā lapā
  1. MCP un savienotāji: universālais standarts
  2. Problēma, ko risina MCP
  3. MCP arhitektūra
  4. OpenAI savienotāju izmantošana
  5. MCP servera izveide Python valodā
  6. MCP resursu eksponēšana
  7. MCP servera pieslēgšana Responses API
  8. Paraugs: daudzu savienotāju centrs
  9. Drošība un autentifikācija
  10. Galvenās atziņas

MCP un savienotāji: universālais standarts

Model Context Protocol (MCP) ir atvērts standarts, kas ļauj modeļiem mijiedarboties ar ārējiem servisiem, izmantojot vienotu protokolu. OpenAI savienotāji ievieš šo standartu, lai Responses API ietvaros tieši saistītu modeļus ar trešo pušu rīkiem.

Problēma, ko risina MCP

Galvenā problēma ir integrāciju vairošanās: lai savienotu N modeļus ar M servisiem, ir nepieciešamas N×M pielāgotas integrācijas, katra no tām rakstīta un uzturēta atsevišķi. Katrs jauns serviss liek tev atkārtot darbu katram lietojumam, un katra API izmaiņa rada risku sabojāt vairākas integrācijas vienlaikus.

MCP šo reizinājumu pārvērš summā: serviss, izmantojot protokolu, vienreiz eksponē savas iespējas, un jebkurš saderīgs klients tās izmanto. Tāda pati loģika ir printeru draiveriem vai Language Server Protocol (LSP) koda redaktoros – standartizācija nepadarīs integrācijas jaudīgākas, taču padarīs tās ekonomiski ilgtspējīgas.

# Pirms MCP: manuāla integrācija katram servisam
tools = [
    # Funkcija priekš Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Funkcija priekš Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Funkcija priekš Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... desmitiem funkciju, kas jāuztur
]

Izmantojot MCP, katrs serviss eksponē savas iespējas, izmantojot standarta protokolu, un modelis tās izmanto tieši.

MCP arhitektūra

Protokols definē trīs pamatjēdzienus:

  • MCP serveris: serviss, kas eksponē rīkus, resursus un uzvednes
  • MCP klients: sistēma, kas izmanto servera iespējas
  • Transports: komunikācijas kanāls starp klientu un serveri
# MCP serveris eksponē:
# - Rīkus: darbības, ko modelis var izpildīt
# - Resursus: datus, ko modelis var lasīt
# - Uzvednes: iepriekš definētus uzvedņu veidņus

OpenAI savienotāju izmantošana

Savienotāji ir MCP serveri, kas jau ir mitināti un uzturēti: tu tos deklarē, autentificējies un izmanto. Tas ir dabiskais sākumpunkts – nav jāraksta MCP serveris, lai sazinātos ar izplatītu servisu, ko kāds jau ir pieslēdzis.

from openai import OpenAI

client = OpenAI()

# Konceptuāls piemērs: savienotājs ar ārēju servisu
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"
        }
    ]
)

Parametrs require_approval kontrolē cilvēka veikto validāciju:

  • "always": katrai darbībai nepieciešama apstiprināšana
  • "never": automātiska izpilde

MCP servera izveide Python valodā

Sava servera rakstīšana kļūst lietderīga tiklīdz iekšējam servisam ir jābūt pieejamam vairākām lietojumprogrammām. Loģika ir tāda pati kā iekšējai API: tu to uzraksti vienreiz, tīri, ar saviem piekļuves noteikumiem – un katrs lietojums gūst labumu, no jauna neizgudrojot integrācijas slāni.

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:
    """Meklē klientu iekšējā CRM.

    Args:
        term: meklējamais termins (vārds, e-pasts vai ID)
        field: lauks, kurā meklēt (name, email, id)
    """
    # Tava biznesa loģika
    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:
    """Izveido pārdošanas iespēju CRM.

    Args:
        client_id: klienta identifikators
        title: iespējas nosaukums
        amount: paredzamā summa eiro
        probability: noslēgšanas varbūtība (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 resursu eksponēšana

MCP nošķir rīkus, kas kaut ko dara, un resursus, kas nodrošina kaut ko lasāmu. Šī atšķirība ir svarīga, jo tā definē risku: resursu apskata bez blakusparādībām, savukārt rīks var mainīt pasaules stāvokli. Apstiprināšanas kontroles dabiski koncentrējas uz pēdējiem.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Pašreizējais pārdošanas cauruļvada stāvoklis."""
    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:
    """Pilns klienta profils."""
    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 servera pieslēgšana Responses API

# MCP savienotāja konfigurācija API izsaukumā
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"
        }
    ]
)

Paraugs: daudzu savienotāju centrs

Šeit standarts patiešām izceļas: vairāki serveri deklarēti blakus, un modelis tos komponē – šeit nolasa biļeti, tur meklē klientu, citur raksta atbildi. Bez kopīga protokola šī pati plūsma prasītu trīs specifiskas integrācijas un to nepārtrauktu uzturēšanu.

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"
        }
    ]
)

Drošība un autentifikācija

# MCP serveri autentifikāciju apstrādā, izmantojot galvenes
# vai tokenus konfigurācijas URL

# Labākā prakse: vienmēr izmanto require_approval rakstīšanas darbībām
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Cilvēka validācija
        "allowed_tools": ["search_client", "client_profile"],  # Ierobežo rīkus
    }
]

Galvenās atziņas

  • MCP ir atvērts standarts modeļu savienošanai ar ārējiem servisiem
  • OpenAI savienotāji integrē MCP tieši Responses API
  • Izveido savus MCP serverus, lai eksponētu iekšējos servisus
  • Izmanto require_approval, lai kontrolētu cilvēka veikto validāciju
  • Vienā izsaukumā savieno vairākus MCP serverus starpfunkcionālu darbplūsmu nodrošināšanai