Webhook de Dynatrace  →  Agent Builder recibe alerta  →  Gemini razona  →  Herramientas MCP ejecutan  →  Amenaza neutralizada
       1 s                        2 s                       8 s                  15 s                  25 s total

┌──────────────────────────────────────────────────────────────────────┐
│                        ENTORNO SANDBOX                               │
│                                                                      │
│   ┌─────────────┐   100–1000 req/s   ┌──────────────────────────┐   │
│   │  atacante   │ ──────────────────►│    victim-service        │   │
│   │ (DDoS/SQLi) │                    │    puerto 8080           │   │
│   └─────────────┘                    │    API de control /admin/*│   │
│                                      └────────────┬─────────────┘   │
└───────────────────────────────────────────────────│──────────────────┘
                                                    │ métricas + webhook de anomalía
                   ┌────────────────────────────────▼─────────────────┐
                   │         Dynatrace Mock  (motor de anomalías)      │
                   │  Puntuación de Riesgo de Amenaza → dispara POST   │
                   │  /alerts/simulate                                 │
                   └────────────────────────┬─────────────────────────┘
                                            │ webhook
          ┌─────────────────────────────────▼──────────────────────────┐
          │          Google Cloud Agent Builder  (Vertex AI Agent)      │
          │  ┌──────────────────────────────────────────────────────┐  │
          │  │  Gemini 2.0 Flash  ──  razona sobre contexto de      │  │
          │  │                     amenaza                          │  │
          │  │  Manifiesto de herramientas  ──  obtenido            │  │
          │  │  dinámicamente desde MCP                              │  │
          │  │  Puerta HITL  ──  se detiene si la confianza es      │  │
          │  │  menor al umbral                                      │  │
          │  └──────────────────────────────────────────────────────┘  │
          └──────────────┬─────────────────────────┬───────────────────┘
                         │ Llamadas REST            │ escritura de auditoría
         ┌───────────────▼──────┐      ┌────────────▼──────────┐
         │  Servidor MCP :8001  │      │  MongoDB 7.0 Atlas    │
         │  11 herramientas      │      │  incidentes + trazas  │
         │  reales               │      │                       │
         └───────────┬──────────┘      └───────────────────────┘
                     │ actúa sobre infraestructura en vivo
         ┌───────────▼──────────┐
         │  FastAPI  :8000      │
         │  victim-service :8080│
         └──────────────────────┘

                   ┌──────────────────────────────────────────────────┐
                   │              PILA DE OBSERVABILIDAD              │
                   │  Colector OTel ──► Jaeger  (trazas distribuidas) │
                   │  Prometheus ──────────────► Grafana              │
                   └──────────────────────────────────────────────────┘

.\attack.production.ps1 status   # verificar que todos los servicios estén saludables
.\attack.production.ps1 ddos     # DDoS — Gemini bloquea IPs + límite de tasa
.\attack.production.ps1 sql      # Inyección SQL — Gemini activa WAF
.\attack.production.ps1 brute    # Fuerza Bruta — Gemini bloquea IPs de origen
.\attack.production.ps1 stop     # restablecer defensas

class SentinelAgent(reasoning_engines.Queryable):

    def set_up(self):
        # Herramientas MCP como FunctionDeclarations de Vertex AI — Gemini selecciona en tiempo de ejecución
        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:
        # Punto de entrada — Agent Builder llama a esto por cada webhook de Dynatrace
        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, ...}

# Prueba local (sin GCP necesario con backend google_ai_studio)
python scripts/deploy_agent_builder.py --test-only

# Desplegar en el endpoint gestionado de Agent Builder
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  →  devuelve 11 descriptores de herramientas  →  Gemini selecciona e invoca herramientas

docker compose up -d --build

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

docker compose ps
# Esperado: 8 servicios ejecutándose/saludables

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

.\attack.ps1 ddos        # Ataque DDoS (predeterminado)
.\attack.ps1 sql         # Inyección SQL
.\attack.ps1 brute       # Fuerza Bruta
.\attack.ps1 stop        # Detener ataque + restablecer defensas
.\attack.ps1 status      # Verificar estado del sistema

http://localhost:8000/dashboard

# Editar .env
GOOGLE_API_KEY=AIza...tu_clave_aqui
GEMINI_BACKEND=google_ai_studio

gcloud auth application-default login
.\scripts\setup_gcloud.ps1   # establece proyecto, crea clave SA, actualiza .env automáticamente

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

sentinel_mcp/
├── api/              Núcleo FastAPI — rutas, esquemas, UI del panel
├── agent/            Motor de decisión + proveedores de LLM (Gemini 2.0 Flash, Vertex AI)
├── mcp_server/       Servidor MCP + 11 implementaciones de herramientas
├── services/         Servicio de incidentes, orquestador de remediación, calculadora de amenazas
├── observability/    Proveedores OTel / Dynatrace / SigNoz
└── core/             Configuración, registro, excepciones

simulacion/
├── victim-service/   Servicio objetivo FastAPI con plano de control /admin/*
└── attacker/         Motor de ataque Python (DDoS / SQLi / fuerza bruta)

docker/
├── prometheus.yml    Configuración de scrape (victim-service en intervalo de 5s)
└── grafana/          Panel auto-aprovisionado — testigo de infraestructura de 6 paneles