PL/SQL Intelligence Engine MCP server
Commit Nov 1, 2026Analyzes Oracle PL/SQL code offline to provide dependency reasoning, change-impact analysis, and static security testing.
Also known as MuhDur/plsql-intelligence, plsql-intelligence
- Stars
- 3
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 0.6.3
- Last commit
- Nov 1, 2026
- License
- Apache-2.0
What is PL/SQL Intelligence Engine MCP?
PL/SQL Intelligence Engine analyzes Oracle PL/SQL code offline to provide dependency reasoning, change-impact analysis, and static security testing.
Summary generated from the project's README
About PL/SQL Intelligence Engine MCP server
PL/SQL Intelligence Engine provides offline analysis for Oracle PL/SQL environments, focusing on package-aware semantics. It is designed for developers managing large Oracle estates where changing a single column or package specification can cause cascading failures in downstream objects like views, triggers, and tables. The engine operates without a live database connection, instead reading code and Oracle catalog snapshots directly from the local file system.
Built with Rust, the tool uses an ANTLR-generated parser to build a semantic intermediate representation and a dependency graph. It distinguishes itself through honest uncertainty, emitting a typed UnknownReason when analysis cannot be certain rather than providing false-clean results. The system includes a self-healing USR Loop that captures parsing gaps and turns them into privacy-clean repairs to improve coverage over time. Users interact with the engine through command-line tools such as plsql, plsql-depgraph, and usr-loop.
What you can do with it
- 1Analyzing dependency websUse the dependency graph to understand the complex relationships between packages, views, and tables.
- 2Performing offline security testingRun static security testing on PL/SQL code without requiring a live database connection or telemetry.
Written from the project's README. Every use case is checked against a quote from it.
How to install PL/SQL Intelligence Engine MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall PL/SQL Intelligence Engine MCP in Claude Code
$ claude mcp add plsql-intelligence -- docker run -i --rm ghcr.io/muhdur/plsql-mcp:0.6.3Install PL/SQL Intelligence Engine MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"plsql-intelligence": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/muhdur/plsql-mcp:0.6.3"
]
}
}
}Install PL/SQL Intelligence Engine MCP in VS Code
.vscode/mcp.json
{
"servers": {
"plsql-intelligence": {
"type": "stdio",
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/muhdur/plsql-mcp:0.6.3"
]
}
}
}Install PL/SQL Intelligence Engine MCP in VS Code CLI
$ code --add-mcp '{"name":"plsql-intelligence","type":"stdio","command":"docker","args":["run","-i","--rm","ghcr.io/muhdur/plsql-mcp:0.6.3"]}'Install PL/SQL Intelligence Engine MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"plsql-intelligence": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/muhdur/plsql-mcp:0.6.3"
]
}
}
}Install PL/SQL Intelligence Engine MCP in Codex
$ codex mcp add plsql-intelligence -- docker run -i --rm ghcr.io/muhdur/plsql-mcp:0.6.3Install PL/SQL Intelligence Engine MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.plsql-intelligence] command = "docker" args = ["run", "-i", "--rm", "ghcr.io/muhdur/plsql-mcp:0.6.3"]
Install PL/SQL Intelligence Engine MCP in Gemini CLI
$ gemini mcp add -s user plsql-intelligence docker -- run -i --rm ghcr.io/muhdur/plsql-mcp:0.6.3Install PL/SQL Intelligence Engine MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"plsql-intelligence": {
"command": "docker",
"args": [
"run",
"-i",
"--rm",
"ghcr.io/muhdur/plsql-mcp:0.6.3"
]
}
}
}Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablemuhdur/plsql-intelligence is public and reachablegithub.com/muhdur/plsql-intelligence ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-01github.com/muhdur/plsql-intelligence ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubPL/SQL Intelligence Engine
Offline, package-aware Oracle PL/SQL code intelligence in Rust, with a self-healing coverage flywheel.
Know what breaks before you change Oracle PL/SQL.
# Build the workspace and run the default test profile
git clone https://github.com/MuhDur/plsql-intelligence
cd plsql-intelligence
cargo build --workspace && cargo test --workspace
TL;DR
The problem. In a large Oracle estate, PL/SQL packages, views, triggers and tables form a deep dependency web. Change one column type or one package spec and you can silently invalidate hundreds of downstream objects; you find out in a failed production recompile. Existing tools each cover a slice (SQL deployment, lineage products, SAST scanners, Oracle's own SQLcl MCP server), but none give offline, package-aware PL/SQL semantics with explicit uncertainty reporting, dependency reasoning, and recompile planning in one workflow.
The solution. A layered Rust workspace that parses PL/SQL with a real
ANTLR backend, builds a semantic IR with name resolution and a dependency
graph, and reports change impact. When the analyzer cannot be certain it
says so, as a typed UnknownReason, instead of reporting a false-clean
result. That honest-uncertainty exhaust feeds the USR Loop, which
turns recorded gaps into proven, privacy-clean parser and lowering
repairs so coverage compounds with use.
MCP belongs in oraclemcp
This repository now owns the offline PL/SQL engine, library crates, and
command-line tools. MCP serving moved to the standalone
oraclemcp repository, where the
database connection layer and server lifecycle already live.
The old plsql-mcp workspace crate has been removed here. Published
historical versions remain a compatibility path until the distribution
retirement beads finish; new PL/SQL intelligence work should flow through
the library crates and the plsql / plsql-depgraph / usr-loop CLIs.
Independent open-source project; not affiliated with Oracle. Oracle client libraries are not included or required for the offline engine.
Why use it?
| Capability | What it does |
|---|---|
| Offline-first | Reads code and an Oracle catalog snapshot in place; no live database required for analysis, no telemetry by default |
| Real parser backend | ANTLR-generated Rust parser code committed in plsql-parser-antlr, no JVM during normal builds, with a lossless token tape (reconstruct(tape) == input) |
| Honest uncertainty | Where analysis cannot be certain it emits a typed UnknownReason; the completeness report is never false-clean |
| Dependency reasoning | Semantic IR, name resolution, a privilege model, and a dependency graph cross-checkable against ALL_DEPENDENCIES |
| USR Loop | A self-healing flywheel: captured gaps become privacy-proven fixtures, candidate patches, and a 9-stage fail-closed conformance gate |
| Verified accretion | A monotone coverage_index with a CI tripwire makes "coverage compounds" a checked property, not a slogan |
| Memory safety | The whole workspace is #![forbid(unsafe_code)] |
How it compares
| Live DB needed | Package-aware PL/SQL semantics | Honest uncertainty | Offline analysis | |
|---|---|---|---|---|
| SQL deployment tools (Liquibase, Flyway) | yes | no | no | no |
| Lineage / catalog products | varies | partial | no | varies |
| Generic SAST scanners | no | no | no | yes |
| Oracle SQLcl MCP server | yes | partial | no | no |
| PL/SQL Intelligence Engine | no | yes | yes | yes |
Status
The current line is the offline-pivot track for 0.7.0. The workspace
builds on the stable channel and no longer contains the plsql-mcp crate.
The project is still pre-1.0, so public APIs can move before the 1.0 line.
plan.md remains the authoritative specification, and
docs/plans/2026-06-29-offline-pivot-retire-plsql-mcp.md is the active
retirement plan for the MCP split.
- The Cargo workspace has 25 members: 20 product crates under
crates/plus 5 tool crates undertools/. - The normal source install path needs the stable-channel toolchain. Java is only needed when regenerating the committed ANTLR parser output, not for ordinary builds, tests, or CLI installation.
- The product-facing binaries are
plsql,plsql-depgraph, andusr-loop. Each hascapabilities,robot-docs,doctor, and--robot-json/--robot-triagesurfaces for agents. - MCP serving is now an
oraclemcpresponsibility. This repo exposes the parser, semantic model, catalog snapshot model, dependency graph, lineage, documentation, SAST, change-impact, and USR Loop library surfaces thatoraclemcpcan consume. - The USR Loop is implemented end to end: the
plsql-accretionlibrary, theusr-looptool, the sha-pinned conformance gate, the monotone tripwire, and the re-runnable acceptance proofscripts/usr_acceptance.sh. AGENTS.mddescribes how automated agents work in this repo.
Testing and Verification
The default local profile is offline and stable-channel:
cargo fmt --all -- --checkcargo clippy --workspace --all-targets -- -D warningscargo test --workspace --all-targetscargo test --workspace --doccargo bench --workspace --no-runcargo deny checkplan-lint, corpus license checks, parse-success checks, lab goldens, demo-no-db, offline honesty grep, offline boundary lint, and the USR accretion gates.
Do not read the test suite as "there are no test doubles anywhere." The repo contains deliberate test doubles where they pin a boundary: feature off live-XE sentinels, GitHub Action posting self-tests, fail-closed bindgen wrappers for invalid identifiers, hermetic Oracle connection doubles, and the deterministic USR proposer path. Those are not unfinished production placeholders.
The private-estate Definition of Done is honest about its boundary. When
PLSQL_PRIVATE_ESTATE is absent, scripts/usr_acceptance.sh exits
successfully with an estate-absent banner and does not claim the full
estate proof. The binding full proof requires an estate-bearing host.
Quick Example
# Build the workspace and run the default test profile
cargo build --workspace
cargo test --workspace
# Inspect the CLI contracts agents should read first
cargo run -p plsql-cicd --bin plsql -- capabilities
cargo run -p plsql-depgraph -- capabilities
cargo run -p usr-loop -- capabilities
# Clippy with the project's deny-warning policy
cargo clippy --workspace --all-targets -- -D warnings
# Predict change impact from a directory, diff, or changeset artifact
cargo run -p plsql-cicd --bin plsql -- predict ./changes --robot-json
# Inspect a serialized dependency graph
cargo run -p plsql-depgraph -- --graph depgraph.json doctor --robot-json
# Drive the USR Loop against an estate (read in place, nothing copied out)
cargo run -p usr-loop -- scan /path/to/estate
cargo run -p usr-loop -- cluster /path/to/estate
cargo run -p usr-loop -- propose /path/to/estate --from-scan
cargo run -p usr-loop -- doctor
# The re-runnable Definition of Done for the USR Loop
scripts/usr_acceptance.sh
The USR Loop (self-healing coverage flywheel)
Most analyzers discard parse errors and unresolved references as failure.
This one records them as typed, provenanced, minimizable, offline
artifacts, then repairs them. The full normative specification is
docs/plans/2026-05-19-usr-loop-self-healing-coverage-flywheel.md; the
repair-class policy and gate honesty manifest are in
docs/decisions/D3-usr-repair-class-policy.md.
estate (read in place; no byte copied out)
│ plsql-engine analyze → typed diagnostics + UnknownReason + provenance
▼
[A] GAP CAPTURE filter repairable diagnostic classes → GapRecord
▼ (provenance only, never source bytes)
[B] MINIMIZE + smallest input that still triggers the same
PRIVACY-PROVE signature; every literal/identifier re-synthesized;
▼ a redaction-delta manifest proves zero leak
[C] CLUSTER/DEDUP N occurrences → 1 GapCluster, K representative
▼ fixtures
[D] PROPOSE one candidate diff, exactly one repair class
▼ (g grammar / l lowering / d typed degradation)
[E] CONFORMANCE GATE the 9-stage, fail-closed, sha-pinned bar
▼ pass ▼ fail
[F] LAND + LEDGER [F'] QUARANTINE-AS-OPEN-BEAD
apply on branch, file a provenanced bead naming the failing
add the fixture + stage; the gate is never weakened to admit it
a pinned test,
append one
content-addressed
ledger entry
▼
[G] ACCRETION TRIPWIRE the monotone coverage_index, CI-checked
Invariants (the spec's spine; each is enforced, not aspirational)
| Invariant | What it guarantees |
|---|---|
| I-PRIVACY | No customer byte leaves the estate. Every persisted artifact is a re-synthesized, structurally-equivalent minimal reproduction, proven leak-free per artifact (gate stage G8). A failed privacy proof aborts the run and persists nothing. |
| I-NO-REGRESSION | A patch lands only if proven behavior-preserving on the whole corpus: lossless round-trip, backend conformance, golden isomorphism, monotonic non-regression. Propose, prove, then land; never auto-merge unproven. |
| I-NO-GAMING | A coverage gain counts only with a commensurate, measured rise in extracted semantics for the targeted signature. Suppressing a diagnostic to "fix" a gap is auto-rejected at G7. |
| I-DETERMINISM | Same estate plus same engine commit yields byte-identical gap records, fixtures, signatures, and candidate set. No wall-clock, no RNG, no map-iteration order in any persisted artifact. |
| I-PROVENANCE | Every record, fixture, candidate, verdict, and landed patch is content-addressed and traces estate-run to diagnostic to fixture to diff to gate result. The ledger is append-only. |
| I-ISOLATION | Patches touch only the .g4 grammar, plsql-parser-antlr codegen / lowering, or the typed-degradation classifier; never make a downstream crate depend on ANTLR types or break public contracts non-additively. |
| I-MONOTONIC-VALUE | The tracked coverage_index is monotone non-decreasing across releases. A release that lowers it fails CI. |
The conformance gate
scripts/usr_gate.sh runs nine ordered stages, all must pass, fail-closed.
Any non-pass rejects the candidate and files it as a bead; the gate is
never weakened to admit a patch.
| Stage | Check |
|---|---|
| G1 | Builds: plsql-parser-antlr --features antlr-codegen and the workspace |
| G2 | Lossless round-trip over the full corpus and every prior MinFixture |
| G3 | Backend conformance (plsql-parser/tests/conformance.rs) |
| G4 | Golden isomorphism, or an explicitly listed and justified golden delta |
| G5 | Never-panic plus the fuzz targets, zero crashes |
| G6 | Monotonic non-regression (scripts/estate_correctness.sh, metrics at or above baseline) |
| G7 | Anti-gaming and honesty: diagnostics fall only with a commensurate extraction rise; posture not weakened |
| G8 | Privacy: redaction-delta verified over the candidate and every added fixture; a leak aborts the run |
| G9 | The added regression test is mutation-killed (fails if the patch is reverted) |
The gate script is content-pinned: crates/plsql-accretion/gate.sha256
holds the expected sha256 and plsql-accretion's gate runner aborts on a
mismatch. Changing the gate requires a deliberate, human-reviewed commit
plus a sha bump. crates/plsql-accretion/tests/gate_selftest.rs feeds the
gate an adversarial trio (a suppression-only patch, a privacy-leaking
fixture, a round-trip-breaking patch) and asserts each is rejected at its
named stage.
coverage_index and the tripwire
coverage_index = extracted_semantics_ratio (frozen public corpus
benchmark, never
private estate code)
+ distinct_resolved_gap_signatures (signature classes the
loop has permanently
closed, from the
append-only ledger)
scripts/accretion_tripwire.sh (a required CI check) asserts
coverage_index(HEAD) >= coverage_index(last release tag) and
extracted_semantics_ratio(HEAD) >= extracted_semantics_ratio(last release).
Fresh CI checkouts compare against the tracked deterministic seed in
crates/plsql-accretion/accretion_floor.json, so the first floor is durable
even though .usr/ledger/ is scratch. A release that lowers either metric
fails. The coverage_index-over-time table lives in CHANGELOG.md.
Definition of Done
scripts/usr_acceptance.sh is the single re-runnable acceptance contract.
It is not a "looks built" check: it drives the loop to close a real,
currently-open gap in a private estate end to end and asserts every
invariant held (provenance, privacy-proven fixture, gate exit 0 or correct
quarantine, strict signature decrease, strict extracted_semantics_ratio
increase, preserved posture, ledger appended exactly once, mutation-killed
test, green adversarial gate self-test, byte-identical double run). When no
private estate is configured the script exits 0 with a loud
"estate-absent" banner, stating that the DoD is not proven in that
environment. CI runs the full acceptance proof nightly
(.github/workflows/usr.yml).
Architecture
The workspace is layered (full detail in plan.md §5 and
docs/ARCHITECTURE.md). Downstream crates never depend on ANTLR-generated
types.
| Layer | Crates | What it owns |
|---|---|---|
| 0 | plsql-core, plsql-output, plsql-render, plsql-store |
Diagnostics, completeness/uncertainty, output shapes, content-addressed cache |
| 1 | plsql-parser, plsql-parser-antlr |
Backend-independent parser surface plus the ANTLR backend |
| 1.5 | plsql-catalog |
Oracle catalog snapshot model and stable row ingestion |
| 2 | plsql-ir, plsql-symbols, plsql-privileges, plsql-depgraph |
Semantic IR, name resolution, privilege model, dependency graph |
| 3 | plsql-engine |
Orchestration: per-run AnalysisRun, CompletenessReport |
| 4 | plsql-lineage, plsql-doc, plsql-bindgen, plsql-cicd, plsql-sast |
Lineage, docs, Rust bindings, change-set planning, static analysis |
| 5 | plsql-accretion, tools/usr-loop |
The USR Loop library and orchestrator |
| External MCP | oraclemcp |
MCP server, Oracle connection lifecycle, guarded live access, and optional integration with these engine crates |
PL/SQL source + Oracle catalog snapshot
│
▼
plsql-parser-antlr (lossless tape + AST)
│
▼
plsql-ir → plsql-symbols → plsql-depgraph
│
▼
plsql-engine: AnalysisRun + CompletenessReport
│ │
▼ ▼
product surfaces typed UnknownReason exhaust
(lineage / docs / │
bindings / cicd / ▼
sast) plsql-accretion + usr-loop
(capture → fixture → gate → land)
Tool binaries: plsql (change-impact, docs, SAST, doctor),
plsql-depgraph (dependency graph query/explain/doctor), usr-loop
(the USR Loop orchestrator), plan-lint, corpus-license-check,
corpus-bench, and corpus-grow.
MCP is intentionally not a binary in this workspace anymore. Agents that
need a server should use oraclemcp; agents that need offline PL/SQL
intelligence should call the library crates directly or use the CLIs.
Installation
The workspace builds with the stable channel pinned in rust-toolchain.toml.
The workspace MSRV is recorded in Cargo.toml as rust-version = "1.96".
Normal installation does not require Java. Java is only needed when a
maintainer explicitly regenerates the ANTLR parser output.
Install Released CLIs
Linux and macOS:
curl -fsSL "https://github.com/MuhDur/plsql-intelligence/releases/latest/download/install.sh?$(date +%s)" | bash
Windows PowerShell:
irm "https://github.com/MuhDur/plsql-intelligence/releases/latest/download/install.ps1?$([DateTimeOffset]::UtcNow.ToUnixTimeSeconds())" | iex
The installers fetch the latest GitHub release, verify SHA256SUMS, install
plsql and plsql-depgraph, and print uninstall instructions.
From source
git clone https://github.com/MuhDur/plsql-intelligence
cd plsql-intelligence
cargo build --workspace --release
Install CLIs from a checkout
cargo install --path crates/plsql-cicd --bin plsql
cargo install --path crates/plsql-depgraph
cargo install --path tools/usr-loop
Install CLIs from Git
cargo install --git https://github.com/MuhDur/plsql-intelligence --package plsql-cicd --bin plsql
cargo install --git https://github.com/MuhDur/plsql-intelligence --package plsql-depgraph
cargo install --git https://github.com/MuhDur/plsql-intelligence --package usr-loop
Per-crate iteration
Per-crate builds keep cycles short during development:
cargo build -p plsql-catalog
cargo test -p plsql-accretion
No Oracle client or database connection is required for the default offline CLIs.
Command Reference
Global discovery commands exist on the main user-facing binaries:
<binary> capabilities # machine-readable agent contract
<binary> robot-docs # concise agent handbook
<binary> --robot-triage # capabilities + health + quick reference
<binary> doctor # local health report
plsql
The release-assurance CLI for change impact, rendered documentation, SAST artifacts, and local diagnostics.
plsql predict ./changes --robot-json
plsql predict --git-range main..HEAD --repo .
plsql doc docset.json --format markdown --robot-json
plsql sast scan-report.json --format sarif --robot-json
plsql doctor ./changes --robot-json
plsql capabilities
plsql robot-docs
plsql-depgraph
Read a serialized dependency graph and query or explain it.
plsql-depgraph --graph depgraph.json doctor --robot-json
plsql-depgraph --graph depgraph.json query reverse-neighbors --logical-id HR.PKG_ORDERS
plsql-depgraph --graph depgraph.json query path --from-logical-id HR.PKG_ORDERS --to-logical-id HR.TABLE_ORDERS
plsql-depgraph --graph depgraph.json explain --logical-id HR.PKG_ORDERS --robot-json
plsql-depgraph capabilities
usr-loop
The USR Loop orchestrator. A global --robot-json flag emits a single-line
machine-readable envelope on every subcommand.
usr-loop scan <estate> # [A] capture GapRecords
usr-loop cluster <estate> # [C] deduped GapClusters
usr-loop propose <estate> --from-scan # [D] one candidate diff
usr-loop propose <estate> --cluster-id ID # propose for a specific signature
usr-loop gate <candidate-diff> # run the sha-pinned §3 gate
usr-loop land <candidate> --fixture F # [F] gate, then land or quarantine
usr-loop ledger <action> # inspect the append-only ledger
usr-loop doctor # crate/schema versions, deps
Exit codes for gate/land: 0 accepted/landed, 3 rejected/quarantined
(spec-correct, not a bug), 4 gate sha-pin abort, 9 I-PRIVACY abort
(nothing persisted).
plan-lint
cargo run -p plan-lint -- # structural lint of plan.md
cargo run -p plan-lint -- --robot-json # machine-readable findings
cargo run -p plan-lint -- --doctor # health summary
Design Commitments
- Rust Cargo workspace, one crate per component.
doctorsubcommands and--robot-jsonoutput on every CLI surface, so agents read the machine contract instead of guessing.- Explicit
UnknownReasonrecords whenever analysis cannot be certain; the completeness report is never false-clean. - Parser backend isolation: downstream crates must not depend on ANTLR-generated types.
- The whole workspace is
#![forbid(unsafe_code)]. - No telemetry by default.
Repository Workflow
- Read
AGENTS.mdandplan.mdfirst. - Treat
plan.mdas the source of truth for intended architecture and scope. If code andplan.mddiverge, fix one or the other deliberately. - Track work in Beads only;
.beads/is authoritative. - Never copy private material into this repository. The USR Loop and the
correctness harness read a private estate in place, at the path given
by the
PLSQL_PRIVATE_ESTATEenvironment variable, and never persist its bytes.
Layout
plan.md: master specificationAGENTS.md: repo operating rulesCargo.toml,crates/,tools/: Rust workspacecorpus/: public and synthetic PL/SQL fixtures used by testsdocs/: architecture snapshot, plans, decisions, integration guidesscripts/:usr_gate.sh,usr_acceptance.sh,accretion_tripwire.sh,estate_correctness.sh.beads/: Beads issue-tracker state (authoritative)CHANGELOG.md: release-notes log plus thecoverage_indextable
Troubleshooting
| Symptom | Fix |
|---|---|
usr-loop gate exits 4 |
Gate sha-pin mismatch. The gate script changed without a sha bump in crates/plsql-accretion/gate.sha256. This is intentional fail-closed behavior; re-pin only via a reviewed commit. |
usr-loop gate/land exits 9 |
An I-PRIVACY leak signal at G8. The run aborted and persisted nothing, by design. Inspect the offending fixture; do not weaken G8. |
usr_acceptance.sh exits 0 with an "estate-absent" banner |
No private estate is configured (PLSQL_PRIVATE_ESTATE unset or empty), so the DoD is not proven here. Run it with the variable pointing at a private estate, or rely on nightly CI. |
| Parser regeneration fails | Normal builds use committed generated Rust. Regeneration is maintainer work: install Java, set PLSQL_ANTLR_REGEN=1, then run the parser drift-check path. |
| Empty dependency graph on a real estate | Expected for the dialect tail the parser cannot yet reach; those are recorded as typed UnknownReason and are exactly the USR Loop's repair input, not a silent failure. |
PL/SQL Intelligence Engine MCP questions
How do I add PL/SQL Intelligence Engine MCP to Claude Code?
Run claude mcp add plsql-intelligence -- docker run -i --rm ghcr.io/muhdur/plsql-mcp:0.6.3 in your terminal. Add --scope user to make it available in every project.
How do I add PL/SQL Intelligence Engine MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Does this require a live Oracle database connection?
No, the engine is offline-first and reads code and Oracle catalog snapshots in place without requiring a live database.
How does the tool handle uncertain analysis results?
Instead of providing false-clean results, the analyzer emits a typed UnknownReason when it cannot be certain of the semantics.
Is the tool compatible with Oracle client libraries?
The offline engine does not include or require Oracle client libraries.