Introdução ao uso do Servidor MCP do Azure com Python

O Servidor MCP do Azure usa o PROTOCOLO MCP (Model Context Protocol) para padronizar as integrações entre aplicativos de IA e ferramentas externas e fontes de dados, permitindo que os sistemas de IA executem operações com reconhecimento de contexto dos recursos do Azure.

Neste artigo, você aprenderá a concluir as seguintes tarefas:

• Instalar e autenticar no Servidor MCP do Azure
• Conectar-se ao Servidor MCP do Azure usando um cliente Python personalizado
• Executar prompts para testar as operações do Servidor MCP do Azure e gerenciar recursos do Azure

Pré-requisitos

• Uma conta do Azure com uma assinatura ativa
• Python 3.9 ou superior instalado
• Node.js LTS instalado

Entrar no Servidor MCP do Azure para desenvolvimento local

O Servidor MCP do Azure se autentica no Microsoft Entra ID usando a Azure Identity library for .NET. O servidor dá suporte a dois modos de autenticação:

• Modo de agente: usa a autenticação nativa do sistema operacional (como o Gerenciador de Contas Web do Windows) com InteractiveBrowserCredential.
• Modo de cadeia de credenciais: tenta vários métodos de autenticação em sequência: variáveis de ambiente, Visual Studio Code, Visual Studio, CLI do Azure, Azure PowerShell, CLI do Desenvolvedor do Azure e autenticação interativa do navegador.

Entre usando qualquer um destes métodos:

az login

Connect-AzAccount

azd auth login

Depois de entrar, o Servidor MCP do Azure pode autenticar e executar operações nos serviços do Azure com base em suas permissões.

Criar o aplicativo do Python

Conclua as etapas a seguir para criar um aplicativo Python (aplicativo host). O aplicativo se conecta a um modelo de IA e atua como um host para um cliente MCP que se conecta a um servidor MCP do Azure (processo local que executa o protocolo MCP).

Criar o projeto

1. Abra uma pasta vazia dentro do editor de sua escolha.

2. Crie um novo arquivo nomeado requirements.txt e adicione as seguintes dependências de biblioteca:

   mcp
   azure-identity
   openai
   logging
   

3. Na mesma pasta, crie um novo arquivo nomeado .env e adicione as seguintes variáveis de ambiente:

   AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
   AZURE_OPENAI_MODEL=<your-model-deployment-name>
   

4. Crie um arquivo vazio nomeado main.py para armazenar o código do aplicativo.

Criar o ambiente e instalar dependências

1. Abra um terminal em sua nova pasta e crie um ambiente virtual python para o aplicativo:

   python -m venv venv
   

2. Ative o ambiente virtual:

   venv\Scripts\activate
   

3. Instale as dependências de requirements.txt:

   pip install -r requirements.txt
   

Adicionar o código do aplicativo

Atualize o conteúdo de main.py com o seguinte código:

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI
from mcp import ClientSession, StdioServerParameters, types
from mcp.client.stdio import stdio_client
import json, os, logging, asyncio
from dotenv import load_dotenv

# Setup logging and load environment variables
logger = logging.getLogger(__name__)
load_dotenv()

# Azure OpenAI configuration
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
AZURE_OPENAI_MODEL = os.getenv("AZURE_OPENAI_MODEL", "gpt-4o")

# Initialize Azure credentials
token_provider = get_bearer_token_provider(
    DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default"
)

async def run():
    # Initialize Azure OpenAI client
    client = AzureOpenAI(
            azure_endpoint=AZURE_OPENAI_ENDPOINT, 
            api_version="2024-04-01-preview", 
            azure_ad_token_provider=token_provider
        )

    # MCP client configurations
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@azure/mcp@latest", "server", "start"],
        env=None
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools = await session.list_tools()
            for tool in tools.tools: print(tool.name)

            # Format tools for Azure OpenAI
            available_tools = [{
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.inputSchema
                }
            } for tool in tools.tools]

            # Start conversational loop
            messages = []
            while True:
                try:
                    user_input = input("\nPrompt: ")
                    messages.append({"role": "user", "content": user_input})

                    # First API call with tool configuration
                    response = client.chat.completions.create(
                        model = AZURE_OPENAI_MODEL,
                        messages = messages,
                        tools = available_tools)

                    # Process the model's response
                    response_message = response.choices[0].message
                    messages.append(response_message)

                    # Handle function calls
                    if response_message.tool_calls:
                        for tool_call in response_message.tool_calls:
                                function_args = json.loads(tool_call.function.arguments)
                                result = await session.call_tool(tool_call.function.name, function_args)

                                # Add the tool response to the messages
                                messages.append({
                                    "tool_call_id": tool_call.id,
                                    "role": "tool",
                                    "name": tool_call.function.name,
                                    "content": result.content,
                                })
                    else:
                        logger.info("No tool calls were made by the model")

                    # Get the final response from the model
                    final_response = client.chat.completions.create(
                        model = AZURE_OPENAI_MODEL,
                        messages = messages,
                        tools = available_tools)

                    for item in final_response.choices:
                        print(item.message.content)
                except Exception as e:
                    logger.error(f"Error in conversation loop: {e}")
                    print(f"An error occurred: {e}")

if __name__ == "__main__":
    import asyncio
    asyncio.run(run())

O código anterior realiza as seguintes tarefas:

• Configura o registro em log e carrega variáveis de ambiente de um arquivo .env.
• Configura o cliente do Azure OpenAI usando azure-identity e openai bibliotecas.
• Inicializa um cliente MCP para interagir com o Servidor MCP do Azure (processo local) usando um transporte de E/S padrão.
• Recupera e exibe uma lista de ferramentas disponíveis (operações do Azure registradas pelo MCP) do Servidor MCP do Azure.
• Implementa um loop de conversação para processar prompts do usuário, utilizar ferramentas e gerenciar chamadas de ferramentas.

Parâmetros de configuração:

Executar e testar o aplicativo

Conclua as seguintes etapas para testar seu aplicativo Python:

1. Em uma janela de terminal aberta para a raiz do projeto, execute o seguinte comando para iniciar o aplicativo:

   python main.py
   

   Verificação de êxito: o aplicativo deve exibir uma lista das ferramentas disponíveis do Servidor MCP do Azure e, em seguida, mostrar uma Prompt: entrada.

2. Depois que o aplicativo estiver em execução, insira o seguinte prompt de teste:

   List all of the resource groups in my subscription
   

   A saída do prompt anterior deve ser semelhante ao seguinte texto:

   The following resource groups are available for your subscription:
   
   1. **DefaultResourceGroup-EUS** (Location: `eastus`)
   2. **rg-testing** (Location: `centralus`)
   3. **rg-azd** (Location: `eastus2`)
   4. **msdocs-sample** (Location: `southcentralus`)
   14. **ai-testing** (Location: `eastus2`)
   
   Let me know if you need further details or actions related to any of these resource groups!
   

3. Explore e teste as operações do MCP do Azure usando outros prompts relevantes, como:

   List all of the storage accounts in my subscription
   Get the available tables in my storage accounts
   

Próximas etapas