Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Konfigurēt attālo SSE serveri

Nodarbība 7 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Pāreja no lokālā uz attālo
  2. Serveris gandrīz nemainās
  3. Publiskas URL adreses iegūšana ar ngrok
  4. Python klienta pieslēgšana
  5. Vairāki serveri vienā resursdatorā
  6. Galvenās atziņas

Atjauninājums, 2026. gada 2. novembris — Le Chat tagad ir Vibe. Kopš 2026. gada 28. maija Le Chat ir pārdēvēts par Vibe (joprojām adresē chat.mistral.ai): vienots aģents darbam un kodam, saglabājot jūsu sarunas, iestatījumus un abonementus. Vecais Le Chat interfeiss joprojām ir pieejams režīmā Chat; režīmā Work aģenti tagad ir prasmes (izsaucamas ar @), atmiņas kalpo kā zināšanu bāze, bet dziļā meklēšana ir prasme Deep Research. Plāni tagad saucas Mistral Free, Pro, Team un Enterprise. Šajā nodarbībā lietots nosaukums Vibe; daži šeit aprakstītie izvēlņu nosaukumi vai atrašanās vietas var būt mainījušies. Pielikums, 3. novembris: run_async rezultāti tiek nolasīti no result.output_as_text; mistralai SDK 3.7.0 versijai nav atribūta output.

Atjauninājums, 2026. gada 2. novembris — MCP Python SDK v2. Šis kurss tagad seko mcp SDK 2. versijai (2.3.0 pēc 2026. gada 2. oktobra datiem): MCPServer aizstāj FastMCP, transporta iestatījumi pārvietoti uz run() vai streamable_http_app(), un lietotnei, kas eksponēta zem reāla resursdatora nosaukuma, ir jādeklarē šis nosaukums (transport_security). Tā ir arī versija, ko pieprasa Mistral SDK: mistralai[agents] papildinājums prasa mcp>=2.2.0,<3.0. Avoti: Kas jauns v2 · Migrācijas ceļvedis · Izvietošana un mērogošana.

Pāreja no lokālā uz attālo

Līdz šim tavs MCP serveris atradās tavā datorā, komunicējot caur STDIO. Šis režīms ir ideāls izstrādei, taču tas izolē tavu darbu: neviens cits to nevar izmantot, un Mistral Vibe nekad nevarēs palaist procesu tavā lokālajā mašīnā. Lai šķērsotu šo robežu, serveris ir jāeksponē caur HTTP.

Izmaiņas ir vieglākas, nekā vari domāt. Attāls MCP serveris publicē savus rīkus URL adresē; klients — Vibe, SDK vai IDE — pieslēdzas caur tīklu, nevis ģenerē procesu. Tava rīku kods paliek nemainīgs.

Serveris gandrīz nemainās

MCPServer atbalsta Streamable HTTP transportu dabiski. Zemāk esošais fails ir rakstīts tieši tāpat kā lokāls serveris: tie paši dekoratori, tie paši dokumentācijas virknes, tie paši tipētie paraksti.

# remote_server.py
"""Attāls MCP serveris ar HTTP transportu."""

from mcp.server.mcpserver import MCPServer

# Serveris ir tāds pats kā lokālais
app = MCPServer("Remote Demo Server")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analizē tekstu un atgriež statistiku.

    Args:
        text: Teksts, ko analizēt
        language: Valodas kods (fr, en, es). Noklusējums: fr

    Returns:
        Teksta statistika: vārdu skaits, rakstzīmju skaits, teikumu skaits
    """
    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:
    """Izvelk galvenos punktus no teksta (vienkāršota versija).

    Args:
        text: Avota teksts
        max_points: Maksimālais izvelkamo punktu skaits (1-10)

    Returns:
        Identificēto galveno punktu saraksts
    """
    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."

Vienīgās izmaiņas ir palaišanas bloks, kas pievienots faila beigās: HTTP transports, ports un to resursdatoru nosaukumu saraksts, kurus serveris pieņem.

import os
from mcp.server.transport_security import TransportSecuritySettings

if __name__ == "__main__":
    # Publiskais resursdators, piemēram, tas, ko piešķir 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

Tavs serveris tagad klausās adresē http://localhost:8000/mcp. Saraksts allowed_hosts nav tikai detaļa: pēc noklusējuma SDK v2 pieņem tikai pieprasījumus, kas adresēti localhost vai 127.0.0.1; tas ir aizsardzības mehānisms pret DNS atkārtotu saistīšanu (DNS rebinding). Aiz tuneļa vai īsta domēna nosaukuma jebkurš cits pieprasījums saņem kļūdu 421 Invalid Host header, ko klients parāda kā vispārēju transporta kļūdu; tikai servera žurnāls atklāj iemeslu.

Publiskas URL adreses iegūšana ar ngrok

Lai pārbaudītu savu serveri no Vibe bez pilnas izvietošanas, ngrok izveido tuneli starp publisku URL un tavu lokālo portu. Šis rīks saīsina izstrādes ciklu vairāk nekā jebkas cits: tu modificē rīku, restartē serveri, un attālais konektors uzreiz redz jauno versiju.

# Instalē ngrok aģentu no https://ngrok.com/download, tad autentificējies (vienreiz)
ngrok config add-authtoken YOUR_NGROK_TOKEN

# Eksponē portu 8000
ngrok http 8000

ngrok piešķir tev adresi, piemēram, https://abc123.ngrok-free.app. Restartē serveri, deklarējot šo resursdatora nosaukumu (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Tavs MCP galapunkts kļūst par šo, vienkārši pievienojot ceļu /mcp:

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

Pievieno šo URL adresi Mistral Vibe tieši tādu, kāda tā ir, kā pielāgotu konektoru. Atceries, ka tā ir pagaidu un eksponē tavu mašīnu: neatstāj tuneli atvērtu serverī, kas pieskaras reāliem datiem.

Python klienta pieslēgšana

Klienta pusē koda struktūra paliek tāda pati kā nodarbībā par RunContext. Atšķiras tikai savienojuma klase: MCPClientStreamableHTTP ar StreamableHTTPServerParams aizstāj STDIO pāri, un tu norādi URL, nevis komandu.

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

    # Savienojums ar attālo serveri
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientStreamableHTTP(
        params=StreamableHTTPServerParams(
            url=server_url,
            timeout=100,  # Noildze sekundēs
        )
    )

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

Parametrs timeout ir pelnījis īpašu uzmanību. Caur STDIO izsaukumi bija gandrīz acumirklīgi; caur tīklu rīks, kas vaicā trešās puses API vai apstrādā lielu dokumentu, var aizņemt vairākas desmit sekundes. Pārāk īsa noildze izpaužas kā periodiskas, grūti reproducējamas kļūdas, parasti visnoderīgākajos pieprasījumos.

Kad serveris sagaida specifiskas galvenes — API tokeni, maršrutēšanas atslēgu, CORS ierobežojumu — tu tās nodod parametrā 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",
        },
    )
)

Vairāki serveri vienā resursdatorā

  1. nodarbībā tika ieteikts izmantot fokusētus serverus, nevis visaptverošu katalogu. Šis ieteikums nenozīmē, ka tev jāīrē atsevišķa mašīna katram serverim: izmantojot FastAPI, vari montēt vairākus MCP serverus viena resursdatora dažādos maršrutos.
# server.py — Vairāki MCP serveri vienā resursdatorā
from contextlib import asynccontextmanager

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

# MCP serveris teksta analīzei
text_mcp = MCPServer("Text Analysis")

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

# MCP serveris aprēķiniem
math_mcp = MCPServer("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Aprēķina matemātisko izteiksmi."""
    return str(eval(expression))  # Brīdinājums: eval ražošanā!

# Katrs MCP serveris ģenerē neatkarīgu ASGI lietotni,
# kurai ir jāzina resursdatora nosaukums, zem kura tā tiek pasniegta
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)

# Apvienots dzīves cikls: katram serverim ir jāstartē savu sesiju pārvaldnieks
@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)

Tu iegūsti divus neatkarīgus galapunktus: https://mon-serveur.com/text/mcp teksta analīzes rīkiem un https://mon-serveur.com/math/mcp matemātikas rīkiem, kurus Vibe pievieno atsevišķi. Kritiskais punkts ir lifespan: katram MCP serverim ir sesiju pārvaldnieks, kas ir jāstartē eksplicīti. Ja montēsi lietotnes, nepadodot šo lifespan FastAPI, serveris atbildēs, bet katrs rīka izsaukums neizdosies ar kļūdu par neinicializētu uzdevumu. Lietotājam, kam vajadzīgi tikai aprēķini, nebūs jāpiesārņo konteksts ar teksta rīkiem. Piezīme par eval nav joks: publiskā galapunktā šī rinda izpilda jebkuru kodu, ko nosūta izsauktājs — tas ir pedagoģisks piemērs, nekad ražošanas paraugs.

Viens pēdējais reflekss: pirms URL adreses pievienošanas sarunai, izlaid to caur Inspector vēlreiz. Attāls galapunkts pievieno kļūmju avotus, ko lokālais ignorēja — slēgts tunelis, trūkstoša galvene, aizņemts ports — un labāk tos atklāt ārpus sarunas.

Galvenās atziņas

  • Attāls MCP serveris eksponē savus rīkus caur HTTP galapunktā /mcp
  • ngrok ļauj iegūt publisku URL izstrādei
  • MCPClientStreamableHTTP ar StreamableHTTPServerParams savieno klientu ar attālo serveri (MCPClientSSE tagad ir tikai vecajiem /sse galapunktiem)
  • Parametrs timeout ir svarīgs lēniem serveriem
  • Vari montēt vairākus MCP serverus vienā FastAPI resursdatorā, ja nodod to lifespan
  • Vienmēr testē ar Inspector, pirms integrē sarunā