Dynatrace webhook  →  Agent Builder receives alert  →  Gemini reasons  →  MCP tools execute  →  Threat neutralized
       1 s                        2 s                      8 s                  15 s                  25 s total

┌──────────────────────────────────────────────────────────────────────┐
│                         SANDBOX ENVIRONMENT                          │
│                                                                      │
│   ┌─────────────┐   100–1000 req/s   ┌──────────────────────────┐   │
│   │  attacker   │ ──────────────────►│    victim-service        │   │
│   │ (DDoS/SQLi) │                    │    port 8080             │   │
│   └─────────────┘                    │    /admin/* control API  │   │
│                                      └────────────┬─────────────┘   │
└───────────────────────────────────────────────────│──────────────────┘
                                                    │ metrics + anomaly webhook
                   ┌────────────────────────────────▼─────────────────┐
                   │         Dynatrace Mock  (anomaly engine)          │
                   │  Threat Risk Score → fires POST /alerts/simulate  │
                   └────────────────────────┬─────────────────────────┘
                                            │ webhook
          ┌─────────────────────────────────▼──────────────────────────┐
          │          Google Cloud Agent Builder  (Vertex AI Agent)      │
          │  ┌──────────────────────────────────────────────────────┐  │
          │  │  Gemini 2.0 Flash  ──  reasons over threat context   │  │
          │  │  Tool manifest  ──  dynamically fetched from MCP     │  │
          │  │  HITL gate  ──  halts if confidence < threshold      │  │
          │  └──────────────────────────────────────────────────────┘  │
          └──────────────┬─────────────────────────┬───────────────────┘
                         │ REST calls                │ audit write
         ┌───────────────▼──────┐      ┌────────────▼──────────┐
         │  MCP Server  :8001   │      │  MongoDB 7.0  Atlas   │
         │  11 real tools       │      │  incidents + traces   │
         └───────────┬──────────┘      └───────────────────────┘
                     │ acts on live infra
         ┌───────────▼──────────┐
         │  FastAPI  :8000      │
         │  victim-service :8080│
         └──────────────────────┘

                   ┌──────────────────────────────────────────────────┐
                   │              OBSERVABILITY STACK                  │
                   │  OTel Collector ──► Jaeger  (distributed traces)  │
                   │  Prometheus ──────────────► Grafana               │
                   └──────────────────────────────────────────────────┘

.\attack.production.ps1 status   # verify all services healthy
.\attack.production.ps1 ddos     # DDoS — Gemini blocks IPs + rate limit
.\attack.production.ps1 sql      # SQL Injection — Gemini activates WAF
.\attack.production.ps1 brute    # Brute Force — Gemini blocks source IPs
.\attack.production.ps1 stop     # reset defenses

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, ...}

# Test locally (no GCP needed with google_ai_studio backend)
python scripts/deploy_agent_builder.py --test-only

# Deploy to managed Agent Builder endpoint
python scripts/deploy_agent_builder.py --project my-gcp-project

# .env
GEMINI_BACKEND=agent_builder
GOOGLE_CLOUD_PROJECT=my-gcp-project
VERTEX_LOCATION=us-central1

GET /mcp/tools  →  returns 11 tool descriptors  →  Gemini selects and invokes tools

docker compose up -d --build

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

docker compose ps
# Expected: 8 services running/healthy

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

.\attack.ps1 ddos        # DDoS attack (default)
.\attack.ps1 sql         # SQL Injection
.\attack.ps1 brute       # Brute Force
.\attack.ps1 stop        # Stop attack + reset defenses
.\attack.ps1 status      # Check system state

http://localhost:8000/dashboard

# Edit .env
GOOGLE_API_KEY=AIza...your_key_here
GEMINI_BACKEND=google_ai_studio

gcloud auth application-default login
.\scripts\setup_gcloud.ps1   # sets project, creates SA key, updates .env automatically

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

sentinel_mcp/
├── api/              FastAPI core — routes, schemas, dashboard UI
├── agent/            Decision engine + LLM providers (Gemini 2.0 Flash, Vertex AI)
├── mcp_server/       MCP server + 11 tool implementations
├── services/         Incident service, remediation orchestrator, threat calculator
├── observability/    OTel / Dynatrace / SigNoz providers
└── core/             Config, logging, exceptions

simulacion/
├── victim-service/   FastAPI target service with /admin/* control plane
└── attacker/         Python attack engine (DDoS / SQLi / brute force)

docker/
├── prometheus.yml    Scrape config (victim-service at 5s interval)
└── grafana/          Auto-provisioned dashboard — 6-panel infrastructure witness