Review MCP Server
You can persist and retrieve engineering review context tied to an exact STEP revision in local SQLite.
Remember reviews: save named features or anonymous notes against artifact entities, with optional tags; named re-remembers replace, anonymous re-remembers append.
Recall reviews: retrieve by artifact, entity ID, free text, or tags; paginate results and mark records stale against the supplied current revision.
Record decisions: save a subject, recommendation, confidence, status, and basis requirement-checks with sources, evidence, states, questions, faces, and engineer verdicts.
Recall decisions: get decisions newest-first, filter by subject text, status, or entity, paginate, and see stale decisions from other revisions.
Forget records: delete a named feature, an entity’s anonymous notes, or a decision by subject; deletes are idempotent.
Stay file-independent: works over local stdio and never opens the CAD file, storing authored context rather than measurements or audit history.
Persists review records — named features, anonymous notes, tags, and decisions — in a local SQLite database at a configurable path, supporting revision-scoped lookup, staleness tracking, and durable storage across restarts.
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., "@Review MCP Server what notes and tags do we have for face:3 on the current revision?"
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.
Ottorev — Review MCP Server
The memory an engineering assistant needs. This local stdio MCP server records names, notes, tags, and decisions against an exact CAD revision in SQLite, so an assistant can pick up where it left off — remember that a face is the mating surface, that a tolerance callout is tight, or that a review concluded hold with the requirements behind it.
It never opens the CAD file: it stores the revision the caller supplies and compares it on recall, so it works on a laptop with no CAD software and no other server running.
Quick start
Requires Node.js 26+ and npm. From this repository:
npm install
npm run build
REVIEW_MCP_DB_PATH=/absolute/path/to/review.db npm startFor any MCP client:
{
"mcpServers": {
"review": {
"command": "node",
"args": ["/absolute/path/to/review-mcp-server/dist/src/index.js"],
"env": { "REVIEW_MCP_DB_PATH": "/absolute/path/to/review.db" }
}
}
}REVIEW_MCP_DB_PATH defaults to ./review-mcp.db; parent directories are created
automatically. Records persist across restarts — protect and back up the database
as application data.
Related MCP server: engineering-mcp
Tools
Tool | Behavior |
| Save a named feature (re-remember replaces) or an anonymous note (re-remember appends) against an entity set, with tags. Returns |
| Retrieve by artifact, entity, free text, or tags; marks each record stale against a supplied current revision. Follow pagination for complete retrieval. |
| Save the disposition reached about a revision and its basis — one row per requirement-check, naming the source, the evidence, the state, and the engineer's verdict. Re-remembering the same subject replaces it. |
| Return decisions newest-first, each marked stale when it belongs to another revision. An |
| Delete a named feature, an anonymous note by entity, or a decision by subject. Idempotent. |
Results provide structured content and text; tool failures set MCP isError.
Writes change local records; the client controls when to request those mutations.
The server also advertises engineering-review prompts that compose with a geometry
server, while the core record operations run on their own.
Artifact and subject semantics
An input artifact contains revision (sha256: plus 64 lowercase hex digits),
format: "step", and optional URI and units:
{
"revision": "sha256:0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
"uri": "file:///work/part.step",
"format": "step",
"units": "mm"
}Supply the actual revision from the producer; the example digest is illustrative. A URI groups records by locator; without a URI, the revision is the lookup key.
uri accepts either a URI or a plain filesystem path, because a path is what a
caller usually has in hand:
{ "uri": "/work/part.step" }Both spellings address the same records: a path is normalised to a file: URI
before anything is stored or matched. A relative path resolves against the server
working directory. Normalisation never opens the file, so a record can be written
for an artifact this server cannot read.
An entity filter is revision-scoped; a text or tag filter is not. An entity ID
denotes different geometry in a different revision, so recall and
recall_decisions match an entity_id only against records written for the
supplied revision, and match it exactly — face:3 does not match face:30. Names,
notes, subjects, and tags are matched across revisions, which is how an earlier
record is found at all, and every result says whether it is stale.
Each returned record contains one artifact reference, its entity IDs, and the ID scheme. The entity IDs are opaque outside that scheme and revision.
Decision records
A review names or annotates geometry. A decision is the other thing a review produces: a disposition about a revision, and the basis it rests on.
One basis item is one requirement-check, and it answers for itself:
field | what it carries |
| what has to hold, stated so it can be checked |
| where the requirement came from: |
| the clause, note number, or document a reader can follow |
| the value as it was reported, quoted with its provenance |
|
|
| required for |
| the geometry the item is about, in this revision; always present, empty when the item is about the part |
| the engineer's |
unresolved and conflicting are first-class outcomes: a decision that carries
them is a complete record of where the work stands, not a failure to decide. A
basis item is refused when it cannot answer for itself — no source, or a state of
unresolved/conflicting with no question.
Three properties matter more than the shape:
A decision is bound to a revision. The revision is part of its key, so the same subject at the same revision is recalled rather than reached again, and a decision made against a different revision comes back marked
stale: true, still carrying the revision it belongs to.Face IDs do not travel between revisions. Topological naming is unsolved in OCCT, and this API does not pretend otherwise: an
entity_idfilter matches only the revision that produced the ID.Verdicts are what make a requirement agreed. Recording a
verdictturns a line the assistant proposed into one the engineer accepted or rejected — the record of how much authority the assistant actually earned.
A stored decision is the caller's own account: the requirement as stated and the evidence as quoted. This server never measures anything, so a recalled decision is a record of what was concluded, not a measurement cache — Geometry remains the authority for numbers.
Limits
Review stores authored context: names, notes, and tags bound to an artifact revision, and decisions with the requirements they rest on. It does not store verified measurements, a complete immutable audit history, or authoritative approval records, and it does not compute geometry, run simulation, or decide manufacturability. Staleness is judged from a revision the caller supplies; Review never opens the CAD file.
There are no schema migrations: the database is a working file, and a changed table shape means deleting it. The server reports the version mismatch rather than guessing at a transformation.
Development
Requires Node.js 26+ and just. A Nix flake and
.envrc provide the toolchain; run direnv allow after changing either.
Recipe | Purpose |
| Install dependencies. |
| Run TypeScript over stdio. |
| Compile into |
| Run unit tests. |
| Run oxlint. |
| Rewrite formatting with Prettier. |
| Verify formatting. |
| Run |
|
|
| Remove compiled output, retaining the database. |
Server logs go to stderr as newline-delimited pino JSON. MCP_LOG_LEVEL
(debug|info|warn|error), MCP_LOG_FORMAT=human, and MCP_TRACE_ID tune
them; secret-like fields are redacted.
Packaging
npm pack builds first and includes compiled runtime code, package metadata, and
this README. Tests and source maps are excluded. Install the tarball to check the
review-mcp executable with a compatible MCP client. The server serves both
protocol eras: the 2025-11-25 handshake that stock MCP hosts negotiate, and the
2026-07-28 envelope through server/discover.
License
MIT. Third-party notices: THIRD_PARTY_NOTICES.md.
Available Tools
5 toolsforgetForget a ReviewBDestructive
Delete a saved record. Pass the feature name to remove a named feature, an entity id to remove the anonymous notes attached to that entity, or a subject to remove a decision. Idempotent. Use only when the user explicitly asks to remove it.
Inputs: artifact (required), name, subject, entity_id. Returns: name, deleted, subject, entity_id
recallRecall ReviewsARead-onlyIdempotent
Retrieve saved reviews for a STEP file, optionally filtered by an entity, free-text search, or tags. Pass the current ArtifactRef from Geometry inspect; its revision is used to mark each returned record stale or current. Each record returns one artifact reference, its entity IDs and the ID scheme; use these together when handing an annotation to another tool. An entity filter matches only reviews written against the supplied revision, because a face ID denotes different geometry in a different revision; text and tag filters are not scoped that way. Use early in a conversation to restore persistent context about a part. Uses the supplied artifact revision to mark saved records stale; it does not open the artifact or require shared filesystem access.
Inputs: artifact (required), tags, limit, offset, +2 more. Returns: reviews, current_revision
recall_decisionsRecall DecisionsARead-onlyIdempotent
Retrieve decisions saved for an artifact, newest first, each marked stale when it was made against a different revision than the one supplied. Pass the current ArtifactRef from Geometry inspect. Filter by subject text, status, or an entity that appears in the basis. An entity filter matches only decisions made against the supplied revision, because a face ID is scoped to the revision that produced it: a decision about face:3 in an older revision is not a decision about face:3 now. Use this when a revision reappears, to recover what was already concluded instead of reaching it again.
Inputs: artifact (required), limit, offset, status, +2 more. Returns: decisions, current_revision
rememberRemember a ReviewA
Save a durable review about geometry: a semantic feature (give it a name, e.g. 'mounting holes') or a plain note (no name). Re-remembering a named feature REPLACES it (use this to correct the AI). Re-remembering the same entities without a name APPENDS facts. The more you save, the more the system understands the part across sessions.
Inputs: artifact (required), entities (required), entity_id_scheme (required), name, +2 more. Returns: review, replaced
remember_decisionRemember a DecisionA
Save the disposition reached about an artifact revision, with the basis it rests on: a list of requirement-checks, each saying where its requirement came from and what happened when it was checked. Re-remembering the same subject on the same artifact revision REPLACES that decision, which is how a decision is revised as the engineer answers questions or disagrees with a line. A different subject starts a separate decision, because one part can carry several at once. Record each engineer verdict when they have given one: a requirement the engineer accepted is a different thing from one that was proposed. Store each requirement as stated and each piece of evidence as it was reported. This server never opens or measures the artifact, so recall returns what was concluded, not a measurement — Geometry remains the authority for numbers.
Inputs: basis (required), subject (required), artifact (required), confidence (required), +3 more. Returns: decision, replaced
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
The set is organized as two parallel pairs: recall/remember operate on reviews (features and notes), while recall_decisions/remember_decision operate on decisions with requirement-checks as a basis. Descriptions make the boundary explicit, though the near-identical verb stems mean an agent skimming names could still pick recall when it wants recall_decisions. forget is the only tool spanning both domains, but its description clarifies how to target features, entity notes, or decision subjects.
Names are all lowercase snake_case with verb-first construction, and the pattern is readable: base verbs (recall, remember, forget) for reviews, and the same verbs plus a _decision(s) suffix for decisions. Minor deviation: singular remember_decision paired with plural recall_decisions breaks the symmetry, and forget has no _decision counterpart despite handling decisions.
Five tools is tightly scoped to a persistent-memory server: two write paths, two read paths, and one delete. Each tool earns its place and there is no redundancy. Nothing feels missing or bloated for the stated purpose.
Full lifecycle is covered for both domains — create (remember, remember_decision), read (recall, recall_decisions), delete (forget) — with 'update' handled through documented replace-on-rewrite semantics, which is a valid design. Minor gaps: there is no way to enumerate or export all saved reviews/decisions without supplying an ArtifactRef, and no cross-artifact or cross-revision listing operation.
Maintenance
Related MCP Connectors
Individual-analyst context layer: recall, remember, and reconcile your data and engineering context.
Versioned artifact review for people and AI agents, with contextual comments and human control.
Durable, shareable and governed project memory with smart triage and explicit project composition.
Agent-native notes, tasks, dev-docs, vaults, sync & handoffs. MCP + OpenAPI dual surface.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables multi-project workspaces to share structured notes, API contracts, and handoff messages via a local SQLite database, with versioning and read tracking.GPL 3.0
- AlicenseBqualityDmaintenanceEnables local engineering workflow management by consolidating tickets, QA evidence, time tracking, root cause investigation, knowledge, and reporting into a single SQLite database, allowing generation of complete ticket packages for handoffs, dailies, or career evidence.2314 npmMIT
- AlicenseBqualityCmaintenanceEnables security analysts to carry structured investigation state across sessions by storing typed observations, hypotheses, tasks, evidence and versioned decisions in a local SQLite graph with full-text search. It also enforces authorized scope and request controls, redacted and content-hashed evidence, duplicate-test signatures and validation gates that leave findings in draft until reproducibly confirmed, then produces technical and executive reports for Antigravity, Codex and other stdio MCP clients.201MIT
- AlicenseNot gradedqualityCmaintenanceEnables clients to index and search reviewed Markdown and text documents with SQLite FTS5, read sources and prompts, manage explicit notes, and query a local Ollama assistant that uses permitted tools.4MIT