Gyors kezdés: MCP SDK-kkal készült gazdagépkiszolgálók az Azure Functions alkalmazásában

Ebben a rövid útmutatóban megtudhatja, hogyan üzemeltethet az Azure Functions Model Context Protocol (MCP) kiszolgálókon, amelyeket hivatalos MCP SDK-k használatával hoz létre. A Rugalmas használati csomag üzemeltetése lehetővé teszi az Azure Functions kiszolgáló nélküli skálázási, használatalapú fizetéses számlázási modelljének és beépített biztonsági funkcióinak előnyeit. Tökéletes a streamelhető http-átvitelt használó MCP-kiszolgálókhoz.

Ez a cikk egy hivatalos MCP SDK-k használatával létrehozott MCP-kiszolgálóprojektet használ.

Jótanács

A Functions egy MCP-bővítményt is biztosít, amely lehetővé teszi MCP-kiszolgálók létrehozását az Azure Functions programozási modellel. További információ : Rövid útmutató: Egyéni távoli MCP-kiszolgáló létrehozása az Azure Functions használatával.

Mivel az új kiszolgáló egy Rugalmas használatú csomagban fut, amely egy használatalapú fizetéses számlázási modellt követ, ennek a rövid útmutatónak a elvégzése néhány cent vagy kevesebb költséget jelent az Azure-fiókjában.

Fontos

Bár az MCP-kiszolgálók egyéni kezelőkkel való üzemeltetése minden nyelv esetében támogatott, ebben a rövid útmutatóban jelenleg csak a C#, a Python és a TypeScript példák találhatók. A rövid útmutató végrehajtásához válasszon egyet a cikk tetején található támogatott nyelvek közül.

Előfeltételek

.NET 8 SDK

Node.js 22 vagy újabb

Python 3.11 vagy újabb
uv a Python-csomagkezeléshez

Visual Studio Code az alábbi bővítményekkel:
- Azure Functions-bővítmény. Ehhez a bővítményhez az Azure Functions Core Tools 4.5.0-s vagy újabb verziójára van szükség, és megpróbálja telepíteni, ha nem érhető el.
- Azure Developer CLI-bővítmény.
Azure Developer CLI 1.17.2-s vagy újabb verzió
Azure parancssori felület (CLI). Az Azure CLI-parancsokat az Azure Cloud Shellben is futtathatja.
Egy Azure-fiók, aktív előfizetéssel. Hozzon létre egy fiókot ingyenesen.

Megjegyzés:

Ehhez a mintához rendelkeznie kell engedéllyel egy Microsoft Entra-alkalmazás létrehozásához a használt Azure-előfizetésben.

Bevezetés a mintaprojektek használatába

Az első lépések legegyszerűbb módja egy mcp-kiszolgálói mintaprojekt klónozása, amely hivatalos MCP SDK-kkal készült:

A Visual Studio Code-ban nyisson meg egy mappát vagy munkaterületet, ahol létre szeretné hozni a projektet.

A terminálban futtassa ezt a parancsot a .NET-minta inicializálásához:
```
azd init --template mcp-sdk-functions-hosting-dotnet -e mcpsdkserver-dotnet
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A Terminálban futtassa ezt a parancsot a TypeScript-minta inicializálásához:
```
azd init --template mcp-sdk-functions-hosting-node  -e mcpsdkserver-node
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A Terminálban futtassa ezt a parancsot a Python-minta inicializálásához:
```
azd init --template mcp-sdk-functions-hosting-python -e mcpsdkserver-python
```
Ez a parancs lekéri a projektfájlokat a sablontárházból , és inicializálja a projektet az aktuális mappában. A -e jelölő megadja az aktuális környezet nevét. Ebben azdaz esetben a környezet egy egyedi üzembehelyezési környezetet tart fenn az alkalmazás számára, és egynél több definiálható. Az Azure-ban létrehozott erőforrások nevében is használatos.

A kódprojekt sablonja egy MCP-kiszolgálóhoz készült, nyilvános időjárási API-khoz hozzáférő eszközökkel.

Az MCP-kiszolgáló helyi futtatása

A Visual Studio Code integrálható az Azure Functions Core Tools szolgáltatással , hogy a projektet a helyi fejlesztői számítógépen futtathassa.

Terminál megnyitása a szerkesztőben (Ctrl+Shift+` )

A gyökérkönyvtárban futtassa func start a kiszolgáló elindításához. A Terminál panelen a Core Tools kimenete látható.

A gyökérkönyvtárban futtassa a npm install parancsot a függőségek telepítéséhez, majd futtassa a npm run build parancsot.
A kiszolgáló elindításához futtassa a következőt func start: .

A gyökérkönyvtárban futtassa uv run func start a virtuális környezet létrehozásához, a függőségek telepítéséhez és a kiszolgáló elindításához.

Kiszolgáló tesztelése a GitHub Copilot használatával

Ha ellenőrizni szeretné a kiszolgálót a GitHub Copilot Visual Studio Code-ban való használatával, kövesse az alábbi lépéseket:

Nyissa meg a mcp.json fájlt a .vscode könyvtárban.
Indítsa el a kiszolgálót a konfiguráció feletti local-mcp-server gombra kattintva.
A Copilot Csevegés ablakban győződjön meg arról, hogy az ügynökmodell ki van jelölve, válassza az Eszközök konfigurálása ikont, és ellenőrizze, hogy MCP Server:local-mcp-server engedélyezve van-e a csevegésben.
Futtassa ezt a parancssort a csevegésben:
```
Return the weather forecast for New York City using #local-mcp-server
```
A Copilotnak fel kell hívnia az egyik időjárási eszközt, hogy segítsen megválaszolni ezt a kérdést. Amikor a rendszer kéri az eszköz futtatását, válassza az Engedélyezés lehetőséget ezen a munkaterületen , hogy ne kelljen továbbra is regisztrálnia ezt az engedélyt.

Miután helyben ellenőrizte az eszköz működését, leállíthatja a kiszolgálót, és üzembe helyezheti a projektkódot az Azure-ban.

Telepítés az Azure-ra

Ez a projekt úgy van konfigurálva, hogy a parancs használatával telepítse ezt a azd up projektet egy új függvényalkalmazásban egy Rugalmas használatú csomagban az Azure-ban. A projekt olyan Bicep-fájlokat tartalmaz, amelyek azd az ajánlott eljárásokat követve hoznak létre biztonságos üzembe helyezést.

Jelentkezzen be az Azure-ba:
```
azd login
```
Konfigurálja a Visual Studio Code-ot előre elkészített ügyfélalkalmazásként:
```
azd env set PRE_AUTHORIZED_CLIENT_IDS aebc6443-996d-45c2-90f0-388ff96faa56
```
Az előhitelesített alkalmazások hitelesítést végezhetnek az MCP-kiszolgálóhoz, és hozzáférhetnek azokhoz anélkül, hogy további hozzájárulási kéréseket kellene kérni.
A Visual Studio Code-ban nyomja le az F1 billentyűt a parancskatalógus megnyitásához. Keresse meg és futtassa a parancsot Azure Developer CLI (azd): Package, Provision and Deploy (up). Ezután jelentkezzen be az Azure-fiókjával.

Amikor a rendszer kéri, adja meg a szükséges üzembehelyezési paramétereket:

Paraméter	Description
Azure-előfizetés	Előfizetés, amelyben az erőforrások létrejönnek.
Azure-lokáció	Azure-régió, amelyben létre kell hozni az új Azure-erőforrásokat tartalmazó erőforráscsoportot. Csak azok a régiók jelennek meg, amelyek jelenleg támogatják a Rugalmas felhasználás csomagot.

A parancs sikeres végrehajtása után a létrehozott erőforrásokra és az üzembe helyezett MCP-kiszolgáló végpontjaira mutató hivatkozások jelennek meg. Jegyezze fel a függvényalkalmazás nevét, amelyre szüksége van a következő szakaszhoz.

Jótanács

Ha hiba történik a azd up parancs futtatásakor, futtassa újra a parancsot. Többször is futtatható azd up , mert kihagyja a már létező erőforrások létrehozását. Ismételten hívhatja a azd up parancsot, amikor a frissítéseket telepíti a szolgáltatáson.

Csatlakozás a távoli MCP-kiszolgálóhoz

Az MCP-kiszolgáló most már az Azure-ban fut. A GitHub Copilot távoli kiszolgálóhoz való csatlakoztatásához konfigurálja azt a munkaterület beállításai között.

A mcp.json fájlban váltson a távoli kiszolgálóra azáltal, hogy a konfigurációnál a local-mcp-server opciót, és a konfigurációnál az remote-mcp-server opciót választja.
Amikor a rendszer a függvényalkalmazás tartományát kéri, adja meg az előző szakaszban feljegyzett függvényalkalmazás nevét. Amikor a rendszer kéri a Microsoft hitelesítését, válassza az Engedélyezés lehetőséget , majd válassza ki az Azure-fiókját.
Ellenőrizze a távoli kiszolgálót egy olyan kérdés feltevésével, mint például:
```
Return the weather forecast for Seattle using #remote-mcp-server.
```
A Copilot meghívja az egyik időjárási eszközt a lekérdezés megválaszolásához.

Jótanács

A kiszolgáló kimenetét a Továbbiak... elemet választva tekintheti meg.>Kimenet megjelenítése. A kimenet hasznos információkat nyújt a lehetséges csatlakozási hibákról. A fogaskerék ikont is kiválasztva a naplószinteket Nyomkövetésre módosíthatja, hogy további részleteket kapjon az ügyfél (Visual Studio Code) és a kiszolgáló közötti interakciókról.

A kód áttekintése (nem kötelező)

Áttekintheti az MCP-kiszolgálót meghatározó kódot:

Az MCP-kiszolgáló kódja a projekt gyökérkönyvtárában van definiálva. A kiszolgáló a hivatalos C# MCP SDK-val határozza meg az időjárással kapcsolatos eszközöket:

using ModelContextProtocol;
using ModelContextProtocol.Server;
using System.ComponentModel;
using System.Globalization;
using System.Text.Json;

namespace QuickstartWeatherServer.Tools;

[McpServerToolType]
public sealed class WeatherTools
{
    [McpServerTool, Description("Get weather alerts for a US state.")]
    public static async Task<string> GetAlerts(
        HttpClient client,
        [Description("The US state to get alerts for. Use the 2 letter abbreviation for the state (e.g. NY).")] string state)
    {
        using var jsonDocument = await client.ReadJsonDocumentAsync($"/alerts/active/area/{state}");
        var jsonElement = jsonDocument.RootElement;
        var alerts = jsonElement.GetProperty("features").EnumerateArray();

        if (!alerts.Any())
        {
            return "No active alerts for this state.";
        }

        return string.Join("\n--\n", alerts.Select(alert =>
        {
            JsonElement properties = alert.GetProperty("properties");
            return $"""
                    Event: {properties.GetProperty("event").GetString()}
                    Area: {properties.GetProperty("areaDesc").GetString()}
                    Severity: {properties.GetProperty("severity").GetString()}
                    Description: {properties.GetProperty("description").GetString()}
                    Instruction: {properties.GetProperty("instruction").GetString()}
                    """;
        }));
    }

    [McpServerTool, Description("Get weather forecast for a location.")]
    public static async Task<string> GetForecast(
        HttpClient client,
        [Description("Latitude of the location.")] double latitude,
        [Description("Longitude of the location.")] double longitude)
    {
        var pointUrl = string.Create(CultureInfo.InvariantCulture, $"/points/{latitude},{longitude}");
        using var jsonDocument = await client.ReadJsonDocumentAsync(pointUrl);
        var forecastUrl = jsonDocument.RootElement.GetProperty("properties").GetProperty("forecast").GetString()
            ?? throw new Exception($"No forecast URL provided by {client.BaseAddress}points/{latitude},{longitude}");

        using var forecastDocument = await client.ReadJsonDocumentAsync(forecastUrl);
        var periods = forecastDocument.RootElement.GetProperty("properties").GetProperty("periods").EnumerateArray();

        return string.Join("\n---\n", periods.Select(period => $"""
                {period.GetProperty("name").GetString()}
                Temperature: {period.GetProperty("temperature").GetInt32()}°F
                Wind: {period.GetProperty("windSpeed").GetString()} {period.GetProperty("windDirection").GetString()}
                Forecast: {period.GetProperty("detailedForecast").GetString()}
                """));
    }
}

A teljes projektsablont a GitHub-adattárat üzemeltető Azure Functions .NET MCP SDK-ban tekintheti meg.

Az MCP-kiszolgáló kódja a server.py fájlban van definiálva. A kiszolgáló a hivatalos Python MCP SDK használatával határozza meg az időjárással kapcsolatos eszközöket. Ez az eszköz definíciója get_forecast :

import os
import sys
import warnings
import logging
from typing import Any
from pathlib import Path

import httpx
from azure.identity import OnBehalfOfCredential, ManagedIdentityCredential
from mcp.server.fastmcp import FastMCP
from fastmcp.server.dependencies import get_http_request
from starlette.requests import Request
from starlette.responses import HTMLResponse

# Initialize FastMCP server
mcp = FastMCP("weather", stateless_http=True)

# Constants
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"
@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Get weather forecast for a location.

    Args:
        latitude: Latitude of the location
        longitude: Longitude of the location
    """
    # First get the forecast grid endpoint
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Unable to fetch forecast data for this location."

    # Get the forecast URL from the points response
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Unable to fetch detailed forecast."

    # Format the periods into a readable forecast
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Only show next 5 periods
        forecast = f"""
{period['name']}:
Temperature: {period['temperature']}°{period['temperatureUnit']}
Wind: {period['windSpeed']} {period['windDirection']}
Forecast: {period['detailedForecast']}
"""
        forecasts.append(forecast)

    return "\n---\n".join(forecasts)

A teljes projektsablont a GitHub-adattárat üzemeltető Azure Functions Python MCP SDK-ban tekintheti meg.

Az MCP-kiszolgáló kódja a src mappában van definiálva. A kiszolgáló a hivatalos Node.js MCP SDK használatával határozza meg az időjárással kapcsolatos eszközöket. Ez az eszköz definíciója get-forecast :

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";
import { ManagedIdentityCredential, OnBehalfOfCredential } from '@azure/identity';

const NWS_API_BASE = "https://api.weather.gov";
const USER_AGENT = "weather-app/1.0";

// Function to create a new server instance for each request (stateless)
export const createServer = () => {
  const server = new McpServer({
    name: "weather",
    version: "1.0.0",
  });
  server.registerTool(
    "get-forecast",
    {
      title: "Get Weather Forecast",
      description: "Get weather forecast for a location",
      inputSchema: {
        latitude: z.number().min(-90).max(90).describe("Latitude of the location"),
        longitude: z
          .number()
          .min(-180)
          .max(180)
          .describe("Longitude of the location"),
      },
      outputSchema: z.object({
        forecast: z.string(),
      }),
    },
    async ({ latitude, longitude }) => {
      // Get grid point data
      const pointsUrl = `${NWS_API_BASE}/points/${latitude.toFixed(4)},${longitude.toFixed(4)}`;
      const pointsData = await makeNWSRequest<PointsResponse>(pointsUrl);

      if (!pointsData) {
        const output = { forecast: `Failed to retrieve grid point data for coordinates: ${latitude}, ${longitude}. This location may not be supported by the NWS API (only US locations are supported).` };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      const forecastUrl = pointsData.properties?.forecast;
      if (!forecastUrl) {
        const output = { forecast: "Failed to get forecast URL from grid point data" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      // Get forecast data
      const forecastData = await makeNWSRequest<ForecastResponse>(forecastUrl);
      if (!forecastData) {
        const output = { forecast: "Failed to retrieve forecast data" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      const periods = forecastData.properties?.periods || [];
      if (periods.length === 0) {
        const output = { forecast: "No forecast periods available" };
        return {
          content: [{ type: "text", text: JSON.stringify(output) }],
          structuredContent: output,
        };
      }

      // Format forecast periods
      const formattedForecast = periods.map((period: ForecastPeriod) =>
        [
          `${period.name || "Unknown"}:`,
          `Temperature: ${period.temperature || "Unknown"}°${period.temperatureUnit || "F"}`,
          `Wind: ${period.windSpeed || "Unknown"} ${period.windDirection || ""}`,
          `${period.shortForecast || "No forecast available"}`,
          "---",
        ].join("\n"),
      );

      const forecastText = `Forecast for ${latitude}, ${longitude}:\n\n${formattedForecast.join("\n")}`;
      const output = { forecast: forecastText };

      return {
        content: [{ type: "text", text: forecastText }],
        structuredContent: output,
      };
    },
  );
  return server;
}

A teljes projektsablont a GitHub-adattárat üzemeltető Azure Functions TypeScript MCP SDK-ban tekintheti meg.

Erőforrások tisztítása

Ha végzett az MCP-kiszolgálóval és a kapcsolódó erőforrásokkal, ezzel a paranccsal törölheti a függvényalkalmazást és annak kapcsolódó erőforrásait az Azure-ból a további költségek elkerülése érdekében:

azd down

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-12-02

Megosztás a következőn keresztül:

Gyors kezdés: MCP SDK-kkal készült gazdagépkiszolgálók az Azure Functions alkalmazásában

Előfeltételek

Bevezetés a mintaprojektek használatába

Az MCP-kiszolgáló helyi futtatása

Kiszolgáló tesztelése a GitHub Copilot használatával

Telepítés az Azure-ra

Csatlakozás a távoli MCP-kiszolgálóhoz

A kód áttekintése (nem kötelező)

Erőforrások tisztítása

Visszajelzés

További források