orthotomeo

ὀρθοτομέω — "to cut straight," from 2 Timothy 2:15: "Be diligent to present yourself approved to God, a worker who does not need to be ashamed, cutting straight the word of truth."

orthotomeo is a read-only scripture-study engine. It imports a multi-edition biblical corpus (Greek New Testament, Hebrew Old Testament, Septuagint, and public-domain English translations) into a derived SQLite database, then serves verbatim, provenance-tagged lookups and complete-or-fail concordance over it - through an MCP server, a CLI, or as a Go library.

A personal project by Justin Rainsberger - not affiliated with, sponsored by, or representing any employer.

Why it's built this way

Three texts shape the engine's design, not just its name:

• Romans 3:4 - "let God be true, and every man a liar." Human sources - lexicons, grammars, commentaries, an LLM's own training - yield to the text itself whenever the two conflict. The engine has no lexicon-category shortcut for settling a word's sense; it returns the raw text and lets every occurrence speak.
• 1 Peter 4:11 - "If any man speak, let him speak as the oracles of God; if any man minister, let him do it as of the ability which God giveth: that God in all things may be glorified through Jesus Christ, to whom be praise and dominion for ever and ever. Amen." Speech about scripture is accountable to scripture as its own oracle - and the verse doesn't stop at the accountability, it names what's actually at stake: that God in all things may be glorified. This project is doxology before it's software. A citation the engine returns must be traceable to an actual row in an actual source file - never a summary, a paraphrase, or a claim from memory - because what's on the line when scripture is handled carelessly isn't a bug, it's whether God is glorified in how His word gets handled.
• 2 Timothy 2:15 - the commission this project is named for, not just framed by. "Cutting straight" isn't a metaphor for careful reading in general; it's an explicit charge to handle the text with exactly this kind of precision - which is why the engine's core operation is complete-or-fail concordance (every matching occurrence, or an error - never a silent partial answer) rather than a best-effort search.

Practically, this means: the engine owns evidence, the LLM traces usage, you own the conclusions. The engine never interprets, never argues a position, and never quotes original-language text it didn't get from its own database. Given a query, it either returns the complete, provenance-tagged result set, or it raises an error - it does not silently truncate, guess, or paraphrase. The LLM fans that out into patterns across occurrences; it never gets the last word on what they mean.

Design principles

• The content itself is never curated by an LLM. Every word, verse, and lemma a caller receives comes straight from the checked-in corpus files (STEPBible, Open Scriptures, public-domain translations) through a deterministic SQL query - no model ever selects, summarizes, paraphrases, or decides what's "relevant" before it reaches you. An LLM client can reason about what the engine returns; it never touches what the engine is. The one place an LLM's own judgment enters is display formatting it builds on top (e.g. how it phrases an answer using the returned Citations)
  • never the underlying text, and the tools exist precisely so that judgment is checkable against the real data, not offered on its own authority.
• Complete-or-fail, never a silent partial answer. A concordance query returns every matching occurrence or raises an error - it never truncates, samples, or guesses at "close enough."
• Provenance always. Every citation traces to a real row in a real source file (edition, license, attribution, locator) - never a summary, a paraphrase, or a claim from memory.
• Reconcile at read time, never assume 1:1 across editions. The five text traditions disagree on versification and canon; cross-edition divergence is surfaced as data (a Caveat) at the moment it's found, never hidden or silently forced onto one edition's numbering.
• Textually faithful defaults, not modern-convention defaults. Where a modern editorial convention doesn't reflect anything in the manuscripts themselves (e.g. letter case, which ancient Greek/Hebrew manuscripts didn't have at all), the engine doesn't treat it as load-bearing by default - but flags it via a Caveat wherever the convention does carry real disambiguating information (e.g. a proper name spelled identically to a common noun apart from case).
• Read-only, and the database is disposable. The engine never writes; the derived SQLite database is a regenerable build artifact, never checked in and never the source of truth - the corpus files are, and the database can be deleted and rebuilt from them at any time.

What's inside

• A derived SQLite database built from the corpus (cmd/build) - a regenerable artifact, not checked in. The corpus files are the source of truth; the DB is just an index over them.
• A Go engine package (the single read-only seam) exposing reference resolution, verbatim verse/passage lookup, lemma/phrase concordance, parse/lemmatize, manuscript attestation, and a citation renderer.
• Five transports over that one engine: an MCP server (cmd/orthotomeo-mcp) for use from an LLM chat client, a CLI (cmd/orthotomeo) for terminal use, an HTTP API + local web UI (httpapi, served by cmd/orthotomeo-web), a desktop launcher (cmd/orthotomeo-desktop) that starts the web server and opens a browser to it, and the engine package itself if you want to embed it directly in Go.

See docs/PLAN.md for the full design (read its cross-cutting invariants first) and docs/erd-v1.svg for the data model. docs/STATUS.md has the detailed ticket-by-ticket build log.

Paired with an LLM, this small local reference engine stops being something you flip through by hand: ask a follow-up in plain language, and the model fans that into the right tool calls and finds patterns across the results - the cross-referencing a printed concordance leaves entirely to you. The engine still owns the text; the LLM adds the conversational follow-through, never the text itself. See the worked example below.

Setting up the corpus

(Evaluating the project rather than installing it? Skip ahead to the worked example and come back to this later.)

This repo does not ship the corpus. The source files are external inputs you supply yourself - each is separately licensed, and cmd/build refuses to run without both roots explicitly given (no default path). What you need:

The authoritative list - exact source_file glob, format, license, and attribution for every source - is checked in at sources/sources.json; treat that file as ground truth over this table.

Each edition keeps its own versification and canon (the LXX numbers Psalms differently and includes deuterocanonical books; the five text traditions disagree on where some verses start). The engine never assumes a 1:1 mapping across editions - see PLAN.md's cross-cutting invariant #4.

Directory layout cmd/build expects, split across two roots: