Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Ikkonfigura Server SSE Remot

Lezzjoni 7 / 14 Aġġornat 3 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Mill-Lokali għar-Remot
  2. Is-Server Kważi Ma Jinbidilx
  3. Niksbu URL Pubbliku b’ngrok
  4. Nqabblu Klijent Python
  5. Servers Multipli fuq Host Wieħed
  6. Punti Ewlenin

Aġġornament 2 ta’ Novembru, 2026 — Le Chat issa huwa Vibe. Mill-28 ta’ Mejju, 2026, Le Chat ġie mibdul għal Vibe (għadu f’chat.mistral.ai): aġent wieħed għax-xogħol u l-kodiċi, li jżomm il-konversazzjonijiet, l-issettjar u s-sottoskrizzjonijiet tiegħek. L-esperjenza antika ta’ Le Chat għadha disponibbli fil-modalità Chat; fil-modalità Work, l-aġenti issa huma ħiliet (invokati b’@), il-memorji jservu bħala bażi tal-għarfien, u t-tfittxija fil-fond hija l-ħila Deep Research. Il-pjanijiet issa jissejħu Mistral Free, Pro, Team, u Enterprise. Din il-lezzjoni tuża l-isem Vibe; xi menijiet deskritti hawnhekk jistgħu biddlu l-ismijiet jew il-postijiet tagħhom. Addendum 3 ta’ Novembru: ir-riżultati ta’ run_async jinqraw minn result.output_as_text; l-SDK mistralai 3.7.0 m’għandux attribut output.

Aġġornament 2 ta’ Novembru, 2026 — MCP Python SDK v2. Dan il-kors issa jsegwi l-verżjoni 2 tal-SDK mcp (2.3.0 sal-2 ta’ Ottubru, 2026): MCPServer jissostitwixxi FastMCP, l-issettjar tat-trasport jiċċaqlaq lejn run() jew streamable_http_app(), u app esposta taħt isem ta’ host reali trid tiddikjara dak l-isem ta’ host (transport_security). Din hija wkoll il-verżjoni meħtieġa mill-Mistral SDK: l-extra mistralai[agents] jeħtieġ mcp>=2.2.0,<3.0. Sorsi: X’inhu ġdid f’v2 · Gwida għall-Migrazzjoni · Iddispjega u skala.

Mill-Lokali għar-Remot

S’issa, is-server MCP tiegħek kien jgħix fuq il-magna tiegħek, jikkomunika permezz ta’ STDIO. Din il-modalità hija ideali għall-iżvilupp, iżda tiżolak ix-xogħol tiegħek: ħadd ieħor ma jista’ jużah, u l-Vibe ta’ Mistral qatt ma jista’ jniedi proċess fuq il-magna lokali tiegħek. Biex taqsam din il-fruntiera, trid tesponi s-server fuq HTTP.

Il-bidla hija eħfef milli taħseb. Server MCP remot jippubblika l-għodod tiegħu f’URL; il-klijent—Vibe, SDK, jew IDE—jikkonnetta man-netwerk minflok ma jniedi proċess. Il-kodiċi tal-għodda tiegħek innifsu jibqa’ mingħajr bidla.

Is-Server Kważi Ma Jinbidilx

MCPServer jappoġġja t-trasport Streamable HTTP nativament. Il-fajl hawn taħt huwa miktub eżattament bħal server lokali: l-istess dekoraturi, l-istess docstrings, l-istess firmi ttajpjati.

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

L-unika bidla hija blokk ta’ tniedija miżjud fit-tmiem tal-fajl: trasport HTTP, port, u l-lista ta’ ismijiet ta’ hosts li l-server jaċċetta.

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

Issa s-server tiegħek jisma’ fuq http://localhost:8000/mcp. Il-lista allowed_hosts mhix dettall: b’mod predefinit, l-SDK v2 jaċċetta biss talbiet indirizzati lil localhost jew 127.0.0.1, protezzjoni kontra DNS rebinding. Wara mina jew isem ta’ dominju reali, kwalunkwe talba oħra tirċievi żball 421 Invalid Host header, li l-klijent juri bħala żball ġeneriku tat-trasport; biss il-log tas-server jiżvela r-raġuni.

Niksbu URL Pubbliku b’ngrok

Biex tittestja s-server tiegħek minn Vibe mingħajr dispjegament sħiħ, ngrok joħloq mina bejn URL pubbliku u l-port lokali tiegħek. Dan l-għodda tqassar iċ-ċiklu ta’ żvilupp aktar minn kwalunkwe ħaġa oħra: timmodifika għodda, terġa’ tibda, u l-konnettur remot jara l-verżjoni l-ġdida immedjatament.

# 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 jassenjak indirizz bħal https://abc123.ngrok-free.app. Erġa’ ibda s-server tiddikjara dan l-isem ta’ host (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). L-endpoint MCP tiegħek isir dan, sempliċiment billi żżid il-mogħdija /mcp:

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

Żid dan l-URL kif inhu lil Mistral Vibe bħala konnettur personalizzat. Ftakar li huwa temporanju u jesponi l-magna tiegħek: tħallix mina miftuħa fuq server li jmiss data reali.

Nqabblu Klijent Python

Fuq in-naħa tal-klijent, l-istruttura tal-kodiċi tibqa’ l-istess bħal fil-lezzjoni RunContext. Tiddifferixxi biss il-klassi tal-konnessjoni: MCPClientStreamableHTTP b’StreamableHTTPServerParams tissostitwixxi l-par STDIO, u tipprovdi URL minflok kmand.

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

Il-parametru timeout jistħoqqilu ftit riflessjoni. Fuq STDIO, is-sejħiet kienu kważi istantanji; fuq in-netwerk, għodda li tistaqsi API ta’ parti terza jew tipproċessa dokument kbir tista’ tieħu diversi għexieren ta’ sekondi. Timeout qosir wisq jidher bħala żbalji intermittenti, diffiċli li jiġu rriprodotti, ġeneralment fuq it-talbiet l-aktar utli.

Meta s-server jistenna headers speċifiċi—token API, ċavetta ta’ routing, restrizzjoni CORS—tgħaddihom f’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",
        },
    )
)

Servers Multipli fuq Host Wieħed

Il-Lezzjoni 3 irrakkomandat servers iffukati minflok katalogu catch-all. Din ir-rakkomandazzjoni ma tikkundannakx li tikri magna għal kull server: b’FastAPI, tista’ timmountja servers MCP multipli fuq rotot distinti tal-istess host.

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

Tikseb żewġ endpoints indipendenti, https://mon-serveur.com/text/mcp għall-għodod tal-analiżi tat-test u https://mon-serveur.com/math/mcp għall-għodod tal-matematika, li żżidhom separatament f’Vibe. Il-punt kritiku huwa l-lifespan: kull server MCP għandu maniġer tas-sessjoni li jrid jinbeda b’mod espliċitu. Jekk timmountja l-apps mingħajr ma tgħaddi dan il-lifespan lil FastAPI, is-server iwieġeb, iżda kull sejħa tal-għodda tfalli b’żball ta’ kompitu mhux inizjalizzat. Utent li għandu bżonn biss tal-kalkolu ma jtellifx il-kuntest tiegħu b’għodod tat-test. Il-kumment dwar eval mhuwiex ċajta: fuq endpoint pubbliku, din il-linja tesegwixxi kwalunkwe kodiċi mibgħut mis-sejjaħ—dan huwa eżempju pedagoġiku, qatt mudell ta’ produzzjoni.

Rifless finali qabel ma żżid l-URL tiegħek f’chat: għaddih mill-ġdid mill-Inspector. Endpoint remot iżid sorsi ta’ falliment li l-lokali jinjora—mina magħluqa, header nieqes, port okkupat—u huwa aħjar li tiskoprihom barra konversazzjoni.

Punti Ewlenin

  • Server MCP remot jesponi l-għodod tiegħu permezz ta’ HTTP fuq endpoint /mcp
  • ngrok jippermettilek tikseb URL pubbliku għall-iżvilupp
  • MCPClientStreamableHTTP b’StreamableHTTPServerParams jgħaqqad il-klijent mas-server remot (MCPClientSSE issa huwa biss għal endpoints /sse antiki)
  • Il-parametru timeout huwa importanti għas-servers bil-mod
  • Tista’ timmountja servers MCP multipli fuq l-istess host FastAPI, sakemm tgħaddi l-lifespan tagħhom
  • Dejjem ittestja bl-Inspector qabel ma tintegra f’chat