MCP i konektory: uniwersalny standard
Na tej stronie
MCP i konektory: uniwersalny standard
Model Context Protocol (MCP) to otwarty standard, który umożliwia modelom interakcję z usługami zewnętrznymi poprzez ujednolicony protokół. Konektory OpenAI implementują ten standard, łącząc modele bezpośrednio z narzędziami firm trzecich w ramach API Responses.
Problem, który rozwiązuje MCP
Głównym wyzwaniem jest mnożenie integracji: połączenie N modeli z M usługami wymaga stworzenia N×M niestandardowych integracji, z których każda jest pisana i utrzymywana oddzielnie. Każda nowa usługa zmusza Cię do powtórzenia pracy dla każdej aplikacji, a każda zmiana w API grozi zerwaniem wielu integracji.
MCP zamienia ten iloczyn w sumę: usługa udostępnia swoje możliwości raz, używając protokołu, a każdy kompatybilny klient z nich korzysta. To ta sama logika, która stoi za sterownikami drukarek czy Language Server Protocol (LSP) w edytorach kodu – standaryzacja nie czyni integracji potężniejszymi; sprawia, że są one ekonomicznie zrównoważone.
# Przed MCP: ręczna integracja dla każdej usługi
tools = [
# Funkcja dla Slack
{"type": "function", "name": "slack_send_message", ...},
{"type": "function", "name": "slack_read_channel", ...},
# Funkcja dla Jira
{"type": "function", "name": "jira_create_ticket", ...},
{"type": "function", "name": "jira_list_tickets", ...},
# Funkcja dla Google Drive
{"type": "function", "name": "gdrive_list_files", ...},
# ... dziesiątki funkcji do utrzymania
]
Dzięki MCP każda usługa udostępnia swoje możliwości poprzez standardowy protokół, a model korzysta z nich bezpośrednio.
Architektura MCP
Protokół definiuje trzy koncepcje:
- Serwer MCP: usługa udostępniająca narzędzia, zasoby i prompty
- Klient MCP: system konsumujący możliwości serwera
- Transport: kanał komunikacji między klientem a serwerem
# Serwer MCP udostępnia:
# - Narzędzia: akcje, które model może wykonać
# - Zasoby: dane, które model może odczytać
# - Prompty: predefiniowane szablony promptów
Korzystanie z konektorów OpenAI
Konektory to serwery MCP, które są już hostowane i utrzymywane: deklarujesz je, uwierzytelniasz i konsumujesz. To naturalny punkt wejścia – nie musisz pisać serwera MCP, aby komunikować się z popularną usługą, do której ktoś już stworzył połączenie.
from openai import OpenAI
client = OpenAI()
# Przykład koncepcyjny: konektor do usługi zewnętrznej
response = client.responses.create(
model="gpt-5.6-terra",
input="Utwórz zgłoszenie w Jira dotyczące błędu na stronie głównej",
tools=[
{
"type": "mcp",
"server_label": "jira",
"server_url": "https://mcp.your-server.com/jira",
"require_approval": "always"
}
]
)
Parametr require_approval kontroluje walidację przez człowieka:
"always": Każda akcja wymaga zatwierdzenia"never": Automatyczne wykonanie
Tworzenie serwera MCP w Pythonie
Napisanie własnego serwera staje się opłacalne, gdy usługa wewnętrzna musi być dostępna dla wielu aplikacji. Logika jest taka sama jak w przypadku wewnętrznego API: piszesz je raz, czysto, z własnymi zasadami dostępu – a każda aplikacja korzysta z tego bez konieczności ponownego wymyślania warstwy integracyjnej.
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:
"""Wyszukaj klienta w wewnętrznym CRM.
Args:
term: Hasło wyszukiwania (nazwa, e-mail lub ID)
field: Pole, w którym należy szukać (name, email, id)
"""
# Twoja logika biznesowa
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:
"""Utwórz szansę sprzedażową w CRM.
Args:
client_id: Identyfikator klienta
title: Tytuł szansy
amount: Szacowana kwota w euro
probability: Prawdopodobieństwo zamknięcia (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"})
Udostępnianie zasobów MCP
MCP rozróżnia narzędzia, które coś robią, oraz zasoby, które dostarczają coś do odczytu. To rozróżnienie ma znaczenie, ponieważ definiuje ryzyko: zasób jest konsultowany bez skutków ubocznych, podczas gdy narzędzie może modyfikować stan świata. Kontrola zatwierdzeń naturalnie skupia się na tych drugich.
@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
"""Aktualny stan lejka sprzedażowego."""
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:
"""Pełny 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
})
Podłączanie serwera MCP do API Responses
# Konfiguracja konektora MCP w wywołaniu API
response = client.responses.create(
model="gpt-5.6-terra",
input="Jaki jest status naszego lejka sprzedażowego? "
"Utwórz szansę dla klienta CLI-789: "
"migracja do chmury, 50000 euro, 70% prawdopodobieństwa.",
tools=[
{
"type": "mcp",
"server_label": "internal-crm",
"server_url": "https://mcp.internal.example.com/crm",
"require_approval": "never"
}
]
)
Wzorzec: wielokonektorowy hub
To moment, w którym standard naprawdę błyszczy: wiele serwerów zadeklarowanych obok siebie, przy czym model komponuje działania między nimi – odczytuje zgłoszenie tutaj, szuka klienta tam, a gdzie indziej zapisuje odpowiedź. Bez wspólnego protokołu ten sam przepływ wymagałby trzech specyficznych integracji i ich ciągłego utrzymania.
response = client.responses.create(
model="gpt-5.6-terra",
input="Sprawdź otwarte zgłoszenia w Jira, wyślij podsumowanie na Slacka "
"i zaktualizuj pulpit nawigacyjny w Notion",
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"
}
]
)
Bezpieczeństwo i uwierzytelnianie
# Serwery MCP obsługują uwierzytelnianie poprzez nagłówki
# lub tokeny w adresie URL konfiguracji
# Najlepsza praktyka: zawsze używaj require_approval dla akcji zapisu
tools = [
{
"type": "mcp",
"server_label": "crm",
"server_url": "https://mcp.example.com/crm",
"require_approval": "always", # Walidacja przez człowieka
"allowed_tools": ["search_client", "client_profile"], # Ogranicz narzędzia
}
]
Kluczowe wnioski
- MCP to otwarty standard łączący modele z usługami zewnętrznymi
- Konektory OpenAI integrują MCP bezpośrednio z API Responses
- Buduj własne serwery MCP, aby udostępniać usługi wewnętrzne
- Używaj
require_approvaldo kontrolowania walidacji przez człowieka - Łącz wiele serwerów MCP w jednym wywołaniu, aby realizować przepływy międzyfunkcyjne