Integrace aplikace Služby App Service jako serveru MCP pro chat Copilot GitHubu (Python)

V tomto kurzu se dozvíte, jak zpřístupnit funkce aplikace FastAPI prostřednictvím protokolu MCP (Model Context Protocol), přidat ho jako nástroj do GitHub Copilotu a pracovat s aplikací pomocí přirozeného jazyka v režimu agenta Copilot Chat.

Snímek obrazovky znázorňující, že odpověď z volání nástroje MCP v okně chatu GitHub Copilot

Pokud už vaše webová aplikace obsahuje užitečné funkce, jako jsou nákupy, rezervace hotelů nebo správa dat, je snadné tyto funkce zpřístupnit pro:

Každá aplikace, která podporuje integraci MCP, jako je režim agenta chatu GitHub Copilot v editoru Visual Studio Code nebo GitHub Codespaces.
Vlastní agent, který přistupuje ke vzdáleným nástrojům pomocí klienta MCP.

Přidáním serveru MCP do webové aplikace povolíte agentovi pochopit a používat funkce vaší aplikace, když reaguje na výzvy uživatele. To znamená, že cokoli může vaše aplikace dělat, agent může také provádět.

Přidejte server MCP do webové aplikace.
Otestujte server MCP místně v režimu agenta chatu GitHub Copilot.
Nasaďte server MCP do služby Azure App Service a připojte se k němu v chatu GitHub Copilot.

Požadavky

Tento kurz předpokládá, že pracujete s ukázkou použitou ve webové aplikaci Python FastAPI s PostgreSQL v Azure.

Alespoň otevřete ukázkovou aplikaci v GitHub Codespaces a nasaďte aplikaci spuštěním azd uppříkazu .

Přidání serveru MCP do webové aplikace

V průzkumníku codespace otevřete soubor src/pyproject.toml, přidejte mcp[cli] do seznamu závislostí, jak je znázorněno v následujícím příkladu:
```
dependencies = [
    ...
    "mcp[cli]",
]
```

V src/fastapi_app vytvořte soubor s názvem mcp_server.py a vložte do souboru následující inicializační kód serveru MCP:

import asyncio
import contextlib
from contextlib import asynccontextmanager

from mcp.server.fastmcp import FastMCP
from sqlalchemy.sql import func
from sqlmodel import Session, select

from .models import Restaurant, Review, engine

# Create a FastMCP server. Use stateless_http=True for simple mounting. Default path is .../mcp
mcp = FastMCP("RestaurantReviewsMCP", stateless_http=True)

# Lifespan context manager to start/stop the MCP session manager with the FastAPI app
@asynccontextmanager
async def mcp_lifespan(app):
    async with contextlib.AsyncExitStack() as stack:
        await stack.enter_async_context(mcp.session_manager.run())
        yield

# MCP tool: List all restaurants with their average rating and review count
@mcp.tool()
async def list_restaurants_mcp() -> list[dict]:
    """List restaurants with their average rating and review count."""

    def sync():
        with Session(engine) as session:
            statement = (
                select(
                    Restaurant,
                    func.avg(Review.rating).label("avg_rating"),
                    func.count(Review.id).label("review_count"),
                )
                .outerjoin(Review, Review.restaurant == Restaurant.id)
                .group_by(Restaurant.id)
            )
            results = session.exec(statement).all()
            rows = []
            for restaurant, avg_rating, review_count in results:
                r = restaurant.dict()
                r["avg_rating"] = float(avg_rating) if avg_rating is not None else None
                r["review_count"] = review_count
                r["stars_percent"] = (
                    round((float(avg_rating) / 5.0) * 100) if review_count > 0 and avg_rating is not None else 0
                )
                rows.append(r)
            return rows

    return await asyncio.to_thread(sync)

# MCP tool: Get a restaurant and all its reviews by restaurant_id
@mcp.tool()
async def get_details_mcp(restaurant_id: int) -> dict:
    """Return the restaurant and its related reviews as objects."""

    def sync():
        with Session(engine) as session:
            restaurant = session.exec(select(Restaurant).where(Restaurant.id == restaurant_id)).first()
            if restaurant is None:
                return None
            reviews = session.exec(select(Review).where(Review.restaurant == restaurant_id)).all()
            return {"restaurant": restaurant.dict(), "reviews": [r.dict() for r in reviews]}

    return await asyncio.to_thread(sync)

# MCP tool: Create a new review for a restaurant
@mcp.tool()
async def create_review_mcp(restaurant_id: int, user_name: str, rating: int, review_text: str) -> dict:
    """Create a new review for a restaurant and return the created review dict."""

    def sync():
        with Session(engine) as session:
            review = Review()
            review.restaurant = restaurant_id
            review.review_date = __import__("datetime").datetime.now()
            review.user_name = user_name
            review.rating = int(rating)
            review.review_text = review_text
            session.add(review)
            session.commit()
            session.refresh(review)
            return review.dict()

    return await asyncio.to_thread(sync)

# MCP tool: Create a new restaurant
@mcp.tool()
async def create_restaurant_mcp(restaurant_name: str, street_address: str, description: str) -> dict:
    """Create a new restaurant and return the created restaurant dict."""

    def sync():
        with Session(engine) as session:
            restaurant = Restaurant()
            restaurant.name = restaurant_name
            restaurant.street_address = street_address
            restaurant.description = description
            session.add(restaurant)
            session.commit()
            session.refresh(restaurant)
            return restaurant.dict()

    return await asyncio.to_thread(sync)

Inicializátor FastMCP() vytvoří server MCP pomocí vzoru bezstavového režimu v sadě MCP Python SDK. Ve výchozím nastavení je jeho streamovatelný koncový bod HTTP nastavený na /mcp dílčí cestu.

Dekorátor @mcp.tool() přidá nástroj na server MCP s implementací.
Popis funkce nástroje pomáhá volajícímu agentovi pochopit, jak nástroj a jeho parametry používat.

Nástroje duplikují stávající funkce kontroly restaurace ve webové aplikaci FastAPI založené na formuláři. Pokud chcete, můžete přidat další nástroje pro aktualizace a odstranění funkcí.

V src/fastapi_app/app.py najděte řádek ( app = FastAPI() řádek 24) a nahraďte ho následujícím kódem:
```
from .mcp_server import mcp, mcp_lifespan
app = FastAPI(lifespan=mcp_lifespan)
app.mount("/mcp", mcp.streamable_http_app())
```
Tento kód připojí streamovatelný koncový bod HTTP serveru MCP k existující aplikaci FastAPI v cestě /mcp. Společně s výchozí cestou streamovatelného koncového bodu HTTP je /mcp/mcpúplná cesta .

Místní testování serveru MCP

V terminálu codespace spusťte aplikaci s následujícími příkazy:

python3 -m venv .venv
source .venv/bin/activate
pip install -r src/requirements.txt
pip install -e src
python3 src/fastapi_app/seed_data.py
python3 -m uvicorn fastapi_app:app --reload --port=8000

Vyberte Otevřít v prohlížeči a přidejte několik restaurací a recenzí.

Nechejte uvicorn běžet. Váš server MCP teď běží http://localhost:8000/mcp/mcp .
Zpátky v codespace otevřete Copilot Chat a pak v poli výzvy vyberte režim agenta .
Vyberte tlačítko Nástroje a pak v pravém horním rohu vyberte ikonu Přidat server MCP .
Vyberte HTTP (HTTP nebo Server-Sent události).
Do zadejte adresu URL serveru, zadejte http://localhost:8000/mcp/mcp.
Do pole Zadejte ID serveru zadejte restaurant_ratings nebo libovolný název, který se vám líbí.
Vyberte Nastavení pracovního prostoru.
V novém okně chatu Copilot zadejte něco jako "Show me the restaurant ratings" (Zobrazit hodnocení restaurace).
GitHub Copilot ve výchozím nastavení zobrazí potvrzení zabezpečení při vyvolání serveru MCP. Zvolte Pokračovat.

Teď byste měli vidět odpověď, která značí, že volání nástroje MCP proběhlo úspěšně.

Nasazení serveru MCP do služby App Service

Zpátky v terminálu codespace nasaďte změny potvrzením změn (metoda GitHub Actions) nebo spuštěním azd up (metoda Azure Developer CLI).

Ve výstupu AZD vyhledejte adresu URL vaší aplikace. Adresa URL vypadá takto ve výstupu AZD:

 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: <app-url>

Po azd up dokončení otevřete soubor .vscode/mcp.json. Změňte adresu URL na <app-url>/mcp/mcp.
Nad upravenou konfigurací serveru MCP vyberte Spustit.
Spusťte nové okno GitHub Copilot Chatu. Měli byste být schopni zobrazit hodnocení restaurací a také vytvořit nové restaurace a nová hodnocení v agentu Copilot.

Osvědčené postupy zabezpečení

Když je server MCP volána agentem využívajícím velké jazykové modely (LLM), mějte na paměti útoky prostřednictvím injektáže výzvy . Zvažte následující osvědčené postupy zabezpečení:

Ověřování a autorizace: Zabezpečte server MCP pomocí ověřování Microsoft Entra, abyste zajistili, že k vašim nástrojům mají přístup jenom autorizovaní uživatelé nebo agenti. Podrobné pokyny najdete v tématu Volání protokolu Zabezpečeného modelového kontextu do služby Azure App Service ze sady Visual Studio Code s ověřováním Microsoft Entra.
Ověřování vstupu a sanitizace: Vždy ověřte příchozí data, aby se zabránilo neplatnému nebo škodlivému vstupu. Pro aplikace v Pythonu použijte knihovny, jako je Pydantic , k vynucení pravidel ověření dat pomocí vyhrazených vstupních modelů (například RestaurantCreate a ReviewCreate). Informace o osvědčených postupech a implementaci najdete v dokumentaci.
HTTPS: Ukázka spoléhá na službu Azure App Service, která ve výchozím nastavení vynucuje HTTPS a poskytuje bezplatné certifikáty TLS/SSL k šifrování přenášených dat.
Princip nejnižších oprávnění: Zpřístupněte pouze potřebné nástroje a data potřebná pro váš případ použití. Vyhněte se zveřejnění citlivých operací, pokud to není nutné.
Omezování rychlosti a omezování: Použití služby API Management nebo vlastního middlewaru k prevenci zneužití a útoků na dostupnost služby.
Protokolování a monitorování: Přístup k protokolům a využití koncových bodů MCP pro auditování a detekci anomálií Monitorování podezřelých aktivit
Konfigurace CORS: Omezte požadavky mezi zdroji na důvěryhodné domény, pokud je váš server MCP přístupný z prohlížečů. Další informace najdete v tématu Povolení CORS.
Pravidelné aktualizace: Udržujte závislosti aktuální a zmírněte tak známá ohrožení zabezpečení.

Další zdroje informací

Integrace AI do aplikací Azure App Service

Váš názor

Byla tato stránka užitečná?

Last updated on 2025-11-10