# OPA MCP (npm · @orygn/opa-mcp) Author, validate, debug, and explain OPA Rego policies through any MCP-compatible client. - Trust score: 81/100 (high trust) - Change this week: +30 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-08-03 ## Components - npm · `@orygn/opa-mcp`: 81/100 (this document), [markdown](https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp.md), [page](https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp) - oci · `docker.io/orygn/opa-mcp:0.2.1`: 44/100, [markdown](https://verifymcp.io/servers/orygnscode-opa-mcp/docker-io-orygn-opa-mcp-0-2-1.md), [page](https://verifymcp.io/servers/orygnscode-opa-mcp/docker-io-orygn-opa-mcp-0-2-1) ## Channel facts - Registry: `npm` - Package: `@orygn/opa-mcp` - Version: `0.2.1` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-08-03. - **Supply Chain Security**: 89/100 - No malware found by supply-chain analysis. - Only part of the dependency tree could be resolved (103 of 107), so this covers what we could see, not the whole tree. - No install/post-install scripts declared. - Only part of the dependency tree could be resolved (103 of 107), so this covers what we could see, not the whole tree. - **Provenance & Transparency**: 97/100 - Source repository is publicly reachable at the declared URL. - Cryptographically verified build provenance (signed, bound to OrygnsCode/opa-mcp-server). - Clear OSI-approved license (MIT). - Actively maintained (last published 38 days ago). - Disclosure check failed: no security disclosure policy was found in the source repository. - **Schema Quality & AI Usability**: 79/100 - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name). - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 10903 tokens (~198/item across 55 items; 52 tools + 3 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 27/100 - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### Claude ```bash claude mcp add orygnscode-opa-mcp -- npx -y @orygn/opa-mcp ``` ### Codex ```bash codex mcp add orygnscode-opa-mcp -- npx -y @orygn/opa-mcp ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "orygnscode-opa-mcp": { "type": "local", "command": [ "npx", "-y", "@orygn/opa-mcp" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add orygnscode-opa-mcp --command npx --arg -y --arg @orygn/opa-mcp ``` ### Hermes ```yaml mcp_servers: orygnscode-opa-mcp: command: "npx" args: ["-y", "@orygn/opa-mcp"] ``` ### Other ```json { "mcpServers": { "orygnscode-opa-mcp": { "command": "npx", "args": [ "-y", "@orygn/opa-mcp" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-08-03 (score 81, +1) No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-08-02 (score 80, +44) - [security improvement] Provenance: unverified → pass - [security improvement] Known CVEs: unverified → partial - [security improvement] Install scripts: unverified → pass - [security improvement] Malware scan: unverified → pass - [security] The attested source repository moved: OrygnsCode/opa-mcp-server - [functional improvement] License: unverified → pass - [functional improvement] Dependency health: unverified → partial - [functional improvement] Maintenance: unverified → pass - [functional improvement] Stability: unverified → 0.23 - [functional] Licence: MIT ### 2026-08-01 (score 36, +31) - [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window). - [functional improvement] Tool coverage: unverified → 100 - [functional improvement] Schema quality: unverified → 100 - [functional improvement] MCP protocol: unverified → pass ### 2026-07-31 (score 5, −58) - [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server ### 2026-07-30 (score 63, −30) - [security regression] Known CVEs: partial → unverified - [security regression] Malware scan: pass → unverified - [functional regression] Dependency health: partial → unverified ### 2026-07-29 (score 93, +42) - [security improvement] Install scripts: unverified → pass - [security improvement] Provenance: unverified → pass - [security improvement] Known CVEs: unverified → partial - [security] The attested source repository moved: OrygnsCode/opa-mcp-server - [functional improvement] License: unverified → pass - [functional improvement] Schema quality: unverified → excellent - [functional improvement] Dependency health: unverified → partial - [functional improvement] Maintenance: unverified → pass - [functional] Licence: MIT ### 2026-07-27 (score 51) First indexed and scored. ## MCP tools (52) ### `rego_format` (~118 tokens) Format Rego Format Rego source code using `opa fmt`. Returns the formatted source and a `changed` flag indicating whether the input was already canonical. When the source uses string interpolation ($"..." or $`...` syntax) and OPA v1.12.0 or v1.12.1 is detected, the tool warns about or blocks formatting due to a known OPA bug that corrupts \{ escape sequences (fixed in OPA v1.12.2). Input parameters: - `source` (string, required): Rego source code to format. ### `rego_check` (~241 tokens) Check Rego Type-check Rego with `opa check`. Returns `{ valid: true, errors: [] }` on success, or a list of structured diagnostics with file/line locations on failure. Provide either `source` for inline checking or `paths` for file/directory checking. Input parameters: - `bundle` (boolean): Load `paths` as bundle files or root directories (`--bundle`). Only valid with `paths`, not inline `source`. - `capabilities` (string): Path to a capabilities JSON file restricting allowed builtins. - `maxErrors` (integer): Maximum number of errors to collect before `opa check` aborts compilation (`--max-errors`, OPA default 10). Raise it to surface more diagnostics from a badly broken policy in a single pass. - `paths` (array): Filesystem paths to check. Each path must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). - `schemaDir` (string): Schema directory for input/data validation. - `source` (string): Inline Rego source. Mutually exclusive with `paths`. - `strict` (boolean): Enable strict mode -- fail on unused vars, deprecated builtins, etc. ### `rego_check_schema` (~353 tokens) Check Rego against a JSON Schema Validate that a Rego policy's input.* field references are consistent with a JSON Schema using `opa check --schema`. Every field the policy reads from `input` must exist in the schema; mismatches surface as rego_type_error diagnostics with file/line locations. Returns `{ valid: true, errors: [] }` when all references match the schema, or `{ valid: false, errors: [...] }` with structured diagnostics when they do not. Accepts the schema inline (pass the `schema` output of `rego_infer_input_schema` directly as `inlineSchema`) or as a path to an existing JSON Schema file on disk (`schemaPath`). Provide `source` for inline Rego or `paths` for file/directory checking. Input parameters: - `inlineSchema` (object): JSON Schema (draft-07) object describing the expected shape of the `input` document. Mutually exclusive with `schemaPath`. Accepts the `schema` field from `rego_infer_input_schema` output directly. - `paths` (array): Filesystem paths to policy files or directories to validate. Each path must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Mutually exclusive with `source`. - `schemaPath` (string): Path to a JSON Schema file on disk to use for `input` validation. Must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Mutually exclusive with `inlineSchema`. - `source` (string): Inline Rego source to validate against the schema. Mutually exclusive with `paths`. - `strict` (boolean): Enable strict mode -- also fail on unused variables, deprecated builtins, and other non-fatal issues in addition to schema violations. ### `rego_lint` (~289 tokens) Lint Rego Lint Rego source with the Regal linter. Returns categorized violations (style, bugs, idiomatic, performance) with file/line locations. Requires `regal` on PATH or `REGAL_BINARY` set; returns REGAL_NOT_FOUND otherwise. When called with inline `source`, location-bound rules whose verdict depends on the on-disk path (`directory-package-mismatch`) are auto-disabled to avoid temp-file false positives, and `location.file` is reported as `` instead of the randomized temp path. Re-enable those rules via `enable` if your workflow actually needs them. Input parameters: - `configFile` (string): Path to a Regal config file (defaults to .regal/config.yaml lookup). - `disable` (array): Disable specific named rules. - `disableCategory` (array): Disable entire rule categories (e.g. style, idiomatic, bugs). - `enable` (array): Enable specific named rules. - `enableCategory` (array): Enable entire rule categories. - `failLevel` (string): Severity at which Regal returns a non-zero exit. Default: `error`. - `ignoreFiles` (array): Glob patterns to skip. - `paths` (array): Filesystem paths to lint. Each path must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). - `source` (string): Inline Rego source. Mutually exclusive with `paths`. ### `rego_parse_ast` (~68 tokens) Parse Rego to AST Parse Rego source to a JSON AST using `opa parse`. Returns the AST as a tree of nodes (package, imports, rules, expressions, terms). Use this when you need to introspect policy structure programmatically. Input parameters: - `source` (string, required): Rego source code to parse. ### `rego_inspect` (~71 tokens) Inspect bundle or policy Inspect an OPA bundle, policy directory, or single Rego file with `opa inspect`. Returns manifest data, namespaces, rule annotations, and (if signed) signature metadata. Input parameters: - `target` (string, required): Path to a bundle archive (`*.tar.gz`), directory, or single Rego file. ### `rego_capabilities` (~219 tokens) OPA capabilities Return OPA capabilities -- the available builtins, future keywords, features, and WASM ABI versions. With `current: true`, returns the running OPA's capabilities. With `version: "v0.69.0"`, returns those of a specific version. With neither, lists available named versions. By default (`names_only: true`), returns only builtin names and count to stay within response size limits; pass `names_only: false` for full type signatures and documentation. Input parameters: - `current` (boolean): Print the capabilities of the currently installed OPA. Mutually exclusive with `version`. - `names_only` (boolean): When true (default), return only builtin names, count, future keywords, and features. The full spec payload routinely exceeds client response size limits. Set to false to retrieve complete type signa… - `version` (string): A specific OPA capabilities version (e.g. "v0.69.0"). When neither flag is set, lists available versions. ### `rego_deps` (~104 tokens) Rego dependency analysis Static dependency analysis for a Rego reference. Given a target ref like "data.example.allow", returns the base document references (input/data leaves) and virtual document references (rules) it depends on, transitively. Input parameters: - `paths` (array, required): Policy / data paths to load before computing dependencies. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). - `ref` (string, required): Reference to compute dependencies for, e.g. "data.example.allow". ### `rego_migrate_v1` (~208 tokens) Migrate Rego to v1 syntax Migrate Rego v0 source to Rego v1 syntax in two phases: (1) `opa fmt --rego-v1` auto-fixes reserved keywords (`if`, `contains`, `every`, `in` in rule heads) and adds `import rego.v1`; (2) `opa check --v1-compatible` validates the migrated source and reports any remaining issues that cannot be auto-fixed (e.g. removed builtins, semantic conflicts). Returns the migrated source and a `changed` flag even when check finds remaining errors -- this lets you inspect what changed and fix the remainder manually. If the source is completely unparseable, returns `INVALID_REGO`. Input parameters: - `source` (string, required): Rego v0 source to migrate to Rego v1 syntax. `opa fmt --rego-v1` auto-fixes reserved keywords and adds `import rego.v1`; any remaining issues are returned in `errors` so you can resolve them manually. ### `rego_eval` (~184 tokens) Evaluate Rego query Evaluate a Rego query against a policy and an input document using `opa eval`. Returns the standard `{result: [...]}` shape. The bread-and-butter authoring tool. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `rego_eval_with_explain` (~199 tokens) Evaluate Rego with execution trace Evaluate with `--explain=full` and return a structured trace alongside the result. Use this when an agent needs to see why a rule fired (or didn't) -- the trace is the basis for `rego_explain_decision`. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `rego_eval_with_profile` (~175 tokens) Evaluate Rego with profiling Evaluate with `--profile` and return per-rule timing and evaluation counts. Use this to find hot rules in slow policies. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `rego_eval_with_coverage` (~177 tokens) Evaluate Rego with coverage Evaluate with `--coverage` and return per-line coverage data. Useful for verifying that tests actually exercise the rules they're meant to. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `rego_test` (~763 tokens) Run Rego tests Run Rego unit tests with `opa test`. Returns aggregate pass/fail counts plus per-test records. Tests live in `*_test.rego` files; rule names beginning with `test_` are picked up automatically. Use `runPattern` to filter by name regex; when no tests match, the error hint includes the pattern you supplied. Use `threshold` to gate on minimum coverage (returns COVERAGE_BELOW_THRESHOLD on failure). Use `varValues: true` with `verbose: true` to include local variable bindings in the trace -- essential for debugging table-driven tests written with `every tc in cases { ... }` to identify which case caused a failure. When tests use the `test_X[case]` parametrized form, the output includes `parameterizedGroups` mapping each base test name to its case records. Use `ignorePatterns` to exclude generated or fixture files. Use `bundle: true` when testing bundle-structured policy directories. Use `timeout` to raise the per-test limit beyond OPA's default 5s. Note: enabling `coverage` or `threshold` switches OPA to coverage-report output mode -- per-test counts are unavailable but `coverage` and `coveragePct` fields are populated. Input parameters: - `bundle` (boolean): Load paths as OPA bundle roots (`--bundle`). Required when testing policies structured as bundles with a `manifest.json` at the root. Not needed for plain policy directories. - `count` (integer): Number of times to repeat each test (`--count N`). Default is 1. Useful for measuring repeatability or catching flaky tests under load. - `coverage` (boolean): Include per-line coverage data. Switches output to coverage-report mode: test record counts are not available, but `coverage` and `coveragePct` fields are populated. - `explain` (string): Add a query-explanation trace to test records (`--explain`). `fails` traces only failing tests, `full` traces everything, `notes` surfaces `trace()` notes, `debug` is most verbose. Populates each rec… - `ignorePatterns` (array): Glob patterns for files to exclude from the test run (`--ignore `). Pass one pattern per array element. Useful for excluding generated or fixture files that contain no tests (e.g. `["*_gener… - `paths` (array, required): Test directories or files. `opa test` looks for `*_test.rego` siblings of source files. - `runPattern` (string): Run only tests whose names match this regular expression (passed as `--run`). - `threshold` (number): Minimum coverage percentage required (0–100). Returns COVERAGE_BELOW_THRESHOLD when actual coverage falls below this value. Implicitly enables coverage-report output mode. - `timeout` (string): Per-test timeout as a Go duration string, e.g. `"30s"` or `"2m"` (`--timeout`). OPA's default is 5s. Increase for tests that load large policy sets or call slow built-ins. - `v1Compatible` (boolean): Opt in to OPA v1.0-compatible behaviors (`--v1-compatible`). - `varValues` (boolean): Include local variable bindings in trace output (`--var-values`). When a table-driven test using `every tc in cases { ... }` fails, the trace shows which `tc` triggered the failure. Has no effect unl… - `verbose` (boolean): Emit per-test pass/fail details. ### `rego_test_multiroot` (~561 tokens) Run Rego tests across multiple roots Run `opa test` once per root and aggregate results. Solves the package-conflict problem that occurs when `opa test .` is run on a repo with multiple independent package namespaces (OPA issue #4724). Two modes: `explicit` (supply root list with optional per-root `include` paths for shared libraries) and `scan` (auto-discover leaf test roots using the leaf rule -- a directory is a root only if it directly contains `*_test.rego` files and none of its eligible subdirectories do, preventing OPA's automatic recursion from double-running tests). Use `sharedPaths` in scan mode to add shared library directories to every root's invocation without including them in discovery. Coverage and threshold work per-root; `overallCoveragePct` is the mean across roots that have coverage data. Input parameters: - `coverage` (boolean): Include per-line coverage data per root. Switches output to coverage-report mode: test record counts are not available, but `coverage`, `coveragePct`, and `overallCoveragePct` fields are populated. - `ignorePatterns` (array): Additional directory name patterns to skip during scan (e.g., ["vendor", "*.generated"]). Supports `*` wildcards. Only used with `scanDir`. - `maxDepth` (integer): Maximum directory depth to scan. Default: 10. Only used with `scanDir`. - `maxRoots` (integer): Maximum number of test roots allowed. Returns INVALID_INPUT if scan finds more. Default: 50. Only used with `scanDir`. - `roots` (array): Explicit list of test root directories. Use when roots are known upfront or when scan mode cannot determine the correct roots. Mutually exclusive with `scanDir`. - `runPattern` (string): Run only tests whose names match this regular expression (passed as `--run` to each root). - `scanDir` (string): Top-level directory to scan for test roots. Uses the leaf rule: a directory is a root only if it directly contains `*_test.rego` files and none of its eligible subdirectories do. Mutually exclusive w… - `sharedPaths` (array): Paths added to every root's `opa test` invocation and excluded from auto-discovery. Use for shared library directories that all roots import from. - `threshold` (number): Minimum coverage percentage required per root (0-100). Roots below threshold have `thresholdMet: false` in their result. Implicitly enables coverage-report output mode. - `varValues` (boolean): Include local variable bindings in trace output (`--var-values`). Only useful with `verbose: true`. - `verbose` (boolean): Emit per-test pass/fail details for each root. ### `rego_bench` (~121 tokens) Benchmark Rego query Benchmark a Rego query against a policy + input with `opa bench`. Returns statistical timing data: iterations, ns/op, and allocation counts. Use this to spot slow rules. Input parameters: - `count` (integer): Number of benchmark iterations. Defaults to OPA's built-in default. - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. - `paths` (array): Policy / data paths to load. Each must be in an allowed root. - `query` (string, required): Rego query to benchmark. ### `rego_compile_query` (~216 tokens) Partially evaluate a Rego query Run partial evaluation on a query -- substitute known values and return the residual policy. Defaults `unknowns` to `["input"]` (treat input as unknown), so the residual encodes "given input X, this is what would have to be true." Use this for offline policy slicing or pre-computing decision sets. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `opa_exec` (~509 tokens) Batch-evaluate OPA policy against input files Evaluate a policy decision against one or more input files using `opa exec --format=json`. Unlike `rego_eval` (single input), `opa exec` processes every file independently and returns a per-file result -- ideal for CI pipelines that check many config files against a policy in one call. Supply `bundle` for bundle-based policies or `dataPaths` for raw policy files; these are mutually exclusive. Each file that fails evaluation appears in `results` with an `error` field rather than a `result` field. Set one of `fail`/`failDefined`/`failNonEmpty` to turn the call into a CI gate: the result then reports `failed: true` (instead of erroring) when the gate condition is met. Input parameters: - `bundle` (string): Path to an OPA bundle directory or `.tar.gz` archive to load as the policy source. Mutually exclusive with `dataPaths`. - `dataPaths` (array): Policy and/or data file or directory paths, each loaded as an OPA bundle root (opa exec loads policy only via bundles). Mutually exclusive with `bundle`. - `decision` (string, required): The policy entrypoint to evaluate for each input, e.g. `"data.authz.allow"` or `"data.policy.violations"`. Must be a fully-qualified Rego reference. - `fail` (boolean): CI gate: report `failed: true` when any decision is undefined or errors. Mutually exclusive with `failDefined` and `failNonEmpty`. - `failDefined` (boolean): CI gate: report `failed: true` when any decision is defined or errors. Use when a defined result means a violation. Mutually exclusive with `fail` and `failNonEmpty`. - `failNonEmpty` (boolean): CI gate: report `failed: true` when any decision result is non-empty or errors. Mutually exclusive with `fail` and `failDefined`. - `inputPaths` (array, required): One or more JSON/YAML input file paths, or a directory containing input files. OPA evaluates each file independently. Every path must be inside an allowed root. - `timeout` (string): Per-exec evaluation timeout as a Go duration, e.g. `"30s"` or `"5m"`. Still bounded by the server subprocess timeout (OPA_MCP_TIMEOUT_MS). - `v1Compatible` (boolean): Opt in to OPA v1.0-compatible behaviors (`--v1-compatible`). ### `opa_bundle_build` (~448 tokens) Build OPA bundle Build a deployable bundle from policy / data paths using `opa build`. Output is a `.tar.gz` archive with optional inline signing. Supports optimization, custom revision strings, and the WASM target. Input parameters: - `bundle` (boolean): Load `paths` as bundle files or root directories (`--bundle`). Required when rebuilding or re-signing an existing bundle. - `capabilities` (string): Path to a capabilities JSON file. - `claimsFile` (string): Path to a claims file for inline signing. - `entrypoints` (array): Entrypoint refs (required when `target=wasm` or `optimize > 0`). - `ignore` (array): File/directory name patterns to ignore during loading (`--ignore`), e.g. `[".*"]` to skip hidden files. These are name patterns, not filesystem paths. - `optimize` (number): Optimization level (0 = none, 2 = aggressive). - `output` (string, required): Output bundle path (typically `*.tar.gz`). Must be in an allowed root. - `paths` (array, required): Policy / data paths to include. Each must be in an allowed root. - `pruneUnused` (boolean): Exclude dependents of entrypoints that are not reachable from them (`--prune-unused`). Most useful alongside `entrypoints`. - `revision` (string): Bundle revision string written to the manifest. - `signingAlg` (string): Signing algorithm (e.g. RS256). - `signingKey` (string): Path to a signing key for inline signing. - `target` (string): Build target (default `rego`; `wasm` compiles to WebAssembly). - `v1Compatible` (boolean): Opt in to OPA v1.0-compatible behaviors (`--v1-compatible`). Affects the built bundle's runtime semantics. - `verificationKey` (string): Path to a PEM public key (or HMAC secret file) used to re-verify an existing signed bundle during the build (`--verification-key`). Pair with `bundle: true`. - `verificationKeyId` (string): Key ID for verification (`--verification-key-id`, OPA default `default`). ### `opa_bundle_sign` (~115 tokens) Sign OPA bundle Sign an OPA bundle with a private key using `opa sign`. Writes a `.signatures.json` next to the bundle directory, or updates the archive in place. Input parameters: - `bundle` (string, required): Path to a bundle directory or archive. Must be in an allowed root. - `claimsFile` (string): Path to extra claims to include in the signature. - `signingAlg` (string): Signing algorithm (e.g. RS256). Default: RS256. - `signingKey` (string, required): Path to the signing key. ### `opa_bundle_verify` (~267 tokens) Verify OPA bundle signature Verify the cryptographic signature of a signed OPA bundle using `opa eval --bundle --verification-key`. The bundle must have been signed with `opa sign` (or `opa_bundle_sign`). OPA checks the `.signatures.json` manifest inside the bundle against the provided public key before loading any policy -- a tampered or unsigned bundle will fail with `INVALID_BUNDLE`. Returns `{ bundle, verified: true }` on success. Input parameters: - `bundle` (string, required): Path to the signed bundle directory or `.tar.gz` archive. Must be inside an allowed root. - `scope` (string): Expected `scope` value in the bundle signature. Required when the bundle was signed with `--scope`. - `signingAlg` (string): Signing algorithm used when the bundle was signed (e.g. `RS256`, `PS256`, `ES256`, `HS256`). Defaults to `RS256`. - `verificationKey` (string, required): Path to the PEM file containing the RSA or ECDSA public key, or the path to the HMAC secret file. Must be inside an allowed root. - `verificationKeyId` (string): Key ID that must match the `keyid` field in the bundle signature. Required when the bundle was signed with `--public-key-id`. ### `opa_list_policies` (~34 tokens) List OPA policies List policies registered on the running OPA server. Returns an array of `{ id, raw, ast }` records. ### `opa_get_policy` (~45 tokens) Get OPA policy by ID Fetch a single policy by ID from the running OPA server. Input parameters: - `id` (string, required): Policy ID, e.g. "rbac" or "policies/auth/main". ### `opa_put_policy` (~69 tokens) Upload or replace OPA policy Upload a Rego policy under the given ID. Replaces any existing policy with that ID. The policy is uploaded as raw text/plain -- OPA parses it on the server side. Input parameters: - `id` (string, required): Policy ID to create or replace. - `source` (string, required): Rego source. ### `opa_delete_policy` (~32 tokens) Delete OPA policy Delete a policy by ID from the running OPA server. Input parameters: - `id` (string, required): Policy ID to delete. ### `opa_get_data` (~68 tokens) Read data from OPA Read a path from OPA's data hierarchy. The `path` argument may be in dotted form (`users.alice`) or slash form (`users/alice`). Input parameters: - `path` (string, required): Data path under `data.`, e.g. "users" or "users/alice". ### `opa_put_data` (~50 tokens) Write data to OPA Write or replace a value at the given data path. Body is sent as JSON. Input parameters: - `path` (string, required): Data path to write to. - `value`: JSON value to store at this path. ### `opa_patch_data` (~68 tokens) Patch data on OPA Apply a JSON Patch (RFC 6902) to the data document. Each operation is `{ op, path, value? }`. Input parameters: - `operations` (array, required): Array of JSON Patch operations. - `path` (string, required): Data path the patch is applied to. Use "" for the root. ### `opa_delete_data` (~132 tokens) Delete a data document from OPA Remove a document from OPA's data store at the given path. The path may be in dotted form (`users.alice`) or slash form (`users/alice`). OPA responds with 204 No Content on success; if no document exists at the path, OPA returns 404 which is mapped to `DATA_NOT_FOUND`. Root-path deletion (`/v1/data/` itself) is intentionally excluded -- supply at least one path segment. Input parameters: - `path` (string, required): Data path to delete, e.g. "users.alice" or "users/alice". Must be at least one segment deep. ### `opa_query_decision` (~119 tokens) Query OPA decision Evaluate a decision against the running OPA server. POSTs to the data path with `{input}` and returns whatever the rule produces. Use this to ask the server "given this input, what does data.X.allow say?" Input parameters: - `explain` (string): Include a trace at the requested level. - `input`: Input document to evaluate against. - `metrics` (boolean): Include metrics in the response. - `path` (string, required): Decision path under `data.`, e.g. "rbac/allow" or "rbac.allow". ### `opa_compile_query` (~96 tokens) Compile (partially evaluate) a query on OPA Send a query to the OPA server's `/v1/compile` endpoint for partial evaluation. Returns the residual query -- what remains after substituting in everything that's known. Input parameters: - `input`: Optional partial input document. - `query` (string, required): Rego query to compile, e.g. "data.rbac.allow == true". - `unknowns` (array): Refs to treat as unknown (default: ["input"]). ### `opa_health` (~77 tokens) OPA health check Hit the OPA `/health` endpoint. Returns `{ healthy: true }` on 200. Supports `bundles` and `plugins` query flags to require those subsystems to also be healthy. Input parameters: - `bundles` (boolean): Require bundle plugin to be healthy as well. - `plugins` (boolean): Require all plugins to be healthy. ### `opa_status` (~86 tokens) OPA status Return the running OPA server configuration via `GET /v1/config`. Returns the same underlying document as `opa_config` but presented under a `status` key as a convenience for agents that want to check "what is running" rather than "what was the server configured with". The response includes bundle settings, decision-log settings, and plugin configuration as OPA reported them at startup. ### `opa_config` (~24 tokens) OPA configuration Return the running OPA server configuration (sanitized -- secrets are not included). ### `rego_explain_decision` (~206 tokens) Explain Rego decision Evaluate a Rego query with full tracing and return a structured trace plus per-rule fired/not-fired summary. Use this when you need to answer "why was this denied?" -- the agent reads the structured trace and narrates the cause without re-implementing the trace parser. Input parameters: - `input`: Inline input document. - `inputPath` (string): Path to a JSON input file. Mutually exclusive with `input`. - `partial` (boolean): Run partial evaluation rather than full evaluation. - `paths` (array): Policy / data file or directory paths. Each must be inside an allowed root. - `query` (string, required): Rego query to evaluate, e.g. "data.example.allow". - `source` (string): Inline Rego policy source. Mutually exclusive with `paths`. - `strictBuiltinErrors` (boolean): Treat builtin errors as fatal instead of returning undefined. - `unknowns` (array): Refs to treat as unknown during partial evaluation. ### `rego_explain_undefined` (~196 tokens) Explain why a Rego query is undefined Diagnose why a fully-qualified Rego query (e.g. "data.authz.allow") produces no value. Combines a plain eval, a full-trace eval, and per-condition AST analysis to identify the exact body expression blocking each rule. Handles both runtime failures (trace-based) and indexer elimination (standalone condition eval). Returns a structured breakdown of which conditions blocked each rule plus a human-readable summary. Input parameters: - `input`: Input document (JSON value) for the query. - `inputPath` (string): Path to an input JSON file. - `paths` (array): Policy .rego file paths to load. Mutually exclusive with source. - `query` (string, required): Fully-qualified rule reference to explain, e.g. "data.authz.allow". Must match the path you would pass to rego_eval. - `source` (string): Inline Rego source to analyse. Mutually exclusive with paths. ### `rego_generate_test_skeleton` (~244 tokens) Generate Rego test skeleton Generate a `*_test.rego` skeleton from a policy. Parses the AST, finds each non-test rule, and emits one stub test per rule. Existing `test_*` and `todo_test_*` rules are skipped automatically -- only testable production rules get stubs. The AST is walked to infer which `input.*` fields the policy accesses; the inferred shape is used as the placeholder `with input as {...}` in each stub, so the developer only needs to fill in realistic values rather than guess the structure. With `tableStyle: true`, each stub uses an `every tc in cases { ... }` loop so you can add multiple input/expected pairs without duplicating assertion code. The `inferredInputShape` field in the response shows the detected shape for reference. Input parameters: - `source` (string, required): Rego source to generate tests for. - `tableStyle` (boolean): Generate table-driven test stubs instead of single-case stubs. Each rule gets a `cases` array and an `every tc in cases { ... }` assertion loop. Pair with `rego_test varValues: true` to see which cas… ### `rego_describe_policy` (~98 tokens) Describe Rego policy Parse a Rego policy and return a structured summary: package, imports, and rules. Each rule reports clauseCount (how many definitions share the name), isDefault (true if any clause is a default), hasArgs, bodyLength (total body expressions across all clauses), and inline annotations. Useful as the first step in any "what does this policy do" workflow. Input parameters: - `source` (string, required): Rego source to describe. ### `rego_suggest_fix` (~87 tokens) Suggest fix for Rego diagnostics Map common Rego compile errors and Regal lint findings to mechanical fix suggestions. Pass diagnostics from `rego_check` or `rego_lint`. Returns one suggestion per input diagnostic; confidence is `high` for well-known patterns, `medium` for partial matches, `low` for everything else. Input parameters: - `diagnostics` (array, required): Diagnostics from rego_check or rego_lint. ### `rego_coverage_gaps` (~138 tokens) Rego test coverage gaps Run opa test --coverage and return a per-file breakdown of uncovered line ranges. Identifies which rules or branches are not yet exercised by tests. Files are sorted by coverage ascending so the worst-covered files appear first. Use threshold to limit the report to files below a target coverage percentage. Input parameters: - `paths` (array, required): Test directories or files. opa test looks for *_test.rego siblings of source files. - `runPattern` (string): Run only tests whose names match this regex. - `threshold` (number): Report only files below this coverage percentage (0-100). When omitted, all files with uncovered ranges are reported. ### `rego_security_audit` (~140 tokens) Rego security audit Run regal lint restricted to the security and bugs categories across one or more policy directories. Returns findings grouped by severity (high/medium) with remediation guidance. Use this for a periodic fleet-wide security sweep rather than per-file style review. Requires regal. Input parameters: - `configFile` (string): Path to a Regal config file. Useful when your repo has custom rule configuration. - `ignoreFiles` (array): Glob patterns to exclude from the audit. - `paths` (array, required): Policy directories or files to audit. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Pass the root of your policy fleet to scan everything at once. ### `rego_infer_input_schema` (~153 tokens) Infer input schema Statically analyse one or more Rego policies and return a JSON Schema (draft-07) object describing every input.* field the policies read. Uses opa parse for AST-level analysis -- no running OPA server required. Correct starting point for writing integration tests, configuring opa check --schema validation, or documenting a policy API. Accepts inline source, individual files, or directories (walked recursively for *.rego files). Input parameters: - `paths` (array): Policy files or directories to analyse. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Directories are walked recursively for *.rego files. - `source` (string): Inline Rego source to analyse. Mutually exclusive with paths. ### `rego_fix` (~300 tokens) Auto-fix Rego violations Run regal fix to automatically apply mechanical fixes for the five rules regal 0.30.0 supports: opa-fmt, use-rego-v1, use-assignment-operator, no-whitespace-comment, and directory-package-mismatch. Use dryRun: true to preview changes before modifying files. NOTE: directory-package-mismatch moves files to match their package path -- use disable: ["directory-package-mismatch"] to skip it. Files with uncommitted git changes require force: true. Requires regal. Input parameters: - `configFile` (string): Path to a Regal config file (.regal/config.yaml). - `disable` (array): Disable specific fix rules. Useful to skip directory-package-mismatch if you do not want files moved. - `disableCategory` (array): Disable all rules in a category. - `dryRun` (boolean): Preview what would be fixed without modifying any files. Recommended before the first real run. - `enable` (array): Enable specific fix rules. - `enableCategory` (array): Enable all rules in a category. - `force` (boolean): Allow fixing files that have uncommitted git changes, or when the project is not a git repository. Without this flag regal refuses to touch uncommitted files. - `ignoreFiles` (array): Glob patterns to exclude from fixing. - `paths` (array, required): Policy files or directories to fix. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). ### `rego_format_write` (~260 tokens) Format Rego files in place Run `opa fmt --write` to canonically format one or more Rego files or directories in place. Use `dryRun: true` to preview which files would change without modifying them. Returns a list of files that were (or would be) reformatted. Unlike `rego_format` which returns formatted source as a string, this tool writes directly to disk. Supports `regoV1`, `v0Compatible`, and `v1Compatible` flags for version-specific formatting. If any file cannot be parsed, the operation is aborted and no files are written. Input parameters: - `dryRun` (boolean): Preview which files would be reformatted without modifying them. Recommended before the first real run. - `paths` (array, required): Policy files or directories to format in place. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). - `regoV1` (boolean): Format module(s) to be compatible with both Rego v1 and the current OPA version. Adds `import rego.v1` where missing. - `v0Compatible` (boolean): Use OPA behaviors and syntax prior to the v1.0 release. - `v1Compatible` (boolean): Use OPA v1.0-compatible behaviors. ### `rego_policy_diff` (~313 tokens) Diff two Rego policies Evaluate the same query against two policies (or two versions of the same policy) and compare the results. Both evaluations run in parallel. Returns `equal: true/false`, the raw result from each side, and `changedPaths` -- the dot/bracket paths that differ. Useful for verifying that a refactor preserves behavior, or understanding exactly where two policies diverge. Each side takes either inline source (sourceA/sourceB) or a file/directory path (pathA/pathB). The same input and query are used for both evaluations. Input parameters: - `dataPaths` (array): Additional data or policy paths loaded for both evaluations. Each must be inside an allowed root. - `input`: Inline input document (JSON). Mutually exclusive with inputPath. - `inputPath` (string): Path to a JSON input file. Must be inside an allowed root. Mutually exclusive with input. - `pathA` (string): File or directory path for policy A. Must be inside an allowed root. Mutually exclusive with sourceA. - `pathB` (string): File or directory path for policy B. Must be inside an allowed root. Mutually exclusive with sourceB. - `query` (string, required): The query to evaluate against both policies, e.g. "data.example.allow". - `sourceA` (string): Inline Rego source for policy A. Mutually exclusive with pathA. - `sourceB` (string): Inline Rego source for policy B. Mutually exclusive with pathB. ### `rego_verify` (~239 tokens) Formally verify a Rego policy rule Formally verify a property about a Rego rule using SMT solving (Microsoft Z3). Unlike testing, this checks ALL possible inputs and either proves the property holds or returns a concrete counterexample input that falsifies it. Supports equality, comparison, startswith, endswith, contains, and simple regex.match patterns (prefix: ^lit.*, suffix: .*lit$, exact: ^lit$, contains: .*lit.*, wildcard: .*). Complex regex patterns (character classes, quantifiers, alternation) return INCONCLUSIVE. Also reports INCONCLUSIVE for negation-as-failure (not), comprehensions, and other unsupported constructs. Input parameters: - `kind` (string, required): Property to prove: always_true - rule is true for every possible input (finds inputs that violate this) never_true - rule is never true for any input (finds inputs that trigger it) satisfiab… - `rule` (string, required): Name of the rule to verify (e.g. "allow", "deny"). - `source` (string, required): Rego source to verify. ### `rego_playground_share` (~292 tokens) Share Rego policy as a GitHub Gist Share a Rego policy with teammates or create a reproducible example by publishing it as a public GitHub Gist. Returns { gistUrl, rawPolicyUrl, id }: the gistUrl renders the policy with syntax highlighting on github.com; the rawPolicyUrl can be passed directly to OPA (`opa eval -d `) or used as a data source in Conftest. When query, input, or data are supplied, a metadata.json file is bundled into the Gist so recipients have the full evaluation context to reproduce results. Each call creates a new Gist -- use the returned id to reference it later. Requires GITHUB_TOKEN in the environment (GitHub personal access token with the "gist" scope); returns GITHUB_TOKEN_MISSING with setup instructions if unset. Input parameters: - `data` (string): Data document as a JSON string. Stored in metadata.json alongside the policy file. - `description` (string): Short description for the Gist (shown on github.com/gists). - `input` (string): Input document as a JSON string. Stored in metadata.json alongside the policy file. - `policy` (string, required): Rego source code to share (the contents of a .rego file). - `query` (string): Default query to evaluate against the policy, e.g. "data.authz.allow". Stored in metadata.json alongside the policy file. ### `conftest_test` (~698 tokens) Conftest test Evaluate configuration files (Kubernetes manifests, Terraform plans, Dockerfiles, Helm charts, or any YAML/JSON/HCL/TOML/INI) against Rego policies using `conftest test`. Returns per-file, per-namespace pass/fail/warn results so you can pinpoint exactly which policy rules fired. Requires `conftest` on PATH or `CONFTEST_BINARY` set; returns CONFTEST_NOT_FOUND otherwise. Provide config via `files` (disk paths) or `inlineConfig` (inline string). Provide policy via `policy` (disk path) or `inlinePolicy` (inline Rego source). Omit `policy` and `inlinePolicy` to use conftest's default `./policy` directory. Input parameters: - `allNamespaces` (boolean): Test policies found in all discovered namespaces. Overrides `namespace`. - `combine` (boolean): Combine all configuration files into a single input document before evaluating. Useful when policies need to inspect relationships across multiple files. - `data` (array): Paths to directories from which additional data will be loaded for the Rego policies. Each path must be inside an allowed root. - `failOnWarn` (boolean): Return `passed: false` even when only warnings (no hard failures) are present. - `files` (array): Filesystem paths to configuration files to evaluate (YAML, JSON, HCL, Dockerfile, etc.). Each path must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Mutually exclusive with `inlineConfig`. - `inlineConfig` (string): Inline configuration content to evaluate (e.g. a Kubernetes manifest as a YAML string). Mutually exclusive with `files`. Defaults to YAML format; set `inlineConfigParser` to override. - `inlineConfigParser` (string): Parser to use for `inlineConfig`. Valid values: yaml (default), json, toml, hcl1, hcl2, ini, xml, dotenv, cue, jsonnet, properties, edn, hocon, dockerfile. Ignored when `files` is used (conftest infe… - `inlinePolicy` (string): Inline Rego policy source. Written to a temporary directory and passed as `--policy`. The policy should declare `package main` (or match the `namespace` parameter). Mutually exclusive with `policy`. - `namespace` (string): Rego namespace (package name) to test against. Defaults to `main`. Use `allNamespaces: true` to test all discovered namespaces instead. - `parser` (string): Force a specific parser for all input `files` via conftest's global `--parser` flag, overriding extension-based detection. Useful for files whose extension does not match their format (e.g. parse a `… - `policy` (string): Path to a directory or file containing Rego policies. Must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Mutually exclusive with `inlinePolicy`. Omit to let conftest use its default `./policy` d… ### `conftest_verify` (~192 tokens) Conftest verify Run the `test_*` rules inside `*_test.rego` files within a conftest policy directory, verifying that the policies themselves are correct. Equivalent to `opa test` but using conftest's policy-loading machinery. Returns per-file pass/fail results. Requires `conftest` on PATH or `CONFTEST_BINARY` set; returns CONFTEST_NOT_FOUND otherwise. Input parameters: - `data` (array): Paths to data directories. Each must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). - `namespace` (string): Namespace to verify. Defaults to `main`. Omit to verify all namespaces. - `policy` (string): Path to the directory containing both the Rego policies and the `*_test.rego` test files. Must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Omit to use conftest's default `./policy` directory. ### `conftest_pull` (~265 tokens) Conftest pull Download Rego policies from an OCI registry or Git repository into a local directory using `conftest pull`. Use this to hydrate a local `policy/` directory before running `conftest_test`. Requires `conftest` on PATH or `CONFTEST_BINARY` set. The `policy` directory must be inside OPA_MCP_ALLOWED_PATHS. SECURITY: pulled policies are arbitrary Rego source that will be executed by `conftest_test`. Only pull from registries or repositories you own or explicitly trust -- malicious policy code can use OPA built-ins (http.send, opa.runtime) to exfiltrate data or make outbound network requests when the tests run. Input parameters: - `policy` (string): Local directory where the pulled policies will be written. Must be inside an allowed root (OPA_MCP_ALLOWED_PATHS). Defaults to `./policy` (conftest's convention). - `url` (string, required): Policy URL to pull. Supported schemes: `oci://registry/repo:tag` (OCI registry), `github.com/org/repo//path` (GitHub subdirectory), `git::https://example.com/repo//path` (generic Git). See https://ww… ### `conftest_push` (~209 tokens) Conftest push Package the local Rego policy directory as an OCI artifact and push it to a registry using `conftest push`. Registry credentials must be pre-configured in the host environment (docker login, ORAS keychain, etc.) -- this tool never handles credentials. The `policy` directory must be inside OPA_MCP_ALLOWED_PATHS. Requires `conftest` on PATH or `CONFTEST_BINARY` set. Input parameters: - `policy` (string): Path to the local directory containing Rego policies to push. Must be inside an allowed root (OPA_MCP_ALLOWED_PATHS) and must exist. Defaults to `./policy` (conftest's convention). - `repository` (string, required): OCI repository URL to push policies to (e.g. `ghcr.io/my-org/policies:latest`). Registry credentials must already be configured in the host environment (via `docker login`, ORAS keychain, or REGISTRY… ### `mcp_server_info` (~61 tokens) MCP server info Return the name, version, and runtime details of this opa-mcp server instance. Use this when you need to confirm which version of opa-mcp is running, or to verify that the OPA, Regal, and Conftest binaries are reachable. ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp#diagnostics ## Score history - 2026-08-03: 81 - 2026-08-02: 80 - 2026-08-01: 36 - 2026-07-31: 5 - 2026-07-30: 63 - 2026-07-29: 93 - 2026-07-28: 51 - 2026-07-27: 51 ## Links - npm package: https://www.npmjs.com/package/@orygn/opa-mcp - Socket report: https://socket.dev/npm/package/@orygn/opa-mcp - Repository: https://github.com/OrygnsCode/opa-mcp-server - Website: https://orygn.tech/ - Changelog RSS feed: https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp/changelog.xml - Changelog JSON feed: https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp/changelog.json - HTML version of this page: https://verifymcp.io/servers/orygnscode-opa-mcp/orygn-opa-mcp