Metadata-Version: 2.4
Name: recordant
Version: 0.2.1
Summary: Recordant: a standalone diagnostic + decisions-ledger engine for any host software system, with an optional MCP console.
Author: Mentor Trading LLC
License: Proprietary -- see LICENSE
Project-URL: Homepage, https://mentorsentinel.ai
Project-URL: Pricing, https://mentorsentinel.ai/markets-ai-governance.html
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Software Development :: Quality Assurance
Requires-Python: >=3.11
Description-Content-Type: text/markdown
Requires-Dist: mcp>=1.28.1
Requires-Dist: requests<3,>=2.32.0
Provides-Extra: anthropic
Requires-Dist: anthropic>=0.40.0; extra == "anthropic"
Provides-Extra: openai
Requires-Dist: openai>=2.44.0; extra == "openai"
Provides-Extra: gemini
Requires-Dist: google-generativeai>=0.8.0; extra == "gemini"
Provides-Extra: all
Requires-Dist: anthropic>=0.40.0; extra == "all"
Requires-Dist: openai>=2.44.0; extra == "all"
Requires-Dist: google-generativeai>=0.8.0; extra == "all"
Provides-Extra: dev
Requires-Dist: pytest>=8.0; extra == "dev"

# Recordant

<!-- mcp-name: io.github.recordant/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

1. Install the package and your LLM provider's SDK (only the one you use):

   ```
   pip install "recordant[anthropic]"     # or [openai], [gemini], or [all]
   ```

2. 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)

3. Export your key and run one cycle:

   ```
   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`.

4. 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.

```
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:

```
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.
