Intégrer une application App Service en tant que serveur MCP pour GitHub Copilot Chat (Python)

Dans ce tutoriel, vous allez apprendre à exposer les fonctionnalités d’une application FastAPI par le biais du protocole MCP (Model Context Protocol), l’ajouter en tant qu’outil à GitHub Copilot et interagir avec votre application à l’aide du langage naturel en mode Agent Copilot Chat.

Capture d’écran montrant que la réponse de l’appel de l’outil MCP dans la fenêtre GitHub Copilot Chat.

Si votre application web dispose déjà de fonctionnalités utiles, telles que le shopping, la réservation d’hôtels ou la gestion des données, il est facile de rendre ces fonctionnalités disponibles :

Toute application prenant en charge l’intégration MCP, telle que le mode d’agent GitHub Copilot Chat dans Visual Studio Code ou gitHub Codespaces.
Agent personnalisé qui accède aux outils distants à l’aide d’un client MCP.

En ajoutant un serveur MCP à votre application web, vous pouvez permettre à un agent de comprendre et d’utiliser les fonctionnalités de votre application lorsqu’elle répond aux invites de l’utilisateur. Cela signifie que tout ce que votre application peut faire, l’agent peut également le faire.

Ajoutez un serveur MCP à votre application web.
Testez le serveur MCP localement en mode agent GitHub Copilot Chat.
Déployez le serveur MCP sur Azure App Service et connectez-vous à celui-ci dans GitHub Copilot Chat.

Prerequisites

Ce tutoriel suppose que vous utilisez l’exemple utilisé dans Déployer une application web Python FastAPI avec PostgreSQL dans Azure.

Au minimum, ouvrez l’exemple d’application dans GitHub Codespaces et déployez l’application en exécutant azd up.

Ajouter un serveur MCP à votre application web

Dans l’explorateur codespace, ouvrez src/pyproject.toml, ajoutez mcp[cli] à la liste des dépendances, comme illustré dans l’exemple suivant :
```
dependencies = [
    ...
    "mcp[cli]",
]
```

Dans src/fastapi_app, créez un fichier appelé mcp_server.py et collez le code d’initialisation du serveur MCP suivant dans le fichier :

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)

L’initialiseur FastMCP() crée un serveur MCP à l’aide du modèle de mode sans état dans le Kit de développement logiciel (SDK) Python MCP. Par défaut, son point de terminaison HTTP streamable est défini sur le /mcp sous-chemin.

Le @mcp.tool() décorateur ajoute un outil au serveur MCP avec son implémentation.
La description de la fonction outil aide l’agent appelant à comprendre comment utiliser l’outil et ses paramètres.

Les outils dupliquer les fonctionnalités existantes des avis de restaurant dans l’application web FastAPI basée sur formulaire. Si vous le souhaitez, vous pouvez ajouter d’autres outils pour la fonctionnalité de mise à jour et de suppression.

Dans src/fastapi_app/app.py, recherchez la ligne pour app = FastAPI() (ligne 24) et remplacez-la par le code suivant :
```
from .mcp_server import mcp, mcp_lifespan
app = FastAPI(lifespan=mcp_lifespan)
app.mount("/mcp", mcp.streamable_http_app())
```
Ce code monte le point de terminaison HTTP streamable du serveur MCP sur l’application FastAPI existante sur le chemin d’accès /mcp. Avec le chemin d’accès par défaut du point de terminaison HTTP streamable, le chemin d’accès complet est /mcp/mcp.

Tester le serveur MCP localement

Dans le terminal codespace, exécutez l’application avec les commandes suivantes :

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

Sélectionnez Ouvrir dans le navigateur, puis ajoutez quelques restaurants et commentaires.

Laissez uvicorn l’exécution. Votre serveur MCP est en cours d’exécution.http://localhost:8000/mcp/mcp
De retour dans l’espace de code, ouvrez Copilot Chat, puis sélectionnez Le mode Agent dans la zone d’invite.
Sélectionnez le bouton Outils , puis sélectionnez l’icône Ajouter un serveur MCP dans le coin supérieur droit de la fenêtre contextuelle.
Sélectionnez HTTP (HTTP ou Server-Sent Événements).
Dans Entrée de l’URL du serveur, tapez http://localhost:8000/mcp/mcp.
Dans Entrer l’ID du serveur, tapez restaurant_ratings ou n’importe quel nom de votre choix.
Sélectionnez Paramètres de l’espace de travail.
Dans une nouvelle fenêtre copilot Chat, tapez quelque chose comme « Afficher les évaluations des restaurants ».
Par défaut, GitHub Copilot affiche une confirmation de sécurité lorsque vous appelez un serveur MCP. Sélectionnez Continuer.

Vous devez maintenant voir une réponse qui indique que l’appel de l’outil MCP réussit.

Déployer votre serveur MCP sur App Service

De retour dans le terminal Codespace, déployez vos modifications en commitant vos modifications (méthode GitHub Actions) ou en exécutant azd up (méthode CLI du développeur Azure).
Dans la sortie AZD, recherchez l’URL de votre application. L’URL ressemble à ceci dans la sortie AZD :
```
 Deploying services (azd deploy)

   (✓) Done: Deploying service web
   - Endpoint: <app-url>
 
```
Une fois azd up terminé, ouvrez .vscode/mcp.json. Remplacez l’URL <app-url>/mcp/mcppar .
Au-dessus de la configuration du serveur MCP modifiée, sélectionnez Démarrer.
Démarrez une nouvelle fenêtre gitHub Copilot Chat. Vous devriez être en mesure d’afficher les évaluations des restaurants, ainsi que de créer de nouveaux restaurants et de nouvelles évaluations dans l’agent Copilot.

Bonnes pratiques de sécurité

Lorsque votre serveur MCP est appelé par un agent alimenté par de grands modèles de langage (LLM), tenez compte des attaques par injection d’invite . Tenez compte des meilleures pratiques de sécurité suivantes :

Authentification et autorisation : Sécurisez votre serveur MCP avec l’authentification Microsoft Entra pour vous assurer que seuls les utilisateurs ou agents autorisés peuvent accéder à vos outils. Consultez Protocole de Contexte de Modèle Sécurisé pour les appels vers Azure App Service depuis Visual Studio Code avec l'authentification Microsoft Entra pour un guide étape par étape.
Validation et assainissement des entrées : validez toujours les données entrantes pour empêcher les entrées non valides ou malveillantes. Pour les applications Python, utilisez des bibliothèques telles que Pydantic pour appliquer des règles de validation des données avec des modèles d’entrée dédiés (tels que RestaurantCreate et ReviewCreate). Reportez-vous à leur documentation pour connaître les meilleures pratiques et les détails de l’implémentation.
HTTPS : L’exemple s’appuie sur Azure App Service, qui applique HTTPS par défaut et fournit des certificats TLS/SSL gratuits pour chiffrer les données en transit.
Principe des privilèges minimum : exposez uniquement les outils et données nécessaires pour votre cas d’usage. Évitez d’exposer des opérations sensibles, sauf si nécessaire.
Limitation et limitation du débit : utilisez gestion des API ou intergiciel personnalisé pour éviter les attaques par déni de service et d’abus.
Journalisation et surveillance : journalisation de l’accès et de l’utilisation des points de terminaison MCP pour l’audit et la détection des anomalies. Surveillez les activités suspectes.
Configuration CORS : limitez les demandes d’origine croisée aux domaines approuvés si votre serveur MCP est accessible à partir de navigateurs. Pour plus d’informations, consultez Activer CORS.
Mises à jour régulières : conservez vos dépendances à jour pour atténuer les vulnérabilités connues.

Plus de ressources

Intégrer l’IA à vos applications Azure App Service

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-11-10