Explication du développement de serveurs MCP et Python MCP

Faire connaissance avec MCP pour la première fois

MCP (Model Context Protocol) est un protocole développé pour standardiser la manière dont les applications fournissent un contexte pour les grands modèles. MCP fournit une manière standard de fournir des données, des outils pour LLM, l'utilisation de MCP facilitera la construction d'agents ou de flux de travail complexes basés sur LLM.

construire

MCP est une structure CS dans laquelle une application hôte MCP peut relier plusieurs serveurs MCP.

• MCP Hôte : Programmes qui ont besoin d'obtenir des données par l'intermédiaire de MCP, tels que Claude Desktop, IDE ou certains outils d'intelligence artificielle, etc.
• MCP Client : client du protocole MCP, et le serveur MCP est un support individuel.
• Serveur MCP : une application légère qui a besoin d'exposer certaines capacités spéciales par le biais de MCP. Selon la définition du protocole MCP, le serveur peut fournir trois types de capacités standard : ressources, outils et invites. Chaque serveur peut fournir simultanément trois types de capacités ou l'un d'entre eux.
  • Ressources : les ressources, similaires à la lecture de données de fichiers, peuvent être des ressources de fichiers ou le contenu renvoyé par la réponse de l'API.
  • Outils : Outils, services tiers, fonctions, par lesquels vous pouvez contrôler quelles fonctions peuvent être appelées par LLM.
  • Invitations : les invitations sont des modèles prédéfinis permettant à l'utilisateur d'accomplir des tâches spécifiques.
• Ressources de données locales : fichiers locaux, bases de données, services, etc. auxquels le serveur MCP peut accéder en toute sécurité.
• Service distant : système externe auquel le serveur MCP peut se connecter par l'intermédiaire d'un réseau (par exemple, une API).

Schéma des services de MCP :

Les serveurs MCP fournissent une liste de fonctions à l'application hôte via le protocole MCP (par exemple, une liste d'outils), puis l'application hôte formate cette liste dans un format que LLM peut lire et comprendre. L'application hôte peut utiliser cette liste de fonctions pour envoyer des demandes à LLM qui doivent être traitées par le grand modèle (c'est l'invite), et LLM renverra une chaîne json d'appels d'outils basée sur cette invite. Lorsque l'application hôte reçoit ces appels d'outils, elle appelle l'outil correspondant du serveur MCP pour renvoyer les résultats correspondants.

Utilisation de MCP avec Claude Desktop

Avec l'aide du client de bureau Claude, vous devez absolument en installer un d'abord, et cette installation est sautée. Nous configurons un système de fichiers MCP Server.

Sélectionnez ensuite Edit Config sous Developer,

spectacle (un billet)claude_desktop_config.jsonSi vous souhaitez utiliser MCP Server pour configurer le système de fichiers, vous pouvez utiliser MCP Server pour configurer le système de fichiers. (Le nom d'utilisateur de configuration doit être remplacé par le nom d'utilisateur de votre propre ordinateur, mais vous devez également installer localement l'environnement node.js).

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/username/Desktop",
        "/Users/username/Downloads"
      ]
    }
  }
}

Une fois la configuration terminée, redémarrez le client Cluade. Il sera prêt à l'essayer.

Cliquez sur l'icône du marteau pour voir les outils fournis par MCP Server.

Vous pouvez l'essayer en tapant l'invite suivante

Can you take all the images on my desktop and move them to a new folder called “Images”?

Le serveur MCP de LLM s'exécute avec quelques rappels supplémentaires de permissions, n'oubliez pas de les autoriser.

Vous verrez alors LLM et MCPServer commencer à fonctionner.

Tutoriel de démarrage pour le développement du serveur MCP (python et pip)

Serveur mcp simple utilisant la pile technologique python

Nécessite une installation

Le serveur MCP nécessite python-sdk, python nécessite 3.10, installez les éléments suivants

pip install mcp

PS : MCP utilise officiellement l'outil de gestion de paquets uv, j'utilise généralement plus pip, donc le texte est principalement pip. Parce que certaines des dépendances de la version du paquet mcp ne sont pas les plus récentes, il est préférable d'obtenir un environnement propre. Le développement d'un serveur MCP nécessite un client de débogage, l'inspecteur MCP fournit cette fonction

npx @modelcontextprotocol/inspector <command> <arg1> <arg2>

Dans le cas d'un serveur écrit en python, nous devrions utiliser la commande python.<arg1> <arg2>est un paramètre facultatif. Après le démarrage

Développer un serveur MCP de démonstration

Serveur MCP : une application légère qui a besoin d'exposer certaines capacités spéciales par le biais de MCP. Selon la définition du protocole MCP, le serveur peut fournir trois types de capacités standard : ressources, outils et invites. Chaque serveur peut fournir simultanément trois types de capacités ou l'un d'entre eux.

• Ressources : les ressources, similaires à la lecture de données de fichiers, peuvent être des ressources de fichiers ou le contenu renvoyé par la réponse de l'API.
• Outils : Outils, services tiers, fonctions, par lesquels vous pouvez contrôler quelles fonctions peuvent être appelées par LLM.
• Invitations : les invitations sont des modèles prédéfinis permettant à l'utilisateur d'accomplir des tâches spécifiques.

Voici une démonstration des trois types de capacités, à l'aide de python-sdk.

Invitations à la discussion

Commençons par l'invite et passons en revue les éléments suivantshandle_list_promoptsListe des modèles de mots clés disponibles.handle_get_promptest d'obtenir un modèle d'invite spécifique basé sur le nom.

@server.list_prompts()
async def handle_list_prompts() -> list[types.Prompt]:
    """
    提示模版定义
    """
    return [
        types.Prompt(
            name="example-prompt",
            description="An example prompt template",
            arguments=[
                types.PromptArgument(
                    name="arg1",
                    description="Example argument",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def handle_get_prompt(
    name: str,
    arguments: dict[str, str] | None
) -> types.GetPromptResult:
    """
    提示模板处理
    """
    if name != "example-prompt":
        raise ValueError(f"Unknown prompt: {name}")

    return types.GetPromptResult(
        description="Example prompt",
        messages=[
            types.PromptMessage(
                role="user",
                content=types.TextContent(
                    type="text",
                    text="Example prompt text"
                )
            )
        ]
    )

Ressources

Code pour les fonctions de gestion des ressourceslist_resourcesRépertorie les ressources disponibles et renvoie une liste de ressources.read_resourceSAMPLE_RESOURCES est une démo conçue pour les tests.

@server.list_resources()
async def list_resources() -> list[types.Resource]:
    """
    资源定义
    """
    test='test'
    return [
        types.Resource(
            uri=AnyUrl(f"file:///{test}.txt"),
            name=test,
            description=f"A sample text resource named {test}",
            mimeType="text/plain",
        )
        # for name in SAMPLE_RESOURCES.keys()
    ]
SAMPLE_RESOURCES={'test':'this demo is a mcp server!'}
@server.read_resource()
async def read_resource(uri: AnyUrl) -> str | bytes:
    assert uri.path is not None
    print(uri.path)
    name = uri.path.replace(".txt", "").lstrip("/")
    # print(name)
    if name not in SAMPLE_RESOURCES:
        raise ValueError(f"Unknown resource: {uri}")

    return SAMPLE_RESOURCES[name]

Outils

工具定义和调用，handle_list_tools定义可用的工具，使用 JSON Schema 验证工具参数。handle_call_tool处理工具调用，根据工具名称和参数执行相应的操作。 @server.list_tools() async def handle_list_tools() -> list[types.Tool]:     """     工具定义.     每个工具都使用JSON Schema验证指定其参数.     """     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 | None ) -> list[Any]:     logging.info(name)     """     处理工具调用     """     if not arguments:         raise ValueError("Missing arguments")     if name == "demo-tool":         param = 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"Unknown tool: {name}")

inspecteur

Un serveur MCP a été écrit comme suit, vous pouvez démarrer l'inspecteur MCP pour le débogage, dans le répertoire où se trouve le code du serveur, entrez

npx @modelcontextprotocal/inspector

Après le démarrage, vous obtenez la capture d'écran suivante selon la figure, visitez http://localhost:5273, conformément à ce que j'ai dit précédemment, sélectionnez STDIO pour le type de transport, entrez python pour la commande, entrez server.py pour les arguments (le code de démonstration ci-dessus est sauvegardé dans le fichier server.py), cliquez sur connecter. Dans le diagramme, vous pouvez saisir l'appel de service du serveur correspondant à chaque type, et cliquer sur List Resource dans Resources pour lister toutes les ressources, et cliquer sur la ressource correspondante pour voir le contenu de la ressource spécifique.

Cela nous permet d'interagir avec le serveur MCP que nous avons développé.

Comment configurer le bureau de Claude

Configurez ce serveur MCP dans Claude en suivant la configuration de commande que vous venez de faire dans l'inspecteur. Cliquez sur Claude desktop's setting, sélectionnez developer's tab et cliquez sur edit config pour accéder à claude_desktop_config.json.

J'ai actuellement deux serveurs MCP installés avec les configurations suivantes, l'un pour l'organisation des fichiers et l'autre pour playwright (pour installer le serveur MCP de playwright via npx.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/crisschan/Desktop",
        "/Users/crisschan/Downloads"
      ]
    },
     "playwright": {
      "command": "npx",
      "args": ["-y", 
      "@executeautomation/playwright-mcp-server"]
    }
  }
}

Configurez notre propre service de démonstration dans ce format, puis enregistrez et redémarrez le bureau de Claude.

{
  "mcpServers": {
    ,
    "demo": {
      "command": "/opt/anaconda3/bin/python3",
      "args": ["/Users/workspace/pyspace/try_mcp/server.py"]
      }
  }
}

Dans la configuration, la commande doit être l'adresse absolue de la version de python correspondante, et il en va de même pour l'emplacement du code server.py dans les args, afin d'utiliser l'adresse absolue.