Metadata-Version: 2.4
Name: neruva-mcp
Version: 0.69.0
Summary: Verified skills for AI agents. Find, install and run helper code that a program has checked on cases it never saw, and build your own: every skill ships the exact checker that proved it, so you can re-run the evidence yourself instead of taking our word for it. Free to read and install, no key and no account. Works with any model that can call a function, from a frontier API to a 0.6B running on your laptop.
Author-email: Clouthier Simulation Labs <info@neruva.io>
License: Proprietary -- (c) Clouthier Simulation Labs. For Neruva integration clients only.
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 :: Other/Proprietary 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<2,>=1.0.0
Requires-Dist: httpx>=0.27
Provides-Extra: forge
Requires-Dist: anthropic>=0.40; extra == "forge"
Dynamic: license-file

# neruva-mcp

**Verified skills for AI agents.** Do not replace your model. Give it proven capabilities.

The Python MCP server for [Neruva](https://neruva.io).

## What this is for

Your model gets some jobs wrong in the same way every time. A page that has to be landscape. A
form field named by a tax agency rather than by its label. A chart the spreadsheet quietly
discards. Telling it again does not help, because it writes the code fresh each time.

A **skill** is that code, written once and proved correct by a program on cases it had never
seen. Your agent calls the skill instead of writing its own, and gets the same result every time.

Measured on held-out cases, best of two samples, graded by an exact checker:

| job | the model alone | with the skill |
| --- | --- | --- |
| Word document, portrait then landscape with a header and table | 25% | 100% |
| PowerPoint combo chart on a secondary axis | 13% | 100% |
| Fillable PDF form | 44% | 100% |
| The real Canadian TD1 tax form | 19% | 94% |

Every number on [neruva.io/evidence](https://neruva.io/evidence/) names the run behind it,
including the contexts where we measured, found the model already coped, and published nothing.

## Install

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

Point your MCP host at it. Reading and installing skills need no key:

```json
{
  "mcpServers": {
    "neruva": { "command": "neruva-mcp" }
  }
}
```

Add a key only to publish a skill, claim a name or post paid work:

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

## Tools

**Using a skill.** No key needed for any of these.

| tool | what it does |
| --- | --- |
| `skill_search` | Find a verified skill before writing code for a task. |
| `skill_get` | One skill: code, usage guide, evidence, checker, certificate. Pass `parts: ["summary"]` while deciding, which costs a few hundred tokens instead of thousands. |
| `skill_install` | Write it into a directory as an Agent Skills folder your harness loads, including its checker so you can audit it. |
| `skill_tasks` | The controlled list of kinds of job, for filtering a search. |
| `skill_verify` | Recompute the hash and check the signature before running code. |

**Building one.** These run on your machine. No key is needed: you are already talking to a
model, so the generative steps are handed back to it and the tool does the deterministic
part, which is the grading. Call `skill_gate` with no key and it returns the prompt per spec;
you attempt them and call again with `attempts`. Call `skill_forge` with your own
`candidate` and `usage` and it grades both. Set `ANTHROPIC_API_KEY` if you would rather a
model be called for you; either way your context, your specifications and your data never
reach us. Only a finished skill is published, and only when you call `skill_publish`.

| tool | what it does |
| --- | --- |
| `skill_requirements` | Turn a spec in words into named, checkable clauses; taste words are refused. |
| `skill_check_checker` | Try to break your checker before trusting it. |
| `skill_gate` | Find out whether a skill is warranted before building one. |
| `skill_forge` | Build it, ratcheting on what your checker actually says. |
| `skill_certify` | The whole protocol in one call: gate the checker, grade the skill on held-out specs, write a certificate that says what was and was not checked. |
| `skill_publish` | Publish it. Free, and it is re-checked before it is listed. |

Use them in that order, and expect `skill_gate` to say no. Of thirteen contexts we measured,
nine were refused because the cheap model already did the job. A refusal costs cents and saves
you from adding something nobody needs.

`skill_check_checker` is not a formality. A checker that accepts a broken file reports a
perfect score for a model that did nothing; a checker that demands what the task never asked
for invents failures and makes any skill look like a triumph. We wrote three versions of one
checker in an hour and two of them did exactly that. Neither was visible by reading it.

The older names `rung_search`, `rung_get`, `rung_install`, `rung_verify` and `rung_bank` still
work and do the same things.

## Using it

Ask your agent for something it usually fumbles. A harness with this server installed will find
the skill first:

```
skill_search(q="fillable pdf form")
skill_install(id="rec_0b825e...", dir="~/.claude/skills")
```

`skill_install` writes `SKILL.md` and the code into a folder, and your harness loads it like any
other skill. Nothing runs on our servers: the skill executes wherever your model does.

Or without this package at all, since the API is public:

```bash
curl "https://api.neruva.io/v1/commons/skills?q=combo%20chart"
curl "https://api.neruva.io/v1/commons"          # every endpoint, described
```

## Building and publishing one

Publishing is free and always will be. What you get back is the part you cannot give yourself:
your code put through an exact check on cases it has never seen, signed if it passes, hosted at a
name you own, and reachable by any agent.

The whole loop, from a job your model keeps getting wrong to a published skill:

```
skill_check_checker(checker_code=..., specs=[...])   # can it be broken? if not, fix it
skill_gate(context="...", checker_code=..., specs=[...])   # is a skill even warranted?
skill_forge(context="...", checker_code=..., specs=[...])  # build it

# or, once you have code and a guide, everything above in one call:
skill_certify(context="...", checker_code=..., specs=[...], code=..., doc=...,
              usage=[{"spec_id": "s3", "code": "..."}, ...])   # your own scripts using it

skill_publish(
  name="invoice_total_check",
  skill="pdf", task="pdf-generation", language="python",
  purpose="Make a purchase order whose line items add up to the total shown.",
  description="A purchase order PDF whose line items total correctly.",
  code=..., doc=..., entry_points=["build_purchase_order"],
  onecall={"wrapper": ..., "schema": {...}, "example": {...}},
  evidence=["16 held-out orders, exact checker: 0.31 alone, 1.00 with this"],
)
```

The certificate `skill_certify` returns has two lists, `checked` and `not_checked`. Read the
second before quoting the first. A checker gated on spoilers alone is known to reject broken
output and not known to accept correct output built another way; three held-out specs is a
smoke test, not a rate. The certificate says so instead of leaving you to find out.

Two fields decide whether anyone ever uses what you publish. `purpose` is one plain sentence
saying what it is FOR, in the words someone types when they need it: without it your skill is
indexed on its own specification and nobody searching in plain language will find it. `onecall`
is a single `build()` entry point plus a JSON schema, so an executor fills in arguments instead
of recovering your function signatures from prose.

## Also in this package

An account on Neruva carries a private memory and replay surface: records, recall, snapshots and
audit. Those tools ship here too, but they are off by default. What you get on a plain install is
the six skill tools and nothing else, because a long tool list makes a model choose worse and
those tools do nothing without an account.

Turn them on if you have one:

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

## Licence

Apache 2.0. Built by Clouthier Simulation Labs, Ontario, Canada.
