Agenten stärken
Installation vom Herausgeber. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
Noch kein paketiertes Release in der Registry. Folgen Sie der README des Repositorys.
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenDocSentinel is an AI-powered SSDLC (Secure Software Development Lifecycle) platform for security teams. It automates security activities across all six phases of the software development lifecycle using intelligent AI agents orchestrated by LangGraph and powered by LangChain. It automates the review of security-related documents, forms, and reports — from requirements and design through development, testing, deployment, and operations — comparing inputs against your policy and knowledge base to produce structured assessment reports with risks, compliance gaps, and remediation suggestions.
Instead of only reviewing documents at the pre-release stage, DocSentinel embeds security from day one:
Built as a React console + FastAPI service + MCP/A2A agent gateway, DocSentinel integrates into local security review workflows, CI/CD pipelines, AI agents, and multi-agent platforms without giving external agents approval authority.
Ideal for enterprises that need to scale security assessments across many projects and SSDLC stages without proportionally scaling headcount.

The local React console brings the main workflow into one operational surface:
See the full problem statement and SSDLC phase details in SPEC.md.
DocSentinel is a React Console + FastAPI application with three governed
entry paths: REST APIs for the console and CI, MCP tools for coding agents, and
A2A JSON-RPC for remote agent delegation. These entry paths converge on the
same AssessmentService, LangGraph assessment pipeline, knowledge base, and
human-review lifecycle. Governance workflows from PallasGuard are now a
first-class domain beside assessment, backed by SQLModel records, policy packs,
control evidence, audit trails, and Pallas Lens readiness scoring.

flowchart TB
subgraph Access["Users and Agent Access"]
direction LR
Staff["Security staff"]
Console["React Console<br/>(Vite + Tailwind)"]
RESTClient["REST / CI clients"]
AgentClient["MCP / A2A clients"]
end
subgraph Runtime["FastAPI Runtime"]
direction LR
Security["Security boundary<br/>CORS, rate limit, JWT/RBAC,<br/>gateway token or loopback"]
REST["REST API routers<br/>assessments, KB, skills,<br/>settings, governance"]
Gateway["Agent Gateway<br/>MCP tools + A2A JSON-RPC"]
Tasks["AssessmentService<br/>async tasks, activity log,<br/>human review queue"]
end
subgraph Pipeline["Assessment Pipeline"]
direction LR
Parse["Parse + guardrails<br/>Docling or legacy"]
Graph["LangGraph workflow<br/>skill, isolated document data,<br/>policy/history/evidence context"]
Review["LLM draft + review<br/>via LangChain"]
Validate["Schema validation<br/>+ S2O rule checks"]
Report["Structured report<br/>risks, gaps, remediations"]
end
subgraph Governance["Governance / Pallas Domain"]
direction LR
Projects["Projects + framework selection"]
Controls["Control generator<br/>questionnaires + applicability"]
Evidence["Gate submissions<br/>evidence + audit logs"]
Lens["Pallas Lens<br/>readiness + exports"]
end
subgraph Support["Shared Support Services"]
direction LR
KB["KnowledgeBaseService<br/>Chroma + LightRAG + history"]
Policies["Policy packs + overlays<br/>schema service + S2O ontology"]
LLMFactory["LLM factory<br/>settings + llm_config.json<br/>base_url SSRF guard"]
Providers["OpenAI, Anthropic, Qwen,<br/>DeepSeek, Ollama, local OpenAI"]
DB["SQLModel DB<br/>SQLite or Postgres"]
end
Staff --> Console
Console --> Security
RESTClient --> Security
AgentClient --> Security
Security --> REST
Security --> Gateway
REST --> Tasks
Gateway --> Tasks
REST --> Projects
REST --> KB
Tasks --> Parse --> Graph --> Review --> Validate --> Report
Report --> Tasks
Report -->|project_id present| Evidence
Projects --> Controls --> Evidence --> Lens
Graph --> KB
Graph --> Policies
Review --> LLMFactory --> Providers
Validate --> Policies
Policies --> Controls
Projects --> DB
Controls --> DB
Evidence --> DB
Data flow (simplified):
/api/v1/*;
coding agents call MCP or A2A through the agent gateway.AssessmentService, which creates an async
task, parses uploaded or approved local documents, applies guardrails, and
invokes the LangGraph assessment pipeline..env plus llm_config.json, and every provider base URL is checked by the
network guard before client construction.Detailed architecture: ARCHITECTURE.md and docs/01-architecture-and-tech-stack.md.
Six dedicated AI agents, each with phase-specific skills, prompts, and knowledge base collections. Run individual phases or a full end-to-end SSDLC assessment:
Submit security questionnaires, design documents, or audit reports. DocSentinel analyzes them using configured LLMs and identifies:
PallasGuard governance capabilities are merged into DocSentinel as first-class project workflows:
generic-ssdlc plus eight public overlays for NIST SSDF,
MAS TRM, ISO 27001:2022, EU AI Act, ISO 42001, China MLPS 2.0, OWASP SAMM,
and EU CRA.Design-phase STRIDE threats are independently checked against the currently uploaded architecture documents in one inference-time pass:
supported, contradicted, or
insufficient_evidence verdict with a support score and reviewer-facing
rationale.insufficient_evidence; all verdicts
still require human review.For a public-demo input and walkthrough, see
examples/evidence-critic-architecture.md
and examples/README.md.
Upload your organization's security policies, standards, and past audits. Phase-specific collections ensure each agent retrieves the most relevant context:
Powered by LangChain + LangGraph — stateful, graph-based agent workflows with conditional routing per SSDLC stage. Parallel execution of Policy and Evidence agents, followed by Drafter and Reviewer agents.
Use the local React console for human review, integrate CI/CD pipelines through the REST API, or expose the same assessment capabilities to AI agents (Claude Desktop, Cursor, OpenClaw) through MCP. A2A-compatible platforms can delegate assessment tasks to DocSentinel as a specialist security agent.
DocSentinel includes an evals/ harness for measuring assessment quality against
public and future golden datasets without going through HTTP or the UI. The first
implemented path covers OWASP Benchmark v1.2 SAST triage:
AssessmentService.submit()
with phase="testing" and skill_id="ssdlc-testing", matching production task
semantics while staying self-contained.scorecard.json and a
human-readable scorecard.md under evals/reports/<run_id>/.python evals/datasets/owasp_benchmark/fetch.py
python -m evals.runner.run_eval \
--dataset-id owasp_benchmark \
--raw-dir evals/datasets/owasp_benchmark/raw/BenchmarkJava-master \
--run-id local-owasp \
--repeats 1
See docs/07-evaluation-plan.md for the full methodology and milestone roadmap.
This roadmap turns the project's agent-safety principles into implementation work that can be delivered and reviewed incrementally. It is informed by Microsoft Learn's Designing Agent Architecture and SDLC Integration module and follows one governing rule: agents propose; deterministic policy and authorized humans accept.
The target control flow is:
Task contract -> Visible plan -> Bounded execution -> Objective evaluation
-> Human/policy approval -> Published result
Status legend: [x] implemented baseline, [ ] planned work. Priorities indicate
delivery order rather than release dates.
Goal: make the pull request the enforceable control point for human and agent-generated changes.
CODEOWNERS for security-sensitive paths, including
.github/workflows/, app/core/, app/agent_gateway/, migrations,
deployment files, and policy packs.main ruleset to require pull requests, passing CI and Plan
Gate checks, resolved conversations, and CODEOWNERS approval for sensitive
changes.Exit criteria: a planless change or an unreviewed sensitive-path change cannot
be merged into main.
Goal: make agent intent, authority, outputs, and success conditions inspectable before effects occur.
AgentTaskContract schema containing goal, inputs,
allowed paths/tools, expected outputs, success criteria, risk tier, approval
mode, retry limit, and escalation owner.PlanArtifact to the
assessment graph.Exit criteria: every assessment can answer what was requested, what the agent was allowed to do, what plan it followed, and which signals determined success.
Goal: make long-running assessments restart-safe, bounded, and recoverable.
task_id as the stable execution/thread identifier.Exit criteria: a process restart can resume an assessment without losing review history, duplicating effects, or entering an infinite retry loop.
Goal: make every meaningful agent action attributable and enforce least privilege independently of model instructions.
Exit criteria: operators can determine who or what performed an action, against which inputs and code state, under which capability policy, and with what result.
Goal: turn assessment quality and production safety into objective release signals.
Exit criteria: releases have reproducible quality evidence, an approved code reference, a human decision for critical effects, and a verified rollback path.
Every roadmap PR must include:
Implementation should proceed in milestone order because M0 establishes the repository controls used to review M1–M4 safely. Each unchecked item is intended to be small enough to become a dedicated GitHub issue and pull request.
Use MCP to expose bounded tools to Claude Desktop, Cursor, coding agents, and workflow platforms. Use A2A to expose DocSentinel as a remote specialist agent. REST, MCP, and A2A submissions share the same task lifecycle and activity log. Agent-created assessments always remain drafts until a human reviewer approves them in the console.
MCP exposes five governed tools:
submit_document_assessmentget_assessment_statusassess_document (compatibility tool)query_knowledge_baseget_agent_gateway_statusThe A2A Agent Card advertises assessment submission, assessment retrieval, and security knowledge query skills.
Once connected, you can ask your AI agent:
"Analyze the attached
requirements.pdffor missing security requirements using DocSentinel.""Run a STRIDE threat model on
system-design.pdfusing the Design Agent.""Triage these SonarQube SAST findings and prioritize by risk."
Add to your claude_desktop_config.json:
{
"mcpServers": {
"docsentinel": {
"command": "/path/to/DocSentinel/.venv/bin/python",
"args": ["/path/to/DocSentinel/app/mcp_server.py"],
"env": {
"OPENAI_API_KEY": "sk-...",
"CHROMA_PERSIST_DIR": "/absolute/path/to/data/chroma",
"MCP_DOCUMENT_ROOTS": "/absolute/path/to/approved/documents"
}
}
}
}
assess_document only reads files inside MCP_DOCUMENT_ROOTS. Use : to
separate multiple roots on macOS/Linux, or ; on Windows. If unset, the
server only allows ./examples.
FastAPI also serves Streamable HTTP MCP at /mcp/ and publishes the A2A Agent
Card at /.well-known/agent-card.json. Tokenless protocol access is
loopback-only. External agents cannot approve, reject, or bypass human review.
For network, Docker, or reverse-proxy access, configure:
AGENT_GATEWAY_TOKEN=generate-a-long-random-value
AGENT_GATEWAY_PUBLIC_URL=https://docsentinel.internal.example
AGENT_GATEWAY_ALLOWED_HOSTS=docsentinel.internal.example
AGENT_GATEWAY_ALLOWED_ORIGINS=https://trusted-agent-console.internal.example
Clients send Authorization: Bearer <AGENT_GATEWAY_TOKEN>. Keep
MCP_DOCUMENT_ROOTS, allowed hosts, and allowed origins as narrow as possible.
Docker bridge traffic is not treated as loopback, so published MCP/A2A ports
require a token.
docsentinelstdio/path/to/DocSentinel/.venv/bin/python/path/to/DocSentinel/app/mcp_server.pySee full guide in docs/06-agent-integration.md.
git clone https://github.com/arthurpanhku/DocSentinel.git
cd DocSentinel
chmod +x deploy.sh
./deploy.sh
To connect an external agent through the published Docker port, set
AGENT_GATEWAY_TOKEN in .env before running ./deploy.sh.
Prerequisites: Python 3.11+ and Node.js 20+. Optional:
Ollama (ollama pull llama2).
git clone https://github.com/arthurpanhku/DocSentinel.git
cd DocSentinel
python3 -m venv .venv
source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -r requirements.txt
cp .env.example .env # Edit if needed: LLM_PROVIDER=ollama or openai
npm install --prefix frontend
npm run build --prefix frontend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
Set these values in .env, or use the Settings page after the server is
running. Never commit real API keys.
LLM_PROVIDER=deepseek
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-chat
DEEPSEEK_API_KEY=sk-your-deepseek-key
http://localhost:8000/mcp/DocSentinel includes a React + TypeScript + Vite + Tailwind CSS console for assessments, knowledge base operations, skills, and system status.

npm install --prefix frontend
npm run build --prefix frontend
uvicorn app.main:app --reload --host 0.0.0.0 --port 8000
Open http://localhost:8000/console. For frontend-only development, run:
npm run dev --prefix frontend
The Vite dev server proxies /api, /health, and /config to http://localhost:8000.
The Settings page can update the running server's LLM provider, model, base URL, and API key. API keys are only returned to the UI as masked previews. For persistent startup defaults, set the matching values in .env.
# Run a Design phase assessment (threat modeling)
curl -X POST "http://localhost:8000/api/v1/assessments" \
-F "files=@examples/architecture-doc.pdf" \
-F "phase=design" \
-F "scenario_id=threat-modeling"
# Response: { "task_id": "...", "status": "accepted" }
# Get the result
curl "http://localhost:8000/api/v1/assessments/TASK_ID"
# Upload a security policy to the requirements KB collection
curl -X POST "http://localhost:8000/api/v1/kb/documents" \
-F "file=@examples/sample-policy.txt" \
-F "collection=kb_requirements"
# Query the KB (RAG)
curl -X POST "http://localhost:8000/api/v1/kb/query" \
-H "Content-Type: application/json" \
-d '{"query": "What are the access control requirements?", "top_k": 5}'
A hosted deployment is available on Fronteir AI.
DocSentinel/
├── frontend/ # React + TypeScript + Vite + Tailwind console
├── app/ # Application code
│ ├── api/ # REST routes: assessments, KB, health, skills
│ ├── agent_gateway/ # MCP/A2A adapters, auth boundary, Agent Card
│ ├── agent/ # LangGraph orchestrator, phase agents, skills
│ │ ├── orchestrator.py # LangGraph state machine & phase routing
│ │ ├── agents/ # Phase-specific agent implementations
│ │ ├── ssdlc/ # SSDLC pipeline: stage router, stage skills, checklists
│ │ ├── skills_registry.py # Built-in skills per SSDLC phase
│ │ └── skills_service.py # Skill CRUD and management
│ ├── core/ # Config, guardrails, security, DB
│ ├── kb/ # Knowledge Base (Chroma + LightRAG graph RAG)
│ ├── llm/ # LangChain LLM abstraction (OpenAI, Ollama)
│ ├── parser/ # Document parsing (Docling + SAST/DAST + legacy)
│ ├── models/ # Pydantic / SQLModel models
│ ├── services/ # Shared assessment task lifecycle
│ ├── main.py # FastAPI app entry point
│ └── mcp_server.py # MCP stdio + Streamable HTTP tools
├── tests/ # Automated tests (pytest)
├── evals/ # Reproducible quality eval harness and scorecards
├── examples/ # Sample files (questionnaires, policies, reports)
├── docs/ # Design & Spec documentation
│ ├── 01-architecture-and-tech-stack.md
│ ├── 02-api-specification.yaml
│ ├── 03-assessment-report-and-skill-contract.md
│ ├── 04-integration-guide.md
│ ├── 05-deployment-runbook.md
│ ├── 06-agent-integration.md
│ ├── 07-evaluation-plan.md
│ └── schemas/
├── .github/ # Issue/PR templates, CI (Actions)
├── Dockerfile
├── docker-compose.yml
├── docker-compose.ollama.yml
├── CONTRIBUTING.md
├── CODE_OF_CONDUCT.md
├── CHANGELOG.md
├── SPEC.md # PRD with SSDLC phase definitions
├── ARCHITECTURE.md # System architecture with LangGraph design
├── LICENSE
├── SECURITY.md
├── requirements.txt
├── requirements-dev.txt
└── .env.example
See .env.example and docs/05-deployment-runbook.md for full options.
evals/.chmod +x test_integration.sh
./test_integration.sh
pip install -r requirements-dev.txt
pytest
pytest tests/test_skills_api.py # Run specific test
pytest evals/tests # Run evaluation harness tests
Issues and Pull Requests are welcome. Please read CONTRIBUTING.md for setup, tests, and commit guidelines. By participating you agree to the CODE_OF_CONDUCT.md.
AI-Assisted Contribution: We encourage using AI tools to contribute! Check out CONTRIBUTING_WITH_AI.md for best practices.
Submit a Skill Template: Have a great security persona for an SSDLC phase? Submit a Skill Template or add it to examples/templates/.
MCP_DOCUMENT_ROOTS; symlink escapes are rejected before file reads.This project is licensed under the MIT License — see the LICENSE file for details.
If you use DocSentinel in your organization or contribute back, we'd love to hear from you (e.g. via GitHub Discussions or Issues).
MCP server for AI agent for cybersecurity: automate assessment of documents, questionnaires & reports. Multi-format parsing, RAG knowledge base,Risks, compliance gaps, remediations.
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
DocSentinel läuft lokal über stdio.
Zuletzt geprüft: 2026-10-28. MCP server for AI agent for cybersecurity: automate assessment of documents, questionnaires & reports. Multi-format parsing, RAG knowledge base,Risks, compliance gaps, remediations.