Mulai menggunakan Azure MCP Server dengan Python

Azure MCP Server menggunakan Model Context Protocol (MCP) untuk menstandarkan integrasi antara aplikasi AI dan alat eksternal dan sumber data, yang memungkinkan sistem AI melakukan operasi yang mengetahui konteks sumber daya Azure Anda.

Dalam artikel ini, Anda mempelajari cara menyelesaikan tugas berikut:

Menginstal dan mengautentikasi ke Azure MCP Server
Menyambungkan ke Azure MCP Server menggunakan klien Python kustom
Jalankan perintah untuk menguji operasi Azure MCP Server dan mengelola sumber daya Azure

Prasyarat

Akun Azure dengan langganan aktif
Python 3.9 atau lebih tinggi terinstal
Node.js LTS terinstal

Nota

Sumber daya Azure yang ingin Anda akses dengan Azure MCP Server harus sudah ada dalam langganan Azure Anda. Selain itu, akun pengguna Anda harus memiliki peran dan izin RBAC yang diperlukan yang ditetapkan untuk sumber daya tersebut.

Azure MCP Server mengautentikasi ke ID Microsoft Entra menggunakan pustaka Identitas Azure untuk .NET. Server mendukung dua mode autentikasi:

Mode broker: Menggunakan autentikasi asli sistem operasi Anda (seperti Windows Web Account Manager) dengan InteractiveBrowserCredential.
Mode rantai kredensial: Mencoba beberapa metode autentikasi secara berurutan: variabel lingkungan, Visual Studio Code, Visual Studio, Azure CLI, Azure PowerShell, Azure Developer CLI, dan autentikasi browser interaktif.

Masuk menggunakan salah satu metode berikut:

Buka Palet Perintah (Ctrl+Shift+P atau Cmd+Shift+P di Mac).
Jalankan Azure: Masuk dan ikuti perintah.

az login

Connect-AzAccount

azd auth login

Setelah masuk, Azure MCP Server dapat mengautentikasi dan menjalankan operasi pada layanan Azure berdasarkan izin Anda.

Membuat aplikasi Python

Selesaikan langkah-langkah berikut untuk membuat aplikasi Python (aplikasi host). Aplikasi ini terhubung ke model AI dan bertindak sebagai host untuk klien MCP yang terhubung ke Azure MCP Server (proses lokal yang menjalankan protokol MCP).

Membuat proyek

Buka folder kosong di dalam editor pilihan Anda.
Buat file baru bernama requirements.txt dan tambahkan dependensi pustaka berikut:
```
mcp
azure-identity
openai
logging
```

Di folder yang sama, buat file baru bernama .env dan tambahkan variabel lingkungan berikut:

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

Buat file kosong bernama main.py untuk menyimpan kode untuk aplikasi Anda.

Membuat lingkungan dan menginstal dependensi

Buka terminal di folder baru Anda dan buat lingkungan virtual Python untuk aplikasi:
```
python -m venv venv
```
Aktifkan lingkungan virtual:
```
venv\Scripts\activate
```
Pasang dependensi dari requirements.txt:
```
pip install -r requirements.txt
```

Menambahkan kode aplikasi

Perbarui konten main.py dengan kode berikut:

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

Kode sebelumnya menyelesaikan tugas-tugas berikut:

Menyiapkan pengelogan dan memuat variabel lingkungan dari .env file.
Mengonfigurasi klien Azure OpenAI menggunakan pustaka azure-identity dan pustaka openai.
Menginisialisasi klien MCP untuk berinteraksi dengan Azure MCP Server (proses lokal) menggunakan transportasi I/O standar.
Mengambil dan menampilkan daftar alat yang tersedia (operasi Azure yang terdaftar pada MCP) dari Server MCP Azure.
Menerapkan perulangan percakapan untuk memproses permintaan pengguna, menggunakan alat, dan menangani panggilan alat.

Parameter konfigurasi:

Pengaturan	Description	Example
`AZURE_OPENAI_ENDPOINT`	Titik akhir layanan Azure OpenAI Anda	`https://your-resource.openai.azure.com/`
`AZURE_OPENAI_MODEL`	Nama penyebaran model	`gpt-4o`
Cakupan token	Cakupan OAuth Azure Cognitive Services	`https://cognitiveservices.azure.com/.default`
Authentication	Menggunakan `DefaultAzureCredential` (Azure CLI, identitas terkelola, atau rantai kredensial lainnya)	Lihat dokumentasi Azure Identity
RBAC yang diperlukan	Peran Pengguna Cognitive Services atau setara pada sumber daya Azure OpenAI	Ditetapkan melalui portal Microsoft Azure atau CLI

Menjalankan dan menguji aplikasi

Selesaikan langkah-langkah berikut untuk menguji aplikasi Python Anda:

Di jendela terminal yang terbuka ke akar proyek Anda, jalankan perintah berikut untuk memulai aplikasi:
```
python main.py
```
Verifikasi keberhasilan: Aplikasi harus menampilkan daftar alat Azure MCP Server yang Prompt: tersedia, lalu menampilkan input.

Setelah aplikasi berjalan, masukkan perintah pengujian berikut:

List all of the resource groups in my subscription

Output untuk perintah sebelumnya harus menyerupai teks berikut:

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!

Jelajahi dan uji operasi Azure MCP menggunakan perintah lain yang relevan, seperti:

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

Langkah selanjutnya

Pelajari selengkapnya tentang alat Azure MCP Server

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2026-02-12