dVeracity Semantic API

dVeracity Semantic MCP server

Gives any MCP-capable AI agent (Claude Code, Cursor, custom agents) metered access to the dVeracity Semantic API — natural-language queries over the verified-emissions knowledge graph (Open Footprint / PPDM / OGMP-methane) — and VaaS standards validation.

Prerequisites

1. A free Explorer account (OAuth) or a paid plan: https://dveracity.com/pricing — Explorer includes API-key management and a monthly metered-call allowance.
2. An API key (dvrc_…): POST /api/v1/api-keys (or the dashboard)
3. API credits for calls beyond the free allowance: POST /api/v1/vaas/credits/purchase (or ask the agent to use billing_purchase)

The machine-readable service contract lives at GET /api/v1/semantic/manifest (public, no auth).

Install

From this directory: npm install

Claude Code

claude mcp add dveracity \

-e DVERACITY_API_KEY=dvrc_yourkey \ -- node /path/to/dVE/mcp/semantic-mcp/index.js

Generic MCP JSON config (Cursor, etc.)

{

"mcpServers": { "dveracity": { "command": "node", "args": ["/path/to/dVE/mcp/semantic-mcp/index.js"], "env": { "DVERACITY_API_KEY": "dvrc_yourkey" } } } }

Optional: DVERACITY_API_URL overrides the API base URL (defaults to prod).

KERI mode — verified agent identity (optional)

If the agent holds a dVeracity Agent Authorization credential (an ACDC issued by its Legal Entity, chained to the Legal Entity's vLEI — see elm/docs/VLEI_AGENT_TOKENS_DESIGN.md), set:

DVERACITY_KERI_AID=<the agent's AID (credential issuee)>

DVERACITY_KERI_PRESENTATION=/path/to/agent-credential.cesr # self-contained CESR

The server then authenticates the agent by verifiable presentation (challenge → exchange → 1-hour session, refreshed transparently) and attaches X-Keri-Session to every call: the API key keeps carrying billing, the KERI session adds verified identity — every metered call is attributed to the agent AID and Legal Entity LEI in dVeracity's audit trail. The keri_identity tool (free) shows the active identity. Scope denials (a credential that doesn't carry e.g. semantic:query) surface as actionable errors naming the carried scopes. Signify-based nonce signing is a planned enhancement.

Tools

Every tool definition carries _meta.pricing: { "unit": "credit", "amount": , "usd": }, with amount 0 for a free tool. A plan-gated tool also carries "plan_required": " " — 0 credits on compliance_policies or compliance_evaluate means "included in the VaaS plan", not "free for any account".

Billing

Open Footprint canonical model

Design-time tools for building an application on the Open Footprint standard. Reading the model is free; only the check at the end is metered.

Two behaviours are deliberate and worth knowing before you build against them.

Ambiguous entity names fail rather than resolve. dozens of entity names (the ofp_models summary reports the count as ambiguousNameCount) are defined in more than one domain — Country is in four. ofp_entity without a domain returns an error listing the candidates instead of picking one. Pass domain whenever you know it.

Semantic codes vary in usefulness. Most canonical fields carry an O-DEF code, but a code shared by many fields is a generic classification, and aligning to one asserts almost nothing. The ofp_models summary reports the real shape under precision — preciseFieldThreshold (the fieldCount at or below which a code is precise rather than generic), fieldsOnPreciseCodes and preciseShareOfAnnotated — and those follow the vendored snapshot rather than this document. Every code is returned with its fieldCount: check it before aligning to one, and pass maxFieldCount at that threshold to ofp_semantics to see only the precise ones.

"Nothing published" is an answer, not an error. Most sectors are named in the taxonomy but have no reference implementation, and only seven publish policy guardrails. ofp_policies on such a sector returns published: false with a reason, and ofp_validate reports policy.ran: false. Both mean *no rules are published*, never *there are no constraints* — a payload checked for structure alone is not a compliant one, and should not be described as one.

A fourth outcome, unevaluable, means the sector's rules ran but every rule that came back false reads an input the payload does not carry (policy.missingInputs, e.g. co2e_kg, direction, counterparty_industry). Those are e-ledger record fields, not canonical Open Footprint field names — ofp_policies lists them per policy under inputs. Unevaluable is neither a pass nor a breach, and valid is null.

What ofp_validate checks, and what it does not

The response is a contract, not a verdict. Every call reports the check catalogue in two lists: checked (what ran) and checks_not_run (what did not, each with a reason and usually a detail). Read both before describing a payload as anything.

Any check can also report schema_not_run, which means the structural check it builds on could not run at all.

calculation_reproducibility is self-referential and nothing more. It resolves its three inputs from the model — the field carrying the emission-measure role, a … Factor Value (never a … Factor ID, which is a reference to a factor rather than a number to multiply by) and a … CO2e … result — or, for a record in the vocabulary the guardrails read, from quantity_value / emission_factor_value / co2e_kg. A slot the record fills more than once is ambiguous_calculation_inputs and the check declines rather than picks. The 1% tolerance is the one CalculationAccuracy in the verification engine and calc_tolerance in the ISO 14064 quantification policy use, so the identity has one tolerance on every surface. What it catches is a record whose own numbers do not multiply out. It does not say the factor is the right one for this source and period (factor_provenance, still not run) or that the quantity came from the meter it claims (the data plane, still not run) — a reproduced calculation is a self-consistent record, not a verified one.

• schemaValid is the structural verdict (null if the structural check could not run).
• assuranceLevel names the depth earned: schema-only, schema-and-value, schema-value-and-policy or full. Each level needs every check beneath it, so guardrails without a value check is still schema-only. The ladder is gated on value_range — a bound the model itself declares — so a record that reproduced its own arithmetic without one still reads schema-only; checked is where that shows up, and it is the more precise of the two.
• Every violation and warning carries severity (error | warning). Rule ids are stable: required_field_missing, pattern_mismatch, format_mismatch, type_mismatch, primary_key_missing, enum_violation, value_range (with bound: minimum | maximum), temporal_consistency, enum_membership, calculation_reproducibility (with expected, received, tolerance and the three inputs it read), … unknown_field is a per-field warning and stays one.
• unknown_field w