Introducción al servidor MCP 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 el modo de agente de Copilot de GitHub en Visual Studio Code
• Ejecución de avisos para probar las operaciones del servidor MCP de Azure e interactuar con los recursos de Azure

Prerrequisitos

• Una cuenta de Azure con una suscripción activa
• Visual Studio Code
• GitHub Copilot Extensión de Visual Studio Code

Instalación del servidor MCP de Azure

Seleccione una de las siguientes opciones para instalar el servidor MCP de Azure en Visual Studio Code:

Uso de avisos para probar el servidor MCP de Azure

1. Abra GitHub Copilot y seleccione Modo de agente.

2. Escriba un mensaje que haga que el agente use las herramientas del servidor MCP de Azure, como Enumerar mis grupos de recursos de Azure.

3. Para autenticar azure MCP Server, Copilot le pide que inicie sesión en Azure mediante el explorador.

   Nota:

   Copilot no le pedirá que inicie sesión en Azure si ya está autenticado a través de otras herramientas locales, como la CLI de Azure.

4. Copilot solicita permiso para ejecutar la operación necesaria del servidor MCP de Azure para tu solicitud. Seleccione Continuar o use la flecha para seleccionar un comportamiento más específico:

   • La sesión actual siempre ejecuta la operación en la sesión actual del modo del agente de Copilot de GitHub.
   • El área de trabajo actual siempre ejecuta el comando para el área de trabajo actual de Visual Studio Code.
   • Permitir siempre establece que la operación se ejecute siempre para cualquier sesión del modo de agente de Copilot de GitHub o cualquier área de trabajo de Visual Studio Code.

   

   La salida de la indicación 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!
   

5. 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
   

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 .NET 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
• .NET 9.0
• Node.js

Inicio de sesión para el desarrollo local

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 admitidas por 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.

Creación de la aplicación host de .NET

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

1. Abra un terminal en una carpeta vacía donde quiera crear el proyecto.

2. Ejecute el comando siguiente para crear una nueva aplicación de consola de .NET:

   dotnet new console -n MCPHostApp
   

3. Vaya a la carpeta del proyecto recién creada:

   cd MCPHostApp
   

4. Abra la carpeta del proyecto en el editor que prefiera, como Visual Studio Code:

   code .
   

Adición de las dependencias

1. En el terminal, ejecute los siguientes comandos para agregar los paquetes NuGet necesarios:

   dotnet add package Azure.AI.OpenAI --prerelease
   dotnet add package Azure.Identity
   dotnet add package Microsoft.Extensions.AI --prerelease
   dotnet add package Microsoft.Extensions.AI.OpenAI --prerelease
   dotnet add package ModelContextProtocol --prerelease
   

2. Compruebe que los paquetes se agregaron comprobando el MCPHostApp.csproj archivo.

3. Ejecute el siguiente comando para compilar el proyecto y asegurarse de que todo está configurado correctamente:

   dotnet build
   

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

Reemplace el contenido de Program.cs por el código siguiente:

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Extensions.AI;
using ModelContextProtocol.Client;
using ModelContextProtocol.Protocol.Transport;

// Create an IChatClient
IChatClient client =
    new ChatClientBuilder(
        new AzureOpenAIClient(new Uri("<your-Azure-OpenAI-endpoint>"), 
        new DefaultAzureCredential())
        .GetChatClient("gpt-4o").AsIChatClient())
    .UseFunctionInvocation()
    .Build();

// Create the MCP client
var mcpClient = await McpClientFactory.CreateAsync(
    new StdioClientTransport(new()
    {
        Command = "npx",
        Arguments = ["-y", "@azure/mcp@latest", "server", "start"],
        Name = "Azure MCP",
    }));

// Get all available tools from the MCP server
Console.WriteLine("Available tools:");
var tools = await mcpClient.ListToolsAsync();
foreach (var tool in tools)
{
    Console.WriteLine($"{tool}");
}
Console.WriteLine();

// Conversational loop that can utilize the tools
List<ChatMessage> messages = [];
while (true)
{
    Console.Write("Prompt: ");
    messages.Add(new(ChatRole.User, Console.ReadLine()));

    List<ChatResponseUpdate> updates = [];
    await foreach (var update in client
        .GetStreamingResponseAsync(messages, new() { Tools = [.. tools] }))
    {
        Console.Write(update);
        updates.Add(update);
    }
    Console.WriteLine();

    messages.AddMessages(updates);
}

El código anterior realiza las siguientes tareas:

• Inicializa una IChatClient abstracción mediante las Microsoft.Extensions.AI librerías.
• Crea un cliente MCP para interactuar con el servidor MCP de Azure mediante un transporte de E/S estándar. El comando proporcionado npx y los argumentos correspondientes descargan e inician el servidor de Azure MCP.
• Recupera y muestra una lista de herramientas disponibles del servidor MCP, que es una función de MCP estándar.
• Implementa un bucle conversacional que procesa las solicitudes del usuario y utiliza las herramientas para las respuestas.

Ejecución y prueba de la aplicación

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

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

   dotnet run
   

2. 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 indicación 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!
   

3. 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
   

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 localmente
• Node.js instalado localmente

Inicio de sesión para el desarrollo local

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 admitidas por 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.

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

1. Abra una carpeta vacía dentro del editor que prefiera.

2. Cree un nuevo archivo denominado requirements.txt y agregue las siguientes dependencias de biblioteca:

   mcp
   azure-identity
   openai
   logging
   

3. 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>
   

4. 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

1. Abra un terminal en la nueva carpeta y cree un entorno virtual de Python para la aplicación:

   python -m venv venv
   

2. Active el entorno virtual:

   venv\Scripts\activate
   

3. 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 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:

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

   python main.py
   

2. 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 indicación 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!
   

3. 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