Metadata-Version: 2.4
Name: neruva-mcp
Version: 0.52.0
Summary: MCP server for Neruva -- reliability for AI agents and multi-agent operations. Agents stop repeating mistakes, stop spinning, and get more reliable the longer they run; every run is deterministic and byte-identical replayable for audit. Typed Records, memory recall + KG, snapshot/restore (.neruva portable container), and Byzantine consensus for multi-agent trust. Bring your LLM. Free tier, no card.
Author-email: Clouthier Simulation Labs <info@neruva.io>
License: MIT
Project-URL: Homepage, https://neruva.io/integrations/
Project-URL: Documentation, https://neruva.io/docs/
Keywords: mcp,model-context-protocol,neruva,agent-memory,agent-context,agentic-ai,knowledge-graph,graph-rag,rag,vector-database,claude-code,claude-agent-sdk,ai,llm
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: mcp>=1.0.0
Requires-Dist: httpx>=0.27
Dynamic: license-file

# neruva-mcp

**Reliability for AI agents — and for multi-agent operations.** The Python MCP server for [Neruva](https://neruva.io). Your agents stop repeating mistakes, stop spinning in circles, remember across every session, and get more reliable the longer they run. Every run is replayable bit-for-bit for audit. Bring your own LLM. **Free tier, no card.**

> [neruva.io](https://neruva.io) · get a key at [app.neruva.io](https://app.neruva.io)

## It just works — that's the point

Neruva is **push, not pull**. It runs silently in the background — no tools to learn, no glue code. Before each action it surfaces the past mistake (and the fix that worked) so the agent does it right; it breaks loops before they burn your budget; it records everything for replay. The agent never spends a token deciding to "use memory." **The automatic operation is the moat** — pull-based memory tools can't match it because they require the agent to stop and ask.

## What you get

- **Stops repeating mistakes** — past mistake + working fix surfaced automatically; a known-destructive repeat is blocked so the agent self-corrects.
- **Stops spinning** — detects loops/stalls on a failing approach and breaks them.
- **Remembers across sessions and projects** — persistent memory that builds itself from what your agents do.
- **Provable + replayable** — deterministic from a seed; reproduce any run bit-for-bit for audit. Export the whole memory as one portable `.neruva` file.
- **Gets more reliable over time** — learns from your agents' own history, no retraining, no weight changes.
- **Built for multi-agent operations** — keeps shared memory consistent and catches an agent that's wrong or lying before it poisons the others. In a swarm, one unreliable agent compounds at every handoff; Neruva is the reliability layer underneath.

## Install

```bash
pip install neruva-mcp
```

This installs the Neruva MCP server. Point your MCP host at it with your key:

```json
{
  "mcpServers": {
    "neruva": {
      "command": "neruva-mcp",
      "env": { "NERUVA_API_KEY": "nv_..." }
    }
  }
}
```

For the silent auto-pilot hook (background mistake-recall, loop-break, recording) in Claude Code, install the companion: `pip install neruva-record && neruva-record-install`. Get a free key at [app.neruva.io](https://app.neruva.io) (no card).

## The tool surface

A small, focused set: typed **Records** (ingest/query/timeline/get/update/delete, GDPR `forget`, compact, export/import), federated **recall** (`agent_recall`), the **memory knowledge graph** (`hd_kg_*`), **snapshot/restore** for replay, multi-agent **consensus**, and op stats. Bring your own LLM — the substrate stays deterministic and `$0`/call server-side.

## Proof (cited honestly on [neruva.io/benchmarks](https://neruva.io/benchmarks))

| Test | Result | Plain meaning |
|---|---|---|
| Learns from mistakes | **+34 pts** | Same model, no retraining: 84%→93% over 2000 tasks vs flat 59% without. |
| Long-history memory (LongMemEval) | **93.3%** | Top-tier on the standard agent-memory benchmark. |
| Replay determinism + accuracy (DFAH) | **100% / 88%** | First to hit both at once. |
| Recall latency (p95, cache hit) | **~80ms** | Answers from memory in well under a tenth of a second. |

## Config

Set `NERUVA_API_KEY`. `NERUVA_URL` defaults to `https://api.neruva.io`.

## License

MIT
