Премини към основното съдържание
Български— Изберете език
Меню

MCP и конектори: универсалният стандарт

Урок 16 от 20 Програмист
На тази страница
  1. MCP и конектори: универсалният стандарт
  2. Проблемът, който MCP решава
  3. Архитектура на MCP
  4. Използване на конектори на OpenAI
  5. Създаване на MCP сървър на Python
  6. Излагане на MCP ресурси
  7. Свързване на MCP сървър към Responses API
  8. Шаблон: Хъб с множество конектори
  9. Сигурност и удостоверяване
  10. Ключови изводи

MCP и конектори: универсалният стандарт

Протоколът за контекст на модела (MCP) е отворен стандарт, който позволява на моделите да взаимодействат с външни услуги чрез единен протокол. Конекторите на OpenAI прилагат този стандарт, за да свържат моделите директно с инструменти на трети страни в рамките на API за отговори (Responses API).

Проблемът, който MCP решава

Основният проблем е умножаването на интеграциите: свързването на N модела с M услуги изисква N×M персонализирани интеграции, всяка от които се пише и поддържа отделно. Всяка нова услуга Ви принуждава да повторите работата за всяко приложение, а всяка промяна в API рискува да наруши множество интеграции.

MCP превръща това произведение в сума: услугата излага своите възможности веднъж чрез протокола, а всеки съвместим клиент ги използва. Това е същата логика зад драйверите за принтери или Протокола за езиков сървър (LSP) в редакторите на код – стандартизацията не прави интеграциите по-мощни; тя ги прави икономически устойчиви.

# Преди MCP: ръчна интеграция за всяка услуга
tools = [
    # Функция за Slack
    {"type": "function", "name": "slack_send_message", ...},
    {"type": "function", "name": "slack_read_channel", ...},
    # Функция за Jira
    {"type": "function", "name": "jira_create_ticket", ...},
    {"type": "function", "name": "jira_list_tickets", ...},
    # Функция за Google Drive
    {"type": "function", "name": "gdrive_list_files", ...},
    # ... десетки функции за поддръжка
]

С MCP всяка услуга излага своите възможности чрез стандартен протокол, а моделът ги консумира директно.

Архитектура на MCP

Протоколът дефинира три концепции:

  • MCP сървър: Услуга, която излага инструменти, ресурси и подсказки (prompts)
  • MCP клиент: Системата, която използва възможностите на сървъра
  • Транспорт: Каналът за комуникация между клиента и сървъра
# Един MCP сървър излага:
# - Инструменти: Действия, които моделът може да изпълни
# - Ресурси: Данни, които моделът може да прочете
# - Подсказки: Предварително дефинирани шаблони за подсказки

Използване на конектори на OpenAI

Конекторите са MCP сървъри, които вече са хоствани и поддържани: Вие ги декларирате, удостоверявате се и ги използвате. Това е естествената отправна точка – няма нужда да пишете MCP сървър, за да общувате с често срещана услуга, към която някой вече е осъществил връзка.

from openai import OpenAI

client = OpenAI()

# Концептуален пример: конектор към външна услуга
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"
        }
    ]
)

Параметърът require_approval контролира човешката валидация:

  • "always": Всяко действие изисква одобрение
  • "never": Автоматично изпълнение

Създаване на MCP сървър на Python

Написването на собствен сървър става полезно веднага щом вътрешна услуга трябва да бъде достъпна за множество приложения. Логиката е същата като при вътрешен API: пишете го веднъж, правилно, със собствени правила за достъп – и всяко приложение се възползва, без да преоткрива слоя за интеграция.

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:
    """Търсене на клиент във вътрешната CRM система.

    Args:
        term: Терминът за търсене (име, имейл или ID)
        field: Полето, в което да се търси (name, email, id)
    """
    # Вашата бизнес логика
    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:
    """Създаване на търговска възможност в CRM.

    Args:
        client_id: Идентификатор на клиента
        title: Заглавие на възможността
        amount: Очаквана сума в евро
        probability: Вероятност за приключване (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 ресурси

MCP прави разлика между инструменти, които извършват действие, и ресурси, които предоставят нещо за четене. Тази разлика е важна, защото определя риска: ресурсът се консултира без странични ефекти, докато инструментът може да промени състоянието на света. Контролите за одобрение естествено се фокусират върху последното.

@server.resource("crm://pipeline")
async def sales_pipeline() -> str:
    """Текущо състояние на търговския канал."""
    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:
    """Пълен профил на клиент."""
    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 сървър към Responses API

# Конфигурация на MCP конектор в API повикването
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"
        }
    ]
)

Шаблон: Хъб с множество конектори

Тук стандартът наистина блести: множество сървъри, декларирани един до друг, като моделът komponира действия между тях – чете билет тук, търси клиент там, пише отговор на друго място. Без общ протокол същият този поток би изисквал три специфични интеграции и тяхната постоянна поддръжка.

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

Сигурност и удостоверяване

# MCP сървърите обработват удостоверяването чрез хедъри
# или токени в URL адреса на конфигурацията

# Най-добра практика: винаги използвайте require_approval за действия на запис
tools = [
    {
        "type": "mcp",
        "server_label": "crm",
        "server_url": "https://mcp.example.com/crm",
        "require_approval": "always",  # Човешка валидация
        "allowed_tools": ["search_client", "client_profile"],  # Ограничаване на инструментите
    }
]

Ключови изводи

  • MCP е отворен стандарт за свързване на модели с външни услуги
  • Конекторите на OpenAI интегрират MCP директно в Responses API
  • Изградете свои собствени MCP сървъри, за да изложите вътрешни услуги
  • Използвайте require_approval, за да контролирате човешката валидация
  • Свържете множество MCP сървъри в едно повикване за междуфункционални работни потоци