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": {
      "comando": "npx",
      "args": [
        "-y".
        "@modelcontextprotocol/server-filesystem",
        "/Usuários/nome de usuário/Desktop",
        "/Usuários/nome de usuário/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

Você pode pegar todas as imagens da minha área de trabalho e movê-las para uma nova pasta chamada "Imagens"?

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

Em que comando devemos usar python se estivermos usando um servidor escrito em python. é 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.]
    """
    Definição do modelo de prompt
    """
    return [
        types.Prompt(
            name="example-prompt",
            description="Um modelo de prompt de exemplo",
            arguments=[
                types.PromptArgument(
                    name="arg1",
                    description="Exemplo de argumento",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def handle_get_prompt(
    name: str, arguments: dict[str, str] | None
    argumentos: dict[str, str] | None
) -> types.GetPromptResult.
    """
    Tratamento do modelo de prompt
    """
    if name ! = "example-prompt": raise ValueError(f "Unknown prompt: {name}")
        raise ValueError(f "Prompt desconhecido: {name}")

    return types.GetPromptResult(
        description="Exemplo de prompt",
        messages=[
            types.PromptMessage(
                role="user", content=types.TextContent(
                content=types.TextContent(
                    text="Texto de exemplo de prompt", text="Texto de exemplo de prompt", content=types.TextContent(
                    text="Exemplo de texto de prompt"
                )
            )
        ]
    )

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.]
    """
    Definição de recursos
    """
    test='test'
    return [
        types.Resource(
            uri=AnyUrl(f "file:///{test}.txt"),
            uri=AnyUrl(f "file://{test}.txt"), name=test,
            description=f "Um recurso de texto de amostra chamado {test}",
            mimeType="text/plain", )
        )
        # for name in SAMPLE_RESOURCES.keys()
    SAMPLE_RESOURCES.keys()
SAMPLE_RESOURCES={'test':'esta demonstração é um servidor mcp!'}
@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 "Recurso desconhecido: {uri}")

    return SAMPLE_RESOURCES[name]

Ferramentas

definições e invocações de ferramentas.handle_list_toolsDefina as ferramentas disponíveis e valide os parâmetros da ferramenta usando o esquema JSON.handle_call_toolTrata as chamadas de ferramentas, executando a ação apropriada com base no nome da ferramenta e nos parâmetros. @server.list_tools() async def handle_list_tools() -> list[types.Tool]: """ Definição da ferramenta.     Cada ferramenta especifica seus parâmetros usando a validação do esquema JSON.     """ return [ types.Tool( name="demo-tool", description="Obter ferramenta de dados para um parâmetro", 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 "Ferramenta desconhecida: {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": {
      "comando": "npx",
      "args": [
        "-y".
        "@modelcontextprotocol/server-filesystem",
        "/Usuários/crisschan/Desktop",
        "/Usuários/crisschan/Downloads"
      ]
    }, }
     "playwright": {
      "command": "npx", "args": ["args" - ["npx" ], "playwright": {
      "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.