# BGB (Germany) (npm · @arxo/mcp-de-bgb)

German Civil Code (BGB) as executable rules: periods, deadlines and more, answered with grounds

- Trust score: 64/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-18

## Components

- remote · `mcp.arxo.io`: 60/100, [markdown](https://verifymcp.io/servers/io-arxo-de-bgb/mcp-de-bgb.md), [page](https://verifymcp.io/servers/io-arxo-de-bgb/mcp-de-bgb)
- npm · `@arxo/mcp-de-bgb`: 64/100 (this document), [markdown](https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb.md), [page](https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb)

## Channel facts

- Registry: `npm`
- Package: `@arxo/mcp-de-bgb`
- Version: `0.1.9`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-18.

- **Supply Chain Security**: 97/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 2 of 2 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 3 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 48/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 8323 tokens (~396/item across 21 items; 21 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 93/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 76% of tool parameters carry a description.
  - Structured output schemas are declared (38% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 22 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the BGB (Germany) MCP server?

BGB (Germany) runs locally as an npm package, launched with npx -y @arxo/mcp-de-bgb. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add io-arxo-de-bgb -- npx -y @arxo/mcp-de-bgb
```

### Cursor

```json
{
  "mcpServers": {
    "io-arxo-de-bgb": {
      "command": "npx",
      "args": [
        "-y",
        "@arxo/mcp-de-bgb"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "io-arxo-de-bgb": {
      "command": "npx",
      "args": [
        "-y",
        "@arxo/mcp-de-bgb"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add io-arxo-de-bgb -- npx -y @arxo/mcp-de-bgb
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "io-arxo-de-bgb": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@arxo/mcp-de-bgb"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add io-arxo-de-bgb --command npx --arg -y --arg @arxo/mcp-de-bgb
```

### Hermes

```yaml
mcp_servers:
  io-arxo-de-bgb:
    command: "npx"
    args: ["-y", "@arxo/mcp-de-bgb"]
```

### Netclaw

```json
{
  "McpServers": {
    "io-arxo-de-bgb": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@arxo/mcp-de-bgb"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add io-arxo-de-bgb -t stdio -c npx -a -y @arxo/mcp-de-bgb
```

### Other

```json
{
  "mcpServers": {
    "io-arxo-de-bgb": {
      "command": "npx",
      "args": [
        "-y",
        "@arxo/mcp-de-bgb"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-15 (score 64, +26)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 76
- [functional] First check of Destructive annotations: 100
- [functional] First check of Schema quality: good
- [functional] First check of Tool coverage: 38

### 2026-10-14 (score 38)

First indexed and scored.

## MCP tools (21)

### `law_search` (~187 tokens)

A semantic SEARCH over formalised law: a question or a notion in your own words → candidates with addresses — predicates with signatures, rules, article fragments. This is the layer of DISCOVERY, not of the answer: the result says WHAT to ask next (law_ask by signature, law_rules, law_sources) and establishes neither a fact nor a norm. The ranking is a deterministic lexical embedder, and similarity of text is not applicability of a norm. If you know the exact name, go straight to law_packages/law_ask; an empty result does NOT mean the norm does not exist.

Input parameters:

- `kinds` (array): narrow the kinds of candidate
- `limit` (integer): how many candidates (8, at most 25)
- `package` (string): search inside this instrument only
- `query` (string, required): a question or a notion in your own words

Output parameters:

- `candidates` (array)
- `corpusFingerprint` (string)
- `fallback` (boolean)
- `indexUnits` (integer)
- `jurisdiction` (string)
- `model` (object)
- `query` (string)

### `law_passport` (~93 tokens)

Passport of an exact release: purpose, interface, boundaries, checks and performance. The reports section holds the history of measurements, failures included. Entries are paged by JSON Pointer; next continues the answer.

Input parameters:

- `contentHash` (string, required)
- `limit` (integer)
- `name` (string, required)
- `offset` (integer)
- `sections` (array)
- `version` (string, required)

### `law_answer_capabilities` (~50 tokens)

A machine-readable matrix of the Lens producers that are actually installed, of replay/projection checks, profiles, limits and the contract tests that confirm them. declared_only means a schema with no executable witness.

### `law_capture_answer` (~55 tokens)

Run a registered producer and obtain producerControl/0.2 for a later verifiable preparation of a Lens. The producer is chosen only from the shipped registry.

Input parameters:

- `producer` (string, required)
- `request` (object, required)

### `law_prepare_answer` (~187 tokens)

At the explicit request of the user, repeat between 1 and 12 earlier law_ask or law_process_run calls, compare their replayControl strictly, and prepare a non-public frozen document for 24 hours. The client never supplies the machine answer: the server obtains it only by executing afresh. A divergence in any input, in the law, in a resource, in the server code, in the engine library or in the result rejects the document as a whole.

Input parameters:

- `assistant` (object)
- `calculations` (array)
- `documentVersion`: Version of the immutable document; 0.1 is kept for transitional compatibility, 0.2 includes all native results and the common reader.
- `language`
- `producerRuns` (array): Runs of registered producers with control/0.2; mutually exclusive with calculations.
- `question` (string, required)

Output parameters:

- `calculationCount` (integer)
- `contentHash` (string)
- `documentHash` (string)
- `expiresAt` (integer)
- `preparationId` (string)
- `previewUrl` (string)
- `resultCount` (integer)

### `law_publish_answer` (~45 tokens)

Publish a prepared document. Repeating it with the same preparationId idempotently returns the same URL and the same separate revocation secret.

Input parameters:

- `preparationId` (string, required)

Output parameters:

- `publicId` (string)
- `publicUrl` (string)
- `publishedAt` (integer)
- `revokeSecret` (string)
- `revoked` (boolean)

### `law_revoke_answer` (~57 tokens)

Revoke a published document using its separate secret. The public id alone grants no control; revocation closes the HTML page, the API and the download.

Input parameters:

- `publicId` (string, required)
- `revokeSecret` (string, required)

Output parameters:

- `publicId` (string)
- `revoked`

### `law_packages` (~690 tokens)

The catalogue of formalised law: instruments, predicates with signatures, the boundaries of coverage. This is where the NAMES of predicates come from — they must never be guessed. But do NOT start from the catalogue when looking for the right instrument: the overview is large, and the title of an instrument rarely matches the words of a question ("Newton's laws of motion" contains no word "physics"). A question in your own words goes to law_search first, which returns addresses; the catalogue is for the exact signature of what you found. With no arguments — the overview: one line per instrument (key, title, legal order, counters of rules, facts, signatures, norms, constants); a whole instrument — package="kz-gpk"; a search over the signatures, labels and constants of every instrument — query="substring". All three modes are PAGED: limit and offset, with the remainder named in the text (`showing a–b of N; k more`) and in structuredContent (total, truncated, next — a ready-made continuation call). The unit of a page is named by pageUnit: the overview and query page over INSTRUMENTS (20 and 20 by default), package=… pages over the SIGNATURES of one instrument (20 by default, 300 at most) — large codes carry thousands. package=… together with catalog=… pages a separate list of the instrument: "questions" — the CATALOGUE OF QUESTIONS: which enquiries are provided for (a question in words, a form, a predicate or norms) and what the instrument does NOT answer, with the type of reason; a card is a template of an enquiry, not an answer, and not every instrument has one; "norms" — the NORMS of the instrument, "constants" — the CONSTANTS (names of declarations). "task-guides" — TASK GUIDES: the order of applying a canon to a document — what to gather, which cards to ask and how to read the answers; a guide answers nothing. catalog="task-guides" is allowed without package too — every guide of the profile; guide=… — the detail of one guide; the walkthrough — MCP Prompts under t…

Input parameters:

- `catalog` (string): together with package: page the catalogue of questions, the norms, the constants or the task guides of the instrument instead of its signatures; "task-guides" also without package: every task guide o…
- `guide` (string): together with catalog="task-guides": the detail of one guide — a name <package>/<id> (as in prompts/list) or an id together with package
- `limit` (integer): how many per page: instruments (overview 20, query 20), signatures of an instrument (20, at most 300) or elements of a catalog list (questions 20, norms 20, constants 100, task guides 20)
- `offset` (integer): from which element of the page (0); the unit is the pageUnit of the answer
- `package` (string): the full signatures of this instrument
- `query` (string): a substring filter over signatures, labels and constants (case-insensitive)

### `law_ask` (~1446 tokens)

Put a question to formalised law. When the answer is "not established" it carries whyNot — the engine's why_not report: the candidate rules and the state of every conjunct (satisfied / not satisfied / undetermined); the missing facts are visible there and need not be guessed. BEFORE THE FIRST call obtain the predicate names through law_search (a question in your own words → addresses) or law_packages (the signatures of a known instrument) — an invented name will be rejected. If the tool returned an error or "not established", THAT IS THE ANSWER: pass it to the user and do not substitute general knowledge about the law of some other country. But "I found no suitable instrument" is NOT an answer until law_search has been asked: silence of the catalogue is a property of searching by title, not a conclusion about the corpus. kind='truth' — whether a fact is established; kind='collect' — enumerate the records; kind='deadline' — compute a time limit on the official calendar; kind='positions' — which DUTIES arose from the facts and what their statuses are; kind='why_not' — the why_not report on the same goal, whatever the status of the answer. The answer carries the rules applied, the warnings and the provenance with hashes; truth/collect also carry a signature block for presentation. The server does not guess: where a norm is not formalised, the answer is "not established" or an error.

Input parameters:

- `after` (string): deadline: the date of the event
- `afterTime` (string): deadline: the time of filing
- `args` (array): the arguments of the predicate in the order of its signature; with kind='collect' exactly one of them is the selection variable ?name (for example ['urn:x:water', 'urn:x:mix', '?value']), the rest ar…
- `calc`: kind='calc': a tree {op,left,right}, op ∈ add|sub|mul|div|le|lt|ge|gt|eq|ne (the synonyms divide/multiply/plus/minus and the signs are accepted); the leaves are 5 | '3932 KZT' | '2 mrp' | {lookup: 'm…
- `cutoff` (string): deadline: the hour operations close
- `days` (integer): deadline: the length of the period
- `deadlinePolicy` (string|object): the policy for counting time limits expressed in days: the StableId of a deadline policy declared in the world of the question (e.g. 'urn:kz:corpus:clir:administrative-code#AC_WORKING_DAY_TERMS'), or…
- `evidence` (array): case documents, section 74, evidence_item nodes. One document is referenced from provenance.evidence of many facts. payload.confidence is data for the EvidencePolicy; the engine does not evaluate the…
- `evidencePolicy` (string): StableId of an evidence_policy node, section 78.2. Without it, previous calls keep their behaviour. The confidence threshold is a rule of that policy, not an argument of the call
- `facts` (array): facts of the case: [{predicate, args, negated?, package?, provenance?, judgment?}]. package resolves an ambiguous short name. provenance is {origin?, evidence?: StableId, span?: {page?, quote?, offse…
- `focused` (boolean): kind='truth': ask as focused_truth — the same answer as the full truth, but the proof and the warnings cover only the cone of the question; the answer carries evaluationKind and the slice hashes (foc…
- `kind`: the kind of question (truth by default)
- `legalTime` (string): the date of the law (YYYY-MM-DD)
- `package` (string): narrow the question to one package of law
- `predicate` (string): what is being asked, e.g. 'duty_amount'
- `proof` (boolean): return the evaluation field with the proof graph in the answer — a ready-made input for law_explain (kind truth|collect; by default a summary without the graph)
- `responseMode`: full (default) — the complete answer. compact is accepted for compatibility: this server builds no short reply and returns the same complete answer in both modes; there is no fullAnswer reference and…
- `selectedInterpretations` (array): named readings; for an exactly_one group choose exactly one StableId out of law_packages/law_rules
- `supportEdges` (array): support edges, section 75, support_edge nodes: from is the document id, to is the fact literal, relation is supports or refutes. Admission is decided by the package EvidencePolicy, not by the host
- `unit`
- `version` (string): the exact package version pinned by the client (open('name@version')); if it differs from the profile composition the host refuses instead of answering with another version

### `law_screen` (~250 tokens)

Build a necessary condition — a superset — for the preliminary selection of rows from an external source. This is NOT a legal answer and NOT SQL: the result is a typed tree and a manifest of the extensions up to TRUE. Every row that passes must then be computed in full by the engine, with a proof graph, on the same snapshot of the data. The binding is passed as a pinnable object; sourceSchemaContentHash is the actual hash of the source schema and is compared loudly with the pin. Case facts that carry provenance (origin, document, quote, extractor) are supplied to law_ask, not here. The confidence figure is read by the package EvidencePolicy, not by this tool and not by the engine.

Input parameters:

- `binding` (object, required): a law.screen.binding/0.1 artefact
- `goal` (string, required): a StableId or a unique short name of the goal
- `legalTime` (string): the date of the law YYYY-MM-DD; without it every window of every rule is taken into account
- `package` (string, required): the package key from law_packages
- `sourceSchemaContentHash` (string, required): the actual sha256 of the source schema

Output parameters:

- `condition` (object)
- `disclaimer` (string)
- `manifest` (object)
- `schemaVersion`

### `law_rules` (~266 tokens)

The rules of formalised law put into words: exactly how a predicate is derived (premises, source articles). Call this BEFORE supplying facts to law_ask — the rules say which facts are needed instead of leaving them to be guessed. For large instruments package=… returns a table of contents; the full text comes from predicate=…. The listing by package is paged: limit (20 by default, 500 at most) and offset; the remainder is named in the text (`showing a–b of N; k more`) and in structuredContent (total, truncated, next — a ready-made continuation call).

Input parameters:

- `contract` (boolean): Return a machine input contract over the same import/dependency world as law_ask. No case evaluation.
- `inputLimit` (integer): Machine contract: leaf declarations per page (50).
- `inputOffset` (integer): Machine contract: offset of leaf declarations.
- `lang`: the language the rules are put into
- `limit` (integer): package: how many rules per page (20; the budget may lower it)
- `offset` (integer): package: from which rule (0)
- `package` (string): every rule of the instrument
- `predicate` (string): the rules that derive this predicate

Output parameters:

- `compact` (boolean)
- `factsTemplate` (array)
- `inputContract` (object)
- `limit` (integer)
- `next` (object)
- `offset` (integer)
- `package` (string)
- `ruleCount` (integer)
- `rules` (array)
- `total` (integer)
- `truncated` (boolean)
- `verbalizationGaps` (integer)

### `law_explain` (~224 tokens)

Unfold the proof of a law_ask answer into a chain "rule ← premises → conclusion". The compact input: question (the original law_ask arguments, truth/collect), resultHash and codeHash from the provenance of the answer. The server repeats the computation and compares the hashes; if anything changed it refuses explicitly. Alternatively pass the evaluation from law_ask(proof=true). answerResource=fullAnswer.uri explains a stored compact snapshot without recomputing and without the client loading pages; by default only the proofRef chain. nodeId selects one node and all of its premises (up to 24 KB, otherwise an explicit refusal). proofHash refers to the whole graph; scope marks the part selected.

Input parameters:

- `answerResource` (string): the fullAnswer.uri of a stored answer taken with proof=true
- `codeHash` (string)
- `evaluation` (object): the evaluation document from law_ask
- `nodeId` (string)
- `question` (object): the original law_ask arguments
- `resultHash` (string)

Output parameters:

- `proofHash` (string)
- `steps` (array)

### `law_inspect` (~210 tokens)

Evaluation inspector over a SAVED evaluation document: summary — the origin card, resultHash and snapshot verification, listings of results, positions and issues; slice — the closure of proof nodes for a query, rule, position or node with addresses, both sides of BOTH, defeats, values, names resolved against the snapshot; diff — what changed between two documents on the context, result and justification levels; locate — the declaration by StableId. Nothing is evaluated or recomputed: the source is evaluation from law_ask(proof=true) or an answerResource. Missing data is a limit state (limits), never a negation.

Input parameters:

- `against` (object)
- `answerResource` (string)
- `bundle` (object)
- `context` (object)
- `evaluation` (object)
- `index` (object)
- `operation` (required)
- `page` (object)
- `select` (object)
- `snapshot` (object)
- `sources` (object)

### `law_case_ask` (~480 tokens)

Die Operation ask: eine registrierte Sache eines Fallpakets über ihren verankerten Abhängigkeiten ausführen und die Antwort zurückgeben: standardmäßig eine Projektion des Auswertungsdokuments ohne Beweisgraph, bei responseMode full oder proof: true das kanonische Dokument mit Beweis und Manifest. Die Frage ist JSON nach query.schema.json (query), eine evaluate-Zeichenkette (evaluate + queryId), eine gespeicherte queryId ohne query oder card + args. Eine Verweigerung der Vorbereitung ist ein Fehler mit LDC-*-Code, nie eine leere Antwort.

Input parameters:

- `args` (object): die Kartenparameter: Name → Zeichenkettenausdruck der Sprache
- `card` (string): die id einer Karte eines installierten Katalogs
- `case` (string): the name of the case declaration from [[cases]]; optional when there is only one case
- `evaluate` (string): the string `evaluate <expression>;`; requires queryId
- `package` (string, required): the path to the case package (the directory holding law.toml) from the root of the repository
- `proof` (boolean): true — das vollständige Dokument mit Beweisgraph (dasselbe wie responseMode full); false — die Projektion. Dieselbe Form wie bei law_ask.
- `query` (object): the question as JSON per query.schema.json; queryId is a URN in the namespace of the package, or a short name given in queryId
- `queryId` (string): ohne query/evaluate — die Wahl einer gespeicherten queries/*.json nach Kurzname oder voller URN; mit evaluate — die id der ausgeführten Frage
- `responseMode`: compact — eine Projektion für einen Agenten: results, positions, conflicts, das Manifest, Issues oberhalb von info und alle Hashes bleiben erhalten, proofGraph ist durch Hash, Wurzeln und Knotenzahl…

### `law_sources` (~296 tokens)

Sources: by default short excerpts (view=summary), 5 texts per page, with the address of the full text in fragments[].full. Either package or fragment is required (a StableId from law_search/law_rules). view=full returns exact parts of the text: textRange sets a range of Unicode characters, fragments[].next is the continuation with a contentHash. The hash refers to the WHOLE source, not to the excerpt or the part. textOffset/textLimit require fragment; a continuation requires contentHash. Lists are paged with offset/limit; the answer budget may shrink a page.

Input parameters:

- `contentHash` (string): the hash of the full text taken from the previous part
- `fragment` (string): the StableId of a fragment
- `language` (string): the language of the variant, as given on the source card
- `limit` (integer): how many texts: summary 5, full 1 (the budget may lower it)
- `offset` (integer): from which fragment (0)
- `package` (string): the package key — every fragment of that instrument
- `status` (string): the status of the variant, as given on the source card
- `textLimit` (integer): the maximum number of Unicode characters in a part of the text (also ≤8000 bytes of UTF-8)
- `textOffset` (integer)
- `view`

### `law_argue` (~304 tokens)

How robust a conclusion is: the map of the dispute under the argumentation profile The answer falls into four classes: SKEPTICALLY_ACCEPTED — the conclusion is invulnerable (it survives in the grounded extension); CREDULOUSLY_ACCEPTED — merely defensible (there is a position for it and a position against); REJECTED — it survives nowhere; NO_ARGUMENT — there are no arguments at all. It builds ALL arguments out of the facts and the rules of the instrument (chains that did not fire in ordinary inference included), the rebut/undermine/undercut attacks and the defeats by priority. Predicate names come from law_packages. On large instruments a refusal by cap is possible — narrow facts or raise limits.maxArguments.

Input parameters:

- `args` (array): the arguments of the predicate
- `facts` (array): facts of the case: [{predicate, args, negated?, provenance?}]. provenance is the same object as on law_ask: origin, document, quote, extractor. confidence is read by the package EvidencePolicy, not b…
- `legalTime` (string): the date of the law (YYYY-MM-DD)
- `limits` (object): the caps of the profile: maxArguments (64), maxExtensions (8), maxUndecided (16)
- `package` (string): narrow the question to one package of law
- `predicate` (string, required): the conclusion whose robustness is being measured

### `law_process` (~144 tokens)

Which stages the procedure established by an instrument consists of, and whether it carries a structural defect. The stages, the transitions and the condition of every transition are reconstructed from the formalisation rather than retold: what leads from where to where, and under what condition. The check of the graph: unreachable stages, dead transitions, a transition that enters no stage at all. Without package — the list of instruments whose procedure is formalised. A stage with no exit is named but is NOT counted as a defect: whether it is terminal by design cannot be seen from the formalisation.

Input parameters:

- `package` (string): the instrument; without it — the list of instruments that carry procedures

### `law_process_run` (~362 tokens)

How a particular case will run, step by step: a log of {date, attempt?, facts?} is executed frame by frame, and the law of each frame is the law of ITS date. The answer says: which stages have been entered; which attempted transition produced NO legal effect; which duties are violated and which time limits are running; what is available next and WHAT EXACTLY is missing for the rest. The names of transitions come from law_process. Stages entered means "was it ever entered", not "where it is now": the core 0.1 does not compute points of the current state.

Input parameters:

- `instance` (string, required): what is going through the procedure: the number of the lot, of the application, of the case
- `legalTime` (string): the base date (YYYY-MM-DD); the date of a frame is set by the step itself
- `package` (string, required): the instrument
- `probeTime` (string): the instant of a hypothetical attempt, used to work out the steps available on the last frame; without it the available steps are not computed — the tool does not invent time
- `procedure` (string): the procedure, where there is more than one
- `steps` (array, required): the log of the case: [{date, attempt?, time?, decisionTime?, knowledgeTime?, facts: [{predicate, args}]}]; on an attempted transition `time` is the instant of the event (ISO 8601 with an offset), and…

### `law_editions` (~141 tokens)

The axis of editions (O-2): what changed in an instrument between two dates of the law — the state of the editions, the dating of the norms and the semantic diff between the D1 projections. The verdict NOT_DATED means "there was nothing to date it by", not "nothing changed". The outcome of a particular question on a date comes from law_ask with legalTime.

Input parameters:

- `dateA` (string, required): the date of the law "before" (YYYY-MM-DD)
- `dateB` (string, required): the date of the law "after" (YYYY-MM-DD)
- `package` (string, required): the instrument of the corpus

### `law_query` (~859 tokens)

Eine deterministische LawQL-Abfrage über das CLIR einer Formalisierung: eine Frage an das Modell des Aktes selbst, nicht an einen Fall. Relationen (14): anchors, edges, fields, imports, interpretations, labels, links, literals, nodes, norms, positions, rules, variables, windows. Feldlisten: `law query --schema`. Funktionen (9): anchor/1, labels/1..2, short/1, contains/2, overlaps/2, starts_with/2, ends_with/2, position/2, derivation/2. exists/not exists über eine gebundene Variable; nur Gleichheit und Mitgliedschaft, keine Arithmetik und keine Ordnungsvergleiche. Bereich: corpus nach package.name (zum Beispiel kz.corpus.labour_code, kein Dateiname) oder ein Glob; ohne corpus der gesamte Profilausschnitt; ein Bereich außerhalb des Profils ist leer (CORPUS_EMPTY). Beispiele: `from r in rules where r.head_predicate == "urn:…#eligible" select r.id as producer, r.strength as strength, anchor(r.id) as anchors` — wer erzeugt; `from l in literals where l.predicate == "urn:…#eligible" select l.node as reader, l.context as context` — wer liest; `query eligible over "pkg" { for x: Person; where applicant(x); select eligible(x); }` — Inferenz durch den Kern. Dies ist Orchestrierung über CLIR und Kern; neue juristische Semantik wird hier nicht implementiert. Statt Text eine Frage aus dem Katalog mit arguments: anchors-of, imports-of, links-of, producers, readers, type-step (Stand: `law query --list`) (die Parameter predicate/node/type sind URNs, pkg ein package.name oder ein Glob). Die strukturelle Antwort ist eine queryPage: resultHash des vollständigen queryResult, snapshot (Hash der Paketliste des Bereichs), rowCount, rows nach rowLimit (20, höchstens 5000) und rowOffset, next mit dem snapshot zur Fortsetzung; full: true liefert das vollständige queryResult, wenn der Bereich ein einzelnes Paket ist. Jede Zeile trägt ihre Provenienz (CLIR-Knoten); eine leere Antwort trägt den Explain-Trichter (emptyAt nennt die Klausel); Fehler tragen LDC-Qxxxx-Codes mit Hinweisen; ein zu bre…

Input parameters:

- `arguments` (object): die Parameter der Frage: ein Objekt „Name → Zeichenkette“ (predicate, node, type — URNs; pkg — ein package.name oder ein Glob)
- `case` (object): the case for query-over; it replaces the case clause
- `corpus` (string): der Bereich des Schnappschusses: ein package.name (zum Beispiel kz.corpus.labour_code) oder ein Glob über package.name; ohne corpus der gesamte Profilausschnitt
- `engine`: there is one engine — the core; the reference implementation is called by its own command
- `full` (boolean): das vollständige queryResult statt einer Seite zurückgeben; nur wenn der Bereich ein einzelnes Paket ist
- `limit` (integer): an explicit cap on eval() materialisations (it does NOT bound the rows — see rowLimit)
- `query` (string): inline LawQL
- `question` (string): der Name einer Frage aus dem Katalog benannter Abfragen (producers, readers, anchors-of, imports-of, links-of, type-step) oder eines Lints; anstelle von query
- `rowLimit` (integer): how many rows in structuredContent (20; the budget may lower it)
- `rowOffset` (integer): ab welcher Zeile (0); die Fortsetzung kommt aus next zusammen mit snapshot; nur strukturelle Abfragen
- `snapshot` (string): der Schnappschuss-Hash aus next.snapshot der vorherigen Seite: eine Fortsetzung auf einem anderen Schnappschuss wird abgelehnt (SNAPSHOT_CHANGED)

### `law_report` (~274 tokens)

A REPORT of a divergence between the formalisation and the source: the answer contradicts the pinned text, a norm of the source is not expressed by a rule, a label diverges from the text, an address cannot be found. A report is a hypothesis for triage by a formaliser: it does NOT change the law, it never reaches the answers of the other tools, and "not derived" does not become "derived" because of it. An address is required and is checked against the catalogue: package, fragment (a StableId from law_sources) and/or predicate; callId is the X-Law-Call-Id of the answer you disagree with. The entry goes into the server log.

Input parameters:

- `callId` (string): the X-Law-Call-Id of the answer you disagree with
- `category` (required): the kind of divergence: norm not expressed / outcome against the text / label against the text / address not found / text against the official one / other
- `expected` (string, required): what the source says (with the article)
- `fragment` (string): the StableId of the source fragment
- `observed` (string, required): what the system answered
- `package` (string, required): the instrument of the corpus
- `predicate` (string): the predicate the report is about

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb#diagnostics

## Score history

- 2026-10-18: 64
- 2026-10-17: 64
- 2026-10-16: 64
- 2026-10-15: 64
- 2026-10-14: 38

## Common questions

### What is the BGB (Germany) MCP server?

BGB (Germany) is an MCP server listed in the public MCP registry as io.arxo/de-bgb. German Civil Code (BGB) as executable rules: periods, deadlines and more, answered with grounds. This page covers its npm package (@arxo/mcp-de-bgb).

### Is the BGB (Germany) MCP server safe to use?

BGB (Germany) scores 64 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 18 October 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the BGB (Germany) MCP server expose?

BGB (Germany) exposes 21 tools: law_search, law_passport, law_answer_capabilities, law_capture_answer, law_prepare_answer, and 16 more. Their descriptions and schemas cost roughly 6,620 tokens of context every time the server is loaded.

### Is the BGB (Germany) MCP server still maintained?

BGB (Germany) is still listed as active in the MCP registry. We last reached this channel on 18 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the BGB (Germany) MCP server under?

BGB (Germany) declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@arxo/mcp-de-bgb
- Socket report: https://socket.dev/npm/package/@arxo/mcp-de-bgb
- Repository: https://github.com/arxohq/arxo-bgb
- Website: https://bgb.law.arxo.io/
- Changelog RSS feed: https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb.xml
- Changelog JSON feed: https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb.json
- HTML version of this page: https://verifymcp.io/servers/io-arxo-de-bgb/arxo-mcp-de-bgb