Aan de slag met de Azure MCP-server met Python

De Azure MCP-server gebruikt het MCP (Model Context Protocol) om integraties tussen AI-apps en externe hulpprogramma's en gegevensbronnen te standaardiseren, zodat AI-systemen bewerkingen kunnen uitvoeren die contextbewust zijn voor uw Azure-resources.

In dit artikel leert u hoe u de volgende taken uitvoert:

• De Azure MCP-server installeren en verifiëren
• Verbinding maken met Azure MCP Server met behulp van een aangepaste Python-client
• Prompts uitvoeren om Bewerkingen van Azure MCP Server te testen en Azure-resources te beheren

Vereiste voorwaarden

• Een Azure-account met een actief abonnement
• Python 3.9 of hoger geïnstalleerd
• Node.js LTS geïnstalleerd

Inloggen voor lokale ontwikkeling

Azure MCP Server biedt een naadloze verificatie-ervaring met behulp van verificatie op basis van tokens via Microsoft Entra ID. Intern maakt Azure MCP Server gebruik DefaultAzureCredential van de Azure Identity-bibliotheek om gebruikers te verifiëren.

U moet zich aanmelden bij een van de hulpprogramma's die lokaal worden ondersteund door DefaultAzureCredential uw Azure-account om te kunnen werken met Azure MCP Server. Meld u aan met behulp van een terminalvenster, zoals de Visual Studio Code-terminal:

az login

Connect-AzAccount

azd auth login

Nadat u zich hebt aangemeld bij een van de voorgaande hulpprogramma's, kan Azure MCP Server uw referenties automatisch detecteren en gebruiken om bewerkingen op Azure-services te verifiëren en uit te voeren.

De Python-app maken

Voer de volgende stappen uit om een Python-app te maken. De app maakt verbinding met een AI-model en fungeert als host voor een MCP-client die verbinding maakt met een Azure MCP-server.

Het project maken

1. Open een lege map in de gewenste editor.

2. Maak een nieuw bestand met de naam requirements.txt en voeg de volgende bibliotheekafhankelijkheden toe:

   mcp
   azure-identity
   openai
   logging
   

3. Maak in dezelfde map een nieuw bestand met de naam .env en voeg de volgende omgevingsvariabelen toe:

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

4. Maak een leeg bestand met de naam main.py dat de code voor uw app bevat.

De omgeving maken en afhankelijkheden installeren

1. Open een terminal in uw nieuwe map en maak een virtuele Python-omgeving voor de app:

   python -m venv venv
   

2. De virtuele omgeving activeren:

   venv\Scripts\activate
   

3. Installeer de afhankelijkheden van requirements.txt:

   pip install -r requirements.txt
   

De app-code toevoegen

Werk de inhoud van Main.py bij met de volgende 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())

Met de voorgaande code worden de volgende taken uitgevoerd:

• Hiermee stelt u logboekregistratie in en laadt u omgevingsvariabelen uit een .env bestand.
• Hiermee configureert u de Azure OpenAI-client met behulp van azure-identity en openai bibliotheken.
• Initialiseert een MCP-client om te communiceren met de Azure MCP-server met behulp van een standaard I/O-transport.
• Hiermee wordt een lijst met beschikbare hulpprogramma's opgehaald en weergegeven van de MCP-server.
• Implementeert een gesprekslus om gebruikersprompts te verwerken, hulpprogramma's te gebruiken en hulpprogrammaaanroepen af te handelen.

De app uitvoeren en testen

Voer de volgende stappen uit om uw .NET-host-app te testen:

1. Open in een terminalvenster naar de hoofdmap van uw project, voer de volgende opdracht in om de app te starten:

   python main.py
   

2. Zodra de app wordt uitgevoerd, voert u de volgende testprompt in:

   List all of the resource groups in my subscription
   

   De uitvoer voor de vorige prompt moet eruitzien als de volgende tekst:

   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. Verken en test de Azure MCP-bewerkingen met behulp van andere relevante prompts, zoals:

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

Volgende stappen