Rozpoczynanie pracy z serwerem MCP platformy Azure

Z tego artykułu dowiesz się, jak wykonać następujące zadania:

Instalowanie i uwierzytelnianie na serwerze usługi Azure MCP
Nawiązywanie połączenia z serwerem MCP platformy Azure przy użyciu trybu agenta GitHub Copilot w programie Visual Studio Code
Uruchom monity, aby przetestować operacje serwera MCP platformy Azure i wchodzić w interakcje z zasobami platformy Azure

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją
Visual Studio Code
GitHub Copilot Rozszerzenie programu Visual Studio Code

Uwaga / Notatka

Zasoby platformy Azure, do których zamierzasz uzyskać dostęp za pomocą serwera Azure MCP, muszą już istnieć w ramach subskrypcji platformy Azure. Ponadto konto użytkownika musi mieć przypisane niezbędne role i uprawnienia RBAC dla tych zasobów.

Instalowanie serwera usługi Azure MCP

Wybierz jedną z następujących opcji, aby zainstalować serwer Azure MCP w programie Visual Studio Code:

Instalacja globalna
Instalacja katalogu

Aby zainstalować program Azure MCP Server for Visual Studio Code w ustawieniach użytkownika, wybierz następujący link:

Zostanie otwarta lista opcji instalacji w programie Visual Studio Code. Wybierz pozycję Zainstaluj serwer , aby dodać konfigurację serwera do ustawień użytkownika.
Otwórz narzędzie GitHub Copilot i wybierz pozycję Tryb agenta. Aby dowiedzieć się więcej na temat trybu agenta, odwiedź dokumentację programu Visual Studio Code.
Odśwież listę narzędzi, aby wyświetlić serwer Azure MCP jako dostępną opcję:

Możesz również ręcznie zainstalować serwer Azure MCP dla określonego katalogu:

Otwórz pusty katalog lub istniejący katalog projektu w programie Visual Studio Code.
Jeśli jeszcze go nie ma, utwórz folder .vscode w folderze głównym.

W folderze .vscode utwórz nowy plik o nazwie mcp.json dodaj następujący kod JSON:

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

Zapisz zmiany w pliku mcp.json.
Otwórz narzędzie GitHub Copilot i wybierz pozycję Tryb agenta.
Wybierz ikonę narzędzi, aby wyświetlić dostępne narzędzia. Wyszukaj pozycję Azure MCP Server , aby filtrować wyniki.

Aby dowiedzieć się więcej na temat trybu agenta, odwiedź dokumentację programu Visual Studio Code.

Użyj monitów, aby przetestować serwer usługi Azure MCP

Otwórz narzędzie GitHub Copilot i wybierz pozycję Tryb agenta.
Wprowadź monit, który powoduje, że agent korzysta z narzędzi serwera MCP platformy Azure, takich jak Wyświetlanie listy grup zasobów platformy Azure.
Aby uwierzytelnić serwer MCP platformy Azure, Copilot monituje o zalogowanie się do platformy Azure przy użyciu przeglądarki.

Uwaga / Notatka

Narzędzie Copilot nie wyświetli monitu o zalogowanie się do platformy Azure, jeśli już uwierzytelniono się za pomocą innych lokalnych narzędzi, takich jak interfejs wiersza polecenia platformy Azure.
Copilot prosi o pozwolenie na uruchomienie niezbędnej operacji serwera platformy Azure MCP dla Twojego monitu. Wybierz pozycję Kontynuuj lub użyj strzałki, aby wybrać bardziej szczegółowe zachowanie:
- Bieżąca sesja zawsze wykonuje operację w trybie agenta Copilot GitHub.
- Bieżący obszar roboczy zawsze uruchamia polecenie dla bieżącego obszaru roboczego programu Visual Studio Code.
- Zawsze zezwalaj ustawia operację na zawsze działającą w każdej sesji trybu agenta Copilot usługi GitHub lub w dowolnym obszarze roboczym Visual Studio Code.
Dane wyjściowe poprzedniego monitu powinny przypominać następujący 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!
```
Eksploruj i przetestuj operacje mcp platformy Azure przy użyciu innych odpowiednich monitów, takich jak:
```
List all of the storage accounts in my subscription
Get the available tables in my storage accounts
```

Z tego artykułu dowiesz się, jak wykonać następujące zadania:

Instalowanie i uwierzytelnianie na serwerze usługi Azure MCP
Nawiązywanie połączenia z serwerem MCP platformy Azure przy użyciu niestandardowego klienta platformy .NET
Uruchom monity, aby przetestować operacje serwera MCP platformy Azure i zarządzać zasobami platformy Azure

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją
.NET 9.0
Node.js

Uwaga / Notatka

Zasoby platformy Azure, do których zamierzasz uzyskać dostęp za pomocą serwera Azure MCP, muszą już istnieć w ramach subskrypcji platformy Azure. Ponadto konto użytkownika musi mieć przypisane niezbędne role i uprawnienia RBAC dla tych zasobów.

Serwer MCP platformy Azure zapewnia bezproblemowe uwierzytelnianie przy użyciu uwierzytelniania opartego na tokenach za pośrednictwem identyfikatora Entra firmy Microsoft. Wewnętrznie serwer usługi Azure MCP używa z DefaultAzureCredentialbiblioteki tożsamości platformy Azure do uwierzytelniania użytkowników.

Aby móc pracować z serwerem MCP platformy Azure, musisz lokalnie zalogować się do jednego z narzędzi obsługiwanych przez DefaultAzureCredential, używając konta platformy Azure. Zaloguj się przy użyciu okna terminalu, takiego jak terminal programu Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Po pomyślnym zalogowaniu się do jednego z powyższych narzędzi serwer usługi Azure MCP może automatycznie odnajdywać poświadczenia i używać ich do uwierzytelniania i wykonywania operacji na usługach platformy Azure.

Uwaga / Notatka

Możesz również zalogować się do platformy Azure za pomocą programu Visual Studio. Serwer MCP platformy Azure może uruchamiać tylko operacje, które zalogowany użytkownik ma uprawnienia do wykonania.

Tworzenie aplikacji hosta platformy .NET

Wykonaj poniższe kroki, aby utworzyć aplikację konsolową platformy .NET. Aplikacja łączy się z modelem AI i działa jako host dla klienta MCP, który nawiązuje połączenie z serwerem MCP platformy Azure.

Tworzenie projektu

Otwórz terminal w pustym folderze, w którym chcesz utworzyć projekt.
Uruchom następujące polecenie, aby utworzyć nową aplikację konsolową platformy .NET:
```
dotnet new console -n MCPHostApp
```
Przejdź do nowo utworzonego folderu projektu:
```
cd MCPHostApp
```
Otwórz folder projektu w wybranym edytorze, na przykład Visual Studio Code:
```
code .
```

Dodawanie zależności

W terminalu uruchom następujące polecenia, aby dodać niezbędne pakiety NuGet:

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

Sprawdź, czy pakiety zostały dodane, sprawdzając MCPHostApp.csproj plik.
Uruchom następujące polecenie, aby skompilować projekt i upewnić się, że wszystko jest poprawnie skonfigurowane:
```
dotnet build
```

Dodawanie kodu aplikacji

Zastąp zawartość Program.cs następującym kodem:

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

Powyższy kod wykonuje następujące zadania:

Inicjuje IChatClient abstrakcję za pomocą Microsoft.Extensions.AI bibliotek.
Tworzy klienta MCP do interakcji z serwerem McP platformy Azure przy użyciu standardowego transportu we/wy. Podane npx polecenie i odpowiednie argumenty pobierają i uruchamiają serwer MCP platformy Azure.
Pobiera i wyświetla listę dostępnych narzędzi z serwera MCP, który jest standardową funkcją MCP.
Implementuje pętlę konwersacyjną, która przetwarza zapytania użytkownika i używa narzędzi do generowania odpowiedzi.

Uruchamianie i testowanie aplikacji

Wykonaj następujące kroki, aby przetestować aplikację hosta .NET.

W oknie terminalu otwartym w katalogu głównym projektu uruchom następujące polecenie, aby uruchomić aplikację:
```
dotnet run
```

Po uruchomieniu aplikacji wprowadź następujący monit testowy:

List all of the resource groups in my subscription

Dane wyjściowe poprzedniego monitu powinny przypominać następujący 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!

Eksploruj i przetestuj operacje mcp platformy Azure przy użyciu innych odpowiednich monitów, takich jak:
```
List all of the storage accounts in my subscription
Get the available tables in my storage accounts
```

Z tego artykułu dowiesz się, jak wykonać następujące zadania:

Instalowanie i uwierzytelnianie na serwerze usługi Azure MCP
Nawiązywanie połączenia z serwerem MCP platformy Azure przy użyciu niestandardowego klienta języka Python
Uruchom monity, aby przetestować operacje serwera MCP platformy Azure i zarządzać zasobami platformy Azure

Wymagania wstępne

Konto platformy Azure z aktywną subskrypcją
Zainstalowany lokalnie język Python w wersji 3.9 lub nowszej
Node.js zainstalowany lokalnie

Uwaga / Notatka

Zasoby platformy Azure, do których zamierzasz uzyskać dostęp za pomocą serwera Azure MCP, muszą już istnieć w ramach subskrypcji platformy Azure. Ponadto konto użytkownika musi mieć przypisane niezbędne role i uprawnienia RBAC dla tych zasobów.

Serwer MCP platformy Azure zapewnia bezproblemowe uwierzytelnianie przy użyciu uwierzytelniania opartego na tokenach za pośrednictwem identyfikatora Entra firmy Microsoft. Wewnętrznie serwer usługi Azure MCP używa z DefaultAzureCredentialbiblioteki tożsamości platformy Azure do uwierzytelniania użytkowników.

Aby móc pracować z serwerem MCP platformy Azure, musisz lokalnie zalogować się do jednego z narzędzi obsługiwanych przez DefaultAzureCredential, używając konta platformy Azure. Zaloguj się przy użyciu okna terminalu, takiego jak terminal programu Visual Studio Code:

az login

Connect-AzAccount

azd auth login

Po pomyślnym zalogowaniu się do jednego z powyższych narzędzi serwer usługi Azure MCP może automatycznie odnajdywać poświadczenia i używać ich do uwierzytelniania i wykonywania operacji na usługach platformy Azure.

Uwaga / Notatka

Możesz również zalogować się do platformy Azure za pomocą programu Visual Studio. Serwer MCP platformy Azure może uruchamiać tylko operacje, które zalogowany użytkownik ma uprawnienia do wykonania.

Tworzenie aplikacji w języku Python

Wykonaj poniższe kroki, aby utworzyć aplikację w języku Python. Aplikacja łączy się z modelem AI i działa jako host dla klienta MCP, który nawiązuje połączenie z serwerem MCP platformy Azure.

Tworzenie projektu

Otwórz pusty folder w wybranym edytorze.
Utwórz nowy plik o nazwie requirements.txt i dodaj następujące zależności biblioteki:
```
mcp
azure-identity
openai
logging
```

W tym samym folderze utwórz nowy plik o nazwie .env i dodaj następujące zmienne środowiskowe:

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

Utwórz pusty plik o nazwie main.py w celu przechowywania kodu dla aplikacji.

Tworzenie środowiska i instalowanie zależności

Otwórz terminal w nowym folderze i utwórz środowisko wirtualne języka Python dla aplikacji:
```
python -m venv venv
```
Aktywuj środowisko wirtualne:
```
venv\Scripts\activate
```
Zainstaluj zależności z pliku requirements.txt:
```
pip install -r requirements.txt
```

Dodawanie kodu aplikacji

Zaktualizuj zawartość Main.py pliku za pomocą następującego kodu:

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

Powyższy kod wykonuje następujące zadania:

Konfiguruje rejestrowanie i ładuje zmienne środowiskowe z .env pliku.
Konfiguruje klienta Azure OpenAI przy użyciu bibliotek azure-identity i openai.
Inicjuje klienta MCP do interakcji z serwerem MCP platformy Azure przy użyciu standardowego transportu we/wy.
Pobiera i wyświetla listę dostępnych narzędzi z serwera MCP.
Implementuje pętlę konwersacyjną w celu przetwarzania monitów użytkownika, korzystania z narzędzi i obsługi wywołań narzędzi.

Uruchamianie i testowanie aplikacji

Wykonaj następujące kroki, aby przetestować aplikację hosta .NET.

W oknie terminalu otwartym w katalogu głównym projektu uruchom następujące polecenie, aby uruchomić aplikację:
```
python main.py
```

Po uruchomieniu aplikacji wprowadź następujący monit testowy:

List all of the resource groups in my subscription

Dane wyjściowe poprzedniego monitu powinny przypominać następujący 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!

Eksploruj i przetestuj operacje mcp platformy Azure przy użyciu innych odpowiednich monitów, takich jak:
```
List all of the storage accounts in my subscription
Get the available tables in my storage accounts
```

Udostępnij za pośrednictwem

Wymagania wstępne

Instalowanie serwera usługi Azure MCP

Użyj monitów, aby przetestować serwer usługi Azure MCP

Wymagania wstępne

Logowanie na potrzeby programowania lokalnego

Tworzenie aplikacji hosta platformy .NET

Tworzenie projektu

Dodawanie zależności

Dodawanie kodu aplikacji

Uruchamianie i testowanie aplikacji

Wymagania wstępne

Logowanie na potrzeby programowania lokalnego

Tworzenie aplikacji w języku Python

Tworzenie projektu

Tworzenie środowiska i instalowanie zależności

Dodawanie kodu aplikacji

Uruchamianie i testowanie aplikacji

Dalsze kroki

Opinia

Dodatkowe zasoby