Piemērs: Lokālais serveris ar aģentu
Šajā lapā
Atjaunināts 2026. gada 2. novembrī — MCP Python SDK v2. Šis kurss tagad seko
mcpSDK 2. versijai (2.3.0 versija, sākot no 2026. gada 2. oktobra):MCPServeraizstājFastMCP, transporta iestatījumi pārcelti uzrun()vaistreamable_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 prasamcp>=2.2.0,<3.0. Avoti: Kas jauns v2 · Migrācijas ceļvedis · Izvietošana un mērogošana. Pielikums 3. novembrī: nolasietrun_asyncrezultātu noresult.output_as_text(Mistral SDK 3.7.0 versijai navoutputatribūta), un straumēšanas režīmā pēdējais notikums irRunResult, ko identificē arisinstance, kā parādīts oficiālajā SDK piemērā.
Daļu apvienošana
Iepriekšējās nodarbībās būvbloki tika izklāstīti atsevišķi: serveris un tā rīki, klients un tā RunContext. Tagad tu tos apvienosi funkcionējošā projektā — lokālā MCP serverī, kas sniedz laika ziņu informāciju un ko vada Mistral aģents, spējīgs atbildēt uz jautājumiem dabiskā valodā. Izlasi kodu, bet pievērs īpašu uzmanību tam, ko katra daļa izlemj: serveris nosaka, kas ir iespējams, bet aģents nosaka, kas ir būtiski.
Serveris: weather_server.py
Šis serveris sastāv no trim rīkiem. Pirmais atgriež laika ziņas konkrētai pilsētai, otrais salīdzina divas pilsētas, bet trešais uzskaita datubāzes saturu. Pēdējais nav tikai dekorācija: tas dod modelim iespēju atklāt pieejamo darbības jomu, nevis minēt pilsētu nosaukumus.
# 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)
Divas dizaina detaļas ir pelnījušas uzmanību. Rīki normalizē ievadi, izmantojot .lower().strip(), jo modelis var uzrakstīt „Paris” vai „paris” atkarībā no lietotāja formulējuma. Un, ja pilsēta nav atrasta, get_weather neizraisa izņēmumu: tas atgriež kļūdas JSON, kas uzskaita zināmās pilsētas, tādējādi pārvēršot neveiksmi informācijā, ko modelis var izmantot.
Klients: main.py
Klients secīgi veic četras darbības: inicializē Mistral, izveido aģentu, apraksta, kā palaist serveri, un pēc tam atver RunContext, lai ķēdētu sarunas.
# 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())
Pievērs uzmanību servera ceļam: Path(__file__).parent / "weather_server.py" atrod failu relatīvi pret skriptu, nevis pašreizējo direktoriju. Tas ir vienīgais veids, kā garantēt, ka palaišana strādās neatkarīgi no tā, no kurienes tu izpildi python main.py.
Projekta palaišana
# Set API key
export MISTRAL_API_KEY="your_mistral_api_key"
# Launch client (it will launch the server automatically)
python main.py
Tu palaid tikai vienu procesu. Klients izveido Mistral aģentu, RunContext palaiž weather_server.py kā STDIO procesu, atklāj trīs rīkus — get_weather, compare_weather un list_cities — un pēc tam, jautājumu pēc jautājuma, ļauj modelim izvēlēties, kurus no tiem izsaukt, pirms integrēt rezultātus savā atbildē. Trešais jautājums piemērā ir visinteresantākais novērošanai: lai uzzinātu, kura pilsēta ir siltākā, modelim nav citas izvēles, kā izmantot list_cities, lai gan nevienā jautājuma vārdā tas nav tieši norādīts.
Atbildes veidošanās vērošana
Gaidīt pilnu atbildi ir pieņemami skriptam, taču, strādājot ar lietotāju, straumēšanas režīms nodrošina daudz labāku pieredzi.
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}")
Notikumu plūsma nav paredzēta tikai attēlošanai: tā ir arī tavs labākais atkļūdošanas rīks, jo tā reāllaikā atklāj modeļa izvēlētos rīku izsaukumus un argumentus.
Kad rīks neizdodas
Pateicoties continue_on_fn_error=True, pieprasījums ārpus darbības jomas neko nesabojā. Ja lietotājs jautā par laika ziņām Tokijā, get_weather atgriež savu kļūdas JSON, modelis to nolasa un reaģē, piedāvājot faktiski pieejamās pilsētas.
# 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..."
Galu galā projekts ietilpst četros failos, no kuriem tikai divi satur loģiku:
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=...
Galvenās atziņas
- Pilnvērtīgs MCP projekts = serveris (rīki) + klients (aģents + RunContext)
- Serveris definē rīkus, izmantojot
MCPServerun@app.tool()dekoratorus - Klients izveido aģentu, atver RunContext un sāk sarunas
- Straumēšanas režīms ļauj pakāpenisku attēlošanu
continue_on_fn_error=Trueeleganti apstrādā rīku kļūdas- Viss kods ir asinhrons — izmanto
asyncio.run()kā ieejas punktu