Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Cumraigh Freastalaí SSE Cianda

Ceacht 7 as 14 Nuashonraithe 3 Samhain 2026 Forbróir
Ar an leathanach seo
  1. Ag bogadh ó Áitiúil go Cianda
  2. Ní Athraíonn an Freastalaí Mórán
  3. URL Poiblí a Fháil le ngrok
  4. Cliant Python a Nascadh
  5. Ilfhreastalaithe ar Óstach Amháin
  6. Príomhphointí

Nuashonrú 2 Samhain 2026 — Is é Vibe anois Le Chat. Ón 28 Bealtaine 2026 i leith, rinneadh athbhrandáil ar Le Chat mar Vibe (fós ag chat.mistral.ai): gníomhaire amháin don obair agus don chód, ag coimeád do chuid comhráite, socruithe, agus síntiúisí. Tá an t-eispéireas Le Chat traidisiúnta ar fáil fós sa mhód Chat; sa mhód Work, is scileanna iad na gníomhairí anois (glaofar orthu le @), feidhmíonn cuimhní mar bhunachar eolais, agus is é an scil Taighde Doimhin an cuardach doimhin. Tugtar Mistral Free, Pro, Team, agus Enterprise ar na pleananna anois. Úsáideann an ceacht seo an t-ainm Vibe; d’fhéadfadh roinnt rochlárlanna cur síos anseo a bheith athraithe ó thaobh ainmneacha nó suímh de. Forlíonadh 3 Samhain: léitear torthaí run_async ó result.output_as_text; níl aon tréith output ag SDK mistralai 3.7.0.

Nuashonrú 2 Samhain 2026 — MCP Python SDK v2. Leanann an cúrsa seo leagan 2 den SDK mcp anois (2.3.0 ón 2 Deireadh Fómhair 2026): téann MCPServer in ionad FastMCP, bogann socruithe iompair go run() nó streamable_http_app(), agus caolfaidh aip a nochtar faoi óstainm fíor an t-óstainm sin a dhearbhú (transport_security). Is é seo an leagan a éilíonn an Mistral SDK freisin: éilíonn an breiseán mistralai[agents] go mbeadh mcp>=2.2.0,<3.0 ann. Foinse: Cad atá nua i v2 · Treoir Imirce · Deighil & scála.

Ag bogadh ó Áitiúil go Cianda

Go dtí seo, bhí do fhreastalaí MCP ina chónaí ar do mheaisín, ag cumarsáid trí STDIO. Tá an mód seo idéalach d’fhorbairt, ach déanann sé do chuid oibre a leithlisiú: ní féidir le duine ar bith eile é a úsáid, agus ní féidir le Vibe de chuid Mistral próiseas a sheoladh ar do mheaisín áitiúil riamh. Chun an teorainn seo a thrasnú, caithfidh tú an freastalaí a nochtadh thar HTTP.

Tá an t-athrú níos éadroime ná mar a shílfeá. Foilsíonn freastalaí MCP cianda a uirlisí ag URL; déanann an cliant—Vibe, SDK, nó IDE—nasc thar an líonra in ionad próiseas a ghiniúint. Fanann do chód uirlise féin gan athrú.

Ní Athraíonn an Freastalaí Mórán

Tacaíonn MCPServer go dúchasach le hiompar Streamable HTTP. Tá an comhad thíos scríofa díreach mar fhreastalaí áitiúil: na maisitheoirí céanna, na docstrings céanna, na sínithe típithe céanna.

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

Níl san athrú ach bloc seolta a cuireadh leis ag deireadh an chomhaid: iompar HTTP, port, agus an liosta d’óstainmneacha a nglacann an freastalaí leo.

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

Éisteann do fhreastalaí anois ag http://localhost:8000/mcp. Ní mionsonra é an liosta allowed_hosts: de réir réamhshocraithe, ní ghlacann SDK v2 ach le hiarratais a sheoltar chuig localhost nó 127.0.0.1, cosaint in aghaidh athcheangal DNS. Taobh thiar de thollán nó d’ainm fearainn fíor, faigheann aon iarratas eile earráid 421 Invalid Host header, a thaispeánann an cliant mar earráid iompair ghinearálta; ní nochtann ach loga an fhreastalaí an fáth.

URL Poiblí a Fháil le ngrok

Chun do fhreastalaí a thástáil ó Vibe gan imlonnú iomlán, cruthaíonn ngrok tollán idir URL poiblí agus do phort áitiúil. Giorraíonn an uirlis seo an lúb forbartha níos mó ná aon rud eile: athraíonn tú uirlis, atosaíonn tú, agus feiceann an nascóir cianda an leagan nua láithreach.

# 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

Sanntar seoladh duit le ngrok cosúil le https://abc123.ngrok-free.app. Atosaigh an freastalaí ag dearbhú an óstainm seo (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Éiríonn do chríochphointe MCP mar seo, ach an cosán /mcp a ghreamú:

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

Cuir an URL seo mar atá sé le Vibe de chuid Mistral mar nascóir saincheaptha. Cuimhnigh go bhfuil sé sealadach agus go nochtann sé do mheaisín: ná fág tollán oscailte ar fhreastalaí a bhfuil teagmháil aige le fíorshonraí.

Cliant Python a Nascadh

Ar thaobh an chliaint, fanann struchtúr an chóid mar an gcéanna leis an gceacht RunContext. Níl ann ach an rang nasctha a athraíonn: téann MCPClientStreamableHTTP le StreamableHTTPServerParams in ionad an phéara STDIO, agus soláthraíonn tú URL seachas ordú.

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

Is fiú smaoineamh ar an bparaiméadar timeout. Thar STDIO, bhí glaonna beagnach meandrach; thar an líonra, féadfaidh uirlis a dhéanann ceist ar API tríú páirtí nó a phróiseálann cáipéis mhór roinnt deichní soicind a ghlacadh. Léiríonn teorainn ama atá ró-ghearr earráidí eatramhacha atá deacair a atáirgeadh, go minic ar na hiarratais is úsáidí.

Nuair a bhíonn ceannchláin shonracha ag teastáil ón bhfreastalaí—chomhartha API, eochair ródaithe, srian CORS—cuireann tú isteach iad in 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",
        },
    )
)

Ilfhreastalaithe ar Óstach Amháin

Mhol Ceacht 3 freastalaithe dírithe seachas catalóg uileghabhálach. Ní cháineann an moladh seo thú chun meaisín a thionóntú in aghaidh gach freastalaí: le FastAPI, is féidir leat ilfhreastalaithe MCP a shuiteáil ar bhealaí ar leith den óstach céanna.

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

Faigheann tú dhá chríochphointe neamhspleácha, https://mon-serveur.com/text/mcp d’uirlisí anailíse téacs agus https://mon-serveur.com/math/mcp d’uirlisí matamaitice, a chuireann tú leis ar leithligh i Vibe. Is é an pointe ríthábhachtach ná an lifespan: tá bainisteoir seisiúin ag gach freastalaí MCP ar gá é a thosú go sainráite. Má shuiteálann tú na haipeanna gan an lifespan seo a rith chuig FastAPI, freagraíonn an freastalaí, ach teipeann ar gach glao uirlise le hearráid tasc gan tosú. Ní dhéanfaidh úsáideoir a bhfuil gá aige le ríomhaireacht amháin truailliú ar a chomhthéacs le huirlisí téacs. Ní magadh é an nóta ar eval: ar chríochphointe poiblí, déanann an líne seo aon chód a sheolann an glaodóir a fhorghníomhú—is sampla oideachais é seo, riamh patrún táirgeachta.

Frithghníomh deireanach amháin: sula gcuireann tú do URL le comhrá, rith tríd an Iniúchóir é arís. Cuireann críochphointe cianda foinseanna teipeanna nach ndearna an leagan áitiúil neamhaird orthu—tollán dúnta, ceannchlí in easnamh, port gnóthach—agus is fearr iad a fháil amach lasmuigh de chomhrá.

Príomhphointí

  • Nochtann freastalaí MCP cianda a uirlisí trí HTTP ar chríochphointe /mcp
  • Ligeann ngrok duit URL poiblí a fháil d’fhorbairt
  • Nascann MCPClientStreamableHTTP le StreamableHTTPServerParams an cliant leis an bhfreastalaí cianda (MCPClientSSE le haghaidh críochphointí /sse traidisiúnta amháin anois)
  • Tá an paraiméadar timeout tábhachtach do fhreastalaithe malla
  • Is féidir ilfhreastalaithe MCP a shuiteáil ar an óstach FastAPI céanna, ar choinníoll go dtugann tú a lifespan dóibh
  • Déan tástáil i gcónaí leis an Iniúchóir sula ndéanann tú comhtháthú i gcomhrá