Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Tools, Ressourcen und Prompts im MCP

Lektion 3 von 14 Aktualisiert am 2. November 2026 Entwickler
Auf dieser Seite
  1. Drei Fähigkeiten, drei Absichten
  2. Tools: ausführbare Funktionen
  3. Ressourcen: lesbare Daten
  4. Prompts: wiederverwendbare Vorlagen
  5. Fähigkeitsverhandlung
  6. Wie viele Tools pro Server?
  7. Kernaussagen

Aktualisiert am 2. November 2026 — MCP Python SDK v2. Dieser Kurs folgt nun Version 2 des mcp SDKs (Stand 2.3.0 vom 2. Oktober 2026): MCPServer ersetzt FastMCP, Transport-Einstellungen werden in run() oder streamable_http_app() verlegt, und eine Anwendung, die unter einem echten Hostnamen ausgesetzt ist, muss diesen Hostnamen deklarieren (transport_security). Dies ist auch die vom Mistral SDK erforderliche Version: Das mistralai[agents]-Extra benötigt mcp>=2.2.0,<3.0. Quellen: Neuigkeiten in v2 · Migrationsanleitung · Bereitstellen und skalieren.

Drei Fähigkeiten, drei Absichten

Ein MCP-Server kann drei Arten von Fähigkeiten gegenüber seinen Clients auslagern. Diese sind nicht austauschbar: Jede adressiert einen spezifischen Bedarf, und das Verwechseln der drei führt zu Servern, die für das Modell schwer zu nutzen sind. In dieser Lektion werden sie einzeln betrachtet, bevor die Frage behandelt wird, die die Serverqualität bestimmt: Wie viele Tools und in welcher Granularität?

Tools: ausführbare Funktionen

Tools sind die am weitesten verbreitete Fähigkeit des Protokolls. Ein Tool ist eine Funktion, die das Modell entscheiden kann, aufzurufen, um eine Aktion durchzuführen oder Informationen abzurufen. Seine Definition stützt sich auf vier Elemente: einen eindeutigen, beschreibenden Namen (create_issue, get_weather), eine Textbeschreibung, die dem Modell sagt, wann es aufgerufen werden soll, ein JSON-Schema für Eingabeparameter mit ihren Typen und Einschränkungen sowie ein RückgabefORMAT – meist Text oder JSON.

from mcp.server.mcpserver import MCPServer

app = MCPServer("My Server")

@app.tool()
def get_weather(latitude: float, longitude: float) -> str:
    """Ruft das aktuelle Wetter für die angegebenen Koordinaten ab.

    Args:
        latitude: Breitengrad in Grad (−90 bis 90)
        longitude: Längengrad in Grad (−180 bis 180)

    Returns:
        Textbeschreibung des aktuellen Wetters
    """
    # Logik für den API-Aufruf
    return f"Sonnig, 22°C bei ({latitude}, {longitude})"

Unterschätzen Sie die Beschreibung und die Typisierung nicht: Das Modell sieht nichts anderes. Es hat keinen Zugriff auf Ihren Code, kann Ihre Absichten nicht erraten und kann keinen Aufruf testen, um zu sehen, was passiert. Vage Beschreibungen oder schlecht typisierte Parameter führen mechanisch zu falschen Aufrufen.

Einige Gewohnheiten machen Ihre Tools deutlich zuverlässiger. Benennen Sie sie nach ihrer Funktion – book_restaurant sagt alles, process_request sagt nichts – und beschreiben Sie sowohl die Aktion als auch den Rückgabewert, da das Modell antizipieren muss, was es abrufen wird. Annotieren Sie Parameter in Python immer und schreiben Sie strukturierte Docstrings mit Args und Returns: Diese füttern das Schema, das das Modell sieht. Geben Sie schließlich lesbare Werte statt undurchsichtiger Identifikatoren zurück; ein Tool, das "John Smith" zurückgibt, ermöglicht es dem Modell, einen Satz zu formulieren, während ein Tool, das eine UUID zurückgibt, es zwingt, zu raten.

Ressourcen: lesbare Daten

Ressourcen stellen Daten bereit, die vom Client gelesen werden können, ohne Nebenwirkungen. Der Unterschied zu Tools lässt sich auf ein Verb reduzieren: Ein Tool tut etwas, eine Ressource enthält etwas. Der Inhalt einer Konfigurationsdatei, eines Wissensbestands, einer API-Dokumentation oder des aktuellen Systemzustands sind alles natürliche Ressourcen.

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

Jede Ressource wird durch eine URI identifiziert – config://database, file:///path/to/doc –, die der Client auflisten und dann auf Abruf lesen kann. In der Praxis werden sie weniger oft als Tools verwendet, da ein einfaches Tool, das Daten zurückgibt, die meisten Bedürfnisse abdeckt. Sie bleiben nützlich, wenn Sie statische oder halb-statische Daten veröffentlichen möchten, ohne dahinter eine Ausführungslogik zu haben.

Prompts: wiederverwendbare Vorlagen

MCP-Prompts sind parametrisierbare Vorlagen, die der Server zur Verfügung stellt. Sie dienen dazu, bewährte Anweisungen für eine bestimmte Aufgabe zu teilen, anstatt dass jeder seine Formulierung neu erfinden muss.

@app.prompt()
def code_review(language: str, code: str) -> str:
    """Generiert einen Code-Review-Prompt für die angegebene Sprache."""
    return f"""Sie sind ein Experte für {language}.
Analysieren Sie den folgenden Code und identifizieren Sie:
1. Mögliche Fehler
2. Leistungsprobleme
3. Verbesserungen der Lesbarkeit

Zu analysierender Code:
```{language}
{code}
```"""

Diese Nutzung macht am meisten Sinn in einem Teamkontext. Ein Senior-Developer kodifiziert seine Code-Review-, Debugging- oder Architektur-Analyse-Prompts in einen MCP-Server, und das gesamte Team greift von seinem eigenen Client aus darauf zu, mit derselben Anweisungsqualität.

Fähigkeitsverhandlung

Wenn sich ein Client mit einem Server verbindet, geht einer jeden Nutzung eine Verhandlungsphase voraus:

  1. Der Client fordert die Fähigkeiten des Servers an
  2. Der Server antwortet mit seiner Liste von Tools, Ressourcen und Prompts
  3. Der Client stellt diese Fähigkeiten dem Sprachmodell zur Verfügung
  4. Das Modell nutzt die Beschreibungen, um zu entscheiden, was es aufrufen soll

Diese Verhandlung ist dynamisch, und das ist eine ausnutzbare Eigenschaft: Der gleiche Server kann je nach verbundenem Benutzer oder Anrufkontext unterschiedliche Fähigkeiten ankündigen – ein Administrator-Konto sieht Tools, die ein nur lesendes Konto niemals sehen wird.

Wie viele Tools pro Server?

Die Frage scheint trivial, bedingt aber die Fehlerrate Ihres Agents. Halten Sie Ihre Server fokussiert: Drei bis zehn gut definierte Tools funktionieren besser als fünfzig generische. Jenseits eines bestimmten Volumens streut das Modell seine Entscheidungen und endet damit, das falsche Tool aufzurufen oder unnötige Aufrufe zu stapeln.

Wenn Ihr funktionaler Umfang breit ist, teilen Sie ihn in mehrere spezialisierte Server auf – einen für Git-Operationen, einen für Projektmanagement, einen für Monitoring. Der Client weiß, wie er sich gleichzeitig mit mehreren Servern verbinden und nur diejenigen aktivieren kann, die für die aktuelle Aufgabe erforderlich sind, was dem Laden des nützlichen Kontexts statt des gesamten Katalogs entspricht.

Ein letzter Kompromiss verdient Ihre Aufmerksamkeit: Granularität. Das Auslagern von drei Tools zum Auflisten von Restaurants, zur Prüfung der Verfügbarkeit und dann zur Buchung zwingt das Modell, eine Sequenz zu orchestrieren, mit einem Fehlerisiko an jedem Schritt. Ein einziges Workflow-Tool – book_restaurant – kapselt die vollständige Sequenz ein, reduziert die Anzahl der Roundtrips und verlagert die Geschäftslogik dort, wo sie testbar ist: in Ihren Code.

Kernaussagen

  • Tools = ausführbare Aktionen (90 % der Anwendungsfälle), erfordern präzise Beschreibung und Typisierung
  • Ressourcen = lesbare Daten über URI, ohne Nebenwirkungen
  • Prompts = wiederverwendbare Vorlagen, nützlich für Teams
  • Halten Sie Ihre Server fokussiert (maximal 3–10 Tools)
  • Bevorzugen Sie Workflow-Tools gegenüber übermäßig granularen Tools
  • Die Beschreibungsqualität bestimmt die Modelleffizienz