Erste Schritte mit dem Azure MCP-Server mit Python

Der Azure MCP-Server verwendet das Model Context Protocol (MCP), um Integrationen zwischen KI-Apps und externen Tools und Datenquellen zu standardisieren, sodass KI-Systeme Vorgänge ausführen können, die kontextbewusst von Ihren Azure-Ressourcen sind.

In diesem Artikel erfahren Sie, wie Sie die folgenden Aufgaben ausführen:

• Installieren und Authentifizieren beim Azure MCP-Server
• Herstellen einer Verbindung mit Azure MCP Server mithilfe eines benutzerdefinierten Python-Clients
• Ausführen von Eingabeaufforderungen zum Testen von Azure MCP Server-Vorgängen und Verwalten von Azure-Ressourcen

Voraussetzungen

• Ein Azure-Konto mit einem aktiven Abonnement
• Python 3.9 oder höher installiert
• Node.js LTS installiert

Anmelden bei Azure MCP Server für die lokale Entwicklung

Azure MCP Server authentifiziert sich bei Microsoft Entra ID mithilfe der Azure Identity-Bibliothek für .NET. Der Server unterstützt zwei Authentifizierungsmodi:

• Brokermodus: Verwendet die systemeigene Authentifizierung Ihres Betriebssystems (z. B. Windows Web Account Manager) mit InteractiveBrowserCredential.
• Modus der Anmeldeinformationskette: Es wird versucht, mehrere Authentifizierungsmethoden in einer festgelegten Reihenfolge zu verwenden: Umgebungsvariablen, Visual Studio Code, Visual Studio, Azure CLI, Azure PowerShell, Azure Developer CLI und interaktive Browserauthentifizierung.

Melden Sie sich mit einer der folgenden Methoden an:

az login

Connect-AzAccount

azd auth login

Nach der Anmeldung kann Azure MCP Server Vorgänge für Azure-Dienste basierend auf Ihren Berechtigungen authentifizieren und ausführen.

Erstellen der Python-App

Führen Sie die folgenden Schritte aus, um eine Python-App (Host-App) zu erstellen. Die App stellt eine Verbindung mit einem KI-Modell her und fungiert als Host für einen MCP-Client, der eine Verbindung mit einem Azure MCP-Server herstellt (lokaler Prozess, der das MCP-Protokoll ausführt).

Erstellen des Projekts

1. Öffnen Sie einen leeren Ordner in Ihrem Editor der Wahl.

2. Erstellen Sie eine neue Datei namens requirements.txt , und fügen Sie die folgenden Bibliotheksabhängigkeiten hinzu:

   mcp
   azure-identity
   openai
   logging
   

3. Erstellen Sie im selben Ordner eine neue Datei mit dem Namen .env , und fügen Sie die folgenden Umgebungsvariablen hinzu:

   AZURE_OPENAI_ENDPOINT=<your-azure-openai-endpoint>
   AZURE_OPENAI_MODEL=<your-model-deployment-name>
   

4. Erstellen Sie eine leere Datei mit dem Namen main.py , um den Code für Ihre App zu speichern.

Erstellen der Umgebung und Installieren von Abhängigkeiten

1. Öffnen Sie ein Terminal in Ihrem neuen Ordner, und erstellen Sie eine virtuelle Python-Umgebung für die App:

   python -m venv venv
   

2. Aktivieren Sie die virtuelle Umgebung:

   venv\Scripts\activate
   

3. Installieren Sie die Abhängigkeiten von requirements.txt:

   pip install -r requirements.txt
   

Hinzufügen des App-Codes

Aktualisieren Sie die Inhalte von main.py mit dem folgenden Code:

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

Der vorangehende Code führt die folgenden Aufgaben aus:

• Richtet die Protokollierung ein und lädt Umgebungsvariablen aus einer .env-Datei.
• Konfiguriert den Azure OpenAI-Client mithilfe azure-identity und openai Bibliotheken.
• Initialisiert einen MCP-Client für die Interaktion mit dem Azure MCP-Server (lokaler Prozess) mithilfe eines standardmäßigen E/A-Transports.
• Ruft eine Liste der verfügbaren Tools (MCP-registrierte Azure-Vorgänge) vom Azure MCP-Server ab und zeigt sie an.
• Implementiert eine Unterhaltungsschleife, um Benutzeraufforderungen zu verarbeiten, Tools zu nutzen und Toolaufrufe zu verarbeiten.

Konfigurationsparameter:

Ausführen und Testen der App

Führen Sie die folgenden Schritte aus, um Ihre Python-App zu testen:

1. Führen Sie in einem Terminalfenster, das im Stammverzeichnis Ihres Projekts geöffnet ist, den folgenden Befehl aus, um die App zu starten:

   python main.py
   

   Erfolgsüberprüfung: Die App sollte eine Liste der verfügbaren Azure MCP Server-Tools anzeigen und dann eine Prompt: Eingabe anzeigen.

2. Sobald die App ausgeführt wird, geben Sie die folgende Testaufforderung ein:

   List all of the resource groups in my subscription
   

   Die Ausgabe für die vorherige Eingabeaufforderung sollte dem folgenden Text ähneln:

   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. Erkunden und testen Sie die Azure MCP-Vorgänge mithilfe anderer relevanter Eingabeaufforderungen, z. B.:

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

Nächste Schritte