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

O Servidor MCP do Azure usa o Protocolo de Contexto de Modelo (MCP) para padronizar integrações entre aplicativos de IA e ferramentas externas e fontes de dados, permitindo que os sistemas de IA executem operações sensíveis ao contexto de seus 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 subscrição ativa
Python 3.9 ou superior instalado
Node.js LTS instalado

Observação

Os recursos do Azure que você pretende acessar com o Azure MCP Server 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 para esses recursos.

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

Tem de iniciar sessão numa das ferramentas suportadas localmente DefaultAzureCredential com a sua conta do Azure para trabalhar com o Azure MCP Server. Entre usando uma janela de terminal, como o terminal de código do Visual Studio:

CLI do Azure
Azure PowerShell
CLI do Azure para Desenvolvedores

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

Também pode iniciar sessão no Azure através do Visual Studio. O Servidor MCP do Azure só pode executar operações que o utilizador com sessão iniciada tem permissões para executar.

Criar o aplicativo Python

Conclua as etapas a seguir para criar um aplicativo Python. 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.

Criar o projeto

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

Na mesma pasta, crie um novo arquivo chamado .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 seu 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 a partir de requirements.txt:
```
pip install -r requirements.txt
```

Adicionar o código do aplicativo

Atualize o conteúdo do 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 registo e carrega variáveis de ambiente de um .env ficheiro.
Configura o cliente OpenAI do Azure usando azure-identity e openai bibliotecas.
Inicializa um cliente MCP para interagir com o Servidor MCP do Azure usando um transporte de E/S padrão.
Recupera e exibe uma lista de ferramentas disponíveis do servidor MCP.
Implementa um loop de conversação para processar solicitações do usuário, utilizar ferramentas e lidar com chamadas de ferramentas.

Executar e testar o aplicativo

Conclua as seguintes etapas para testar seu aplicativo host .NET:

Em uma janela de terminal aberta para a raiz do seu projeto, execute o seguinte comando para iniciar o aplicativo:
```
python main.py
```

Quando o aplicativo estiver em execução, digite o seguinte prompt de teste:

List all of the resource groups in my subscription

A saída para o 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 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óximos passos

Saiba mais sobre as ferramentas do Azure MCP Server

Comentários

Esta página foi útil?

Last updated on 2025-08-20