Rozpoczynanie pracy z serwerem MCP platformy Azure przy użyciu języka Python

Serwer McP platformy Azure używa protokołu MCP (Model Context Protocol) do standaryzacji integracji między aplikacjami sztucznej inteligencji a zewnętrznymi narzędziami i źródłami danych, co umożliwia systemom sztucznej inteligencji wykonywanie operacji obsługujących kontekst zasobów 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 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 język Python w wersji 3.9 lub nowszej
Node.js Zainstalowano lts

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 (kontrolowane przez Role-Based Access Control) 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 pracować z serwerem MCP platformy Azure, musisz lokalnie zalogować się do jednego z obsługiwanych narzędzi przy użyciu konta 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ę hostującą .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
```

Dalsze kroki

Dowiedz się więcej o narzędziach serwera MCP platformy Azure

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-09-02