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 proporciona una experiencia de autenticación sin problemas mediante la autenticación basada en tokens a través de Microsoft Entra ID. Internamente, Azure MCP Server usa DefaultAzureCredential desde la biblioteca de identidades de Azure para autenticar a los usuarios.

Debe iniciar sesión en una de las herramientas compatibles DefaultAzureCredential localmente con su cuenta de Azure para trabajar con Azure MCP Server. Inicie sesión con una ventana de terminal, como el terminal de Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Una vez que haya iniciado sesión correctamente en una de las herramientas anteriores, Azure MCP Server puede detectar automáticamente las credenciales y usarlas para autenticar y realizar operaciones en los servicios de Azure.

Nota:

También puede iniciar sesión en Azure a través de Visual Studio. Azure MCP Server solo puede ejecutar operaciones que el usuario que ha iniciado sesión tiene permisos para realizar.

Crear la aplicación de Python

Complete los pasos siguientes para crear una aplicación de Python. 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.

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 mediante azure-identity bibliotecas y openai .
Inicializa un cliente MCP para interactuar con el servidor MCP de Azure mediante un transporte de E/S estándar.
Recupera y muestra una lista de herramientas disponibles del servidor MCP.
Implementa un bucle conversacional para procesar las solicitudes del usuario, usar herramientas y controlar llamadas a herramientas.

Ejecución y prueba de la aplicación

Complete los pasos siguientes para probar la aplicación host de .NET:

En una ventana de terminal abierta a la raíz del proyecto, ejecute el siguiente comando para iniciar la aplicación:
```
python main.py
```

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

List all of the resource groups in my subscription

La salida 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

Comentarios

¿Le resultó útil esta página?

Last updated on 2025-08-20