Sampla Iomlán: Freastalaí Áitiúil le Gníomhaire
Ar an leathanach seo
Nuashonraithe an 2 Samhain, 2026 — MCP Python SDK v2. Leanann an cúrsa seo anois leagan 2 den SDK
mcp(2.3.0 ón 2 Deireadh Fómhair, 2026): téannMCPServerin ionadFastMCP, bogann socruithe iompair gorun()nóstreamable_http_app(), agus caithfidh 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ánmistralai[agents]go mbeadhmcp>=2.2.0,<3.0ann. Foinse: Cad atá nua i v2 · Treoir Imirce · Deighilt & scálú. Forlíonadh an 3 Samhain: léigh toradhrun_asyncóresult.output_as_text(níl aon tréithoutputag an SDKmistralai3.7.0), agus sa mhód sruthúcháin, isRunResulté an ócáid dheireanach, arna shainaithint leisinstance, mar atá i sampla oifigiúil an SDK.
Na píosaí a chur le chéile
Leag na ceachtanna roimhe seo amach na bloic thógála ar leithligh: an freastalaí agus a uirlisí, an cliant agus a RunContext. Anois, cuirfidh tú le chéile iad chun tionscadal oibre a chruthú—freastalaí MCP áitiúil a sholáthraíonn faisnéis aimsire, faoi stiúir gníomhaire Mistral atá in ann ceisteanna a fhreagairt i ngnáththeanga. Léigh an cód, ach tabhair aird dhíreach ar an méid a chinneann gach cuid: is é an freastalaí a chinneann cad is féidir a dhéanamh, is é an gníomhaire a chinneann cad atá ábhartha.
An freastalaí: weather_server.py
Tá trí uirlis sa fhreastalaí seo. Tugann an chéad cheann an aimsir do chathair, déanann an dara ceann comparáid idir dhá chathair, agus liostaíonn an tríú ceann cad atá sa bhunachar sonraí. Níl an ceann deireanach maisiúil: tugann sé bealach don mhúnla an raon atá ar fáil a aimsigh in ionad ainmneacha cathracha a thuar.
# weather_server.py
"""Local MCP server providing weather tools."""
from mcp.server.mcpserver import MCPServer
import json
app = MCPServer("Weather Service")
# Simulated database
WEATHER_DATA = {
"paris": {"temp": 18.5, "condition": "Cloudy", "humidity": 72},
"lyon": {"temp": 22.0, "condition": "Sunny", "humidity": 45},
"marseille": {"temp": 25.3, "condition": "Sunny", "humidity": 38},
"lille": {"temp": 14.2, "condition": "Rainy", "humidity": 88},
"bordeaux": {"temp": 20.1, "condition": "Partly cloudy", "humidity": 55},
}
@app.tool()
def get_weather(city: str) -> str:
"""Retrieves current weather for a French city.
Args:
city: City name in lowercase (paris, lyon, marseille, etc.)
Returns:
JSON with temperature, condition, and humidity.
Returns an error if the city is unknown.
"""
city_lower = city.lower().strip()
if city_lower in WEATHER_DATA:
data = WEATHER_DATA[city_lower]
return json.dumps({
"city": city.capitalize(),
"temperature_celsius": data["temp"],
"condition": data["condition"],
"humidity_percent": data["humidity"],
}, ensure_ascii=False)
return json.dumps({"error": f"City {city} not found. Available cities: {', '.join(WEATHER_DATA.keys())}"})
@app.tool()
def compare_weather(city_a: str, city_b: str) -> str:
"""Compares weather between two French cities.
Args:
city_a: First city (lowercase)
city_b: Second city (lowercase)
Returns:
Comparison of temperatures and conditions for both cities
"""
a = WEATHER_DATA.get(city_a.lower().strip())
b = WEATHER_DATA.get(city_b.lower().strip())
if not a:
return f"Unknown city: {city_a}"
if not b:
return f"Unknown city: {city_b}"
diff = a["temp"] - b["temp"]
warmer = city_a if diff > 0 else city_b
return json.dumps({
"city_a": {"name": city_a.capitalize(), **a},
"city_b": {"name": city_b.capitalize(), **b},
"temperature_difference": abs(diff),
"warmer_city": warmer.capitalize(),
}, ensure_ascii=False)
@app.tool()
def list_cities() -> str:
"""Lists all cities available in the weather database.
Returns:
List of cities with their current temperature
"""
cities = [
{"city": k.capitalize(), "temp": v["temp"], "condition": v["condition"]}
for k, v in WEATHER_DATA.items()
]
return json.dumps(cities, ensure_ascii=False)
Tá dhá mhionsonra dearaidh ar fiú aird a thabhairt orthu. Déanann na huirlisí normalú ar an ionchur le .lower().strip() toisc go bhféadfadh an múnla “Paris” nó “paris” a scríobh ag brath ar chaoi a gcuireann an t-úsáideoir an cheist. Agus nuair a bhíonn cathair in easnamh, ní chruthaíonn get_weather eisceacht: seolann sé JSON earráide a liostaíonn na cathracha aitheanta, ag casadh teipe ina fhaisnéis is féidir leis an múnla a úsáid.
An cliant: main.py
Déanann an cliant ceithre rud in ord: Mistral a chur ar bun, an gníomhaire a chruthú, cur síos a dhéanamh ar conas an freastalaí a sheoladh, agus ansin an RunContext a oscailt chun comhráite a shlabhrú.
# main.py
"""MCP client with Mistral agent for weather queries."""
import asyncio
import os
from pathlib import Path
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from mcp import StdioServerParameters
from pydantic import BaseModel
# Configuration
MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY")
SERVER_PATH = Path(__file__).parent / "weather_server.py"
# Structured output format (optional)
class WeatherResponse(BaseModel):
summary: str
details: dict | None = None
async def main():
# 1. Initialize Mistral client
client = Mistral(api_key=MISTRAL_API_KEY)
# 2. Create the agent
agent = client.beta.agents.create(
model="mistral-medium-latest",
name="weather-assistant",
instructions=(
"You are a weather assistant for France. "
"Use available tools to answer questions. "
"Always respond in French with metric units."
),
)
# 3. Configure local MCP server
server_params = StdioServerParameters(
command="python",
args=[str(SERVER_PATH)],
env=None,
)
mcp_client = MCPClientSTDIO(stdio_params=server_params)
# 4. Open context and register MCP client
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)
# 5. Launch conversations
questions = [
"What's the weather like in Paris?",
"Compare the weather between Marseille and Lille.",
"Which city is the warmest right now?",
]
for question in questions:
print(f"\n{'='*60}")
print(f"Question: {question}")
print(f"{'='*60}")
result = await client.beta.conversations.run_async(
run_ctx=run_ctx,
inputs=question,
)
print(f"Response: {result.output_as_text}")
# 6. Automatic cleanup upon exiting context manager
print("\nAgent and MCP server closed cleanly.")
if __name__ == "__main__":
asyncio.run(main())
Tabhair faoi deara conas atá cosán an fhreastalaí: aimsíonn Path(__file__).parent / "weather_server.py" an comhad i gcoibhneas leis an script seachas leis an gcomhadlann reatha. Is é seo an t-aon bhealach chun a ráthú go n-oibreoidh an seoladh cibé áit a rithfidh tú python main.py uaidh.
An tionscadal a rith
# Set API key
export MISTRAL_API_KEY="your_mistral_api_key"
# Launch client (it will launch the server automatically)
python main.py
Ní sheolann tú ach próiseas amháin. Cruthaíonn an cliant an gníomhaire Mistral, seolann an RunContext weather_server.py mar phróiseas STDIO, aimsíonn sé na trí uirlis—get_weather, compare_weather, agus list_cities—agus ansin, ceist ar cheist, ligeann sé don mhúnla roghnú cé acu cinn a ghlaofar sula gcomhtháthaíonn sé na torthaí ina fhreagra. Is é an tríú ceist sa sampla an ceann is suimiúla le breathnú air: chun a fháil amach cé hiad na cathracha is teo, níl aon rogha ag an múnla ach dul trí list_cities, cé nach bhfuil aon fhocal sa cheist a thugann le fios é.
Ag breathnú ar an bhfreagra á thógáil
Oibríonn fanacht leis an bhfreagra iomlán do script; agus tú os comhair úsáideora, tairgeann mód sruthúcháin taithí i bhfad níos fearr.
from mistralai.extra.run.result import RunResult
async with RunContext(agent_id=agent.id) as run_ctx:
await run_ctx.register_mcp_client(mcp_client=mcp_client)
events = await client.beta.conversations.run_stream_async(
run_ctx=run_ctx,
inputs="What's the weather like in Lyon?",
)
async for event in events:
if isinstance(event, RunResult):
# Last event: complete run result
print(event.output_as_text)
else:
# Intermediate events (tool calls, etc.)
print(f"[Event] {event}")
Níl an sruth ócáidí ann le taispeáint amháin: is é do uirlis dífhabhtaithe is fearr freisin, ós rud é go nochtann sé glaonna uirlisí agus argóintí a roghnaíonn an múnla i bhfíor-am.
Nuair a theipeann ar uirlis
Buíochas le continue_on_fn_error=True, ní bhristear aon rud le hiarratas atá lasmuigh den raon. Má iarrann an t-úsáideoir an aimsir i dTóiceo, seolann get_weather a JSON earráide, léann an múnla é, agus freagraíonn sé ar ais trí na cathracha atá ar fáil go hiarbhír a mholadh.
# If the user requests a non-existent city:
# → get_weather returns {"error": "City tokyo not found..."}
# → The model reads the error and reformulates its response
# → "I'm sorry, Tokyo is not in my database. Here are the available cities..."
Sa deireadh, oireann an tionscadal i gceithre chomhad, agus níl loighic ach i dhá cheann acu:
weather-mcp-project/
├── weather_server.py # MCP server (3 tools)
├── main.py # Client with Mistral agent
├── requirements.txt # mcp>=2.2,<3, mistralai[agents], pydantic
└── .env # MISTRAL_API_KEY=...
Príomhphointí
- Tionscadal MCP iomlán = freastalaí (uirlisí) + cliant (gníomhaire + RunContext)
- Sainíonn an freastalaí uirlisí le maisíní
MCPServeragus@app.tool() - Cruthaíonn an cliant an gníomhaire, osclaíonn sé an RunContext, agus seolann sé comhráite
- Cumasaíonn mód sruthúcháin taispeáint chéimnitheach
- Láimhseálann
continue_on_fn_error=Trueearráidí uirlisí go deasghnáthach - Tá gach cód asincronach—úsáid
asyncio.run()mar an pointe iontrála