Webhook Dynatrace  →  Agent Builder reçoit l'alerte  →  Gemini raisonne  →  Outils MCP exécutent  →  Menace neutralisée
       1 s                        2 s                      8 s                  15 s                  25 s total

┌──────────────────────────────────────────────────────────────────────┐
│                         ENVIRONNEMENT SANDBOX                        │
│                                                                      │
│   ┌─────────────┐   100–1000 req/s   ┌──────────────────────────┐   │
│   │  attaquant  │ ──────────────────►│    victim-service        │   │
│   │ (DDoS/SQLi) │                    │    port 8080             │   │
│   └─────────────┘                    │    /admin/* API contrôle │   │
│                                      └────────────┬─────────────┘   │
└───────────────────────────────────────────────────│──────────────────┘
                                                    │ métriques + webhook d'anomalie
                   ┌────────────────────────────────▼─────────────────┐
                   │         Dynatrace Mock  (moteur d'anomalies)     │
                   │  Score de Risque de Menace → POST /alerts/simulate│
                   └────────────────────────┬─────────────────────────┘
                                            │ webhook
          ┌─────────────────────────────────▼──────────────────────────┐
          │          Google Cloud Agent Builder  (Agent Vertex AI)      │
          │  ┌──────────────────────────────────────────────────────┐  │
          │  │  Gemini 2.0 Flash  ──  analyse le contexte de menace │  │
          │  │  Manifeste d'outils ──  récupéré dynamiquement du MCP│  │
          │  │  Porte HITL ──  s'arrête si confiance < seuil        │  │
          │  └──────────────────────────────────────────────────────┘  │
          └──────────────┬─────────────────────────┬───────────────────┘
                         │ appels REST              │ écriture d'audit
         ┌───────────────▼──────┐      ┌────────────▼──────────┐
         │  Serveur MCP :8001   │      │  MongoDB 7.0 Atlas    │
         │  11 outils réels     │      │  incidents + traces   │
         └───────────┬──────────┘      └───────────────────────┘
                     │ agit sur l'infra en direct
         ┌───────────▼──────────┐
         │  FastAPI :8000       │
         │  victim-service:8080 │
         └──────────────────────┘

                   ┌──────────────────────────────────────────────────┐
                   │              STACK D'OBSERVABILITÉ                │
                   │  Collecteur OTel ──► Jaeger  (traces distribuées)│
                   │  Prometheus ──────────────► Grafana               │
                   └──────────────────────────────────────────────────┘

.\attack.production.ps1 status   # vérifier que tous les services sont sains
.\attack.production.ps1 ddos     # DDoS — Gemini bloque les IP + limite de débit
.\attack.production.ps1 sql      # Injection SQL — Gemini active le WAF
.\attack.production.ps1 brute    # Force brute — Gemini bloque les IP sources
.\attack.production.ps1 stop     # réinitialiser les défenses

class SentinelAgent(reasoning_engines.Queryable):

    def set_up(self):
        # MCP tools as Vertex AI FunctionDeclarations — Gemini selects at runtime
        mcp_tools = Tool(function_declarations=[
            FunctionDeclaration(name="block_ip_address", ...),
            FunctionDeclaration(name="activate_waf", ...),
            FunctionDeclaration(name="rate_limit_requests", ...),
            FunctionDeclaration(name="scale_service", ...),
            FunctionDeclaration(name="collect_forensic_logs", ...),
            FunctionDeclaration(name="analyze_attack_pattern", ...),
        ])
        self._model = GenerativeModel("gemini-2.0-flash-001", tools=[mcp_tools])
        self._chat = self._model.start_chat()

    def query(self, *, incident: dict) -> dict:
        # Entry point — Agent Builder calls this for every Dynatrace webhook
        response = self._chat.send_message(threat_prompt(incident))
        tool_calls = [{"name": p.function_call.name, "args": dict(p.function_call.args)}
                      for p in response.candidates[0].content.parts if p.function_call]
        return {"engine": "agent_builder", "tool_calls": tool_calls, ...}

# Tester localement (pas besoin de GCP avec le backend google_ai_studio)
python scripts/deploy_agent_builder.py --test-only

# Déployer vers le point de terminaison géré Agent Builder
python scripts/deploy_agent_builder.py --project mon-projet-gcp

# .env
GEMINI_BACKEND=agent_builder
GOOGLE_CLOUD_PROJECT=mon-projet-gcp
VERTEX_LOCATION=us-central1

GET /mcp/tools  →  renvoie 11 descripteurs d'outils  →  Gemini sélectionne et invoque les outils

docker compose up -d --build

cd simulacion
docker compose up -d victim-service
cd ..

docker compose ps
# Attendu : 8 services en cours d'exécution / sains

curl http://localhost:8000/health
# Attendu : {"status": "healthy", "service": "SentinelMCP", ...}

.\attack.ps1 ddos        # Attaque DDoS (par défaut)
.\attack.ps1 sql         # Injection SQL
.\attack.ps1 brute       # Force brute
.\attack.ps1 stop        # Arrêter l'attaque + réinitialiser les défenses
.\attack.ps1 status      # Vérifier l'état du système

http://localhost:8000/dashboard

# Modifier .env
GOOGLE_API_KEY=AIza...votre_clé_ici
GEMINI_BACKEND=google_ai_studio

gcloud auth application-default login
.\scripts\setup_gcloud.ps1   # définit le projet, crée la clé SA, met à jour .env automatiquement

GET http://localhost:8001/mcp/tools

sentinel_mcp/
├── api/              Cœur FastAPI — routes, schémas, interface utilisateur du tableau de bord
├── agent/            Moteur de décision + fournisseurs LLM (Gemini 2.0 Flash, Vertex AI)
├── mcp_server/       Serveur MCP + implémentations des 11 outils
├── services/         Service d'incidents, orchestrateur de remédiation, calculateur de menace
├── observability/    Fournisseurs OTel / Dynatrace / SigNoz
└── core/             Configuration, journalisation, exceptions

simulacion/
├── victim-service/   Service cible FastAPI avec plan de contrôle /admin/*
└── attacker/         Moteur d'attaque Python (DDoS / SQLi / force brute)

docker/
├── prometheus.yml    Configuration de collecte (victim-service à intervalle de 5s)
└── grafana/          Tableau de bord auto-provisionné — 6 panneaux de témoin d'infrastructure