Kom igång med Azure MCP Server med Python

Azure MCP Server använder Model Context Protocol (MCP) för att standardisera integreringar mellan AI-appar och externa verktyg och datakällor, vilket gör det möjligt för AI-system att utföra åtgärder som är sammanhangsmedvetna om dina Azure-resurser.

I den här artikeln får du lära dig hur du utför följande uppgifter:

• Installera och autentisera till Azure MCP Server
• Ansluta till Azure MCP Server med en anpassad Python-klient
• Kör uppmaningar för att testa Azure MCP Server-åtgärder och hantera Azure-resurser

Förutsättningar

• Ett Azure-konto med en aktiv prenumeration
• Python 3.9 eller senare installerat
• Node.js LTS installerat

Logga in för lokal utveckling

Azure MCP Server ger en sömlös autentiseringsupplevelse med tokenbaserad autentisering via Microsoft Entra-ID. Internt använder DefaultAzureCredential Azure MCP Server från Azure Identity-biblioteket för att autentisera användare.

Du måste logga in på något av de verktyg som stöds lokalt DefaultAzureCredential med ditt Azure-konto för att arbeta med Azure MCP Server. Logga in med ett terminalfönster, till exempel Visual Studio Code-terminalen:

az login

Connect-AzAccount

azd auth login

När du har loggat in på något av ovanstående verktyg kan Azure MCP Server automatiskt identifiera dina autentiseringsuppgifter och använda dem för att autentisera och utföra åtgärder på Azure-tjänster.

Skapa Python-appen

Slutför följande steg för att skapa en Python-app. Appen ansluter till en AI-modell och fungerar som värd för en MCP-klient som ansluter till en Azure MCP-server.

Skapa projektet

1. Öppna en tom mapp i valfri redigerare.

2. Skapa en ny fil med namnet requirements.txt och lägg till följande biblioteksberoenden:

   mcp
   azure-identity
   openai
   logging
   

3. I samma mapp skapar du en ny fil med namnet .env och lägger till följande miljövariabler:

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

4. Skapa en tom fil med namnet main.py för att lagra koden för din app.

Skapa miljön och installera beroenden

1. Öppna en terminal i den nya mappen och skapa en virtuell Python-miljö för appen:

   python -m venv venv
   

2. Aktivera den virtuella miljön:

   venv\Scripts\activate
   

3. Installera beroendena från requirements.txt:

   pip install -r requirements.txt
   

Lägg till appkoden

Uppdatera innehållet i Main.py med följande kod:

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

Föregående kod utför följande uppgifter:

• Konfigurerar loggning och läser in miljövariabler från en .env fil.
• Konfigurerar Azure OpenAI-klienten med hjälp av azure-identity och openai bibliotek.
• Initierar en MCP-klient för att interagera med Azure MCP-servern med hjälp av en standard-I/O-transport.
• Hämtar och visar en lista över tillgängliga verktyg från MCP-servern.
• Implementerar en konversationsloop för att bearbeta användarfrågor, använda verktyg och hantera verktygsanrop.

Köra och testa appen

Utför följande steg för att testa .NET-värdappen:

1. Kör följande kommando i ett terminalfönster som är öppet för projektets rot för att starta appen:

   python main.py
   

2. När appen har körts anger du följande testprompt:

   List all of the resource groups in my subscription
   

   Utdata för föregående fråga bör likna följande text:

   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. Utforska och testa Azure MCP-åtgärder med hjälp av andra relevanta frågor, till exempel:

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

Nästa steg