Introducción al uso del servidor MCP de Azure con Python

El servidor MCP de Azure usa el Protocolo de contexto de modelo (MCP) para estandarizar las integraciones entre las aplicaciones de IA y las herramientas externas y los orígenes de datos, lo que permite a los sistemas de inteligencia artificial realizar operaciones que tienen en cuenta el contexto de los recursos de Azure.

En este artículo, aprenderá a completar las siguientes tareas:

Instalación y autenticación en el servidor MCP de Azure
Conexión al servidor MCP de Azure mediante un cliente de Python personalizado
Ejecución de avisos para probar las operaciones del servidor MCP de Azure y administrar recursos de Azure

Prerrequisitos

Una cuenta de Azure con una suscripción activa
Python 3.9 o posterior instalado
Node.js LTS instalado

Nota:

Los recursos de Azure a los que pretende acceder con azure MCP Server ya deben existir dentro de la suscripción de Azure. Además, la cuenta de usuario debe tener asignados los roles y permisos de RBAC necesarios para esos recursos.

Azure MCP Server se autentica con Microsoft Entra ID mediante la biblioteca de identidad de Azure para .NET. El servidor admite dos modos de autenticación:

Modo de agente: usa la autenticación nativa del sistema operativo (como el Administrador de cuentas web de Windows) con InteractiveBrowserCredential.
Modo de cadena de credenciales: intenta varios métodos de autenticación en secuencia: variables de entorno, Visual Studio Code, Visual Studio, CLI de Azure, Azure PowerShell, CLI para desarrolladores de Azure y autenticación interactiva del explorador.

Inicie sesión con cualquiera de estos métodos:

Abra la paleta de comandos (Ctrl+Shift+P o Cmd+Shift+P en Mac).
Ejecución de Azure: inicie sesión y siga las indicaciones.

az login

Connect-AzAccount

azd auth login

Después de iniciar sesión, Azure MCP Server puede autenticar y ejecutar operaciones en los servicios de Azure en función de los permisos.

Crear la aplicación de Python

Complete los pasos siguientes para crear una aplicación de Python (aplicación host). La aplicación se conecta a un modelo de IA y actúa como host para un cliente MCP que se conecta a un servidor de Azure MCP (proceso local que ejecuta el protocolo MCP).

Creación del proyecto

Abra una carpeta vacía dentro del editor que prefiera.
Cree un nuevo archivo denominado requirements.txt y agregue las siguientes dependencias de biblioteca:
```
mcp
azure-identity
openai
logging
```
En la misma carpeta, cree un nuevo archivo denominado .env y agregue las siguientes variables de entorno:
```
AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
AZURE_OPENAI_MODEL=<your-model-deployment-name>
```
Cree un archivo vacío denominado main.py para contener el código de la aplicación.

Creación del entorno e instalación de dependencias

Abra un terminal en la nueva carpeta y cree un entorno virtual de Python para la aplicación:
```
python -m venv venv
```
Active el entorno virtual:
```
venv\Scripts\activate
```
Instale las dependencias desde requirements.txt:
```
pip install -r requirements.txt
```

Adición del código de la aplicación

Actualice el contenido de main.py con el código siguiente:

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())

El código anterior realiza las siguientes tareas:

Configura el registro y carga las variables de entorno desde un .env archivo.
Configura el cliente de Azure OpenAI utilizando las bibliotecas azure-identity y openai.
Inicializa un cliente MCP para interactuar con el servidor de Azure MCP (proceso local) mediante un transporte de E/S estándar.
Recupera y muestra una lista de herramientas disponibles (operaciones de Azure registradas por MCP) del servidor de Azure MCP.
Implementa un bucle conversacional para procesar las solicitudes del usuario, usar herramientas y controlar llamadas a herramientas.

Parámetros de configuración:

Parámetro	Description	Example
`AZURE_OPENAI_ENDPOINT`	El punto de conexión del servicio Azure OpenAI	`https://your-resource.openai.azure.com/`
`AZURE_OPENAI_MODEL`	Nombre de implementación del modelo	`gpt-4o`
Ámbito del token	Ámbito de OAuth de Azure Cognitive Services	`https://cognitiveservices.azure.com/.default`
Autenticación	Usa `DefaultAzureCredential` (Azure CLI, identidad administrada u otra cadena de credenciales)	Consulte la documentación de Azure Identity.
RBAC obligatorio	Rol de usuario de Cognitive Services o equivalente en el recurso de Azure OpenAI	Asignado a través de Azure Portal o la CLI

Ejecución y prueba de la aplicación

Complete los pasos siguientes para probar la aplicación de Python:

En una ventana de terminal abierta a la raíz del proyecto, ejecute el siguiente comando para iniciar la aplicación:
```
python main.py
```
Verificación exitosa: la aplicación debe mostrar una lista de las herramientas disponibles de Azure MCP Server y, a continuación, mostrar un campo de Prompt: entrada.

Una vez que se esté ejecutando la aplicación, escriba el siguiente mensaje de prueba:

List all of the resource groups in my subscription

El resultado de la solicitud anterior debe ser similar al texto siguiente:

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 y pruebe las operaciones de Azure MCP mediante otras solicitudes pertinentes, como:

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

Pasos siguientes

Más información sobre las herramientas de Azure MCP Server

Retroalimentació

Ha estat útil aquesta pàgina?

Last updated on 2026-02-12