MCP.Market

Kaval MCP server

by LufeMC·io.github.LufeMC/kaval·v0.7.1
No reviews yet

Verify the facts an agent's action depends on before it acts — ALLOW, REVIEW, or BLOCK.

A85/100grade A
Write a reviewInstall
What users say
No reviews yet
Be the first
Safety scan
A85/100

full report

Adoption
Growing

0 stars64 downloads/wk

Reviews

Write one

Nobody has reviewed Kaval yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

Kaval tools (7, 1 write)

write = sends, deletes, buys or posts

Read from the package source without running it. The installed server may list more.

  • add_source

    Tell Kaval what to watch, so later checks are answered from fresh state instead of live research. Registering the NAME of an authority is usually enough: {kind:'entity', name:'Aetna', intent:'payer policy bulletins'} resolves to the pages that publish it and watches them. Use kind:'url' for a specific page, kind:'push' for a document your own system will send in. Kaval polls watched sources adapti

  • check
  • get_receipt

    Fetch the full signed receipt for a check you already ran, by the `receipt.id` that check returned. `check` gives you only the id, the signature, and when it was signed; this returns the document that was actually signed — every fact with its state and the evidence basis under it (source locator, content digest, fetch and publication time), the freshness failure if state could not be served, the d

  • list_sources

    List what Kaval currently watches for this workspace — including sources it auto-registered after a check cited them. Each row shows the locator, what it was registered for, when it was last successfully fetched, and whether it is active. Use it to see whether the fact you care about is actually backed by a watched source (and therefore fast and monitored) before relying on a check being warm.

  • remove_sourcewrite action

    Stop watching a source and forget it, by the `id` `add_source` or `list_sources` returned. Removal is the only thing that frees registry capacity, and capacity is finite: a workspace watches a bounded number of ACTIVE sources, and every URL a check cites gets auto-registered against that same bound, so an agent that only ever adds eventually fills it — after which new citations are silently droppe

  • report_outcome

    Report what actually happened after a prior check, using the receipt id it returned, so Kaval can calibrate. Use `relied_and_correct` when you acted on an ALLOW and it held; `current_later_contradicted` when an ALLOW turned out to be wrong; `stale_caught_real` when a REVIEW/BLOCK caught a genuine change; `stale_was_false_alarm` when it did not.

  • verify

    DEPRECATED — prefer the `check` tool. Verifies one load-bearing conclusion against evidence references you supply and returns a signed ProofPacket receipt (status valid | invalidated | could_not_verify, receipt.decision ALLOW | REVIEW | BLOCK). Kept only for existing pilot integrations that pass explicit evidence_refs; it will be removed. New calls should use `check`, which needs no evidence list,

Public scan report

scanner v0.1.9 · 2026-09-24 · same rubric, same numbers if you re-run it

no findings
  • Code scan9 source files scanned25/25
  • –Live reliabilityno gateway calls yet and no remote to proben/a
  • –Tool poisoningtools not inspected (local package is not executed); not countedn/a
  • Auth qualitystatic API keys via environment variables6/15
  • Maintenancelast push 13 days ago15/15
  • Maintainer identityregistry namespace matches repository owner; GitHub account older than a year9/10
Overall 85/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How Kaval compares

Against every graded AI and agents MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
85/100
higher than 73% of 4,460 AI and agents servers
Tools
7
the typical AI and agents server has 6
Tools that change things
14%
typical: 0%. Fewer write tools means less an agent can break
Downloads a week
64
more than 51% of 1,538 AI and agents servers with a package

What its tools let an agent do: 5 read · 1 create · 1 delete

Install Kaval in Claude Code, Cursor or VS Code

Runs npx -y @usekaval/mcp on your machine. Read the scan report first; the gateway never runs local packages.

claude mcp add kaval -- npx -y @usekaval/mcp
Add to Cursor

What the publisher says

From the Kaval repository's README, as published. We do not edit it. Read it on GitHub

Kaval clients

Open-source client libraries for Kaval. Register the payers and pages you care about once. Kaval watches them, extracts structured records against a schema you define, and delivers each extraction — plus a monthly PDF + manifest rollup — as a webhook the moment it lands, instead of you polling or re-researching it. check() is the second half: before an agent acts on one of those facts, send Kaval the action and it answers ALLOW, REVIEW, or BLOCK with a signed receipt.

Policy engines decide whether an action is permitted under the rules; Kaval verifies whether the facts those rules depend on are still true.

These are thin HTTP clients for the hosted Kaval API (https://api.usekaval.com). Create an API key at usekaval.com.

The 0.7.3 portfolio methods are available in the Node SDK and MCP server.

The Python SDK does not yet expose contracts, fact imports, bulletins, or training review.

Sources → Extractions → Webhooks

The primary loop needs no LLM call and no polling loop of your own:

import { Kaval } from "@usekaval/kaval";

const kaval = new Kaval({ apiKey: process.env.KAVAL_API_KEY });

// 1. Watch a payer.
const { source } = await kaval.addSource({
  kind: "entity",
  name: "Aetna",
  intent: "payer policy bulletins",
});

// 2. Register the shape you want extracted, and bind it to the source.
const schema = await kaval.createExtractionSchema({
  name: "prior-auth-bulletin",
  json_schema: {
    type: "object",
    properties: { cpt_code: { type: "string" }, requires_prior_auth: { type: "boolean" } },
    required: ["cpt_code", "requires_prior_auth"],
  },
});
await kaval.updateSource({ id: source.id, extraction_schema_id: schema.id });
// reprocess: true also re-extracts versions that already ran under another schema
// (webhook source_change: "schema_changed"; join on source_version_id).

// 3. Get pushed an extraction.document webhook every time a new bulletin lands, already
//    extracted against the schema — or poll listExtractionRuns() for the same records.
const { webhook_verification } = await kaval.subscribeExtractions({
  callback_url: "https://your-app.example.com/hooks/kaval",
});
import os

from kaval import KavalClient

kaval = KavalClient(api_key=os.environ["KAVAL_API_KEY"])

source = kaval.add_source(kind="entity", name="Aetna", intent="payer policy bulletins")
schema = kaval.create_extraction_schema(
    name="prior-auth-bulletin",
    json_schema={
        "type": "object",
        "properties": {"cpt_code": {"type": "string"}, "requires_prior_auth": {"type": "boolean"}},
        "required": ["cpt_code", "requires_prior_auth"],
    },
)
kaval.update_source(source["id"], extraction_schema_id=schema["id"])
# reprocess=True also re-extracts versions that already ran under another schema
# (webhook source_change="schema_changed"; join on source_version_id).
kaval.subscribe_extractions(callback_url="https://your-app.example.com/hooks/kaval")

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Kaval: common questions

Is Kaval MCP server safe?
Yes, by our scan: it is graded A (85/100). Read the Kaval safety report
How do I install Kaval?
It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.
Does Kaval need an API key?
Yes. The registry entry asks for KAVAL_API_KEY.
Is Kaval maintained?
The last commit was 54 days ago (2026-09-10). The latest release is v0.7.1.
What can I use instead of Kaval?
Servers from other publishers that do the same job: Decionis MCP server, Emilia Protocol MCP server and Agent-Native Chat MCP server.
How does Kaval compare with other AI and agents MCP servers?
safety score 85/100 (higher than 73% of 4,460 AI and agents servers); tools 7 (the typical AI and agents server has 6); tools that change things 14% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.

Alternatives to Kaval

Same job from other publishers: the closest match first, then the best rated.

  • Decionis
    Authorize consequential AI agent actions before execution
    A
  • Emilia Protocol
    Exact-action approval for consequential agent actions: request, track, and verify signed receipts.
    B
  • Agent-Native Chat
    Minimal chat-first app with durable threads, actions, and the app-agent loop
    A
  • Watch Skill
    Watch video and live sessions, keep timestamped evidence, and verify an agent's own work.
    B
  • OpenWorkProof
    Verifiable agent evidence; opt-in Codex guard and reference SOC alert review.
    A