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

Observação

Os recursos do Azure que você pretende acessar com o Servidor MCP do Azure já devem existir em sua assinatura do Azure. Além disso, sua conta de usuário deve ter as funções e permissões rbac necessárias atribuídas a esses recursos.

O Servidor MCP do Azure fornece uma experiência de autenticação perfeita usando a autenticação baseada em token por meio da ID do Microsoft Entra. Internamente, o Servidor MCP do Azure usa da biblioteca de Identidade do DefaultAzureCredentialAzure para autenticar usuários.

Você precisa entrar em uma das ferramentas compatíveis DefaultAzureCredential localmente com sua conta do Azure para trabalhar com o Servidor MCP do Azure. Entre usando uma janela de terminal, como o terminal do Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Depois de entrar com êxito em uma das ferramentas anteriores, o Servidor MCP do Azure pode descobrir automaticamente suas credenciais e usá-las para autenticar e executar operações nos serviços do Azure.

Observação

Você também pode entrar no Azure por meio do Visual Studio. O Servidor MCP do Azure só é capaz de executar operações que o usuário conectado tem permissões para executar.

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

Abra uma pasta vazia dentro do editor de sua escolha.
Crie um novo arquivo nomeado requirements.txt e adicione as seguintes dependências de biblioteca:
```
mcp
azure-identity
openai
logging
```

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>

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

Criar o ambiente e instalar dependências

Abra um terminal em sua nova pasta e crie um ambiente virtual python para o aplicativo:
```
python -m venv venv
```
Ative o ambiente virtual:
```
venv\Scripts\activate
```
Instale as dependências de requirements.txt:
```
pip install -r requirements.txt
```

Adicionar o código do aplicativo

Atualize o conteúdo com main.py 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 .env arquivo.
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 para processar prompts do usuário, utilizar ferramentas e manipular chamadas de ferramentas.

Parâmetros de configuração:

Parâmetro	Description	Example
`AZURE_OPENAI_ENDPOINT`	Seu ponto de extremidade de serviço do Azure OpenAI	`https://your-resource.openai.azure.com/`
`AZURE_OPENAI_MODEL`	Nome da implantação do modelo	`gpt-4o`
Escopo do token	Escopo do OAuth dos Serviços Cognitivos do Azure	`https://cognitiveservices.azure.com/.default`
Autenticação	`DefaultAzureCredential` Usa (CLI do Azure, identidade gerenciada ou outra cadeia de credenciais)	Consulte a documentação do Azure Identity
RBAC necessário	Função de usuário dos Serviços Cognitivos ou equivalente no recurso do Azure OpenAI	Atribuído por meio do portal ou da CLI do Azure

Executar e testar o aplicativo

Conclua as seguintes etapas para testar seu aplicativo Python:

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.

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!

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

Saiba mais sobre as ferramentas do Servidor MCP do Azure

Comentários

Esta página foi útil?

Last updated on 2025-12-13