MCP un savienotāji: universālais standarts
Šajā lapā
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