ndlaw

# ndlaw A Model Context Protocol (MCP) server for North Dakota Supreme Court opinions, 1889–present (plus a small number of North Dakota Court of Appeals decisions). Coverage is complete since statehood (November 2, 1889); the court issued its first opinions in 1890. Built on SQLite with FTS5 full-text search and served via [FastMCP](https://github.com/jlowin/fastmcp). The opinions corpus currently contains **<!-- COUNT:opinions -->20,117<!-- /COUNT --> opinions** with **<!-- COUNT:citelinks -->127,279<!-- /COUNT --> citation links** between them, with per-release corrections summarized in the release notes. Where the court's own print contains an apparent typo, the text is preserved verbatim; where that typo is in a citation, the citation graph still resolves it to the case the court meant. It also serves North Dakota **primary law** — the Constitution (a point-in-time layer spanning 1889–present), N.D.C.C. statutes, court rules, and the Administrative Code — from separate per-corpus databases. See [Primary law](#primary-law-constitution-court-rules-ndcc-statutes-admin-code) below for what each database contains. > **Not an official court product.** This is an independent, unofficial > project. It is not published, endorsed, or maintained by the North Dakota > Supreme Court, the North Dakota Court System, or any agency of the State of > North Dakota, and nothing here is an official version of any opinion, > statute, rule, or regulation. The official sources are the court's own > publications ([ndcourts.gov](https://www.ndcourts.gov)) and the Legislative > Branch's ([ndlegis.gov](https://ndlegis.gov)); verify there before relying > on or filing anything. > > **No claim to official government works.** The opinions, statutes, rules, > and regulations reproduced here are works of North Dakota's government, > reproduced as public documents; this project claims no rights in them. What > the project adds — the compilation, corrections, citation graph, and > software — is released under CC0 (see [`NOTICE.md`](NOTICE.md)). This is a working tool, not an authoritative text. See [`NOTICE.md`](NOTICE.md) for sources, redistribution scope, and attribution. To install it, jump to [Quick start](#quick-start) below. --- ## MCP tools exposed | Tool | Purpose | |-----------------------|---------------------------------------------------------------------------------| | `lookup_opinion` | Retrieve an opinion by any citation (neutral, N.W.2d, N.W.) | | `get_opinion_text` | Read opinion text in paginated chunks | | `search_opinions` | Full-text search with date/author filters | | `list_opinions_by_date` | Browse opinions by date range | | `get_database_stats` | Corpus summary: totals, date range, coverage by decade, most-published authors | | `justice_info` | Voting record for a case, or aggregate stats for a justice | | `search_by_case_type` | Filter by case type (criminal, civil, etc.) | | `get_citing_opinions` | Find opinions that cite a given opinion | | `verify_citation` | Confirm a cite/case name and return its canonical form + Redbook-ordered cites; flags name drift | | `get_parallel_citations` | Return a case's full parallel-cite set (synthetic IDs bracketed separately) | | `verify_quotation` | Confirm a quoted passage is verbatim (typography-tolerant) and return the pinpoint ¶ | | `get_pinpoint` | Resolve a paragraph number to its text, or a quote to the ¶ it lives in | | `check_treatment` | Citator: citing opinions with citing-sentence context + a conservative, non-authoritative treatment signal | | `get_cited_authorities` | Outbound authorities a case relies on (cases, statutes, rules, constitution), grouped with source links | | `case_summary` | One-call bench-memo front matter: cites, panel, voting, disposition, ¶ count, syllabus points | | `get_subsequent_history` | Related opinions sharing the docket (rehearings, supplemental, companions) | | `authoring_justice_on_issue` | A justice's authored opinions matching an issue (predictive bench-memo signal) | | `search_boolean` | Boolean/proximity search (`&` `\|` `%` `/N` `/s` `/p` `!`), translated to FTS5 | | `search_faceted` | Filter by date, author, case type, disposition, dissent/concurrence, unanimity (+ optional full text) | | `find_opinions_construing` | Every opinion citing an N.D.C.C. section or court rule, with the official source link | | `more_like_this` | Doctrinally similar opinions (hybrid co-citation + keyword ranking) | | `detect_overruled_in_draft` | Scan a draft's cited cases through the citator; flag possible negative treatment (with citing context) | ### Primary law (Constitution, court rules, N.D.C.C. statutes, Admin. Code) Beyond opinions, the server serves North Dakota primary law from separate per-corpus SQLite databases, each `ATTACH`-ed onto the opinions connection at startup (the server serves whatever corpus DBs are present). All use a shared point-in-time *versioned-provision* schema, so `lookup_authority` accepts an `as_of_date` to return a provision's text as it stood on a given date. | Database | Corpus | Contents (approx.) | |----------|--------|--------------------| | `opinions.db` | ND Supreme Court opinions (+ some Court of Appeals) | <!-- COUNT:opinions -->20,117<!-- /COUNT --> opinions, <!-- COUNT:citelinks -->127,279<!-- /COUNT --> citation links, 1889–present | | `constitution.db` | ND Constitution | ~496 provisions / 774 dated versions, **point-in-time across the full 1889–present span**: a modern article/§ layer (1981–present, with the 1981/1986/1997 article reorganizations and post-1981 amendments reconstructed) + a historical layer in the original 1889 numbering (§§ 1–217 + Schedule + amendment articles, in force 1889–1980), plus the amendment chronology | | `statutes.db` | N.D.C.C. (statutes) | ~29,100 Century Code sections | | `rules.db` | ND court rules | ~650 rule provisions | | `admincode.db` | ND Administrative Code | ~13,800 provisions | | `ag_opinions.db` | ND Attorney General opinions | ~6,750 published opinions, 1942–present, cross-linked to the statutes/Constitution/rules/admin/opinions they cite (~35,000 citation links) | Each ships as its own GitHub release asset (`<name>.db.zip` + `.sha256`) — see [Quick start](#quick-start) to install them locally and `deploy/SETUP.md` for the server-side multi-corpus delivery. Both constitutional layers are `as_of_date`-queryable: the modern layer by its article/§ citation (e.g. `lookup_authority("N.D. Const. art. VIII, § 6", as_of_date="1990-01-01")`) and the historical layer by its original 1889 citation (e.g. `lookup_authority("N.D. Const. § 82", as_of_date="1945-01-01")`). The two numbering schemes are cross-linked through the official 1981 disposition tables (NDCC Replacement Vol. 13): a modern cite at a pre-1981 date returns its original-section predecessor, and an original §-cite at a post-1981 date returns its modern successor — each answer carries provenance (`requested_citation`, `returned_provision`, `relation`, a source note), and lookups that would land past a wholesale article replacement (1982/1986/1997) say so rather than implying content continuity. `get_authority_history` merges the pre- and post-1981 amendment chronologies into one timeline per provision. The primary-law corpora are newer and less exhaustively validated than the opinions corpus, though the constitution layer has now been verified section-by-section against the official annotated apparatus and every usable printed compilation 1889–1989. | Tool | Purpose | |-----------------------|---------------------------------------------------------------------------------| | `lookup_authority` | Text of a constitutional / rule / statute / admin-code provision (with `as_of_date` for the version in force) | | `search_authority` | Full-text search across the primary-law corpora | | `get_authority_history` | Amendment / version history of a provision | | `constitutional_amendments` | The ND Constitution's amendment chronology | | `search_ag_opinions` | Full-text search across ND Attorney General opinions (1942–present) | | `lookup_ag_opinion` | An AG opinion by number (e.g. `2015-L-12`) + the authorities it cites | | `get_ag_opinions_citing` | AG opinions that cite a given statute / constitutional / rule / case authority | | `get_court_opinions_citing_ag` | Court opinions that cite a given AG opinion (the inbound direction) | See [Quick start](#quick-start) to install the server and [Connecting to Claude](#connecting-to-claude) to wire it into an MCP client. --- ## What's in the database Counts below are as of 2026-08-21; the corpus total is **<!-- COUNT:opinions -->20,117<!-- /COUNT --> opinions** (of which 80 are North Dakota Court of Appeals decisions and the rest North Dakota Supreme Court) — rerun `sqlite3 opinions.db "SELECT COUNT(*) FROM opinions"` for the live total. | Era | Opinions | Notes | |--------------|----------|-------| | 1890–1952 | ~6,530 | includes the court-authored "Syllabus by the Court" that accompanies opinions of this era | | 1953–1996 | ~6,300 | validation of a residual slice of the earliest N.W.2d years is ongoing | | 1997–2019 | ~5,650 | neutral-citation era (`2019 ND 54`) | | 2020–present | ~1,630 | | The database ships the court's text and the citation graph over it. It does not ship the development record behind that text — the correction history, the working copies collated to produce it, or the pipeline's own bookkeeping. Those are maintained separately and are not needed to read an opinion or to verify a citation. See [`NOTICE.md`](NOTICE.md) for what is and isn't redistributed in `text_content`, and the release notes for the corrections in each published version. --- ## Quick start ### The easy way: let Claude do it If you're already a Claude user, the simplest install is to ask Claude to do it for you. Paste the prompt below into **Claude Code** (CLI), **Claude Desktop** (Mac/Windows), or **Claude on the web** (claude.ai). Claude will read this repository's `README.md` and `NOTICE.md`, detect your platform, walk you through the steps, and — if running in an environment with shell access (Claude Code, or Claude Desktop with appropriate MCP servers) — run them for you. After install it will add the server to your Claude MCP config and verify it works. > Please help me install the `ndlaw` server from > `https://github.com/jet52/ndlaw` on my computer. Read the > repository's `README.md` and `NOTICE.md` first so you understand what > it is and what it redistributes. Then walk me through (or run for me, > if you can) the install steps for my platform, download the latest > `opinions.db` release asset, smoke-test it, and add the server to my > Claude MCP config. Stop and ask me before any step that needs a > decision. If you'd rather do it by hand, the manual instructions follow. ### 1. Prerequisites — all platforms - **Python 3.12 or newer** - **git** - ~1 GB of free disk space (for the database) - An MCP-capable client (e.g. Claude Desktop, Claude Code) — optional, only needed if you want LLM integration ### 2. Install the code and database Pick your platform. The commands install [`uv`](https://docs.astral.sh/uv/), clone the repo, download the latest release of the database, and install the Python dependencies. #### Windows (PowerShell) ```powershell # Install uv (a fast Python package manager) — skip if already installed irm https://astral.sh/uv/install.ps1 | iex git clone https://github.com/jet52/ndlaw.git cd ndlaw # Download + extract every database release asset (opinions + primary-law corpora). # The corpus DBs ship from v0.11.0 on; opinions.db is the only one in older releases. foreach ($db in "opinions","constitution","statutes","rules","admincode") { Invoke-WebRequest ` -Uri "https://github.com/jet52/ndlaw/releases/latest/download/$db.db.zip" ` -OutFile "$db.db.zip" Expand-Archive "$db.db.zip" -DestinationPath . -Force Remove-Item "$db.db.zip" } uv sync ``` #### macOS ```bash # Install uv — skip if already installed curl -LsSf https://astral.sh/uv/install.sh | sh git clone https://github.com/jet52/ndlaw.git cd ndlaw # Download + extract every database release asset (opinions + primary-law corpora). # The corpus DBs ship from v0.11.0 on; opinions.db is the only one in older releases. for db in opinions constitution statutes rules admincode; do curl -LO "https://github.com/jet52/ndlaw/releases/latest/download/$db.db.zip" unzip -o "$db.db.zip" && rm "$db.db.zip" done uv sync ``` #### Linux ```bash # Install uv — skip if already installed curl -LsSf https://astral.sh/uv/install.sh | sh git clone https://github.com/jet52/ndlaw.git cd ndlaw # Download + extract every database release asset (opinions + primary-law corpora). # The corpus DBs ship from v0.11.0 on; opinions.db is the only one in older releases. for db in opinions constitution statutes rules admincode; do curl -LO "https://github.com/jet52/ndlaw/releases/latest/download/$db.db.zip" unzip -o "$db.db.zip" && rm "$db.db.zip" done uv sync ``` ### 3. Smoke test Confirm the database is wired correctly: ```bash sqlite3 opinions.db "SELECT COUNT(*) FROM opinions" # exact count # Primary-law corpora (if you downloaded them): sqlite3 constitution.db "SELECT COUNT(*) FROM provisions" # ~496 sqlite3 statutes.db "SELECT COUNT(*) FROM provisions" # ~29,100 ``` ### Updating to a newer database release When a new database release is published, replace the local copy: ```bash # macOS / Linux — refresh every database (or list just the ones you use) for db in opinions constitution statutes rules admincode; do rm -f "$db.db" curl -LO "https://github.com/jet52/ndlaw/releases/latest/download/$db.db.zip" unzip -o "$db.db.zip" && rm "$db.db.zip" done ``` ```powershell # Windows PowerShell foreach ($db in "opinions","constitution","statutes","rules","admincode") { Remove-Item "$db.db" -ErrorAction SilentlyContinue Invoke-WebRequest ` -Uri "https://github.com/jet52/ndlaw/releases/latest/download/$db.db.zip" ` -OutFile "$db.db.zip" Expand-Archive "$db.db.zip" -DestinationPath . -Force Remove-Item "$db.db.zip" } ``` Then `git pull` to pick up any code changes since the release was cut. ### 4. Run **MCP server (stdio mode, for Claude Desktop / Claude Code):** ```bash uv run ndlaw-mcp ``` --- ## Connecting to Claude The server can run under any MCP client. The two most common are Claude Code (CLI, all platforms) and Claude Desktop (Mac and Windows only — no Linux build is shipped today). Throughout the snippets below, replace `/absolute/path/to/ndlaw` with the full path to your cloned repo. On Windows you can use forward slashes in JSON strings (`C:/Users/you/ndlaw`) — they work fine and avoid double-backslash escaping. ### Claude Code (Windows, macOS, Linux) One-liner from any directory: ```bash claude mcp add ndlaw -- uv --directory /absolute/path/to/ndlaw run ndlaw-mcp ``` This stores the server in your user-level Claude Code config and makes it available in every project. Restart any active Claude Code session and the `ndlaw` server's tools will be available. Alternative: a project-scoped `.mcp.json` in any project where you want ndlaw available. Create the file with: ```json { "mcpServers": { "ndlaw": { "type": "stdio", "command": "uv", "args": ["--directory", "/absolute/path/to/ndlaw", "run", "ndlaw-mcp"] } } } ``` ### Claude Desktop (macOS) Edit `~/Library/Application Support/Claude/claude_desktop_config.json`: ```json { "mcpServers": { "ndlaw": { "command": "uv", "args": ["--directory", "/absolute/path/to/ndlaw", "run", "ndlaw-mcp"] } } } ``` Then quit and restart Claude Desktop (Cmd-Q, not just close the window). ### Claude Desktop (Windows) Edit `%APPDATA%\Claude\claude_desktop_config.json`. Same JSON shape, but specify the absolute paths to both `uv` and your repo. If `uv` is on your PATH (it is by default after the install script), `"command": "uv"` works; otherwise use the full path, e.g. `"C:/Users/you/.local/bin/uv.exe"`. ```json { "mcpServers": { "ndlaw": { "command": "uv", "args": ["--directory", "C:/Users/you/ndlaw", "run", "ndlaw-mcp"] } } } ``` Then quit and restart Claude Desktop from the system tray. ### Linux Claude Desktop is not available on Linux. Use Claude Code (above). ### Verifying the connection Once connected, try a prompt like: > Use ndlaw to look up *State v. Boger*, 2021 ND 152. The tool call should return the case metadata and (with `include_text=true`) the opinion text. For the full set of tools, see the [MCP tools exposed](#mcp-tools-exposed) table near the top. --- ## Remote / team deployment By default the server speaks **stdio** — each user runs their own copy and their MCP client launches it as a subprocess (the configs above). To serve a whole team from one host instead, the same server can run over **Streamable HTTP**. The opinion data is public (CC0), so the goal of auth here is access control, not secrecy; the recommended posture is **work-network / VPN-only with a bearer token**, with TLS and the token check handled by a reverse proxy in front of the app. The only thing the app itself needs is three environment variables: | Variable | Purpose | Default | |----------|---------|---------| | `NDLAW_TRANSPORT` | `http` (Streamable HTTP) or `sse`; anything else = stdio | `stdio` | | `NDLAW_HOST` | bind address — keep `127.0.0.1` so only the local proxy can reach it | `127.0.0.1` | | `NDLAW_PORT` | bind port | `8000` | | `NDLAW_DB` | path to `opinions.db` on the server | bundled / app-data | | `NDLAW_CONST_DB` | path to `constitution.db` (ND Constitution corpus) | bundled / app-data | | `NDLAW_NDCC_DB` | path to `statutes.db` (N.D.C.C. corpus) | bundled / app-data | | `NDLAW_RULE_DB` | path to `rules.db` (court-rules corpus) | bundled / app-data | | `NDLAW_ADMIN_DB` | path to `admincode.db` (Admin. Code corpus) | bundled / app-data | | `NDLAW_AG_DB` | path to `ag_opinions.db` (Attorney General opinions) | bundled / app-data | The MCP endpoint is **`/mcp`** (no trailing slash — `/mcp/` issues a 307 redirect, which some clients mishandle on POST). The tools are read-only (search / lookup / citation analysis); the data-editing CLIs are not exposed over MCP. ### Run it as a service (systemd) ```ini # /etc/systemd/system/ndlaw-mcp.service [Unit] Description=ndlaw-mcp (Streamable HTTP) After=network.target [Service] User=ndcourts WorkingDirectory=/srv/ndcourts/ndlaw-mcp Environment=NDLAW_TRANSPORT=http Environment=NDLAW_HOST=127.0.0.1 Environment=NDLAW_PORT=8000 Environment=NDLAW_DB=/srv/ndcourts/opinions.db ExecStart=/srv/ndcourts/ndlaw-mcp/.venv/bin/ndlaw-mcp Restart=on-failure [Install] WantedBy=multi-user.target ``` ### Terminate TLS and enforce the token (Caddy) ``` mcp.court.example { # only requests carrying the shared token reach the app @authorized header Authorization "Bearer REPLACE_WITH_A_LONG_RANDOM_TOKEN" handle @authorized { reverse_proxy 127.0.0.1:8000 } respond "Unauthorized" 401 } ``` For revocable, per-person access, give each user a distinct token and add a matching `@authorized` line per token. Restrict the host's firewall so the proxy port is reachable only from the VPN subnet. ### What each team member runs ```bash claude mcp add --transport http ndlaw https://mcp.court.example/mcp \ --header "Authorization: Bearer REPLACE_WITH_A_LONG_RANDOM_TOKEN" ``` (Claude Desktop: add an equivalent `"type": "http"` server with a `headers` block in `claude_desktop_config.json`.) Users connect to the VPN first, then the client reaches the server. ### Updating the deployed database The weekly pipeline regenerates `opinions.db`. Because it is served read-only, deploying an update is just: copy the new file to the server, then `systemctl restart ndlaw-mcp`. ### Public VPS test (open internet) The model above is VPN-only with a bearer token. To instead expose the server on the public internet for a quick test — with **TLS + HTTP Basic Auth + rate limiting + fail2ban** — use the ready-to-run Ubuntu templates in [`deploy/`](deploy/): - [`deploy/SETUP.md`](deploy/SETUP.md) — step-by-step Ubuntu 22.04/24.04 walkthrough (system user, `uv` install, database download, systemd, Caddy with the rate-limit plugin, `ufw`, SSH hardening, fail2ban, client config). - [`deploy/Caddyfile`](deploy/Caddyfile) — auto-HTTPS, per-IP `rate_limit`, `basic_auth`, and `flush_interval -1` so MCP's SSE streaming isn't buffered. - [`deploy/ndlaw-mcp.service`](deploy/ndlaw-mcp.service) — hardened systemd unit bound to localhost. - [`deploy/fail2ban/`](deploy/fail2ban/) — filter + jail that ban IPs on repeated `401`s. The data is public (CC0), so this auth is access control and abuse prevention, not secrecy. --- ## Sources, redistribution scope, and license Code: dedicated to the public domain under [CC0 1.0 Universal](LICENSE). Use it however you want. Data: the opinions database redistributes only the court's own published work (opinions and court-authored syllabi) plus factual record content (parties, dates, attorneys, dispositions, citations). Judicial opinions of state courts are edicts of government and are not protected by copyright; what is published here is the North Dakota courts' own text. See [`NOTICE.md`](NOTICE.md) for the redistribution scope in full. --- ## Building one for another jurisdiction Nothing here is North Dakota-specific except the sources and a few tables. (This repository is the serve-only half; the ingest pipeline lives in the development repository. The method is what transfers.) The shape: raw sources kept as untouched witnesses, one SQLite database per corpus, a citation graph, a correction log, and a thin MCP layer on top. This is the order that worked. ### 1. Decide what the corpora are, and what the unit of each one is Two kinds of law need two data models. **Opinions** are immutable dated documents: one row per opinion, parallel citations in a side table, text searched with FTS5. **Codes** — constitution, statutes, court rules, regulations — are *versioned provisions*: a stable identity (`art. I, § 8`, `§ 28-32-46`, `Rule 12`) with dated text versions, so a query can ask for the text in force on a given date. Decide early how you will name every unit, because the citation graph resolves cross-references by exact string match on that canonical name. ### 2. Locate the sources For each corpus, find the official publisher first, then the independent witnesses. What we used, and where the equivalents usually live: | Corpus | Official | Independent witnesses | |---|---|---| | Opinions, modern | The court's own site: slip PDFs plus a neutral-citation index (`2019 ND 54`); weekly scrape | [CourtListener](https://www.courtlistener.com) bulk data and API (Free Law Project); the court's legacy archive if one exists | | Opinions, pre-digital | The bound official reports (public domain for state government works) | CourtListener's historical case-law collection (texts and page scans); Google Books / HathiTrust scans of the reporter volumes; the regional reporter's own volumes | | Statutes | The legislature. Look for a structured export before scraping HTML — North Dakota's Legislative Council publishes the whole code as JSON | Session laws (for point-in-time history); the archived prior editions | | Constitution | Legislature or Secretary of State | A compiled amendment chronology (ballot measures, session laws) is what makes the history layer possible | | Court rules | The court's rules page; amending orders carry effective dates | The orders themselves | | Administrative code | Whoever publishes it (here, the Legislative Council) | The register / notices of adopted rules | | Attorney General, ethics advisory opinions | The issuing office's site | — | Read the terms of use and `robots.txt` for every source. Commercial reporter text is subscriber content: it can serve as a *validation* witness under your own subscription, but you cannot redistribute it, and your shipped database must contain only the government's own text plus factual record content. Write that scope down before you ingest anything ([`NOTICE.md`](NOTICE.md) is ours). ### 3. Acquire, and keep the raw files forever Everything lands in a witness tree (a `refs/<state>/…` directory outside the repository) that the pipeline reads and never writes. A file there is authoritative about what the *source said*, never about what the opinion *should* say; corrections live only in the database and its changelog. Alongside each acquired file keep a small provenance sidecar (URL, fetch date, checksum). Scrape politely, with a fixed rate and a real user agent; some court sites sit behind Cloudflare and need TLS impersonation (`curl_cffi`) rather than plain `requests`. Automate the weekly pull (`launchd`/`cron`) from day one, because the corpus is only ever as current as the last run. ### 4. Extract text with two witnesses per document - **Born-digital PDFs**: `pdftotext -layout`, then a reflow pass that rejoins wrapped lines, keeps paragraph numbers, star pages, footnotes, and block quotes, and strips clerk stamps and page furniture. - **Scanned pages**: OCR twice with different engines (we use tesseract via `ocrmypdf` as the baseline and a vision-language model, Surya, as the second witness) and accept a correction only where the two agree against the stored text, then read the page image for anything digit-bearing. - **HTML**: a parser per site; the archive's `<u>` may be italics on one page and inserted text on another, so decide per element with the page in front of you. Pick unambiguous in-text sigils for structure (`[¶12]`, `[*363]`, `[n3]`) that cannot collide with the court's own bracketed material, and document them where every consumer will see them. Preserve the court's misprints verbatim and record them in a `print_anomalies` table with the intended reading; the citation graph resolves to the intended target while the text stays faithful. ### 5. Load, deduplicate, and link Ingest each source separately, then merge by **parallel-citation matching**: the same opinion appears in the regional reporter, the state reports, the court's site, and CourtListener, and the citation set is the join key. Record every source that contributed in a sources table so a later audit can diff the stored text against each witness. Extract citations with a parser that knows your jurisdiction's reporters, rules, and statute forms — we use [`jetcite`](https://github.com/jet52/jetcite) — into an outbound table (document → authority) and derive the inbound side (cited-by, notes of decisions) from it. Provision-to-provision cross-references get the same treatment inside each code database, keyed to the version they appeared in. ### 6. Serve [FastMCP](https://github.com/jlowin/fastmcp) turns plain functions into tools; `ndlaw_mcp/server.py` attaches the per-corpus databases to one connection and registers about forty. Name tools by the questions a lawyer asks (`lookup_opinion`, `get_citing_opinions`, `lookup_authority` with `as_of_date`, `check_draft`), keep responses paginated, and give every tool an end-to-end test. Ship a `get_database_stats` tool that reports the corpus counts and the date of the last update, so users can tell how current an instance is. ### 7. Validate, log, release Write integrity invariants and run them after every data batch; log every correction as a batch with a reason and the witness it was checked against (a data changelog, separate from the code changelog); and plan an independent text-fidelity audit against the original sources. Release the databases as versioned assets on a fixed cadence, separate from the code, with the distribution copy stripped of anything you may not redistribute. ### What to fork and what to rewrite Reuse as-is: the schemas, the server and web layers, the invariants framework, the changelog and release tooling, the two-witness OCR gate. Rewrite for your jurisdiction: the scrapers, the court-composition table (justices and terms), the reporter taxonomy and citation patterns, the text conventions of your court's print, and the redistribution scope. Budget most of the effort for step 4: acquiring sources is a week, getting the text right is the project. --- ## Reporting errors This repository ships a validated, read-only corpus and the minimal server that serves it; the data pipeline and its correction history are maintained separately. If you find a text or metadata discrepancy against an official source, please open an issue with the citation and the source you checked against.