Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Verktyg, resurser och prompts i MCP

Lektion 3 av 14 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Tre förmågor, tre syften
  2. Verktyg: exekverbara funktioner
  3. Resurser: läsbar data
  4. Prompts: återanvändbara mallar
  5. Förhandlingsfas för förmågor
  6. Hur många verktyg per server?
  7. Viktiga punkter

Uppdaterat 2 november 2026 — MCP Python SDK v2. Denna kurs följer nu version 2 av mcp-SDK:t (2.3.0 per den 2 oktober 2026): MCPServer ersätter FastMCP, transportinställningar flyttas till run() eller streamable_http_app(), och en applikation som exponeras under ett riktigt värdnamn måste deklarera detta värdnamn (transport_security). Detta är också den version som krävs av Mistral SDK: tillägget mistralai[agents] kräver mcp>=2.2.0,<3.0. Källor: Vad är nytt i v2 · Migreringsguide · Distribuera och skala.

Tre förmågor, tre syften

En MCP-server kan exponera tre typer av förmågor för sina klienter. De är inte utbytbara: var och en tillgodoser ett specifikt behov, och att blanda ihop dem leder till servrar som är svåra för modellen att använda. I denna lektion granskar vi dem en efter en, innan vi tar itu med frågan som avgör serverns kvalitet: hur många verktyg, och på vilken granularitetsnivå?

Verktyg: exekverbara funktioner

Verktyg är protokollets mest använda förmåga. Ett verktyg är en funktion som modellen kan välja att anropa för att utföra en åtgärd eller hämta information. Dess definition vilar på fyra element: ett unikt och beskrivande namn (create_issue, get_weather), en textbeskrivning som talar om för modellen när den ska anropas, ett JSON-schema för inmatningsparametrar med deras typer och begränsningar, samt ett returformat – oftast text eller JSON.

from mcp.server.mcpserver import MCPServer

app = MCPServer("My Server")

@app.tool()
def get_weather(latitude: float, longitude: float) -> str:
    """Retrieves current weather for the given coordinates.

    Args:
        latitude: Latitude in decimal degrees (-90 to 90)
        longitude: Longitude in decimal degrees (-180 to 180)

    Returns:
        Text description of current weather
    """
    # Weather API call logic
    return f"Sunny, 22°C at ({latitude}, {longitude})"

Underskatta inte beskrivningen och typningen: modellen ser inget annat. Den har ingen tillgång till din kod, kan inte gissa dina avsikter och kan inte testa ett anrop för att se vad som händer. Otydliga beskrivningar eller dåligt typade parametrar leder mekaniskt till felaktiga anrop.

Några vanor gör dina verktyg betydligt mer tillförlitliga. Namnge dem efter vad de gör – book_restaurant säger allt, process_request säger ingenting – och beskriv både åtgärden och returinnehållet, eftersom modellen måste förutse vad den kommer att få tillbaka. Annotera alltid parametrar i Python och skriv strukturerade docstrings med Args och Returns: dessa matar schemat som modellen ser. Returnera slutligen läsbara värden snarare än ogenomskinliga identifierare; ett verktyg som returnerar "John Smith" låter modellen komponera en mening, medan ett verktyg som returnerar en UUID tvingar den att gissa.

Resurser: läsbar data

Resurser exponerar data som klienten kan läsa utan sidoeffekter. Nyansen gentemot verktyg kokar ner till ett verb: ett verktyg gör något, en resurs innehåller något. Innehållet i en konfigurationsfil, en kunskapsbas, API-dokumentation eller det aktuella tillståndet i ett system är alla naturliga resurser.

@app.resource("config://database")
def get_db_config() -> str:
    """Current database configuration."""
    return json.dumps({
        "host": "localhost",
        "port": 5432,
        "database": "production"
    })

Varje resurs identifieras av en URI – config://database, file:///path/to/doc – som klienten kan lista och sedan läsa på begäran. I praktiken används de mindre ofta än verktyg, eftersom ett enkelt verktyg som returnerar data täcker de flesta behov. De är ändå användbara när du vill publicera statisk eller semi-statisk data utan exekveringslogik bakom sig.

Prompts: återanvändbara mallar

MCP-Prompts är parametriserbara mallar som servern gör tillgängliga. De tjänar till att dela beprövade instruktioner för en given uppgift, istället för att låta alla uppfinna sina egna formuleringar.

@app.prompt()
def code_review(language: str, code: str) -> str:
    """Generates a code review prompt for the given language."""
    return f"""You are an expert in {language}.
Analyze the following code and identify:
1. Potential bugs
2. Performance issues
3. Readability improvements

Code to analyze:
```{language}
{code}
```"""

Denna användning ger mest mening i en teammiljö. En senior utvecklare kodar sina prompts för kodgranskning, felsökning eller arkitekturanalys i en MCP-server, och hela teamet får tillgång till dem från sina egna klienter med samma instruktionskvalitet.

Förhandlingsfas för förmågor

När en klient ansluter till en server föregår en förhandlingsfas all användning:

  1. Klienten begär serverns förmågor
  2. Servern svarar med sin lista över verktyg, resurser och prompts
  3. Klienten presenterar dessa förmågor för språkmodellen
  4. Modellen använder beskrivningarna för att besluta vad den ska anropa

Denna förhandling är dynamisk, och det är en egenskap du kan utnyttja: samma server kan annonsera olika förmågor beroende på vilken användare som är ansluten eller i vilket anropssammanhang det rör sig om – ett administratörskonto ser verktyg som ett skrivskyddat konto aldrig kommer att se.

Hur många verktyg per server?

Frågan verkar banal, men den styr din agents felfrekvens. Håll dina servrar fokuserade: tre till tio väldefinierade verktyg fungerar bättre än femtio generiska. Över en viss volym sprider modellen sina val och hamnar till slut med att anropa fel verktyg, eller stapla onödiga anrop.

Om ditt funktionella omfång är brett, dela upp det i flera specialiserade servrar – en för Git-operationer, en för projektledning, en för övervakning. Klienten vet hur man ansluter till flera servrar samtidigt och aktiverar endast de som krävs för den aktuella uppgiften, vilket motsvarar att lasta användbar kontext snarare än hela katalogen.

En sista avvägning förtjänar din uppmärksamhet: granularitet. Att exponera tre verktyg för att lista restauranger, kontrollera tillgänglighet och sedan boka tvingar modellen att orkestrera en sekvens, med risk för fel vid varje steg. Ett enda arbetsflödesverktyg – book_restaurant – kapslar in hela sekvensen, minskar antalet tur-och-retur-kommunikationer och flyttar affärslogiken dit där den är testbar: i din kod.

Viktiga punkter

  • Verktyg = exekverbara åtgärder (90 % av användningsfallen), kräver exakt beskrivning och typning
  • Resurser = läsbar data via URI, inga sidoeffekter
  • Prompts = återanvändbara mallar, användbara för team
  • Håll dina servrar fokuserade (max 3–10 verktyg)
  • Föredra arbetsflödesverktyg framför alltför granulära verktyg
  • Beskrivningens kvalitet avgör modellens effektivitet