Kom igång med Azure MCP Server

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 hjälp av GitHub Copilot-agentläget i Visual Studio Code
Kör uppmaningar om att testa Azure MCP Server-åtgärder och interagera med Azure-resurser

Förutsättningar

Ett Azure-konto med en aktiv prenumeration
Visual Studio Code
GitHub Copilot Visual Studio Code-tillägg

Anmärkning

De Azure-resurser som du tänker komma åt med Azure MCP Server måste redan finnas i din Azure-prenumeration. Dessutom måste ditt användarkonto ha nödvändiga RBAC-roller och behörigheter tilldelade för dessa resurser.

Installera Azure MCP Server

Välj något av följande alternativ för att installera Azure MCP Server i Visual Studio Code:

Global installation
Kataloginstallation

Om du vill installera Azure MCP Server för Visual Studio Code i användarinställningarna väljer du följande länk:

En lista över installationsalternativ öppnas i Visual Studio Code. Välj Installera server för att lägga till serverkonfigurationen i dina användarinställningar.
Öppna GitHub Copilot och välj Agentläge. Mer information om Agent Mode finns i Visual Studio Code-dokumentationen.
Uppdatera verktygslistan för att se Azure MCP Server som ett tillgängligt alternativ:

Du kan också installera Azure MCP Server manuellt för en specifik katalog:

Öppna en tom katalog eller en befintlig projektkatalog i Visual Studio Code.
Skapa en .vscode mapp vid roten av mappen om det inte redan finns en.

.vscode I mappen skapar du en ny fil med namnet mcp.json lägg till följande JSON:

{
  "servers": {
    "Azure MCP Server": {
      "command": "npx",
      "args": [
        "-y",
        "@azure/mcp@latest",
        "server",
        "start"
      ]
    }
  }
}

Spara ändringarna i mcp.json.
Öppna GitHub Copilot och välj Agentläge.
Välj verktygsikonen för att visa de tillgängliga verktygen. Sök efter Azure MCP Server för att filtrera resultatet.

Mer information om Agent Mode finns i Visual Studio Code-dokumentationen.

Använd anvisningarna för att testa Azure MCP-servern

Öppna GitHub Copilot och välj Agentläge.
Ange en uppmaning som gör att agenten använder Azure MCP Server-verktyg, till exempel Lista mina Azure-resursgrupper.
För att autentisera Azure MCP Server uppmanar Copilot dig att logga in på Azure med hjälp av webbläsaren.

Anmärkning

Copilot uppmanar dig inte att logga in på Azure om du redan har autentiserats via andra lokala verktyg som Azure CLI.
Copilot begär behörighet att köra den nödvändiga Azure MCP Server-åtgärden för din fråga. Välj Fortsätt eller använd pilen för att välja ett mer specifikt beteende:
- Den aktuella sessionen kör alltid åtgärden i den aktuella GitHub Copilot-agentlägessessionen.
- Den aktuella arbetsytan kör alltid kommandot för den aktuella Visual Studio Code-arbetsytan.
- Tillåt alltid att åtgärden alltid körs för alla GitHub Copilot-agentlägessessioner eller visual Studio Code-arbetsytor.
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!
```

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

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

Anmärkning

De Azure-resurser som du tänker komma åt med Azure MCP Server måste redan finnas i din Azure-prenumeration. Dessutom måste ditt användarkonto ha nödvändiga RBAC-roller och behörigheter tilldelade för dessa resurser.

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

Du måste logga in lokalt på något av de verktyg som stöds av 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.

Anmärkning

Du kan också logga in på Azure via Visual Studio. Azure MCP Server kan bara köra åtgärder som den inloggade användaren har behörighet att utföra.

Skapa .NET-värdappen

Slutför följande steg för att skapa en .NET-konsolapp. 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

Öppna en terminal till en tom mapp där du vill skapa projektet.
Kör följande kommando för att skapa ett nytt .NET-konsolprogram:
```
dotnet new console -n MCPHostApp
```
Navigera till den nyligen skapade projektmappen:
```
cd MCPHostApp
```
Öppna projektmappen i valfri redigerare, till exempel Visual Studio Code:
```
code .
```

Lägg till beroendena

I terminalen kör du följande kommandon för att lägga till nödvändiga NuGet-paket:

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

Kontrollera att paketen har lagts till genom att kontrollera MCPHostApp.csproj filen.
Kör följande kommando för att skapa projektet och se till att allt är korrekt konfigurerat:
```
dotnet build
```

Lägg till appkoden

Ersätt innehållet i Program.cs med följande kod:

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);
}

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

Initierar en IChatClient abstraktion med hjälp av biblioteken Microsoft.Extensions.AI .
Skapar en MCP-klient för att interagera med Azure MCP Server med hjälp av en vanlig I/O-transport. Det angivna npx kommandot och motsvarande argument laddar ned och startar Azure MCP-servern.
Hämtar och visar en lista över tillgängliga verktyg från MCP-servern, som är en mcp-standardfunktion.
Implementerar en konversationsloop som bearbetar användarens frågor och använder verktygen för svar.

Köra och testa appen

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

Kör följande kommando i ett terminalfönster som är öppet för projektets rot för att starta appen:
```
dotnet run
```

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!

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

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 lokalt
Node.js installerat lokalt

Anmärkning

De Azure-resurser som du tänker komma åt med Azure MCP Server måste redan finnas i din Azure-prenumeration. Dessutom måste ditt användarkonto ha nödvändiga RBAC-roller och behörigheter tilldelade för dessa resurser.

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

Du måste logga in lokalt på något av de verktyg som stöds av 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.

Anmärkning

Du kan också logga in på Azure via Visual Studio. Azure MCP Server kan bara köra åtgärder som den inloggade användaren har behörighet att utföra.

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

Öppna en tom mapp i valfri redigerare.
Skapa en ny fil med namnet requirements.txt och lägg till följande biblioteksberoenden:
```
mcp
azure-identity
openai
logging
```

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>

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

Skapa miljön och installera beroenden

Öppna en terminal i den nya mappen och skapa en virtuell Python-miljö för appen:
```
python -m venv venv
```
Aktivera den virtuella miljön:
```
venv\Scripts\activate
```
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ärdprogrammet:

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

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!

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

Dela via

Förutsättningar

Installera Azure MCP Server

Använd anvisningarna för att testa Azure MCP-servern

Förutsättningar

Logga in för lokal utveckling

Skapa .NET-värdappen

Skapa projektet

Lägg till beroendena

Lägg till appkoden

Köra och testa appen

Förutsättningar

Logga in för lokal utveckling

Skapa Python-appen

Skapa projektet

Skapa miljön och installera beroenden

Lägg till appkoden

Köra och testa appen

Nästa steg

Feedback

Ytterligare resurser