Explicação sobre o desenvolvimento de servidores MCP e Python MCP

Conhecendo a MCP pela primeira vez

O MCP (Model Context Protocol) é um protocolo desenvolvido para padronizar a forma como os aplicativos fornecem contexto para modelos grandes. O MCP oferece uma maneira padrão de fornecer dados e ferramentas para o LLM. O uso do MCP facilitará a criação de agentes ou fluxos de trabalho complexos baseados no LLM.

construir

MCP é uma estrutura de CS em que um aplicativo host MCP pode vincular vários servidores MCP.

• MCP Host: programas que precisam obter dados por meio do MCP, como o Claude Desktop, IDEs ou algumas ferramentas de IA, etc.
• Cliente MCP: cliente do protocolo MCP, e o servidor MCP é um suporte individual.
• Servidor MCP: um aplicativo leve que precisa expor alguns recursos especiais por meio do MCP. De acordo com a definição do protocolo MCP, o servidor pode fornecer três tipos de recursos padrão: recursos, ferramentas e prompts. Cada servidor pode fornecer simultaneamente três tipos de recursos ou um deles.
  • Recursos: os recursos, semelhantes à leitura de dados de arquivos, podem ser recursos de arquivos ou o conteúdo retornado pela resposta da API.
  • Ferramentas: ferramentas, serviços de terceiros, funções de função, por meio das quais você pode controlar quais funções podem ser chamadas pelo LLM.
  • Prompts: Prompts, modelos predefinidos para que o usuário conclua tarefas específicas.
• Recursos de dados locais: arquivos locais, bancos de dados, serviços, etc. que o MCP Server pode acessar com segurança.
• Serviço remoto: um sistema externo ao qual o servidor MCP pode se conectar por meio de uma rede (por exemplo, uma API).

Esquema dos serviços da MCP:

Os servidores MCP fornecem uma lista de funções para o aplicativo host por meio do protocolo MCP (por exemplo, fornecem uma lista de ferramentas) e, em seguida, o aplicativo host formata essa lista em um formato que o LLM pode ler e entender. O aplicativo host pode usar essa lista de recursos para enviar algumas solicitações ao LLM que precisam ser processadas pelo modelo grande (esse é o prompt), e o LLM retornará uma cadeia de caracteres json de tool_calls com base nesse prompt. Quando o aplicativo host receber essas tool_calls, ele chamará a ferramenta do servidor MCP correspondente para retornar os resultados correspondentes.

Uso do MCP com o Claude Desktop

Com a ajuda do cliente de desktop Claude, você definitivamente precisa instalar um primeiro, e essa instalação é ignorada. Configuramos um sistema de arquivos MCP Server.

Em seguida, selecione Edit Config em Developer,

show (um ingresso)claude_desktop_config.jsonPara concluir a configuração do servidor MCP para o sistema de arquivos, é necessário substituir o nome de usuário pelo nome de usuário do seu próprio computador. (O nome de usuário da configuração precisa ser substituído pelo nome de usuário do seu próprio computador, mas também é necessário instalar localmente o ambiente node.js).

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

Quando a configuração estiver concluída, reinicie o cliente Cluade. Ele estará pronto para ser testado.

Clique no ícone do martelo para ver as ferramentas fornecidas pelo MCP Server.

Você pode experimentá-lo digitando o seguinte prompt

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

O feedback do LLM e o servidor MCP do sistema de arquivos são executados com mais alguns lembretes de permissões, lembre-se de permiti-los.

Em seguida, você verá o LLM e o MCPServer começarem a funcionar.

Tutorial de introdução ao desenvolvimento do servidor MCP (python e pip)

Servidor mcp simples usando a pilha de tecnologia python

Requer instalação

O servidor MCP requer python-sdk, python precisa de 3.10, instale o seguinte

pip install mcp

PS: O MCP usa oficialmente a ferramenta de gerenciamento de pacotes uv, mas eu costumo usar mais o pip, portanto, o texto é principalmente pip. Como algumas das dependências da versão do pacote mcp não são as mais recentes, é melhor obter um ambiente limpo. O desenvolvimento de um servidor MCP requer um cliente de depuração, o inspetor MCP fornece essa função

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

Em que comando devemos usar python se estivermos usando um servidor escrito em python.<arg1> <arg2>é um parâmetro opcional. Após a inicialização

Desenvolver um servidor MCP de demonstração

Servidor MCP: um aplicativo leve que precisa expor alguns recursos especiais por meio do MCP. De acordo com a definição do protocolo MCP, o servidor pode fornecer três tipos de recursos padrão: recursos, ferramentas e prompts. Cada servidor pode fornecer simultaneamente três tipos de recursos ou um deles.

• Recursos: os recursos, semelhantes à leitura de dados de arquivos, podem ser recursos de arquivos ou o conteúdo retornado pela resposta da API.
• Ferramentas: ferramentas, serviços de terceiros, funções de função, por meio das quais você pode controlar quais funções podem ser chamadas pelo LLM.
• Prompts: Prompts, modelos predefinidos para que o usuário conclua tarefas específicas.

Aqui está uma demonstração dos três tipos de recursos, usando o python-sdk.

Prompts

Vamos começar com o prompt e examinar ohandle_list_promoptsListagem de modelos de palavras-chave disponíveis.handle_get_prompté obter um modelo de prompt específico com base no nome.

@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"
                )
            )
        ]
    )

Recursos

Código para funções de gerenciamento de recursoslist_resourcesLista os recursos disponíveis, retornando uma lista de recursos.read_resourceSAMPLE_RESOURCES é uma demonstração criada para testes.

@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]

Ferramentas

工具定义和调用，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}")

inspetor

Um servidor MCP foi escrito da seguinte forma: você pode iniciar o inspetor MCP para depuração, no diretório em que o código do servidor está localizado, digite

npx @modelcontextprotocal/inspector

Após a inicialização, obtenha a seguinte captura de tela de acordo com a figura, acesse http://localhost:5273, de acordo com o que eu disse anteriormente, selecione STDIO para o tipo de transporte, insira python para o comando, insira server.py para os argumentos (o código de demonstração acima é salvo no arquivo server.py), clique em conectar. No diagrama, você pode inserir a chamada de serviço do servidor correspondente para cada tipo e clicar em List Resource (Listar recurso) em Resources (Recursos) para listar todos os recursos e clicar no recurso correspondente para ver o conteúdo do recurso específico.

Isso nos permite interagir com o servidor MCP que desenvolvemos.

Como configurar na área de trabalho do Claude

Configure esse servidor MCP no Claude seguindo a configuração de comando que você acabou de fazer no inspetor. Clique na configuração da área de trabalho do Claude, selecione a guia do desenvolvedor e, em seguida, clique em editar configuração para ir para claude_desktop_config.json.

Atualmente, tenho dois servidores MCP instalados com as seguintes configurações, um para organização de arquivos e outro para o playwright (para instalar o servidor MCP do 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"]
    }
  }
}

Configure nosso próprio serviço de demonstração nesse formato, salve e reinicie o desktop do Claude.

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

Na configuração, o comando deve ser o endereço absoluto da versão correspondente do python, e o mesmo vale para o local do código server.py em args, para usar o endereço absoluto.