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

Konfiguracja zdalnego serwera SSE

Lekcja 7 z 14 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Przejście od lokalnego do zdalnego
  2. Serwer prawie się nie zmienia
  3. Uzyskanie publicznego adresu URL za pomocą ngrok
  4. Łączenie klienta Python
  5. Wiele serwerów na jednym hoście
  6. Kluczowe wnioski

Aktualizacja z 2 listopada 2026 r. — Le Chat to teraz Vibe. Od 28 maja 2026 r. Le Chat zmienił nazwę na Vibe (nadal pod adresem chat.mistral.ai): to pojedynczy agent do pracy i kodu, który zachowuje Twoje konwersacje, ustawienia i subskrypcje. Legacyjne doświadczenie Le Chat pozostaje dostępne w trybie Chat; w trybie Work agenci to teraz umiejętności (wywoływane za pomocą @»), pamięci służą jako baza wiedzy, a głębokie wyszukiwanie to umiejętność Deep Research. Plany noszą teraz nazwy Mistral Free, Pro, Team i Enterprise. W tej lekcji używamy nazwy Vibe; niektóre opisane tu menu mogły zmienić nazwy lub lokalizację. *Dodatek z 3 listopada: wyniki run_asyncsą odczytywane zresult.output_as_text; SDK mistralaiw wersji 3.7.0 nie posiada atrybutuoutput`.*

Aktualizacja z 2 listopada 2026 r. — MCP Python SDK v2. Ten kurs opiera się na wersji 2 SDK mcp (2.3.0 na dzień 2 października 2026 r.): MCPServer zastępuje FastMCP, ustawienia transportu przeniesiono do run() lub streamable_http_app(), a aplikacja wystawiona pod rzeczywistą nazwą hosta musi ją zadeklarować (transport_security). Jest to również wersja wymagana przez Mistral SDK: dodatek mistralai[agents] wymaga mcp>=2.2.0,<3.0. Źródła: Co nowego w v2 · Przewodnik migracyjny · Wdrażanie i skalowanie.

Przejście od lokalnego do zdalnego

Do tej pory Twój serwer MCP działał na Twojej maszynie, komunikując się przez STDIO. Ten tryb jest idealny do rozwoju, ale izoluje Twoją pracę: nikt inny nie może z niego skorzystać, a Vibe od Mistrala nigdy nie uruchomi procesu na Twojej lokalnej maszynie. Aby przekroczyć tę granicę, musisz udostępnić serwer przez HTTP.

Zmiana jest lżejsza, niż mogłoby się wydawać. Zdalny serwer MCP publikuje swoje narzędzia pod określonym adresem URL; klient — Vibe, SDK lub IDE — łączy się przez sieć zamiast uruchamiać proces. Sam kod Twoich narzędzi pozostaje bez zmian.

Serwer prawie się nie zmienia

MCPServer natywnie obsługuje transport Streamable HTTP. Poniższy plik jest napisany dokładnie tak jak serwer lokalny: te same dekoratory, te same docstringi, te same typowane sygnatury.

# remote_server.py
"""Zdalny serwer MCP z transportem HTTP."""

from mcp.server.mcpserver import MCPServer

# Serwer jest taki sam jak lokalny
app = MCPServer("Remote Demo Server")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analizuj tekst i zwróć statystyki.

    Args:
        text: Tekst do analizy
        language: Kod języka (fr, en, es). Domyślnie: fr

    Returns:
        Statystyki tekstu: liczba słów, znaków, zdań
    """
    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:
    """Wyodrębnij kluczowe punkty z tekstu (wersja uproszczona).

    Args:
        text: Tekst źródłowy
        max_points: Maksymalna liczba punktów do wyodrębnienia (1-10)

    Returns:
        Lista zidentyfikowanych kluczowych punktów
    """
    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."

Jedyną zmianą jest blok uruchamiania dodany na końcu pliku: transport HTTP, port oraz lista nazw hostów, które serwer akceptuje.

import os
from mcp.server.transport_security import TransportSecuritySettings

if __name__ == "__main__":
    # Publiczny host, np. ten przydzielony przez ngrok (bez 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

Twój serwer nasłuchuje teraz na http://localhost:8000/mcp. Lista allowed_hosts to nie szczegół: domyślnie SDK v2 akceptuje tylko żądania skierowane do localhost lub 127.0.0.1, co jest zabezpieczeniem przed rebindingiem DNS. Za tunelem lub pod rzeczywistą domeną każde inne żądanie otrzyma błąd 421 Invalid Host header, który klient wyświetli jako ogólny błąd transportu; tylko log serwera ujawni przyczynę.

Uzyskanie publicznego adresu URL za pomocą ngrok

Aby przetestować serwer z poziomu Vibe bez pełnego wdrożenia, ngrok tworzy tunel między publicznym adresem URL a Twoim lokalnym portem. Narzędzie to skraca pętlę deweloperską bardziej niż cokolwiek innego: modyfikujesz narzędzie, restartujesz serwer, a zdalny konektor natychmiast widzi nową wersję.

# Zainstaluj agenta ngrok ze strony https://ngrok.com/download, a następnie uwierzytelnij się (raz)
ngrok config add-authtoken YOUR_NGROK_TOKEN

# Udostępnij port 8000
ngrok http 8000

ngrok przydziela Ci adres typu https://abc123.ngrok-free.app. Uruchom serwer ponownie, deklarując tę nazwę hosta (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Twój endpoint MCP staje się tym, po prostu przez dopisanie ścieżki /mcp:

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

Dodaj ten adres URL jako taki do Mistral Vibe jako niestandardowy konektor. Pamiętaj, że jest tymczasowy i wystawia Twoją maszynę: nie pozostawiaj otwartego tunelu na serwerze obsługującym rzeczywiste dane.

Łączenie klienta Python

Po stronie klienta struktura kodu pozostaje taka sama jak w lekcji RunContext. Różni się tylko klasa połączenia: MCPClientStreamableHTTP z StreamableHTTPServerParams zastępuje parę STDIO, a Ty podajesz adres URL zamiast polecenia.

# 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.",
    )

    # Połączenie ze zdalnym serwerem
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientStreamableHTTP(
        params=StreamableHTTPServerParams(
            url=server_url,
            timeout=100,  # Timeout w sekundach
        )
    )

    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())

Parametr timeout zasługuje na chwilę zastanowienia. Przez STDIO wywołania były niemal natychmiastowe; przez sieć narzędzie odpytujące zewnętrzne API lub przetwarzające duży dokument może zająć kilkadziesiąt sekund. Zbyt krótki timeout objawia się przerywanymi, trudnymi do odtworzenia błędami, zazwyczaj przy najbardziej użytecznych żądaniach.

Gdy serwer oczekuje określonych nagłówków — tokenu API, klucza routingu, ograniczenia CORS — przekazujesz je w 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",
        },
    )
)

Wiele serwerów na jednym hoście

Lekcja 3 rekomendowała skupione serwery zamiast katalogu typu „wszystko w jednym“. Ta rekomendacja nie skazuje Cię na wynajmowanie maszyny dla każdego serwera: dzięki FastAPI możesz zamontować wiele serwerów MCP na różnych trasach tego samego hosta.

# server.py — Wiele serwerów MCP na jednym hoście
from contextlib import asynccontextmanager

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

# Serwer MCP do analizy tekstu
text_mcp = MCPServer("Text Analysis")

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

# Serwer MCP do obliczeń
math_mcp = MCPServer("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Oblicz wyrażenie matematyczne."""
    return str(eval(expression))  # Uwaga: eval w produkcji!

# Każdy serwer MCP generuje samodzielną aplikację ASGI,
# która musi znać nazwę hosta, pod którą jest obsługiwana
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)

# Wspólny cykl życia: każdy serwer musi uruchomić swój menedżer sesji
@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)

Otrzymujesz dwa niezależne endpointy: https://mon-serveur.com/text/mcp dla narzędzi do analizy tekstu i https://mon-serveur.com/math/mcp dla narzędzi matematycznych, które dodajesz osobno w Vibe. Kluczowym punktem jest lifespan: każdy serwer MCP posiada menedżera sesji, który musi zostać uruchomiony jawnie. Jeśli zamontujesz aplikacje bez przekazania tego lifespan do FastAPI, serwer odpowie, ale każde wywołanie narzędzia zakończy się błędem niezainicjowanego zadania. Użytkownik potrzebujący tylko obliczeń nie zaśmieci swojego kontekstu narzędziami tekstowymi. Komentarz dotyczący eval to nie żart: na publicznym endpointie ta linia wykonuje dowolny kod wysłany przez wywołującego — jest to przykład dydaktyczny, nigdy wzorzec produkcyjny.

Jeszcze jeden odruch: przed dodaniem adresu URL do czatu, przetestuj go ponownie w Inspectorze. Zdalny endpoint dodaje źródła błędów, które lokalne ignorowało — zamknięty tunel, brakujący nagłówek, zajęty port — i lepiej wykryć je poza konwersacją.

Kluczowe wnioski

  • Zdalny serwer MCP udostępnia swoje narzędzia przez HTTP na endpointzie /mcp
  • ngrok pozwala uzyskać publiczny adres URL do celów deweloperskich
  • MCPClientStreamableHTTP z StreamableHTTPServerParams łączy klienta ze zdalnym serwerem (MCPClientSSE jest teraz tylko dla legacyjnych endpointów /sse)
  • Parametr timeout jest ważny dla wolnych serwerów
  • Możesz zamontować wiele serwerów MCP na tym samym hoście FastAPI, pod warunkiem przekazania ich lifespan
  • Zawsze testuj za pomocą Inspectora przed integracją z czatem