MCP und Python MCP Server-Entwicklung erklärt

MCP zum ersten Mal kennenlernen

MCP (Model Context Protocol) ist ein Protokoll, das entwickelt wurde, um zu standardisieren, wie Anwendungen Kontext für große Modelle bereitstellen. MCP bietet eine Standardmethode zur Bereitstellung von Daten und Werkzeugen für LLM, die Verwendung von MCP erleichtert die Erstellung von Agenten oder komplexen Arbeitsabläufen auf der Grundlage von LLM.

bauen

MCP ist eine CS-Struktur, bei der eine MCP-Host-Anwendung mehrere MCP-Server verbinden kann.

• MCP Host: Programme, die Daten über MCP abrufen müssen, z. B. Claude Desktop, IDEs oder einige KI-Tools usw.
• MCP-Client: MCP-Protokoll-Client, und MCP-Server ist eine Eins-zu-Eins-Unterstützung.
• MCP-Server: eine einfache Anwendung, die einige spezielle Fähigkeiten über MCP zur Verfügung stellen muss. Gemäß der Definition des MCP-Protokolls kann ein Server drei Arten von Standardfähigkeiten bereitstellen: Ressourcen, Werkzeuge und Eingabeaufforderungen, wobei jeder Server gleichzeitig drei Arten von Fähigkeiten oder eine davon bereitstellen kann.
  • Ressourcen: Bei den Ressourcen kann es sich, ähnlich wie beim Lesen von Dateidaten, um Dateiressourcen oder den von der API-Antwort zurückgegebenen Inhalt handeln.
  • Tools: Tools, Dienste von Drittanbietern, Funktionsfunktionen, über die Sie steuern können, welche Funktionen vom LLM aufgerufen werden können.
  • Prompts: Prompts, vordefinierte Vorlagen für den Benutzer, um bestimmte Aufgaben zu erledigen.
• Lokale Datenressourcen: Lokale Dateien, Datenbanken, Dienste usw., auf die MCP Server sicher zugreifen kann.
• Ferndienst: Ein externes System, mit dem sich der MCP-Server über ein Netzwerk verbinden kann (z. B. eine API).

Schematische Darstellung der MCP-Dienste:

MCP-Server stellen der Host-Anwendung über das MCP-Protokoll eine Liste von Funktionen zur Verfügung (z. B. eine Liste von Werkzeugen), und dann formatiert die Host-Anwendung diese Liste in ein Format, das LLM lesen und verstehen kann. Die Host-Anwendung kann diese Funktionsliste verwenden, um einige Anfragen an den LLM zu senden, die vom großen Modell verarbeitet werden müssen (dies ist die Eingabeaufforderung), und der LLM wird eine json-Zeichenkette von tool_calls basierend auf dieser Eingabeaufforderung zurückgeben. Wenn die Host-Anwendung diese tool_calls erhält, ruft sie das entsprechende MCP-Server-Tool auf, um die entsprechenden Ergebnisse zurückzugeben.

Verwendung von MCP mit Claude Desktop

Mit Hilfe der Claude-Desktop-Client, müssen Sie auf jeden Fall einen ersten zu installieren, und diese Installation wird übersprungen. Wir konfigurieren ein Dateisystem MCP Server.

Wählen Sie dann Edit Config unter Developer,

zeigen (eine Eintrittskarte)claude_desktop_config.jsonUm die Konfiguration des MCP-Servers für das Dateisystem abzuschließen, müssen Sie den Benutzernamen durch den Benutzernamen Ihres eigenen Computers ersetzen. (Der Konfigurationsbenutzername muss durch den Benutzernamen des eigenen Computers ersetzt werden, aber auch die node.js-Umgebung muss lokal installiert werden).

{
  "mcpServer": {
    "filesystem": {
      "Befehl": "npx",
      "args": [
        "-y".
        "@modelcontextprotocol/server-filesystem",
        "/Benutzer/Benutzername/Desktop",
        "/Benutzer/Benutzername/Downloads"
      ]
    }
  }
}

Sobald die Konfiguration abgeschlossen ist, starten Sie den Cluade-Client neu. Er ist nun bereit, die Software auszuprobieren.

Klicken Sie auf das Hammersymbol, um die von MCP Server bereitgestellten Werkzeuge anzuzeigen.

Sie können es ausprobieren, indem Sie die folgende Eingabeaufforderung eingeben

Können Sie alle Bilder auf meinem Desktop in einen neuen Ordner namens "Bilder" verschieben?

LLMs Feedback- und Dateisystem MCP-Server wird mit ein paar weiteren Erinnerungen an Berechtigungen ausgeführt, denken Sie daran, sie zuzulassen.

Dann können Sie sehen, dass LLM und MCPServer zu arbeiten beginnen.

Einführung in die MCP-Serverentwicklung (python und pip)

Einfacher mcp-Server mit dem Python-Technologie-Stack

Erfordert Installation

MCP-Server erfordert python-sdk, python benötigt 3.10, installieren Sie Folgendes

pip install mcp

PS: MCP verwendet offiziell das uv-Paketmanagement-Tool, ich verwende normalerweise eher pip, daher ist der Text hauptsächlich pip. Da einige der Abhängigkeiten der mcp-Paketversion nicht die neueste ist, ist es am besten, eine saubere Umgebung zu erhalten. Die Entwicklung eines MCP-Servers erfordert einen Debugging-Client, MCP inspector bietet diese Funktion

npx @modelcontextprotocol/inspector

Wo Befehl sollten wir Python, wenn wir einen Server in Python geschrieben sind. ist ein optionaler Parameter. Nach dem Starten

Entwickeln Sie einen Demo-MCP-Server

MCP-Server: eine einfache Anwendung, die einige spezielle Fähigkeiten über MCP zur Verfügung stellen muss. Gemäß der Definition des MCP-Protokolls kann ein Server drei Arten von Standardfähigkeiten bereitstellen: Ressourcen, Werkzeuge und Eingabeaufforderungen, wobei jeder Server gleichzeitig drei Arten von Fähigkeiten oder eine davon bereitstellen kann.

• Ressourcen: Bei den Ressourcen kann es sich, ähnlich wie beim Lesen von Dateidaten, um Dateiressourcen oder den von der API-Antwort zurückgegebenen Inhalt handeln.
• Tools: Tools, Dienste von Drittanbietern, Funktionsfunktionen, über die Sie steuern können, welche Funktionen vom LLM aufgerufen werden können.
• Prompts: Prompts, vordefinierte Vorlagen für den Benutzer, um bestimmte Aufgaben zu erledigen.

Hier ist eine Demonstration der drei Arten von Fähigkeiten unter Verwendung von python-sdk.

Aufforderungen zur Einreichung von Vorschlägen

Beginnen wir mit der Eingabeaufforderung und gehen wir diehandle_list_promoptsAuflistung der verfügbaren Schlagwortvorlagen.handle_get_promptist es, eine bestimmte Eingabeaufforderungsvorlage auf der Grundlage des Namens zu erhalten.

@server.list_prompts()
async def handle_list_prompts() -> list[types.]
    """
    Definition der Prompt-Vorlage
    """
    return [
        types.Prompt(
            name="Beispiel-Prompt",
            description="Eine Beispiel-Prompt-Vorlage",
            arguments=[
                types.PromptArgument(
                    name="arg1",
                    description="Beispielargument",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def handle_get_prompt(
    name: str, argumente: dict[str, str] | None
    arguments: dict[str, str] | None
) -> types.GetPromptResult.
    """
    Behandlung von Prompt-Vorlagen
    """
    if name ! = "Beispiel-Prompt": raise ValueError(f "Unbekannter Prompt: {Name}")
        raise ValueError(f "Unbekannte Eingabeaufforderung: {Name}")

    return types.GetPromptResult(
        description="Beispiel-Prompt",
        messages=[
            types.PromptMessage(
                role="Benutzer", content=types.TextContent(
                content=types.TextContent(
                    text="Beispiel Prompt-Text", text="Beispiel Prompt-Text", content=types.TextContent(
                    text="Beispiel Prompt-Text"
                )
            )
        ]
    )

Ressourcen

Code für Funktionen der RessourcenverwaltungListe_RessourcenListet die verfügbaren Ressourcen auf und gibt eine Liste der Ressourcen zurück.ressource_lesenSAMPLE_RESOURCES ist eine zu Testzwecken erstellte Demo.

@server.list_resources()
async def list_resources() -> list[types.]
    """
    Ressourcendefinition
    """
    test='test'
    return [
        types.Resource(
            uri=AnyUrl(f "file:///{test}.txt"),
            uri=AnyUrl(f "file://{test}.txt"), name=test,
            description=f "Eine Beispiel-Textressource namens {test}",
            mimeType="text/plain", )
        )
        # for name in SAMPLE_RESOURCES.keys()
    SAMPLE_RESOURCES.keys()
SAMPLE_RESOURCES={'test':'Diese Demo ist ein mcp-Server!'}
@server.read_resource()
async def read_resource(uri: AnyUrl) -> str | bytes.
    assert uri.path ist nicht None
    print(uri.path)
    name = uri.path.replace(".txt", "").lstrip("/")
    # print(name)
    if name nicht in SAMPLE_RESOURCES.
        raise ValueError(f "Unbekannte Ressource: {uri}")

    return SAMPLE_RESOURCES[name]

Werkzeuge

Werkzeugdefinitionen und -aufrufe.handle_list_toolsDefinieren Sie die verfügbaren Werkzeuge und validieren Sie die Werkzeugparameter mithilfe des JSON-Schemas.handle_call_toolVerarbeitet Werkzeugaufrufe und führt die entsprechende Aktion auf der Grundlage des Werkzeugnamens und der Argumente durch. @server.list_tools() async def handle_list_tools() -> list[types.Tool]: """ Werkzeugdefinition.     Jedes Tool spezifiziert seine Parameter mit Hilfe der JSON-Schema-Validierung.     """ return [ types.Tool( name="demo-tool", description="Get data tool for a param", inputSchema={ "type": "object", "properties": { "param": { "type ": "string", "description": "url", }, }, "required": ["param"], }, ) ] @server.call_tool() async def handle_call_tool( name: str, arguments: dict |  arguments.get("param") if not param: raise ValueError("Missing state parameter"") param = param.upper() return [ types.TextContent( type="text", text=f "text:{param}" ) ] else: raise ValueError(f "Unbekanntes Werkzeug: {name}")

Inspektor

Ein MCP-Server wurde wie folgt geschrieben, Sie können den MCP-Inspektor zum Debuggen starten, in dem Verzeichnis, in dem sich der Server-Code befindet, geben Sie

npx @modelcontextprotocal/inspector

Nach dem Start erhalten Sie den folgenden Screenshot gemäß der Abbildung, besuchen Sie http://localhost:5273, wählen Sie STDIO als Transporttyp, geben Sie Python als Befehl ein, geben Sie server.py als Argumente ein (der obige Democode wird in der Datei server.py gespeichert) und klicken Sie auf Connect. Im Diagramm können Sie für jeden Typ den entsprechenden Serverdienstaufruf eingeben und unter Ressourcen auf Ressource auflisten klicken, um alle Ressourcen aufzulisten, und auf die entsprechende Ressource klicken, um den Inhalt der spezifischen Ressource anzuzeigen.

Dies ermöglicht uns die Interaktion mit dem von uns entwickelten MCP-Server.

So konfigurieren Sie den Claude-Desktop

Konfigurieren Sie diesen MCP-Server in Claude, indem Sie der Befehlskonfiguration folgen, die Sie gerade im Inspektor vorgenommen haben. Klicken Sie auf die Einstellung des Claude-Desktops, wählen Sie die Registerkarte "Entwickler" und klicken Sie dann auf "Konfiguration bearbeiten", um zur Datei claude_desktop_config.json zu gelangen.

Ich habe derzeit zwei MCP-Server mit den folgenden Konfigurationen installiert, einen für die Dateiorganisation und einen für Playwright (um den MCP-Server von Playwright über npx zu installieren.

{
  "mcpServer": {
    "filesystem": {
      "Befehl": "npx",
      "args": [
        "-y".
        "@modelcontextprotocol/server-filesystem",
        "/Benutzer/crisschan/Desktop",
        "/Benutzer/crisschan/Downloads"
      ]
    }, }
     "playwright": {
      "command": "npx", "args": ["args" - ["npx" ], "playwright": {
      "args": ["-y".
      "@executeautomation/playwright-mcp-server"]]
    }
  }
}

Konfigurieren Sie unseren eigenen Demodienst in diesem Format, speichern Sie ihn und starten Sie Claude Desktop neu.

{
  "mcpServer": {
    ,
    "demo": {
      "command":"/opt/anaconda3/bin/python3", ,
      "args": ["/Benutzer/Workspace/pyspace/try_mcp/server.py"]
      }
  }
}

In der Konfiguration muss der Befehl die absolute Adresse der entsprechenden Python-Version sein, und dasselbe gilt für die Position des Codes server.py in args, um die absolute Adresse zu verwenden.