MCP.Market

Kaval MCP server

by usekaval·io.github.usekaval/kaval·v0.8.2
No reviews yet

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

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

full report

Adoption
Growing

0 stars112 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 (37, 10 write)

write = sends, deletes, buys or posts

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

  • add_source
  • check
  • create_extraction_runwrite action

    Request a one-off publisher + period extraction run. Pass source_id or extraction_schema_id, not both; omit both when exactly one schema is bound in the workspace. Requires policy-update:manage. Answers with the run in status 'processing' — poll get_extraction_run or wait for its extraction.document webhook.

  • create_extraction_schemawrite action

    Register a JSON Schema Kaval extracts structured records against. Bind the returned schema's id to a source with update_source so every document that lands on it afterward is extracted automatically and delivered as an extraction.document webhook, or pass it directly to create_extraction_run for a one-off publisher + period run. This is the schema-bound successor to list_bulletins' free-text extra

  • create_publisherwrite action

    Create an org-owned publisher (renameable display name; UUID is the identity). Pass the returned id as publisher_id to add_source. Duplicate names in the same org return 409.

  • delete_extraction_schemawrite action

    Delete a schema from lists and selectors. Historical extraction records remain available. Returns a conflict if an active watched source uses it.

  • get_bulletin

    Get one structured bulletin by source-version id. Each field includes its status and exact evidence when available. Prefer get_extraction_run for new integrations — this free-text pipeline still works but is not receiving new record types.

  • get_bulletin_extraction_attempt

    Get one customer-readable bulletin extraction attempt by source-version id. This tool cannot requeue work. Prefer get_extraction_run for new integrations — this free-text pipeline still works but is not receiving new record types.

  • get_contract

    Get contract processing status, candidate counts, and extraction issue state. Poll until the contract is ready for review or has failed.

  • get_extraction_runwrite action

    Get one extraction run (an Update) by id — its status (processing | retry | succeeded | review_required | failed | out_of_scope), the schema it ran against, and its extracted result once it succeeds. Document PDF chrome (pdf_href, content_href, sections) is nested on extraction_run.document by default; pass expand_document=false to omit. Records and nested evidence live on extraction_run.result.

  • get_fact_import

    Get one bulk import and every item result. Poll until the batch reaches a terminal state.

  • get_publisher

    Get one org-owned publisher by UUID. Display name is renameable; identity is the UUID used as publisher_id on sources and extraction runs.

  • 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

  • get_source_version_contentwrite action

    Fetch the captured content of one fetched version of a watched source, by the `source_version_id` an extraction.document webhook or an extraction run names. Defaults to the raw canonical text; pass format:'sections' to get it pre-split into the same sections the sectionizer feeds extraction runs.

  • get_training_job

    Get one training job status. Production promotion remains an internal operation and is not available through MCP.

  • import_facts

    Queue 1 through 400 reviewed facts for warm checks. This tool does not create watched sources. Each item gets a terminal result.

  • ingest_contract

    Queue a contract for extraction. Use canonical text, an approved HTTPS content URL, or an upload id from prepare_contract_upload.

  • list_bulletin_extraction_attempts

    List customer-readable bulletin extraction status. Filter by source or lifecycle state. This tool cannot requeue work. Prefer list_extraction_runs for new integrations — this free-text pipeline still works but is not receiving new record types.

  • list_bulletins

    List structured payer bulletins. Filter by payer, policy, code, publisher date, or review status. Dates are publisher-stated dates only. Prefer create_extraction_schema + create_extraction_run (or update_source's extraction_schema_id binding) for new integrations — this free-text pipeline still works but is not receiving new record types.

  • list_contract_claims

    List extracted claim candidates with exact evidence spans. A reviewer must approve, correct, or reject each candidate before activation.

  • list_contract_extraction_issues

    List deterministic contract extraction failures for customer review. Each issue identifies the rejected candidate and evidence-line range without exposing contract text.

  • list_extraction_packages

    List the monthly PDF + manifest rollups every publisher/period's extraction runs are packaged into, optionally filtered by publisher UUID and/or YYYY-MM period. Each row's pdf_href is GET /v1/extraction-packages/{id}/document — follow the 302 to a short-lived signed PDF (this tool does not download bytes).

  • list_extraction_runs

    List extraction runs (Updates). Filter by publisher_id (org publisher UUID), optional period_from and/or period_to (YYYY-MM), created_since/updated_since (ISO-8601), and page with limit + cursor. Document chrome is nested on each run.document by default; pass expand_document=false to omit. Returns { extraction_runs, next_cursor }. Prefer webhooks for steady state; use this to catch up. Sources: li

  • list_extraction_schemas

    List the extraction schemas registered in this workspace, newest first.

  • list_publishers

    List org-owned publishers for this workspace's billing account. publisher_id on sources and extraction runs is the UUID returned here; rename the display name without changing identity. Create with create_publisher.

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

  • list_training_feedback

    List reviewed feedback and its effective training-use state. This read requires training:manage and does not approve data for training.

  • list_training_jobs

    List training and evaluation job status. This read-only tool does not start, approve, or promote a model.

  • prepare_contract_uploadwrite action

    Create a private PDF upload target. Upload the exact bytes to upload_url before you call ingest_contract with the returned upload id.

  • record_training_feedback_consent

    Record an explicit, auditable training-use decision for one reviewed feedback item. This mutation requires training:manage. Approval requires consent_to_training=true.

  • 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 a slot. Capacity is two ceilings: up to 200 active registered/resolved sources per workspace (every URL a check cites auto-registers against that ceiling), and up to 200 active discovered children per parent (those do not consume the workspace registered/resolved budget).

  • rename_extraction_schema

    Rename a schema without changing its definition or hash. Active watched sources can continue to use it.

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

  • review_contract_claim

    Record an immutable human review. Use correct only with corrected_claim. The expected version prevents a stale review from overwriting newer work.

  • update_publisherwrite action

    Rename an org-owned publisher. The UUID identity is unchanged — existing sources and runs keep grouping under it.

  • update_sourcewrite action

    Bind (or unbind) an extraction schema and/or set publisher_id on a watched source, by the `id` add_source or list_sources returned. Provide extraction_schema_id and/or publisher_id. Once a schema is bound, every document that lands on the source is extracted automatically and delivered as an extraction.document webhook. Pass extraction_schema_id: null to unbind. Pass reprocess: true to also fill-m

  • 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.10 · 2026-10-14 · 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 34 days ago12/15
  • Maintainer identityregistry namespace matches repository owner7/10
Overall 77/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
77/100
higher than 50% of 4,461 AI and agents servers
Tools
37
the typical AI and agents server has 6
Tools that change things
27%
typical: 0%. Fewer write tools means less an agent can break
Downloads a week
112
more than 66% of 1,554 AI and agents servers with a package

What its tools let an agent do: 24 read · 5 create · 6 change · 2 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?
Mostly: it is graded B (77/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 56 days ago (2026-09-10). The latest release is v0.8.2.
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 77/100 (higher than 50% of 4,461 AI and agents servers); tools 37 (the typical AI and agents server has 6); tools that change things 27% (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