omniseek-mcp
Provides SARIF 2.1.0 output compatible with GitHub code scanning, enabling integration with GitHub's security features.
Allows using Google's Gemini models for deeper, cross-file code analysis. The server sends line-numbered code excerpts to the model and verifies the returned findings against the repository.
Allows using OpenAI's models for deeper, cross-file code analysis. The server sends line-numbered code excerpts to the model and verifies the returned findings against the repository.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@omniseek-mcpscan this repo for security and performance issues and render an HTML dossier"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
OmniSeek
Citation-grounded codebase intelligence. OmniSeek reviews a repository through four lenses (architecture, security, performance, product) and backs every finding with file:line evidence. Then it checks that evidence against your files, so a hallucinated line number or invented function cannot slip into the report.
Runs anywhere, immediately. Pure Python standard library: no compiler, no native wheels, no mandatory dependencies.
Deterministic by default. More than 40 built-in rules, with Python rules evaluated on the syntax tree, so code inside strings and comments never matches. The same tree gives the same findings.
Bring your own model. Add
--model anthropic/…,openai/…orgemini/…and your own key for deeper, cross-file findings. Model findings are verified like everything else, and the ones whose citations do not exist are dropped.Verifies anyone's claims.
omniseek verifychecks any findings file (yours, another tool's, an AI assistant's) against the working tree or a git revision and scores it from 0.0 to 1.0.Ships where you work. A self-contained HTML dossier, SARIF 2.1.0 for GitHub code scanning, Markdown for pull requests, and an MCP server for Claude, Cursor and other assistants.
60-second quickstart
pipx install omnirogue-omniseek # or: pip install omnirogue-omniseek
omniseek scan . --output findings.json --html dossier.html
omniseek verify findings.json --repo .
open dossier.html # xdg-open on LinuxNo install at all? From a checkout, python3 -m omniseek scan . works with any Python 3.10+.
Package name. On PyPI this tool is
omnirogue-omniseek; the command and the Python package areomniseek. The PyPI project calledomniseekis unrelated. To install straight from this repository instead:pipx install "git+https://github.com/omnirogue/omniseek".
Try it on the deliberately flawed demo app, including a findings file with planted hallucinations:
bash examples/run_demo.sh # writes the dossier, SARIF and Markdown to a temp directoryRelated MCP server: architectos
How it works
┌──────────────────────── omniseek scan ─────────────────────────┐
local dir │ repo walker ──▶ heuristic lenses ──┐ │
or git URL ────────▶│ (git ls-files, architecture │ │
│ .gitignore, security ├──▶ findings ──▶ verifier ├──▶ findings.json
│ no symlinks) performance │ + citations (0.0-1.0)│ (omniseek.findings/v1)
│ product │ │
│ optional: --model provider/model ──┘ redacted, line-numbered │
│ (your key; ungrounded findings dropped) │
└────────────────────────────────────────────────────────────────┘
│
┌────────────────────┬───────────────────┼────────────────────┬─────────────────────┐
▼ ▼ ▼ ▼ ▼
omniseek report omniseek report omniseek report omniseek verify omniseek cloud-sync
--format html --format sarif --format md any findings file (optional, OmniSI Cloud)
dark-mode dossier GitHub code PR comments vs. working tree
scanning or a git revision
omniseek-mcp: the same scan, verify and render as MCP tools (stdio, or streamable HTTP)Commands
Command | What it does |
| Scans a local directory, or shallow-clones an |
| Checks every citation; prints the grounding score and each flagged citation |
| Renders a findings file; |
| Optional: sends a findings file to OmniSI Cloud (needs |
| Lists the built-in rules |
Exit codes: 0 success, 1 a gate failed (--fail-on severity or --min-score), 2 bad input or usage.
Lenses
Lens | Examples of what the built-in rules find |
security | Hardcoded credentials (never copied into output), committed |
performance | HTTP or database calls inside loops (N+1), blocking calls in |
architecture | Import cycles (Python and JS/TS), very large files, long and highly complex functions, change hotspots from git history, swallowed exceptions, wildcard imports, deep relative imports, TODO/FIXME debt |
product | Missing README, license, security policy or contributing guide; README without install/usage; broken relative links in Markdown; no tests; no CI; incomplete package metadata; placeholder (lorem-ipsum) copy in user-facing files |
Test and example code is not held to the architecture and performance rules, and security findings there are marked low confidence. Add an .omniseekignore file (one glob per line) to skip more paths.
The citation verifier
A finding is only as good as its evidence. Every finding carries citations:
{
"rule_id": "security/sql-string-building",
"lens": "security",
"severity": "high",
"title": "SQL built from strings",
"citations": [
{"kind": "span", "path": "app.py", "start_line": 17, "end_line": 17,
"snippet": "return conn.execute(f\"SELECT id, email FROM users WHERE name = '{name}'\").fetchone()",
"symbol": "find_user"},
{"kind": "absence", "globs": ["license", "license.*"]}
]
}omniseek verify checks that the path stays inside the repository (no .., no absolute paths, no symlinks out), the file exists and is text, the line range is inside the file, the quoted snippet appears in exactly those lines (whitespace-insensitive), and the symbol appears there as a whole identifier. An absence citation is verified only if none of its paths or globs exist.
Status | Score | Meaning |
| 1.0 | Path, range, quote and symbol all check out |
| 0.5 | The quote or symbol exists in the file, but at other lines (the actual lines are reported) |
| 0.5 | The range exists but nothing was quoted, so the content could not be checked |
| 0.0 | The file, quote or symbol does not exist, or a claimed absence is present |
| 0.0 | Malformed, or points outside the repository |
A finding's grounding_score is the mean of its citation scores (0.0 when it cites nothing), and the document's score is the mean over findings. Verification proves provenance, not correctness: a verified citation shows the evidence exists where the finding says it does.
Shorthand citations such as "app.py:15-17" and {"file": …, "lines": "15-17"} are accepted, so you can verify output from other tools and assistants. Use --ref <sha> to verify against a commit instead of the working tree.
Bring your own model
export ANTHROPIC_API_KEY=... # or OPENAI_API_KEY / GEMINI_API_KEY
omniseek scan . --model anthropic/claude-sonnet-5-5 --html dossier.html
omniseek scan . --model openai/<model-id>
omniseek scan . --model gemini/<model-id>Provider | Key | Endpoint override |
|
|
|
|
|
|
|
|
|
What is sent: a file list, the heuristic leads, and line-numbered excerpts (lead areas, entry points, configuration, then the largest source files) within --max-context-chars (default 120,000). .env files, key files and lockfiles are never sent, and values that look like credentials are replaced with «redacted» first. Keys are read from the environment only. Requests go over HTTPS (plain HTTP only to localhost). Install omnirogue-omniseek[httpx] to use httpx instead of urllib.
The model's findings are validated against the schema, then verified; findings with no valid citation are dropped unless you pass --keep-ungrounded.
MCP server
omniseek-mcp exposes three tools: omniseek_scan (read-only, offline), omniseek_verify_citations (read-only) and omniseek_render_dossier (writes a file only when given output_path, and never overwrites without overwrite: true). Every path must be inside a --root directory (default: the working directory). Scans through MCP never call a model; your assistant already is one.
Claude Code:
claude mcp add omniseek -- omniseek-mcp --root /path/to/projectClaude Desktop, Cursor, OmniConsole and other clients that read an mcpServers file:
{
"mcpServers": {
"omniseek": {
"command": "omniseek-mcp",
"args": ["--root", "/path/to/project"]
}
}
}Without installing, use "command": "python3", "args": ["-m", "omniseek.mcp_server", "--root", "/path/to/project"] with "env": {"PYTHONPATH": "/path/to/omniseek"}.
Streamable HTTP (needs pip install "omnirogue-omniseek[mcp]", works with MCP SDK 1.x and 2.x):
omniseek-mcp --transport streamable-http --root /path/to/project --port 8765 # http://127.0.0.1:8765/mcpIt binds to 127.0.0.1 and has no authentication of its own; put it behind your own authenticating proxy if you expose it.
GitHub code scanning (SARIF)
Copy examples/github-action-sarif.yml to .github/workflows/omniseek.yml:
name: omniseek
on:
push:
branches: [main]
pull_request:
permissions:
contents: read
security-events: write
jobs:
scan:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
- run: pip install "omnirogue-omniseek==0.1.0"
- run: omniseek scan . --output omniseek-findings.json --sarif omniseek.sarif --html omniseek-dossier.html --md omniseek.md
- uses: github/codeql-action/upload-sarif@v3
if: always()
with:
sarif_file: omniseek.sarif
category: omniseek
- uses: actions/upload-artifact@v4
if: always()
with:
name: omniseek-dossier
path: omniseek-dossier.htmlResults appear under Security → Code scanning. Security rules carry a security-severity, so GitHub ranks them as critical, high, medium or low. Add --fail-on high to the scan step to block merges on serious findings.
OmniSeek open source vs. OmniSI Cloud
OmniSeek is the open-source core of OmniSI. OmniSI Cloud is a separate, proprietary service built on the OmniRogue Rust Engine. cloud-sync is the only bridge between them: it is optional, sends only a findings file you already have (never your repository), and nothing leaves your machine without OMNISI_API_KEY.
OmniSeek (this repository, Apache-2.0) | OmniSI Cloud (proprietary, OmniRogue Rust Engine) | |
Where it runs | Your machine or CI, offline by default | Hosted service |
Analysis | 40+ deterministic rules across 4 lenses, plus your own model | Parallel Rust ingestion of large monorepos and evidence packs; multi-stage model pipeline |
Verification | Deterministic citation and grounding verifier | Cross-family adversarial verification: findings challenged by models from different labs |
Memory | Stateless; one findings file per run | Organization memory: deduplicates findings across repositories and runs |
Action | HTML, SARIF, Markdown, MCP | Turns a confirmed finding into a Decision your team approves, then executes the action exactly once |
Models and keys | Bring your own (OpenAI, Anthropic, Gemini, OpenAI-compatible) | Managed |
Price | Free | Commercial |
Bridge |
| Receives findings from OmniSeek |
export OMNISI_API_KEY=...
omniseek cloud-sync findings.json --dry-run # see exactly what would be sent
omniseek cloud-sync findings.json --no-snippets # send without quoted codecloud-sync posts omniseek.cloud-sync/v1 JSON to {api_url}/v1/omniseek/scans with an idempotency key. The local repository path is never sent.
Privacy and security
scan,verifyandreportmake no network calls. Only--model,cloud-syncand scanning a git URL do, and only to the endpoint you chose.Secret values are never copied into findings or reports: citations quote the text before the value plus its first four characters, and code excerpts are redacted.
The HTML dossier is one file with no external requests. All content is escaped and the inline script is pinned by a Content-Security-Policy hash.
The scanner never follows symlinks out of the repository, and the verifier rejects citations that escape it.
Report vulnerabilities privately; see SECURITY.md.
Findings schema
omniseek.findings/v1: schema, tool, generated_at, repo (name, commit, files_scanned, languages), analyzer (mode, model, lenses), summary, findings[] and, after verification, verification plus a verification block on each finding. Each finding has id (stable across line moves), rule_id, lens, severity (critical, high, medium, low, info), confidence, title, description, remediation[], citations[] and source (heuristic or llm:<provider>/<model>). See examples/sample_findings.json.
Development
python -m unittest discover -s tests # no dependencies needed
python -m omniseek scan . --output /tmp/self.json && python -m omniseek verify /tmp/self.json --repo .Tested on Linux and macOS with Python 3.10 to 3.13. See CONTRIBUTING.md to add a rule.
License
Apache-2.0. See NOTICE.
Available Tools
3 toolsomniseek_render_dossierRender a dossierA
Render findings as a self-contained dark-mode HTML dossier, GitHub SARIF 2.1.0 or Markdown. With output_path the result is written to that file (inside a root) and only its path is returned.
| Name | Required | Description | Default |
|---|---|---|---|
| format | No | html | |
| findings | No | A findings document (as returned by omniseek_scan) or a list of findings. | |
| overwrite | No | ||
| output_path | No | File to write; must not exist unless overwrite. | |
| findings_path | No | Path to a findings JSON file, instead of `findings`. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare write-but-not-destructive and non-open-world; the description adds real behavioral context beyond that: output is self-contained, writes are confined 'inside a root', and only the file path is returned. It stops short of explaining overwrite semantics or failure modes, but the sandboxing and return behavior are genuinely useful additions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with zero filler; the primary capability (formats) is front-loaded and the output_path side effect follows. Every clause carries information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and five optional parameters, the description adequately covers the format choices and the file-writing path. It is slightly thin on the findings/findings_path input alternatives and overwrite behavior, but the core invocation path is well covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 60%. The description usefully maps the format enum to human-readable outputs and clarifies output_path's write-and-return-path behavior, but it says nothing about findings vs findings_path, the overwrite flag, or the required-at-least-one-input constraint, leaving part of the parameter surface unexplained.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (render) and resource (findings into a dossier) plus the exact output formats (dark-mode HTML, GitHub SARIF 2.1.0, Markdown). This is clearly distinguishable from the sibling scan and verify_citations tools without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by explaining what happens when output_path is supplied, but never states when to choose this tool over its siblings or when each format is appropriate. No exclusions or alternatives are given, so usage must be inferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
omniseek_scanScan a repositoryARead-onlyIdempotent
Deterministic multi-lens scan (architecture, security, performance, product) of a local directory. Every finding cites file:line evidence and comes back verified against the files. Offline and read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| path | No | Directory to scan (default: the first root). | |
| lenses | No | ||
| max_findings | No | ||
| min_severity | No | info |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint=false and idempotentHint, so 'offline and read-only' is largely redundant. The description nonetheless adds real behavioral context beyond them: deterministic execution, file:line evidence for every finding, and verification against the actual files.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three compact sentences with the core capability front-loaded and no wasted clauses. The closing 'Offline and read-only' sentence partly restates what the annotations already provide, which is the only slack.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should carry more of the return-value burden. It does say findings cite file:line and are verified, but never explains the result shape, ordering, truncation relative to max_findings, or what 'verified' concretely means. Adequate but with clear gaps for a 4-param tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 25% (only 'path' is documented), so the description must compensate. It partially does by enumerating the four lens values that map to the undocumented 'lenses' parameter, but max_findings and min_severity/severity semantics remain undocumented in both places.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb+resource ('multi-lens scan ... of a local directory') with the four lenses enumerated, so the agent knows exactly what the tool does. It does not, however, distinguish itself from the siblings omniseek_verify_citations and omniseek_render_dossier, even though 'comes back verified' hints at overlap with the former.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The scoping hints ('local directory', 'offline') imply when this is appropriate, but there is no explicit when-to-use, no exclusion, and no routing to omniseek_verify_citations or omniseek_render_dossier even though they sound adjacent. Usage is left largely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
omniseek_verify_citationsVerify citationsARead-onlyIdempotent
Check that every cited file:start-end span, quoted snippet and symbol in a findings document exists in the repository (working tree or a git ref). Returns a 0.0-1.0 grounding score and flags drifted, hallucinated and invalid citations. Use it on findings you or another model wrote.
| Name | Required | Description | Default |
|---|---|---|---|
| ref | No | Optional git revision to verify against. | |
| repo | No | Repository directory (default: the first root). | |
| findings | No | A findings document (as returned by omniseek_scan) or a list of findings. | |
| findings_path | No | Path to a findings JSON file, instead of `findings`. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations cover the safety profile (readOnly, idempotent, closed-world), and the description adds substantial behavior beyond that: what is verified against (working tree or a git ref), the return shape (a 0.0-1.0 grounding score), and the failure categories produced (drifted, hallucinated, invalid). Since there is no output schema, disclosing the score and flags here is genuinely necessary and valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences: verification scope first, return values second, usage cue last. Every sentence carries distinct information and nothing is repeated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and only a small optional-parameter surface, the description supplies exactly what an agent needs: what gets verified, what the result means, and when to reach for it. Nothing material is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so `ref`, `repo`, `findings` and `findings_path` are already documented, and the description largely restates them (git ref, findings document). The one added nuance is that findings may come from another model's output, which the schema does not say. Baseline 3 is appropriate when the schema carries the parameter burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (verify that each cited span/snippet/symbol in a findings document exists in the repo) and enumerates the exact citation kinds checked. This is clearly distinguishable from omniseek_scan (produces findings) and omniseek_render_dossier (renders them) without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
"Use it on findings you or another model wrote" gives clear context for invocation, and the schema's reference to findings "as returned by omniseek_scan" chains it into the workflow. It stops short of naming an alternative or stating when not to use it (e.g. verifying against uncommitted work vs a ref), so it is not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
omniseek_render_dossier - First observed
omniseek_scan - First observed
omniseek_verify_citations
TDQS
Scored across 3 tools
Each tool targets a clearly distinct stage of a pipeline: omniseek_scan generates findings, omniseek_verify_citations validates citations in a findings document, and omniseek_render_dossier formats output. There is no overlap in trigger conditions or inputs, so misselection is unlikely.
All three tools use the same omniseek_ snake_case prefix followed by a concise action phrase (scan, verify_citations, render_dossier). The convention is predictable and readable throughout.
Three tools is on the lean side but each corresponds to a genuine, non-redundant step (scan, verify, render). The surface feels intentionally minimal rather than padded.
The scan → verify → render lifecycle covers the core workflow end to end, including multiple output formats and git-ref grounding checks. Minor gaps exist, such as baseline/diff comparison between scans or filtering of prior findings, but nothing blocks the primary use case.
Maintenance
Related MCP Connectors
Screens public GitHub repos and PRs to generate risk maps, findings, and merge-readiness signals.
Generate SBOMs, scan vulnerabilities, and analyze dependencies from local projects or Git repos.
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
Read-only AI coding tools for change verification, release readiness, capacity, and guidance.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables triage of SAST findings by exposing a read-only MCP server with tools to access hash-verified source-to-sink code slices, unguarded sinks, and layered enrichment for local LLM analysis.10MIT
- FlicenseNot gradedqualityCmaintenanceAnalyzes repositories, explains architecture, calculates change impact, and enforces guardrails for AI Agents like Claude Code, Cursor, and Codex via MCP tools.-

repo-doctorofficial
AlicenseNot gradedqualityCmaintenanceMCP server that produces scored, evidence-cited audits of public GitHub repos via tools for fetching metadata, reading files, scanning git history, and checking hygiene.MIT- AlicenseNot gradedqualityBmaintenanceEnables MCP clients to query previously analyzed GitHub repositories for architecture analysis, code review findings, and single-turn code Q&A with verifiable file and line references.MIT