Een App Service-app integreren als een MCP-server voor GitHub Copilot Chat (Python)

In deze zelfstudie leert u hoe u de functionaliteit van een FastAPI-app beschikbaar maakt via Model Context Protocol (MCP), deze toevoegt als een hulpprogramma aan GitHub Copilot en hoe u met uw app communiceert met behulp van natuurlijke taal in de copilot Chat-agentmodus.

Schermopname die laat zien dat het antwoord van de MCP-tooloproep in het GitHub Copilot Chat-venster wordt weergegeven.

Als uw webtoepassing al nuttige functies heeft, zoals winkelen, hotelreservering of gegevensbeheer, kunt u deze mogelijkheden eenvoudig beschikbaar maken voor:

Elke toepassing die ONDERSTEUNING biedt voor MCP-integratie, zoals de modus GitHub Copilot Chat-agent in Visual Studio Code of in GitHub Codespaces.
Een aangepaste agent die externe hulpprogramma's opent met behulp van een MCP-client.

Door een MCP-server toe te voegen aan uw web-app, stelt u een agent in staat om de mogelijkheden van uw app te begrijpen en te gebruiken wanneer deze reageert op gebruikersprompts. Dit betekent dat alles wat uw app kan doen, de agent ook kan doen.

Voeg een MCP-server toe aan uw web-app.
Test de MCP-server lokaal in de modus GitHub Copilot Chat-agent.
Implementeer de MCP-server in Azure App Service en maak er verbinding mee in GitHub Copilot Chat.

Vereiste voorwaarden

In deze zelfstudie wordt ervan uitgegaan dat u met het voorbeeld werkt dat wordt gebruikt in Een Python FastAPI-web-app implementeren met PostgreSQL in Azure.

Open minimaal de voorbeeldtoepassing in GitHub Codespaces en implementeer de app door deze uit te voeren azd up.

MCP-server toevoegen aan uw web-app

Open in codespace explorer src/pyproject.toml, voeg deze toe mcp[cli] aan de lijst met afhankelijkheden, zoals wordt weergegeven in het volgende voorbeeld:
```
dependencies = [
    ...
    "mcp[cli]",
]
```

Maak in src/fastapi_app een bestand met de naam mcp_server.py en plak de volgende MCP-serverinitialisatiecode in het bestand:

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)

De FastMCP() initializer maakt een MCP-server met behulp van het staatloze moduspatroon in de MCP Python SDK. Het streambare HTTP-eindpunt is standaard ingesteld op het /mcp subpad.

De @mcp.tool() decorator voegt een hulpprogramma toe aan de MCP-server met de implementatie.
De beschrijving van de functie van het hulpprogramma helpt de aanroepende agent te begrijpen hoe u het hulpprogramma en de bijbehorende parameters gebruikt.

De hulpprogramma's dupliceren de functionaliteit van het bestaande restaurantbeoordelingen in de fastAPI-webtoepassing op basis van formulieren. Desgewenst kunt u meer hulpprogramma's toevoegen voor het bijwerken en verwijderen van functionaliteit.

Zoek in src/fastapi_app/app.py de regel voor app = FastAPI() (regel 24) en vervang deze door de volgende code:
```
from .mcp_server import mcp, mcp_lifespan
app = FastAPI(lifespan=mcp_lifespan)
app.mount("/mcp", mcp.streamable_http_app())
```
Met deze code wordt het streambare HTTP-eindpunt van de MCP-server gekoppeld aan de bestaande FastAPI-app op het pad /mcp. Samen met het standaardpad van het streambare HTTP-eindpunt is /mcp/mcphet volledige pad.

De MCP-server lokaal testen

Voer in de codespace-terminal de toepassing uit met de volgende opdrachten:

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

Selecteer Openen in browser en voeg vervolgens enkele restaurants en beoordelingen toe.

Laat lopen uvicorn . Uw MCP-server wordt momenteel http://localhost:8000/mcp/mcp uitgevoerd.
Open Copilot Chat in de coderuimte en selecteer vervolgens de agentmodus in het promptvak.
Selecteer de knop Extra en selecteer vervolgens het pictogram MCP-server toevoegen in de rechterbovenhoek van de pop-up.
Selecteer HTTP (HTTP of Server-Sent-gebeurtenissen).
Typ in Enter Server URLhttp://localhost:8000/mcp/mcp.
Typ in Server-id invoerenrestaurant_ratings of een naam die u wilt.
Selecteer Werkruimte-instellingen.
Typ in een nieuw Copilot Chat-venster iets als 'Laat me de restaurantbeoordelingen zien'.
GitHub Copilot toont standaard een beveiligingsbevestiging wanneer u een MCP-server aanroept. Klik op Doorgaan.

U ziet nu een antwoord dat aangeeft dat de MCP-hulpprogramma-aanroep is geslaagd.

Uw MCP-server implementeren in App Service

Implementeer uw wijzigingen in de codespace-terminal door uw wijzigingen door te voeren (GitHub Actions-methode) of door deze uit te voeren azd up (Azure Developer CLI-methode).

Zoek in de AZD-uitvoer de URL van uw app. De URL ziet er als volgt uit in de AZD-uitvoer:

 Deploying services (azd deploy)

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

Zodra azd up het is voltooid, opent u .vscode/mcp.json. Wijzig de URL in <app-url>/mcp/mcp.
Selecteer Start boven de gewijzigde MCP-serverconfiguratie.
Start een nieuw GitHub Copilot Chat-venster. U moet restaurantbeoordelingen kunnen bekijken en nieuwe restaurants en nieuwe beoordelingen maken in de Copilot-agent.

Aanbevolen procedures voor beveiliging

Wanneer uw MCP-server wordt aangeroepen door een agent die wordt aangedreven door grote taalmodellen (LLM), moet u rekening houden met promptinjectieaanvallen . Houd rekening met de volgende aanbevolen beveiligingsprocedures:

Verificatie en autorisatie: beveilig uw MCP-server met Microsoft Entra-verificatie om ervoor te zorgen dat alleen geautoriseerde gebruikers of agents toegang hebben tot uw hulpprogramma's. Zie Secure Model Context Protocol-aanroepen naar Azure App Service vanuit Visual Studio Code met Microsoft Entra-verificatie voor een stapsgewijze handleiding.
Invoervalidatie en opschoning: valideer altijd binnenkomende gegevens om ongeldige of schadelijke invoer te voorkomen. Gebruik voor Python-apps bibliotheken zoals Pydantic om regels voor gegevensvalidatie af te dwingen met toegewezen invoermodellen (zoals RestaurantCreate en ReviewCreate). Raadpleeg de bijbehorende documentatie voor aanbevolen procedures en implementatiedetails.
HTTPS: Het voorbeeld is afhankelijk van Azure App Service, dat HTTPS standaard afdwingt en gratis TLS/SSL-certificaten biedt om gegevens tijdens overdracht te versleutelen.
Principe van minimale bevoegdheden: alleen de benodigde hulpprogramma's en gegevens beschikbaar maken die nodig zijn voor uw use-case. Vermijd het blootstellen van gevoelige bewerkingen, tenzij dat nodig is.
Snelheidsbeperking en beperking: gebruik API Management of aangepaste middleware om misbruik en denial-of-service-aanvallen te voorkomen.
Logboekregistratie en bewaking: logboektoegang en gebruik van MCP-eindpunten voor controle en anomaliedetectie. Controleren op verdachte activiteiten.
CORS-configuratie: grensoverschrijdende aanvragen beperken tot vertrouwde domeinen als uw MCP-server toegankelijk is vanuit browsers. Zie CORS inschakelen voor meer informatie.
Regelmatige updates: houd uw afhankelijkheden up-to-date om bekende beveiligingsproblemen te beperken.

Meer middelen

AI integreren in uw Azure App Service-toepassingen

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-20