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

Hinweis

Die Azure-Ressourcen, auf die Sie mit Azure MCP Server zugreifen möchten, müssen bereits in Ihrem Azure-Abonnement vorhanden sein. Darüber hinaus muss Ihr Benutzerkonto über die erforderlichen RBAC-Rollen und Berechtigungen für diese Ressourcen verfügen.

Azure MCP Server bietet eine nahtlose Authentifizierung mithilfe der tokenbasierten Authentifizierung über Microsoft Entra ID. Intern verwendet DefaultAzureCredential Azure MCP Server aus der Azure Identity-Bibliothek , um Benutzer zu authentifizieren.

Sie müssen sich bei einem der Tools anmelden, die von DefaultAzureCredential Ihrem Azure-Konto unterstützt werden, um mit Azure MCP Server zu arbeiten. Melden Sie sich mit einem Terminalfenster an, z. B. dem Visual Studio Code-Terminal:

az login

Connect-AzAccount

azd auth login

Nachdem Sie sich erfolgreich bei einem der vorherigen Tools angemeldet haben, kann Azure MCP Server Ihre Anmeldeinformationen automatisch ermitteln und zum Authentifizieren und Ausführen von Vorgängen für Azure-Dienste verwenden.

Hinweis

Sie können sich auch über Visual Studio bei Azure anmelden. Azure MCP Server kann nur Vorgänge ausführen, für die der angemeldete Benutzer über Berechtigungen zum Ausführen verfügt.

Erstellen der Python-App

Führen Sie die folgenden Schritte aus, um eine Python-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.

Erstellen des Projekts

Öffnen Sie einen leeren Ordner in Ihrem Editor der Wahl.
Erstellen Sie eine neue Datei namens requirements.txt , und fügen Sie die folgenden Bibliotheksabhängigkeiten hinzu:
```
mcp
azure-identity
openai
logging
```
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>
```
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

Öffnen Sie ein Terminal in Ihrem neuen Ordner, und erstellen Sie eine virtuelle Python-Umgebung für die App:
```
python -m venv venv
```
Aktivieren Sie die virtuelle Umgebung:
```
venv\Scripts\activate
```
Installieren Sie die Abhängigkeiten von requirements.txt:
```
pip install -r requirements.txt
```

Hinzufügen des App-Codes

Aktualisieren Sie den Inhalt mit Main.py 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 protokollierungs- und lädt Umgebungsvariablen aus einer .env Datei ein.
Konfiguriert den Azure OpenAI-Client mithilfe azure-identity und openai Bibliotheken.
Initialisiert einen MCP-Client für die Interaktion mit dem Azure MCP-Server mithilfe eines standardmäßigen E/A-Transports.
Ruft eine Liste der verfügbaren Tools vom MCP-Server ab und zeigt sie an.
Implementiert eine Unterhaltungsschleife, um Benutzeraufforderungen zu verarbeiten, Tools zu nutzen und Toolaufrufe zu verarbeiten.

Ausführen und Testen der App

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

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
```

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!

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

Weitere Informationen zu Azure MCP Server-Tools

Feedback

War diese Seite hilfreich?

Last updated on 2025-08-20