Adicionar um servidor MCP a uma extensão

Uma extensão da CLI do Desenvolvedor Azure (azd) pode expor ferramentas a agentes de IA por meio de um servidor MCP (Model Context Protocol). Quando você adiciona a mcp-server funcionalidade, agentes como GitHub Copilot podem descobrir e chamar as ferramentas da extensão. Este artigo mostra como adicionar um servidor MCP à extensão de exemplo Contoso Resource Tagger presente no guia de início rápido Criar uma extensão de exemplo. Você pode aplicar o mesmo padrão a qualquer extensão.

Note

azd as extensões estão atualmente na versão beta.

Como funcionam os servidores MCP

O Protocolo de Contexto de Modelo é um padrão aberto que permite que os agentes de IA descubram e chamem ferramentas fornecidas por servidores externos. Quando sua extensão declara a mcp-server funcionalidade, azd pode iniciar sua extensão como um servidor MCP e rotear solicitações de ferramenta de um agente para sua extensão. Sua extensão implementa ferramentas que o agente chama para executar tarefas, como sugerir marcas padronizadas para um projeto.

Declarar a funcionalidade

Adicione a capacidade mcp-server ao seu manifesto extension.yaml:

capabilities:
  - custom-commands
  - mcp-server

Você também pode adicionar uma mcp seção ao manifesto para configurar como azd inicia o servidor MCP. A propriedade serve oferece suporte a args e env; azd já conhece o executável da extensão, portanto não é necessário especificar um comando:

mcp:
  serve:
    args:
      - mcp
      - start

Adicionar um comando MCP

Adicione um comando que inicie o servidor MCP. azd invoca esse comando para executar sua extensão como um servidor MCP. Use uma biblioteca de servidorES MCP para Go, como mcp-go, para lidar com o protocolo.

  1. Crie um arquivo nomeado mcp.go em seu internal/cmd diretório:

    package cmd

import (
    "context"
    "fmt"

    "github.com/mark3labs/mcp-go/mcp"
    "github.com/mark3labs/mcp-go/server"
    "github.com/spf13/cobra"
)

func newMcpCommand() *cobra.Command {
    mcpCmd := &cobra.Command{
        Use:    "mcp",
        Short:  "Model Context Protocol server commands.",
        Hidden: true,
    }

    mcpCmd.AddCommand(newMcpStartCommand())
    return mcpCmd
}

func newMcpStartCommand() *cobra.Command {
    return &cobra.Command{
        Use:   "start",
        Short: "Starts the MCP server.",
        RunE: func(cmd *cobra.Command, args []string) error {
            s := server.NewMCPServer(
                "Contoso Resource Tagger",
                "0.1.0",
            )

            // Register the suggest_tags tool.
            s.AddTool(newSuggestTagsTool())

            // Serve over stdio so azd and agents can connect.
            return server.ServeStdio(s)
        },
    }
}

  2. Registre o comando mcp no comando raiz:

    rootCmd.AddCommand(newMcpCommand())

Implementar uma ferramenta

Defina a ferramenta que o agente de IA chama. Adicione a seguinte ferramenta suggest_tags ao mesmo arquivo internal/cmd/mcp.go que você criou anteriormente. Os identificadores mcp e server vêm dos pacotes já importados naquele arquivo (github.com/mark3labs/mcp-go/mcp e github.com/mark3labs/mcp-go/server), e o manipulador também usa as importações context e fmt. Adicionar a função a mcp.go reutiliza essas importações para que o código compile:

func newSuggestTagsTool() (mcp.Tool, server.ToolHandlerFunc) {
    tool := mcp.NewTool(
        "suggest_tags",
        mcp.WithDescription("Suggests standardized Azure resource tags for a project."),
        mcp.WithString("environment",
            mcp.Description("The target environment, such as dev or prod."),
            mcp.Required(),
        ),
    )

    handler := func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
        environment, err := request.RequireString("environment")
        if err != nil {
            return mcp.NewToolResultError(err.Error()), nil
        }

        suggestion := fmt.Sprintf(
            "Suggested tags: environment=%s, managed-by=azd, cost-center=<required>",
            environment,
        )

        return mcp.NewToolResultText(suggestion), nil
    }

    return tool, handler
}

Testar o servidor MCP

Depois de adicionar o servidor MCP, recompile sua extensão e verifique se o servidor é iniciado:

  1. Recompile a extensão:

    azd x build

  2. Inicie o servidor MCP diretamente para verificar se ele é executado sem erros:

    azd tagger mcp start

    O servidor inicia e escuta na entrada e saída padrão. Um cliente MCP, como um agente de IA configurado para usar sua extensão, conecta-se a esse servidor para chamar suas ferramentas.

Conteúdo relacionado

  • Last updated on