← Back to Blog

AiSOC — Self-Host Your Own AI-Powered Security Operations Center (Complete Docker Guide)

2026-05-21

AiSOC — Self-Host Your Own AI-Powered Security Operations Center (Complete Docker Guide)

What is AiSOC?

AiSOC is an open-source, self-hostable AI Security Operations Center that ingests security events from 50+ sources, correlates them in real time, runs autonomous AI-driven investigation via a LangGraph multi-agent system, and surfaces the results in a polished SOC console — all under the MIT license.

GitHub: github.com/beenuar/AiSOC
Stars: ⭐ 1,100+ (trending rapidly since early May 2026)
License: MIT
Live Demo: tryaisoc.com

Why this matters: Traditional SIEM/SOC solutions cost thousands per gigabyte of ingested data and lock your security telemetry in a vendor's cloud. AiSOC gives you the same capabilities — autonomous triage, MITRE ATT&CK mapping, SOAR playbooks, threat intel, compliance dashboards — running entirely on your own infrastructure for $0 in licensing fees.

What Makes AiSOC Different

Unlike closed-source AI SOC vendors, AiSOC publishes three things they don't:

  1. Every agent decision is logged. The Investigation Ledger stores every LLM prompt, response, evidence citation, and tool call for every investigation step. You can replay the full reasoning chain later.
  2. The eval harness is public and CI-gated. Five test suites gate every PR: a 200-incident synthetic dataset across 55 templates drives MITRE-tactic, investigation-completeness, and response-quality gates, plus a 1,000-alert noisy stream for alert-reduction measurement.
  3. It runs entirely on your infrastructure. No callbacks to a vendor cloud, no data exfiltration for "model improvement," no per-GB pricing.

Key Features at a Glance

  • 52 first-party connectors — EDR/XDR (CrowdStrike, SentinelOne, Defender XDR, Cortex XDR), SIEM (Splunk, Sentinel, Elastic, Chronicle, Sumo Logic), cloud (AWS Security Hub, GuardDuty, Azure, GCP SCC, Wiz, Lacework), identity (Okta, Entra ID, Duo), SaaS (M365, Google Workspace, Cloudflare, GitHub), and more
  • LangGraph multi-agent investigation — Orchestrator, recon, forensic, responder, and report-writer agents grounded in MITRE ATT&CK with Qdrant RAG memory
  • Investigation Ledger — Step-by-step replayable record of every AI decision, prompt, tool call, and evidence citation
  • 800+ native detection rules plus 6,000+ imported from SigmaHQ, Splunk Security Content, and Chronicle
  • Real-time alert fusion — Kafka spine, Bloom-filter dedup on 10M+ IOCs, ML scoring (LightGBM + Isolation Forest)
  • Neo4j attack graph — Entity graph with blast-radius gating on automated responses
  • UEBA — Per-user behavioral baselines with Z-score anomaly scoring
  • SOAR playbook engine — 50+ community playbooks with HMAC-signed human-approval gates
  • Threat intelligence — TAXII 2.1, MISP, OTX, CISA KEV with triple storage (search, vector, graph)
  • MCP server — Query alerts, run investigations, and replay agent decisions from Claude, Cursor, or any MCP-compatible IDE
  • Compliance dashboards — SOC 2, ISO 27001, NIST CSF, PCI-DSS, HIPAA, DORA with continuous evidence collection

Architecture Overview

AiSOC Architecture

AiSOC follows a microservice architecture built around a Kafka event spine. Here's how data flows through the system:

  1. Ingestion Layer — 52 connectors push normalized OCSF events into Kafka. Each connector runs as a poller on its own APScheduler schedule. Secrets are encrypted at rest with the Fernet-based CredentialVault.
  2. Fusion & Correlation — The fusion service consumes alerts from Kafka, applies Bloom-filter deduplication, runs ML scoring (LightGBM + Isolation Forest), writes a deterministic correlation narrative, and assigns confidence scores. Data is stored in OpenSearch for search and ClickHouse for analytics.
  3. Entity Graph — A Neo4j graph is built inline with Kafka consumption (17 node labels, 14 edge types). Risk-Based Alerting accumulates time-decayed risk points on users, hosts, IPs, and domains.
  4. Multi-Agent Investigation — Four LangGraph agents (Detect, Triage, Hunt, Respond) orchestrate investigations with Qdrant vector memory, MITRE ATT&CK grounding, and full Investigation Ledger logging.
  5. Storage Layer — Postgres (relational), Redis (session/working memory), OpenSearch (search), ClickHouse (analytics), Neo4j (graph), Qdrant (vector embeddings).
  6. Console & API — Next.js 14 web console surfaces alerts, cases, hunts, investigation timelines, and dashboards. REST API with Swagger docs at /docs. A real-time WebSocket server pushes live alerts.
  7. Response Actions — Playbook engine executes SOAR actions with blast-radius gating. Live Actions dispatcher pushes responses to EDR/IAM surfaces (isolate host, disable user, block IP). ChatOps integration via Slack/Teams with HMAC-signed approval prompts.

Prerequisites

  • A Linux server (or macOS) with Docker 24+ and Docker Compose v2 (the docker compose plugin, not docker-compose)
  • At least 6 GB of RAM allocated to Docker (8 GB+ recommended for production use)
  • 20 GB of free disk space for images, containers, and data volumes
  • Node.js 20+ and pnpm 8+ (only required for the one-shot demo path or development)
  • An Anthropic API key or OpenAI API key for AI investigation features (optional for deterministic/demo mode)

Setup Guide

AiSOC offers multiple deployment paths. We'll cover the most practical ones.

Path 1: One-Click Demo — 60 Seconds to a Running SOC

This is the fastest way to see AiSOC in action. It pulls prebuilt images and seeds demo data automatically.

# One-liner — requires nothing but curl and bash
curl -fsSL https://raw.githubusercontent.com/beenuar/AiSOC/main/install.sh | bash

This installer detects your OS, installs Docker, Node, pnpm, and Python idempotently, clones the repo, and launches the demo. It works on Ubuntu/Debian, Fedora/RHEL, Arch, openSUSE, Alpine, macOS, and Windows (via WSL2).

Alternative — Docker Compose demo:

git clone https://github.com/beenuar/AiSOC.git
cd AiSOC
pnpm aisoc:demo

This pulls prebuilt ghcr.io/beenuar/* images, brings up the slim demo profile (Postgres, Redis, Kafka, API, agents, realtime, web), runs the seeder as a one-shot container, and opens your browser at /cases/INC-RT-001?tab=ledger with demo@tryaisoc.com already logged in. Clone-to-investigation takes about 3.5 minutes on a warm Docker daemon.

Stop with:

pnpm aisoc:demo:down

Path 2: Full Production Stack with Docker Compose

For a self-hosted production instance, you'll build the full stack from source.

Step 1 — Clone and configure

git clone https://github.com/beenuar/AiSOC.git
cd AiSOC
cp .env.example .env

Step 2 — Set your environment variables

Edit .env and add at least one AI provider key:

# AI providers (one required for full AI features)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...

# Optional enrichment APIs
VIRUSTOTAL_API_KEY=...
ABUSEIPDB_API_KEY=...
SHODAN_API_KEY=...

# Optional SSO (SAML 2.0 or OIDC)
SAML_IDP_METADATA_URL=...
OIDC_DISCOVERY_URL=...

Step 3 — Run the pre-flight check

pnpm aisoc:doctor

This sanity-checks Docker, Compose v2, allocated RAM, and port availability before you invest time in a build.

Step 4 — Build and start

docker compose up -d --build

The first build compiles 22 services from source (Python, Go, Node, Next.js) and pulls ~5 GB of base images. On a typical laptop, plan for 10–20 minutes for the cold build. Subsequent starts reuse cached layers and take roughly 90 seconds.

Step 5 — Seed demo data (optional)

pnpm seed:demo

This generates cases, alerts, IOCs, attack paths, and UEBA anomalies so you can explore the console immediately.

Step 6 — Access the console

  • SOC Console — http://localhost:3000/dashboard (login: admin@aisoc.local / changeme)
  • API (Swagger) — http://localhost:8000/docs
  • Agents API — http://localhost:8001/docs
  • UEBA — http://localhost:8007/docs
  • Neo4j Browser — http://localhost:7474 (neo4j / neo4j_dev_secret)
  • Kafka UI — http://localhost:8090
  • Grafana — http://localhost:3001 (admin / admin)

Path 3: One-Click Cloud Deploy

AiSOC can deploy to several platforms with a single click:

  • Render: Deploy to Render button in the repo — hobby tier with sleep-on-idle, ~$14/mo
  • Fly.io: ./infra/fly/fly-demo-deploy.sh --provision — 4 apps, managed Postgres + Upstash Redis, ~$14/mo at idle
  • Railway: Uses infra/railway/railway.toml — pay-as-you-go PaaS deployment
  • Coolify: Point your Coolify instance to the docker-compose.yml in the repo
  • Kubernetes: helm install aisoc ./infra/helm/aisoc — full HPA, PDB, Ingress setup
  • AWS: cd infra/terraform && terraform apply — VPC, EKS, RDS, ElastiCache, MSK

Connecting Data Sources

AiSOC's connector catalog covers 52 sources. Each connector presents a schema-driven form in the console:

  1. Navigate to Settings → Connectors
  2. Choose your source (e.g., CrowdStrike, Splunk, AWS Security Hub, Okta)
  3. Fill in the API endpoint, credentials, and polling interval
  4. Click Test connection for a live authentication round-trip
  5. Click Save & enable

Secrets are encrypted with the application-layer CredentialVault (Fernet AES-128-CBC + HMAC-SHA256) before they reach Postgres. Each connector polls on its own APScheduler schedule and pushes normalized OCSF events to the Kafka ingest spine.

Key Connectors

  • EDR/XDR: CrowdStrike Falcon, SentinelOne, Microsoft Defender XDR, Palo Alto Cortex XDR / XSIAM, VMware Carbon Black, Trellix Helix
  • SIEM: Splunk, Microsoft Sentinel, Elastic, Google Chronicle, Sumo Logic, Rapid7 InsightIDR, Wazuh Indexer
  • Cloud: AWS Security Hub, GuardDuty, CloudTrail, VPC Flow Logs, Azure Activity, Azure Defender, GCP Cloud Audit, GCP SCC
  • CNAPP: Wiz, Lacework, Prisma Cloud, Orca, Tenable
  • Identity: Okta, Microsoft Entra ID, Duo Security, Auth0, 1Password
  • SaaS: Microsoft 365, Google Workspace, Cloudflare, GitHub, Slack audit, Jira, ServiceNow
  • Network: Tailscale, Zscaler, Cisco Umbrella
  • Container: Kubernetes audit logs (apiserver webhook or file_tail), Falco

Using the MCP Server

AiSOC ships a Model Context Protocol server so you can query alerts and run investigations from your IDE:

npx -y @aisoc/mcp install --host claude \
--aisoc-url https://aisoc.your-company.com \
--api-key aisoc_pat_xxxxxxxxxxxx

This exposes 13 tools including alert list/detail queries, case investigation, detection rule lookup, lake query (aisoc_lake_query for governed warm-tier SELECTs), and the full Investigation Ledger replay suite (aisoc_run_investigation, aisoc_replay_decision, aisoc_explain_step).

Verification Checklist

After deployment, run through these checks:

  • Console accessible at http://localhost:3000/dashboard — login with admin@aisoc.local / changeme
  • API docs load at http://localhost:8000/docs — all endpoint groups visible
  • Demo data seeded: navigate to /alerts and /cases — you should see pre-populated entries including INC-RT-001 (LockBit 3.0 ransomware)
  • Investigation Ledger replayable: open a case — click the Ledger tab — verify you can step through the AI agent's reasoning chain
  • Connector test: go to Settings → Connectors — pick any source — Test connection returns success
  • AI investigation works: open an alert — click Investigate — the LangGraph agent should execute and produce findings
  • Health check: pnpm aisoc:doctor passes all checks
  • Public eval harness runs: python scripts/run_evals.py --out eval_report.json completes without errors

Resources

  • GitHub: github.com/beenuar/AiSOC
  • Live Demo: tryaisoc.com
  • Documentation: GitHub Docs
  • Docker Images: ghcr.io/beenuar
  • MCP Package: @aisoc/mcp on npm
  • Python SDK: aisoc-sdk on PyPI
  • CLI Tool: aisoc-cli on PyPI — scaffold plugins, validate detections, publish to marketplace
  • License: MIT — free to use, modify, and distribute
← Retour au Blog

AiSOC — Auto-hébergez Votre Propre Centre d'Opérations de Sécurité Piloté par IA (Guide Docker Complet)

2026-05-21

AiSOC — Auto-hébergez Votre Propre Centre d'Opérations de Sécurité Piloté par IA (Guide Docker Complet)

Qu'est-ce qu'AiSOC ?

AiSOC est un centre d'opérations de sécurité (SOC) open-source, auto-hébergeable et piloté par IA qui ingère des événements de sécurité provenant de plus de 50 sources, les corrèle en temps réel, mène des investigations autonomes via un système multi-agents LangGraph, et affiche les résultats dans une console SOC élégante — le tout sous licence MIT.

GitHub : github.com/beenuar/AiSOC
Stars : ⭐ 1 100+ (en pleine croissance depuis début mai 2026)
Licence : MIT
Démo en ligne : tryaisoc.com

Pourquoi c'est important : Les solutions SIEM/SOC traditionnelles coûtent des milliers d'euros par gigaoctet de données ingérées et verrouillent votre télémétrie de sécurité dans le cloud d'un fournisseur. AiSOC offre les mêmes capacités — triage autonome, cartographie MITRE ATT&CK, playbooks SOAR, renseignement sur les menaces, tableaux de bord de conformité — sur votre propre infrastructure pour 0 € de licence.

Ce qui Rend AiSOC Différent

Contrairement aux fournisseurs de SOC IA propriétaires, AiSOC publie trois choses qu'ils ne publient pas :

  1. Chaque décision de l'agent est enregistrée. Le registre d'investigation stocke chaque prompt LLM, réponse, citation de preuve et appel d'outil pour chaque étape. Vous pouvez rejouer toute la chaîne de raisonnement plus tard.
  2. Le harnais d'évaluation est public et validé en CI. Cinq suites de tests valident chaque PR : un jeu de données synthétiques de 200 incidents basé sur 55 modèles pilote les tests de précision MITRE, d'exhaustivité des investigations et de qualité des réponses, plus un flux bruyant de 1 000 alertes pour mesurer la réduction d'alertes.
  3. Il fonctionne entièrement sur votre infrastructure. Aucun rappel vers le cloud d'un fournisseur, aucune exfiltration de données pour « l'amélioration du modèle », aucune tarification au Go.

Fonctionnalités Clés

  • 52 connecteurs propriétaires — EDR/XDR (CrowdStrike, SentinelOne, Defender XDR, Cortex XDR), SIEM (Splunk, Sentinel, Elastic, Chronicle, Sumo Logic), cloud (AWS Security Hub, GuardDuty, Azure, GCP SCC, Wiz, Lacework), identité (Okta, Entra ID, Duo), SaaS (M365, Google Workspace, Cloudflare, GitHub), etc.
  • Investigation multi-agents LangGraph — Agents orchestrateurs, reconnaissance, forensique, réponse et rédacteur de rapports ancrés dans MITRE ATT&CK avec mémoire vectorielle Qdrant
  • Registre d'investigation — Enregistrement rejouable étape par étape de chaque décision IA, prompt, appel d'outil et citation de preuve
  • 800+ règles de détection natives plus 6 000+ importées de SigmaHQ, Splunk Security Content et Chronicle
  • Fusion d'alertes en temps réel — Spine Kafka, déduplication Bloom-filter sur 10M+ IOC, scoring ML (LightGBM + Isolation Forest)
  • Graphe d'attaque Neo4j — Graphe d'entités avec évaluation du rayon d'explosion pour les réponses automatisées
  • UEBA — Profils comportementaux par utilisateur avec scoring d'anomalie Z-score
  • Moteur de playbooks SOAR — 50+ playbooks communautaires avec portes d'approbation humaine signées HMAC
  • Renseignement sur les menaces — TAXII 2.1, MISP, OTX, CISA KEV avec stockage triple (recherche, vecteur, graphe)
  • Serveur MCP — Interrogez les alertes, lancez des investigations et rejouez les décisions des agents depuis Claude, Cursor ou tout IDE compatible MCP
  • Tableaux de bord de conformité — SOC 2, ISO 27001, NIST CSF, PCI-DSS, HIPAA, DORA avec collecte continue de preuves

Architecture

Architecture AiSOC

AiSOC suit une architecture microservices construite autour d'une colonne vertébrale d'événements Kafka. Voici comment les données circulent dans le système :

  1. Couche d'ingestion — 52 connecteurs envoient des événements OCSF normalisés dans Kafka. Chaque connecteur s'exécute comme un poller sur son propre planning APScheduler. Les secrets sont chiffrés au repos avec le CredentialVault basé sur Fernet.
  2. Fusion et corrélation — Le service de fusion consomme les alertes de Kafka, applique une déduplication Bloom-filter, exécute un scoring ML (LightGBM + Isolation Forest), écrit un récit de corrélation déterministe et attribue des scores de confiance. Les données sont stockées dans OpenSearch pour la recherche et ClickHouse pour l'analytique.
  3. Graphe d'entités — Un graphe Neo4j est construit en ligne avec la consommation Kafka (17 étiquettes de nœuds, 14 types d'arêtes). L'alerting basé sur les risques accumule des points de risque à décroissance temporelle sur les utilisateurs, hôtes, IP et domaines.
  4. Investigation multi-agents — Quatre agents LangGraph (Détection, Triage, Chasse, Réponse) orchestrent les investigations avec une mémoire vectorielle Qdrant, un ancrage MITRE ATT&CK et un enregistrement complet dans le registre d'investigation.
  5. Couche de stockage — Postgres (relationnel), Redis (mémoire session/travail), OpenSearch (recherche), ClickHouse (analytique), Neo4j (graphe), Qdrant (plongements vectoriels).
  6. Console et API — Console web Next.js 14 qui affiche les alertes, cas, chasses, chronologies d'investigation et tableaux de bord. API REST avec docs Swagger à /docs. Un serveur WebSocket en temps réel pousse les alertes en direct.
  7. Actions de réponse — Le moteur de playbooks exécute des actions SOAR avec évaluation du rayon d'explosion. Le dispatcher Live Actions envoie des réponses aux surfaces EDR/IAM (isolation d'hôte, désactivation d'utilisateur, blocage IP). Intégration ChatOps via Slack/Teams avec invites d'approbation signées HMAC.

Prérequis

  • Un serveur Linux (ou macOS) avec Docker 24+ et Docker Compose v2 (le plugin docker compose, pas docker-compose)
  • Au moins 6 Go de RAM allouée à Docker (8 Go+ recommandé pour la production)
  • 20 Go d'espace disque libre pour les images, conteneurs et volumes de données
  • Node.js 20+ et pnpm 8+ (uniquement requis pour la démo one-shot ou le développement)
  • Une clé API Anthropic ou OpenAI pour les fonctionnalités d'investigation IA (optionnel en mode démo/déterministe)

Guide d'Installation

AiSOC propose plusieurs chemins de déploiement. Nous couvrons les plus pratiques.

Chemin 1 : Démo en un clic — 60 secondes pour un SOC opérationnel

C'est le moyen le plus rapide de voir AiSOC en action. Il télécharge des images préconstruites et initialise les données de démonstration automatiquement.

# En une ligne — ne nécessite que curl et bash
curl -fsSL https://raw.githubusercontent.com/beenuar/AiSOC/main/install.sh | bash

Cet installateur détecte votre OS, installe Docker, Node, pnpm et Python de manière idempotente, clone le dépôt et lance la démo. Il fonctionne sur Ubuntu/Debian, Fedora/RHEL, Arch, openSUSE, Alpine, macOS et Windows (via WSL2).

Alternative — Démo Docker Compose :

git clone https://github.com/beenuar/AiSOC.git
cd AiSOC
pnpm aisoc:demo

Ceci télécharge les images préconstruites ghcr.io/beenuar/*, démarre le profil de démo léger (Postgres, Redis, Kafka, API, agents, temps réel, web), exécute l'initialiseur comme conteneur unique, et ouvre votre navigateur à /cases/INC-RT-001?tab=ledger avec demo@tryaisoc.com déjà connecté. Du clonage à l'investigation en environ 3,5 minutes sur un Docker daemon chaud.

Arrêter avec :

pnpm aisoc:demo:down

Chemin 2 : Stack de production complet avec Docker Compose

Pour une instance de production auto-hébergée, vous construirez la stack complète à partir des sources.

Étape 1 — Cloner et configurer

git clone https://github.com/beenuar/AiSOC.git
cd AiSOC
cp .env.example .env

Étape 2 — Définir vos variables d'environnement

Modifiez .env et ajoutez au moins une clé de fournisseur IA :

# Fournisseurs IA (un requis pour les fonctionnalités IA complètes)
ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...

# API d'enrichissement optionnelles
VIRUSTOTAL_API_KEY=...
ABUSEIPDB_API_KEY=...
SHODAN_API_KEY=...

# SSO optionnel (SAML 2.0 ou OIDC)
SAML_IDP_METADATA_URL=...
OIDC_DISCOVERY_URL=...

Étape 3 — Exécuter la vérification préalable

pnpm aisoc:doctor

Ceci vérifie Docker, Compose v2, la RAM allouée et la disponibilité des ports avant d'investir du temps dans une construction.

Étape 4 — Construire et démarrer

docker compose up -d --build

La première construction compile 22 services à partir des sources (Python, Go, Node, Next.js) et télécharge ~5 Go d'images de base. Sur un ordinateur portable typique, prévoyez 10–20 minutes pour la construction à froid. Les démarrages suivants réutilisent les couches mises en cache et prennent environ 90 secondes.

Étape 5 — Initialiser les données de démo (optionnel)

pnpm seed:demo

Ceci génère des cas, alertes, IOC, chemins d'attaque et anomalies UEBA pour explorer la console immédiatement.

Étape 6 — Accéder à la console

  • Console SOC — http://localhost:3000/dashboard (connexion : admin@aisoc.local / changeme)
  • API (Swagger) — http://localhost:8000/docs
  • API Agents — http://localhost:8001/docs
  • UEBA — http://localhost:8007/docs
  • Neo4j Browser — http://localhost:7474 (neo4j / neo4j_dev_secret)
  • Kafka UI — http://localhost:8090
  • Grafana — http://localhost:3001 (admin / admin)

Chemin 3 : Déploiement cloud en un clic

AiSOC peut être déployé sur plusieurs plateformes en un clic :

  • Render : Bouton Deploy to Render dans le dépôt — niveau hobby avec mise en veille, ~$14/mois
  • Fly.io : ./infra/fly/fly-demo-deploy.sh --provision — 4 apps, Postgres managé + Upstash Redis, ~$14/mois au repos
  • Railway : Utilise infra/railway/railway.toml — déploiement PaaS à l'utilisation
  • Coolify : Pointez votre instance Coolify vers le docker-compose.yml du dépôt
  • Kubernetes : helm install aisoc ./infra/helm/aisoc — configuration complète HPA, PDB, Ingress
  • AWS : cd infra/terraform && terraform apply — VPC, EKS, RDS, ElastiCache, MSK

Connexion des sources de données

Le catalogue de connecteurs d'AiSOC couvre 52 sources. Chaque connecteur présente un formulaire dans la console :

  1. Naviguez vers Paramètres → Connecteurs
  2. Choisissez votre source (ex. CrowdStrike, Splunk, AWS Security Hub, Okta)
  3. Remplissez le point de terminaison API, les identifiants et l'intervalle d'interrogation
  4. Cliquez sur Test de connexion pour un aller-retour d'authentification en direct
  5. Cliquez sur Enregistrer et activer

Les secrets sont chiffrés avec le CredentialVault de la couche applicative (Fernet AES-128-CBC + HMAC-SHA256) avant d'atteindre Postgres. Chaque connecteur interroge selon son propre planning APScheduler et envoie des événements OCSF normalisés à la colonne vertébrale d'ingestion Kafka.

Connecteurs Clés

  • EDR/XDR : CrowdStrike Falcon, SentinelOne, Microsoft Defender XDR, Palo Alto Cortex XDR / XSIAM, VMware Carbon Black, Trellix Helix
  • SIEM : Splunk, Microsoft Sentinel, Elastic, Google Chronicle, Sumo Logic, Rapid7 InsightIDR, Wazuh Indexer
  • Cloud : AWS Security Hub, GuardDuty, CloudTrail, VPC Flow Logs, Azure Activity, Azure Defender, GCP Cloud Audit, GCP SCC
  • CNAPP : Wiz, Lacework, Prisma Cloud, Orca, Tenable
  • Identité : Okta, Microsoft Entra ID, Duo Security, Auth0, 1Password
  • SaaS : Microsoft 365, Google Workspace, Cloudflare, GitHub, Slack audit, Jira, ServiceNow
  • Réseau : Tailscale, Zscaler, Cisco Umbrella
  • Conteneur : Journaux d'audit Kubernetes (apiserver webhook ou file_tail), Falco

Utilisation du Serveur MCP

AiSOC est livré avec un serveur Model Context Protocol pour interroger les alertes et lancer des investigations depuis votre IDE :

npx -y @aisoc/mcp install --host claude \
--aisoc-url https://aisoc.your-company.com \
--api-key aisoc_pat_xxxxxxxxxxxx

Ceci expose 13 outils incluant les requêtes de liste/détail d'alertes, l'investigation de cas, la recherche de règles de détection, l'interrogation du lac de données (aisoc_lake_query pour des SELECT à chaud gouvernés), et la suite complète de rejeu du registre d'investigation (aisoc_run_investigation, aisoc_replay_decision, aisoc_explain_step).

Liste de Vérification

Après le déploiement, vérifiez ces points :

  • Console accessible à http://localhost:3000/dashboard — connexion avec admin@aisoc.local / changeme
  • Documentation API à http://localhost:8000/docs — tous les groupes d'endpoints visibles
  • Données de démo initialisées : allez à /alerts et /cases — vous devriez voir des entrées préremplies incluant INC-RT-001 (ransomware LockBit 3.0)
  • Registre d'investigation rejouable : ouvrez un cas → onglet Ledger → vérifiez que vous pouvez parcourir la chaîne de raisonnement de l'agent IA
  • Test de connecteur : Paramètres → Connecteurs → choisissez une source → Test de connexion retourne un succès
  • Investigation IA fonctionnelle : ouvrez une alerte → cliquez Investiguer → l'agent LangGraph doit s'exécuter et produire des résultats
  • Vérification d'état : pnpm aisoc:doctor réussit tous les tests
  • Harnais d'évaluation public : python scripts/run_evals.py --out eval_report.json se termine sans erreur

Ressources

  • GitHub : github.com/beenuar/AiSOC
  • Démo en ligne : tryaisoc.com
  • Documentation : GitHub Docs
  • Images Docker : ghcr.io/beenuar
  • Paquet MCP : @aisoc/mcp sur npm
  • SDK Python : aisoc-sdk sur PyPI
  • Outil CLI : aisoc-cli sur PyPI — générer des plugins, valider des détections, publier sur la marketplace
  • Licence : MIT — libre d'utilisation, de modification et de distribution