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

Конфигуриране на отдалечен SSE сървър

Урок 7 от 14 Обновен 3 ноември 2026 г. Програмист
На тази страница
  1. Преход от локален към отдалечен режим
  2. Сървърът почти не се променя
  3. Получаване на публичен URL с ngrok
  4. Свързване на Python клиент
  5. Няколко сървъра на един хост
  6. Ключови изводи

Актуализация от 2 ноември 2026 г. — Le Chat вече е Vibe. От 28 май 2026 г. Le Chat беше ребрандиран като Vibe (все още на chat.mistral.ai): единен агент за работа и кодиране, който запазва вашите разговори, настройки и абонаменти. Legacy изживяването на Le Chat остава достъпно в режим Chat; в режим Work агентите вече са умения (извикват се с @, спомените служат като база знания, а задълбоченото търсене е умението Deep Research. Плановете вече се наричат Mistral Free, Pro, Team и Enterprise. Този урок използва името Vibe; някои менюта, описани тук, може да са променили имената или местоположенията си. Добавка от 3 ноември: резултатите от run_async се четат от result.output_as_text; SDK mistralai версия 3.7.0 няма атрибут output.

Актуализация от 2 ноември 2026 г. — MCP Python SDK v2. Този курс следва версия 2 на SDK mcp (2.3.0 към 2 октомври 2026 г.): MCPServer замества FastMCP, настройките за транспорт се преместват в run() или streamable_http_app(), а приложение, изложено под реално име на хост, трябва да декларира това име на хост (transport_security). Това е също версията, изисквана от Mistral SDK: екстрата mistralai[agents] изисква mcp>=2.2.0,<3.0. Източници: Какво е ново във v2 · Ръководство за миграция · Разполагане и мащабиране.

Преход от локален към отдалечен режим

Досега вашият MCP сървър работеше на вашата машина, комуникирайки чрез STDIO. Този режим е идеален за разработка, но изолира работата ви: никой друг не може да го използва, а Vibe на Mistral никога не може да стартира процес на вашата локална машина. За да преминете тази граница, трябва да изложите сървъра чрез HTTP.

Промяната е по-лека, отколкото може да си мислите. Отдалеченият MCP сървър публикува своите инструменти на URL адрес; клиентът — Vibe, SDK или IDE — се свързва през мрежата, вместо да стартира процес. Кодът на самия инструмент остава непроменен.

Сървърът почти не се променя

MCPServer поддържа транспорт Streamable HTTP по подразбиране. Файлът по-долу е написан точно като локален сървър: същите декоратори, същите docstrings, същите типизирани подписи.

# remote_server.py
"""Remote MCP server with HTTP transport."""

from mcp.server.mcpserver import MCPServer

# The server is the same as local
app = MCPServer("Remote Demo Server")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analyze text and return statistics.

    Args:
        text: The text to analyze
        language: Language code (fr, en, es). Default: fr

    Returns:
        Text statistics: word count, character count, sentence count
    """
    words = len(text.split())
    chars = len(text)
    sentences = text.count(".") + text.count("!") + text.count("?")
    return (
        f"Language: {language}\n"
        f"Words: {words}\n"
        f"Characters: {chars}\n"
        f"Sentences: {sentences}"
    )

@app.tool()
def summarize_key_points(text: str, max_points: int = 5) -> str:
    """Extract key points from text (simplified version).

    Args:
        text: The source text
        max_points: Maximum number of points to extract (1-10)

    Returns:
        List of identified key points
    """
    sentences = [s.strip() for s in text.split(".") if len(s.strip()) > 20]
    points = sentences[:max_points]
    return "\n".join(f"- {p}" for p in points) if points else "No key points identified."

Единствената промяна е блокът за стартиране, добавен в края на файла: HTTP транспорт, порт и списък с имената на хостовете, които сървърът приема.

import os
from mcp.server.transport_security import TransportSecuritySettings

if __name__ == "__main__":
    # Public hostname, e.g., the one ngrok assigns you (without https://)
    public_host = os.environ.get("MCP_PUBLIC_HOST")
    hosts = ["localhost:*", "127.0.0.1:*"]
    if public_host:
        hosts += [public_host, f"{public_host}:*"]
    app.run(
        transport="streamable-http",
        port=8000,
        transport_security=TransportSecuritySettings(allowed_hosts=hosts),
    )
python remote_server.py

Сега вашият сървър слуша на http://localhost:8000/mcp. Списъкът allowed_hosts не е детайл: по подразбиране SDK v2 приема само заявки, адресирани до localhost или 127.0.0.1, което е защита срещу DNS rebinding. Зад тунел или реално име на домейн всяка друга заявка получава грешка 421 Invalid Host header, която клиентът показва като обща транспортна грешка; само логът на сървъра разкрива причината.

Получаване на публичен URL с ngrok

За да тествате сървъра си от Vibe без пълно разполагане, ngrok създава тунел между публичен URL и вашия локален порт. Този инструмент съкращава цикъла на разработка повече от всичко друго: модифицирате инструмент, рестартирате и отдалеченият конектор вижда новата версия незабавно.

# Install the ngrok agent from https://ngrok.com/download, then authenticate (once)
ngrok config add-authtoken YOUR_NGROK_TOKEN

# Expose port 8000
ngrok http 8000

ngrok ви присвоява адрес като https://abc123.ngrok-free.app. Рестартирайте сървъра, декларирайки това име на хост (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Вашият MCP крайна точка става тази, просто чрез добавяне на пътя /mcp:

https://abc123.ngrok-free.app/mcp

Добавете този URL както е в Mistral Vibe като персонализиран конектор. Помнете, че той е временен и излага вашата машина: не оставяйте тунел отворен на сървър, докосващ реални данни.

Свързване на Python клиент

От страна на клиента, структурата на кода остава същата като в урока за RunContext. Различава се само класът за връзка: MCPClientStreamableHTTP с StreamableHTTPServerParams замества двойката STDIO и предоставяте URL, вместо команда.

# remote_client.py
import asyncio
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
    MCPClientStreamableHTTP,
    StreamableHTTPServerParams,
)

async def main():
    client = Mistral(api_key="YOUR_API_KEY")

    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="remote-assistant",
        instructions="You use remote tools to analyze text.",
    )

    # Connect to the remote server
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientStreamableHTTP(
        params=StreamableHTTPServerParams(
            url=server_url,
            timeout=100,  # Timeout in seconds
        )
    )

    async with RunContext(
        agent_id=agent.id,
        continue_on_fn_error=True,
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Analyze this text: MCP is an open protocol.",
        )
        print(result.output_as_text)

asyncio.run(main())

Параметърът timeout заслужава внимание. При STDIO повикванията бяха почти мигновени; през мрежата инструмент, който заявява външен API или обработва голям документ, може да отнеме няколко десетки секунди. Твърде кратък таймаут се проявява като прекъсващи, трудно възпроизводими грешки, обикновено при най-полезните заявки.

Когато сървърът очаква специфични хедъри — API токен, ключ за маршрутизиране, CORS ограничение — ги предавате в headers:

mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.example.com/mcp",
        timeout=100,
        headers={
            "Authorization": "Bearer my_api_token",
            "X-Custom-Header": "value",
        },
    )
)

Няколко сървъра на един хост

Урок 3 препоръча фокусирани сървъри, вместо каталог „всичко в едно“. Тази препоръка не ви осъжда да наемате машина за всеки сървър: с FastAPI можете да монтирате няколко MCP сървъра на различни маршрути на един и същи хост.

# server.py — Multiple MCP servers on a single host
from contextlib import asynccontextmanager

from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings

# MCP server for text analysis
text_mcp = MCPServer("Text Analysis")

@text_mcp.tool()
def analyze(text: str) -> str:
    """Analyze text."""
    return f"Words: {len(text.split())}"

# MCP server for calculations
math_mcp = MCPServer("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Evaluate a mathematical expression."""
    return str(eval(expression))  # Warning: eval in production!

# Each MCP server produces a standalone ASGI app,
# which must know the hostname under which it is served
security = TransportSecuritySettings(allowed_hosts=["mon-serveur.com", "mon-serveur.com:*"])
text_app = text_mcp.streamable_http_app(transport_security=security)
math_app = math_mcp.streamable_http_app(transport_security=security)

# Combined lifespan: each server must start its session manager
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with text_mcp.session_manager.run(), math_mcp.session_manager.run():
        yield

api = FastAPI(lifespan=lifespan)
api.mount("/text", text_app)
api.mount("/math", math_app)

Получавате две независими крайни точки: https://mon-serveur.com/text/mcp за инструменти за анализ на текст и https://mon-serveur.com/math/mcp за математически инструменти, които добавяте отделно във Vibe. Критичният момент е lifespan: всеки MCP сървър има мениджър на сесии, който трябва да бъде стартиран изрично. Ако монтирате приложенията, без да предадете този lifespan на FastAPI, сървърът отговаря, но всяко повикване на инструмент се проваля с грешка за неинициализирана задача. Потребител, който се нуждае само от изчисления, няма да замърси контекста си с текстови инструменти. Коментарът за eval не е шега: на публична крайна точка този ред изпълнява всеки код, изпратен от подателя — това е педагогически пример, никога производствен шаблон.

Един последен рефлекс: преди да добавите вашия URL в чат, пропуснете го отново през Inspector. Отдалечената крайна точка добавя източници на грешки, които локалните игнорираха — затворен тунел, липсващ хедър, зает порт — и е по-добре да ги откриете извън разговора.

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

  • Отдалеченият MCP сървър излага своите инструменти чрез HTTP на крайна точка /mcp
  • ngrok ви позволява да получите публичен URL за разработка
  • MCPClientStreamableHTTP с StreamableHTTPServerParams свързва клиента с отдалечения сървър (MCPClientSSE сега е само за legacy крайни точки /sse)
  • Параметърът timeout е важен за бавни сървъри
  • Можете да монтирате няколко MCP сървъра на един и същи FastAPI хост, стига да предадете техния lifespan
  • Винаги тествайте с Inspector, преди да интегрирате в чат