Primer celovit: Lokalni strežnik z agentom
Na tej strani
Posodobljeno 2. novembra 2026 — MCP Python SDK v2. Ta tečaj zdaj sledi različici 2 paketa SDK
mcp(2.3.0 z dne 2. oktobra 2026):MCPServernadomeščaFastMCP, nastavitve prenosa se premaknejo vrun()alistreamable_http_app(), aplikacija, izpostavljena pod realnim gostiteljskim imenom, pa mora to ime deklarirati (transport_security). To je tudi različica, ki jo zahteva Mistral SDK: dodatekmistralai[agents]zahtevamcp>=2.2.0,<3.0. Viri: Kaj je novega v v2 · Vodnik za selitev · Uvajanje in skaliranje. Dodatek 3. novembra: rezultat klicarun_asyncpreberite izresult.output_as_text(SDKmistralai3.7.0 nima atributaoutput), v načinu pretakanja pa je zadnji dogodekRunResult, kar prepoznate zisinstance, kot kaže uradni primer SDK.
Sestavljanje delov
Prejšnje lekcije so ločeno predstavile gradnike: strežnik z njegovimi orodji ter odjemalca z njegovim kontekstom izvajanja (RunContext). Zdaj jih boš združil v delujoč projekt – lokalni strežnik MCP, ki ponuja vremenske podatke in ga poganja agent Mistral, zmožen odgovarjati na vprašanja v naravnem jeziku. Preberi kodo, a bodi pozoren na to, kaj odloča vsak del: strežnik določa, kaj je mogoče, agent pa določa, kaj je relevantno.
Strežnik: weather_server.py
Ta strežnik vsebuje tri orodja. Prvo vrne vreme za določeno mesto, drugo primerja dve mesti, tretje pa izpiše vsebino baze podatkov. Zadnje ni zgolj okrasno: modelu omogoča, da odkrije razpoložljivi obseg namesto ugibanja imen mest.
# 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)
Dve podrobnosti pri zasnovi si zaslužita pozornost. Orodja normalizirajo vnos z .lower().strip(), ker lahko model glede na formulacijo uporabnika zapiše „Paris” ali „paris”. Ko mesto manjka, get_weather ne sproži izjeme: vrne JSON z napako, ki našteje znana mesta, s čimer neuspeh spremeni v informacijo, ki jo model lahko uporabi.
Odjemalec: main.py
Odjemalec zaporedoma opravi štiri stvari: inicializira Mistral, ustvari agenta, opiše način zagona strežnika in nato odpre RunContext za veriženje pogovorov.
# 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())
Bodi pozoren na pot do strežnika: Path(__file__).parent / "weather_server.py" locira datoteko relativno glede na skripto in ne glede na trenutni delovni imenik. To je edini način, da zagotoviš uspešen zagon ne glede na to, od kod zaženeš python main.py.
Zagon projekta
# Set API key
export MISTRAL_API_KEY="your_mistral_api_key"
# Launch client (it will launch the server automatically)
python main.py
Zaženeš le en proces. Odjemalec ustvari agenta Mistral, RunContext zažene weather_server.py kot proces STDIO, odkrije tri orodja – get_weather, compare_weather in list_cities – nato pa vprašanje za vprašanjem modelu dovoli izbiro, katera orodja poklicati, preden rezultate vključi v svoj odgovor. Tretje vprašanje v primeru je najbolj zanimivo za opazovanje: da bi vedel, katero mesto je najtoplejše, model nima druge izbire, kot da uporabi list_cities, čeprav v vprašanju ni nobene besede, ki bi to nakazovala.
Opazovanje nastajanja odgovora
Čakanje na celoten odgovor deluje za skripto; ob soočenju z uporabnikom način pretakanja (streaming) ponuja bistveno boljšo izkušnjo.
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}")
Tok dogodkov ni namenjen zgolj prikazu: je tudi tvoje najboljše orodje za razhroščevanje, saj v realnem času razkriva klice orodij in argumente, ki jih izbere model.
Ko orodje odpove
Zahvaljujoč continue_on_fn_error=True zahteva zunaj obsega ne poruši ničesar. Če uporabnik vpraša za vreme v Tokiu, get_weather vrne svoj JSON z napako, model ga prebere in se odzove tako, da predlaga dejansko razpoložljiva mesta.
# 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..."
Na koncu se projekt prilega v štiri datoteke, od katerih le dve vsebujeta logiko:
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=...
Ključne ugotovitve
- Celovit projekt MCP = strežnik (orodja) + odjemalec (agent + RunContext)
- Strežnik definira orodja z
MCPServerin okrasniki@app.tool() - Odjemalec ustvari agenta, odpre RunContext in zažene pogovore
- Način pretakanja omogoča postopen prikaz
continue_on_fn_error=Trueelegantno obravnava napake orodij- Vsa koda je asinhrona – kot vstopno točko uporabi
asyncio.run()