Przejdź do głównej treści
Polski— Wybierz język
Menu

MCP i konektory: uniwersalny standard

Lekcja 16 z 20 Programista
Na tej stronie
  1. MCP i konektory: uniwersalny standard
  2. Problem, który rozwiązuje MCP
  3. Architektura MCP
  4. Korzystanie z konektorów OpenAI
  5. Tworzenie serwera MCP w Pythonie
  6. Udostępnianie zasobów MCP
  7. Podłączanie serwera MCP do API Responses
  8. Wzorzec: wielokonektorowy hub
  9. Bezpieczeństwo i uwierzytelnianie
  10. Kluczowe wnioski

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_approval do kontrolowania walidacji przez człowieka
  • Łącz wiele serwerów MCP w jednym wywołaniu, aby realizować przepływy międzyfunkcyjne