io.github.recordant/recordant (Model Context Protocol Server)

Recordant is a patent-pending diagnostic + decisions-ledger engine exposed as an MCP server with an operator-brief workflow and a chat-native MCP console. It scans a target repository, changelog, and logs periodically to produce an operator brief covering changes, what looks broken, what was fixed, and a prioritized diagnosis list.

🛠️ Key Features

Diagnostic + decisions-ledger engine
Periodic scan of a target repo, changelog, and logs
Operator brief: what changed, what looks broken, what was fixed, prioritized diagnosis list
Chat-native MCP console over the same data
Operates without provider assumption (supports Anthropic, OpenAI, and Gemini via bring-your-own LLM)

🚀 Use Cases

Diagnosing issues in a host software system using repo/changelog/logs inputs
Producing operator briefs from periodic scans
Reviewing a prioritized diagnosis list in an MCP console

⚡ Developer Benefits

Uses the same underlying data for briefs and console interactions
Bring your own LLM (your key and usage)

⚠️ Limitations

Source data describes scanning behavior and console access but does not specify exact tool count, supported endpoints, or configuration details.

Recordant

Recordant is a patent-pending diagnostic + decisions-ledger engine for any host software system. Point it at a target's repo, changelog, and logs, and it runs a periodic scan that produces an operator brief: what changed, what looks broken, what was fixed, and a prioritized diagnosis list — plus a chat-native MCP console over the same data.

Bring your own LLM (Anthropic, OpenAI, or Gemini — your key, your usage, your bill). Recordant makes no provider assumption.

15-minute install and first brief

Install the package and your LLM provider's SDK (only the one you use):
code
```
pip install "recordant[anthropic]"     # or [openai], [gemini], or [all]
```
Copy recordant.example.toml to recordant.toml and set:
- repo_root — the target repo to diagnose
- changelog_path — usually CHANGELOG.md (falls back to git log if absent)
- log_globs — which log files to health-scan
- [llm] — your provider, model, and api_key_env (the name of the environment variable holding your key — never the key itself)
Export your key and run one cycle:
code
```
export RECORDANT_LLM_KEY=sk-...
recordant --config recordant.toml
```
The brief path prints to stdout. The brief, snapshot, and (optional) decisions ledger are written under your configured output_dir.
Schedule it (cron / systemd timer / your own scheduler) at the schedule_seconds cadence in your config.

That's the whole loop. See ENGINE.md for the adapter architecture, config reference, and known limitations.

MCP console

Recordant also runs as an MCP server exposing 7 tools over stdio, for use from a chat-native MCP client:

Tool	Purpose
`recordant_brief`	Latest delta brief since the prior cycle
`recordant_status`	Current status snapshot (health, cadence, active book)
`recordant_digest`	Open items, Accepted-Risk Register, fixes shipped, deadlines
`recordant_open_items`	Every open diagnosis with age, recurrence, evidence
`recordant_acknowledge`	Acknowledge a diagnosis (P0 items cannot be acknowledged)
`recordant_accept_risk`	Pin a diagnosis in the Accepted-Risk Register
`recordant_resolve`	Assert a diagnosis is resolved (audited against the changelog)

Token-auth is on by default — there is no anonymous mode. The server requires a valid RECORDANT_LICENSE_KEY and verifies it against the license service at startup before registering a single tool; it will not run unlicensed, even briefly. A short offline-grace window covers a transient network failure to the license service, but an explicitly invalid or expired key is refused immediately.

code

export RECORDANT_LICENSE_KEY=rk-...
recordant-mcp --config recordant.toml

Add it to your MCP client's config (Claude Desktop, Claude Code, etc.):

json

{
  "mcpServers": {
    "recordant": {
      "command": "recordant-mcp",
      "args": ["--config", "/absolute/path/to/recordant.toml"],
      "env": { "RECORDANT_LICENSE_KEY": "rk-..." }
    }
  }
}

Licensing and pricing

Recordant is licensed software, not open source (see LICENSE). Get a key and see current pricing at https://mentorsentinel.ai/markets-ai-governance.html.

Docker

Recordant ships as a compiled image -- there is no engine source to build from, so docker build is not part of a customer workflow. Pull the licensed image (published per BUILD-RELEASE.md) and run it:

code

docker pull recordant/recordant:<version>
docker run -v $PWD/recordant.toml:/app/recordant.toml:ro \
           -v $PWD/target-repo:/app/target-repo:ro \
           -e RECORDANT_LLM_KEY \
           recordant/recordant:<version> --config recordant.toml

The image is signed (cosign) and ships with an SBOM (syft) so you can audit what it does -- dependencies, egress -- without needing readable engine source; see BUILD-RELEASE.md for verification commands.

See docker-compose.example.yml for a compose-based setup, including the MCP console service.

Support

Found a bug or have a feature request? Open an issue — see .github/ISSUE_TEMPLATE/. For licensing or account questions, use the pricing page above.

Patents

Recordant's inference loop and decisions-ledger lifecycle are patent-pending (U.S. application numbers available on request). "Patent-pending" reflects filed, unexamined provisional applications — no patent has issued.

io.github.recordant/recordant