Orthotomeo

io.github.jrainsberger由 GitHub 账号 jrainsberger 发布v0.1.0更新于 Oct 24, 2026

Read-only scripture-study engine: complete-or-fail concordance over Greek NT, Hebrew OT, LXX.

已验证Streamable HTTP可网页运行知识与记忆数据与分析

概览

AI 生成的概览

只读的圣经研究引擎,让助手获取带出处标注的逐字经文,并在希腊文、希伯来文和七十士译本上执行完整或报错的索引检索。

可以做什么
解析经文引用,按多个版本(KJV、ASV、WEB、BSB、Brenton、TAGNT、TAHOT、Swete、OSS-LXX-lemma)读取逐字经文或连续段落,并附出处与跨版本编号差异提示。按词元、Strong 编号或精确词形执行完整或报错的索引检索,也可按同一节内有序多词短语检索。统计出现次数(总数与按书卷分布),并据此核对索引结果。解析并词元化经文中的词,返回消歧后的 Strong 编号与展开的词法信息。查询词典条目、抄本见证代码与版本,并生成逐词对齐的对照阅读视图。将结果渲染为带完整引注的引用条目。
适用场景
适合需要穷尽每一处出现、且每条论断都能追溯到真实语料行的解经或词语研究,而不是凭记忆作答。适用于希腊文新约、希伯来文旧约和七十士译本的研究,包括文本异文与各版本章节编号差异的问题。
运行要求
托管实例是远程 Streamable HTTP 端点,无需本地二进制、数据库或构建步骤,公开且无需认证。若在本地运行,则需要 Go 工具链、由你自行提供的分别授权语料文件构建的数据库,并在 MCP 客户端中注册。
安装前请注意
托管实例有速率限制(每 IP 每小时 60 次引擎查询,全站每天 2,000 次),单次索引结果上限为 2,000 处;超出范围的查询会直接报错并给出确切匹配数,而非截断。引擎为只读,不写入数据。语料文件是外部的、分别授权的输入,希伯来文词典释义在使用前需核对条款。

安装

在 SourceWeft 中

  1. 打开 控制台中的 Orthotomeo,将其添加到工作区。
  2. 为需要使用其工具的对话启用该服务。

Web executable,通过 Streamable HTTP。 远程服务在工作区中配置后即可从网页运行时运行。

交给智能体安装

把这段提示词粘贴到 Claude Code、Codex、Cursor 等智能体,或 SourceWeft 对话中。智能体会读取该服务器的安装指南,先向你展示发布者、端点和登录方式,经你同意后再把它添加到你的客户端。密钥不会写进任何命令。

阅读 https://sourceweft.com/mcp/io.github.jrainsberger%2Forthotomeo/install.md,并按其中说明把这个 MCP 服务器接入我的客户端。修改任何配置之前,先告诉我它的发布者、端点和登录方式,等我确认。不要把 API 密钥写进命令或我会提交的文件;问我密钥应从哪里获取。

查看智能体所依据的安装指南

其他 MCP 客户端

把它添加到你客户端的 mcpServers 配置中。

{
  "mcpServers": {
    "orthotomeo": {
      "type": "http",
      "url": "https://orthotomeo.app/mcp"
    }
  }
}

README

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:

EditionWhat it isFormatLicense / attribution
TAGNTTranslators Amalgamated Greek New Testamenttab-delimited TSV, one row per Greek word (lemma, disambiguated Strong's, morphology, manuscript attestation)CC BY 4.0, STEPBible.org / Tyndale House Cambridge
TAHOTTranslators Amalgamated Hebrew Old Testamentsame TSV shape, Hebrew/AramaicCC BY 4.0, STEPBible.org / Tyndale House Cambridge
TEGMC / TEHMCGreek/Hebrew morphology-code expansion tablesplain TSVCC BY 4.0, STEPBible.org / Tyndale House Cambridge
TBESG / TBESHBrief lexicon of Extended Strong's (Greek/Hebrew)plain TSVCC BY 4.0 (Hebrew definitions require checking terms before use - see sources/sources.json)
SweteSwete's 1909-1930 Cambridge Septuagint, Greek surface textCSVPublic Domain, via archive.org
OSS-LXX-lemmaOpen Scriptures LXX lemma indexJS files, one per book, {key, lemma} per wordCC BY 4.0, Open Scriptures
KJV / ASVKing James (1769) / American Standard (1901)single JSON file, books[].chapters[].verses[]Public Domain
WEBWorld English Bible (2024)USFM, one file per book, Strong's numbers inlinePublic Domain, eBible.org
BSBBerean Standard Bible - a modern, literal translation from the critical textUSFM, one file per bookPublic Domain (released 2023-04-30), Bible Hub / Berean Bible
BrentonBrenton's 1851 English SeptuagintHTML, one file per chapterPublic Domain
OpenBible-xrefCross-references (from the Treasury of Scripture Knowledge)TSVCC BY 4.0, OpenBible.info

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:

RootContains
--referenceSTEPBible-Data/ (TAGNT, TAHOT, lexicons, morphology codes), LXX-Swete-1930/
--corpusbible-text/ (KJV, ASV, WEB, BSB, Brenton, OSS-LXX-lemma), cross_references.txt

The exact path under each root is not configurable per run - it's fixed, per source, in sources/sources.json's source_file field, the one place this mapping lives (no loader hard-codes a path itself; corpus.Locate is the only path-aware code in the whole importer, and it just joins root + source_file and globs). --corpus and --reference are tried in that order per source, so a tree can live under either root - but the path segments below whichever root resolves it are literal, not patterns (only the filename portion is a glob, where shown below):

SourcePath under its root
KJVbible-text/KJV/KJV.json
ASVbible-text/ASV/ASV.json
WEBbible-text/WEB/*.usfm
BSBbible-text/BSB/*.usfm
Brentonbible-text/LXX/eng-Brenton_html/*.htm
OSS-LXX-lemmabible-text/LXX/GreekResources-master/LxxLemmas/*.js
TAGNTSTEPBible-Data/Translators Amalgamated OT+NT/TAGNT*.txt
TAHOTSTEPBible-Data/Translators Amalgamated OT+NT/TAHOT*.txt
TBESG / TBESHSTEPBible-Data/Lexicons/TBESG*.txt / TBESH*.txt
TEGMC / TEHMCSTEPBible-Data/Morphology codes/TEGMC*.txt / TEHMC*.txt
TVTMSSTEPBible-Data/Versification/TVTMS*.txt
SweteLXX-Swete-1930/*.csv
OpenBible-xrefcross_references.txt

Placing files anywhere else fails fast with corpus tree missing: <path> under [...], naming exactly what it looked for. To use a different layout, edit the source_file value in sources/sources.json - that's the only change needed, since every loader reads it from there rather than assuming a path.

STEPBible-Data is published by STEPBible.org / Tyndale House Cambridge; the Swete CSV is the archive.org digitization of the 1930 Cambridge edition; the public-domain English translations and Open Scriptures lemma files are available from their respective publishers (eBible.org, Open Scriptures). None of these are fetched automatically yet - sources/sources.json's fetch_url field is a placeholder for that, not yet built.

Reading attestation codes

Every parse/attestation/interlinear result carries two fields worth knowing how to read: attestation (the Type code, e.g. "NKO") and manuscripts (the specific published editions, e.g. "NA28+NA27+Tyn+SBL+WH+Treg+TR+Byz"). Both are reported as neutral text-critical data, per this project's own discipline (see Design principles) - never an argument for or against a reading.

This legend is TAGNT (Greek NT) specific - straight from TAGNT's own source-file header, not paraphrased:

LetterTraditionMeaning
N"Ancient"Greek in Nestle-Aland, the base text most modern translations use
K"Traditional"Greek behind the KJV, i.e. the Textus Receptus per Scrivener's 1894 edition
O"Others"Any other Greek reading found in a major edition, rarely translated

A word's Type is the concatenation of every tradition that attests it - "NKO" (94% of all TAGNT words) means all three traditions agree; "KO" means Ancient (Nestle-Aland) doesn't have this word at all (the real, famous example: Mark 16:9-20 is tagged KO - absent from the Nestle-Aland base text, present in the Traditional/KJV text and some other editions). Case carries real meaning too: a letter is lowercase (n/k/o) when that tradition's own variant reading is "too minor to entail a different translation" (e.g. spelling, word order) - "NKo" means all three attest the word, but the Other-edition text differs in some way too small to affect meaning. Parentheses (e.g. "N(K)(O)") mark a tradition where the word is present but as a differing variant reading, rather than identically.

manuscripts names the actual published editions behind that Type code: Byz (Byzantine/RP 2005), NA27/NA28 (Nestle-Aland), TR (Scrivener's 1894 Textus Receptus), SBL (Holmes 2010), Treg (Tregelles), WH (Westcott-Hort), Tyn (Tyndale House GNT 2017).

TAHOT (Hebrew OT) uses a different scheme entirely - Hebrew textual criticism isn't about Nestle-Aland vs. Textus Receptus. Its Type letters track the Leningrad Codex against the Masoretic Qere/Ketiv apparatus (L=Leningrad text, Q=Qere scribal correction, K=Ketiv/original consonantal text, R=restored text, X=text supplied from the LXX), with the same lowercase-for-minor-variant convention. Don't read a TAHOT Type value against the TAGNT table above - they use the same field name for two unrelated apparatus systems.

Building the database

sh
go run ./cmd/build --corpus <path-to-bible-text-root> --reference <path-to-STEPBible-Data-root> --out data/orthotomeo.db --verifygo test ./...   # all green

Or via the Makefile: make build-db CORPUS=<path> REFERENCE=<path>, make build (all four transport binaries), make lint (fmt-check + vet + test, the same checks this project's own sessions run before every commit).

--verify runs the completeness self-test (invariant #3 made enforceable) - source/FK integrity, full-canon book coverage, and known per-edition word counts, each checked against the real build. The DB is regenerable: delete it and re-run the build at any time; the corpus files, never the DB, are the source of truth.

Using it

As an MCP server

Build the binary and register it with an MCP host (e.g. Claude Desktop):

sh
go build -o orthotomeo-mcp ./cmd/orthotomeo-mcp
json
{  "mcpServers": {    "orthotomeo": {      "command": "/path/to/orthotomeo-mcp",      "args": ["--db", "/path/to/data/orthotomeo.db"]    }  }}

Twelve tools are exposed: resolve_ref, get_verse, get_passage, concord_lemma, concord_phrase, count, parse, lemmatize, attestation, interlinear, lexicon_lookup, cite. Every book argument accepts a USFM code or the full English book name, in any case (MAT, mat, Matthew, MATTHEW all resolve to the same book).

This is stdio, for an MCP host running on the same machine as the DB.

Connecting to the hosted instance

No local binary, no local DB, no build step - point an MCP client's remote-server config at the hosted instance instead:

json
{  "mcpServers": {    "orthotomeo": {      "url": "https://orthotomeo.app/mcp"    }  }}

The exact config shape (a url field vs. a command/args pair) depends on your MCP client - check its docs for "remote MCP server" or "Streamable HTTP" support. Same twelve tools as the stdio server above; this is in fact this project's primary reason for having a cloud deployment at all. It's a public, unauthenticated, cost-bounded instance - rate-limited to 60 engine queries per hour per IP and 2,000/day total, and a single concordance result is capped at 2,000 occurrences.

Only requests that actually reach the engine draw on that budget: a tool call, or one of the REST query endpoints. Page loads, static assets, /books autocomplete data, MCP handshakes (initialize, tools/list) and 404 probes are free, and sit behind a separate, much looser flood guard instead. The budget is meant for study, so a liveness poller or a browser fetching CSS should never be able to spend it.

Those two bounds do different jobs: the rate limit caps how often you can ask, the result cap caps how expensive one ask can be. A query matching more than the cap is refused outright with the exact match count in the error - never silently truncated, which would break complete-or-fail. Call count first for a broad query; count is never capped, since it returns numbers rather than Citations.

The cap applies only to this hosted instance. The CLI, desktop, and local web builds are unbounded, so a study that genuinely needs every occurrence of a common word (TAGNT ὁ matches 20,705) belongs there - or get in touch.

As a CLI

sh
go build -o orthotomeo ./cmd/orthotomeoorthotomeo concord --corpus TAGNT G0859               # every occurrence of a lemma/Strong's numberorthotomeo concord --corpus TAGNT --phrase "εἰς,ἄφεσις" --adjacentorthotomeo lookup --edition KJV,ASV,WEB,BSB MAT.26.28   # verbatim verse textorthotomeo parse --corpus TAGNT --word 2 MRK.16.16     # dStrong + expanded morphologyorthotomeo attest --corpus TAGNT MRK.16.16             # manuscript attestation (Type/Editions)orthotomeo define G0859                                # lexicon/Strong's lookuporthotomeo interlinear --corpus TAGNT MRK.16.16         # row-aligned original/translit/gloss/grammar

Every subcommand also takes --json for machine-readable output. A ref's book token (e.g. the MAT in MAT.26.28) accepts a USFM code or the full English name, in any case.

As an HTTP API + local web UI

sh
go build -o orthotomeo-web ./cmd/orthotomeo-web./orthotomeo-web --db data/orthotomeo.db   # loopback only, default port 8420

Or via the Dockerfile (make docker-build && make docker-run DB=data/orthotomeo.db, or plain docker build/docker run) - it builds only cmd/orthotomeo-web into a minimal, cgo-free image; the DB is never baked in, it's mounted at /data/orthotomeo.db (build it on the host first, per "Building the database" above).

Open http://127.0.0.1:8420/ for the landing page and /app/ for the query tool; /docs is the API and MCP reference. Or hit the GET-only JSON endpoints directly: /verse, /passage, /concord, /count, /parse, /attest, /interlinear, /define, /books (the canonical 66-book registry, used by the UI's book-field autocomplete).

/count returns the occurrence tally - total and per book - for the same query /concord would match. It is never subject to the result cap, because it returns numbers rather than Citations, which makes it the answer to a query too broad to return.

sh
curl "http://127.0.0.1:8420/verse?book=JHN&chapter=3&verse=16&editions=KJV"
json
{  "citations": [    {      "ref": {"book": "JHN", "chapter": 3, "verse": 16},      "edition": "KJV",      "text": "For God so loved the world, that he gave his only begotten Son, that whosoever believeth in him should not perish, but have everlasting life.",      "locator": "John 3:16",      "confidence": "High"    }  ],  "sources": {    "KJV": {"file": "bible-text/KJV/KJV.json", "license": "Public Domain", "homepage_url": "https://github.com/scrollmapper/bible_databases"}  }}
sh
curl "http://127.0.0.1:8420/concord?query=G0859&corpus=TAGNT"
json
{  "citations": [    {      "ref": {"book": "MAT", "chapter": 26, "verse": 28},      "edition": "TAGNT",      "text": "ἄφεσιν",      "locator": "Mat.26.28#16=NKO",      "lemma": "ἄφεσις",      "translit": "aphesin",      "dstrong": "G0859",      "grammar": "N-ASF",      "attestation": "NKO",      "manuscripts": "NA28+NA27+Tyn+SBL+WH+Treg+TR+Byz",      "confidence": "High"    },    { "...": "16 more occurrences, one per real match - complete-or-fail, never a sample" }  ],  "sources": {    "TAGNT": {"file": "STEPBible-Data/Translators Amalgamated OT+NT/TAGNT*.txt", "license": "CC BY 4.0", "attribution": "STEPBible.org / Tyndale House Cambridge", "homepage_url": "https://github.com/STEPBible/STEPBible-Data"}  }}

Everything above is loopback-only, by design (see cmd/orthotomeo-web's doc comment). cmd/orthotomeo-web-cloud is the separate, publicly-reachable counterpart (e.g. for Cloud Run) - a different binary and image, not a flag on this one; see its own package doc comment for what's different.

As a desktop app

sh
go build -ldflags -H=windowsgui -o orthotomeo-desktop.exe ./cmd/orthotomeo-desktop

A native GUI shell (renders no scripture itself) that starts the HTTP server on an ephemeral loopback port, opens your browser to it, and shuts the server down cleanly on close.

As a Go library

go
e, err := engine.Open("data/orthotomeo.db") // opens read-onlyif err != nil { ... }defer e.Close()
citations, err := e.ConcordLemma("G0859", "TAGNT", "") // by: "" (auto-detect), "lemma", "dstrong", or "surface"fmt.Println(e.Cite(citations)) // Markdown-formatted, fully cited

Worked example

A real, captured exchange (not fabricated) - an LLM client with the system prompt shown below (and orthotomeo's MCP tools) registered, asked about the project's own namesake word. Included because it demonstrates the "engine owns evidence, the LLM traces usage, you own the conclusions" principle in practice, not just in description: every grammatical/attestation claim traces to a tool result, the model stops and asks before reaching into LXX or Hebrew data on its own, and it explicitly labels its own cross-corpus synthesis as inference rather than a tool-verified fact.

Me: Where does the Greek word ὀρθοτομέω occur in the New Testament, and what does it mean in context?

Concordance result: ὀρθοτομέω (G3718)

The complete-or-fail concordance against TAGNT returns exactly one occurrence in the New Testament: 2 Timothy 2:15.

  • Greek form: ὀρθοτομοῦντα - Present Active Participle, Accusative Singular Masculine (V-PAP-ASM)
  • Manuscript attestation: NKO - attested across the full set carried in this corpus (NA28, NA27, Tyndale House GNT, SBLGNT, WH, Tregelles, TR, Byzantine). No variant flagged for this word.

Full verse (TAGNT): σπούδασον σεαυτὸν δόκιμον παραστῆσαι τῷ θεῷ, ἐργάτην ἀνεπαίσχυντον, ὀρθοτομοῦντα τὸν λόγον τῆς ἀληθείας.

  • KJV: "...a workman that needeth not to be ashamed, rightly dividing the word of truth."
  • ASV: "...handling aright the word of truth."
  • WEB: "...properly handling the Word of Truth."

Because this is a NT hapax legomenon (single occurrence), the concordance method's core move - letting unambiguous instances fix an ambiguous one - has no other NT data to draw on within this corpus. I haven't searched the LXX for this lemma - say the word if you want that pulled as a separate, clearly marked follow-up, since it would be extra-NT.

Me: Yes, please search LXX also.

LXX concordance result: ὀρθοτομέω

Searching OSS-LXX-lemma returns two occurrences, both in Proverbs. The Swete surface-text corpus doesn't carry lemma tags at all (confirmed: every word is flagged "Swete is surface-only, T12"), so the lemma search against Swete correctly returns zero.

  • Proverbs 3:6 - ὀρθοτομῇ (present subjunctive). Brenton: "...that she may rightly direct thy paths." Object: τὰς ὁδούς σου ("your paths").
  • Proverbs 11:5 - ὀρθοτομεῖ (present indicative). Brenton: "Righteousness traces out blameless paths." Object: ὁδούς ("paths"), qualified ἀμώμους ("blameless").

Across all three attested occurrences, the verb's object is consistently a "path/way" noun in the LXX, but in 2 Timothy the object is τὸν λόγον τῆς ἀληθείας ("the word of truth") - not a path. That's a real semantic extension worth weighing: three data points across two authors/eras is not enough to fix the sense with certainty, and there's no fourth instance anywhere in the tagged corpora to anchor it further.

Me: Please xref with the Hebrew.

Hebrew cross-reference (TAHOT)

Both Proverbs verses translate the same underlying Hebrew verb - יָשַׁר (yashar), Piel stem (H3474) - not a "cutting" verb.

  • Proverbs 3:6: יְיַשֵּׁר (Piel imperfect 3ms) - "he will make straight/level." Object: אֹרְחֹתֶיךָ ("your paths").
  • Proverbs 11:5: תְּיַשֵּׁר (Piel imperfect 3fs). Object: דַּרְכּוֹ ("his way").

This changes the picture: the "cutting" sense is a Greek-translator choice, not inherited from the Hebrew. יָשַׁר means "make straight/level/ smooth" - the same root behind יָשָׁר ("upright, straight") - with no lexical component of cutting or incising. The LXX translators rendered a "straightening/leveling" verb with a Greek compound built on τέμνω ("cut"); that's the translators' own image, layered onto the Hebrew rather than reproduced from it. For 2 Timothy 2:15, this means a gloss like "keep the word of truth on a straight/level course" is at least as defensible from this trail as "cut a straight path" - the Hebrew data doesn't support building an interpretation on the "cut" etymology alone.

(This is as far as the concordance data takes it - three Greek instances, two underlying Hebrew instances, no fourth anywhere in the tagged corpora. The synthesis above is inference from the pattern, explicitly distinguished throughout the actual exchange from what a citation states outright.)

Example prompt

The system prompt that produced the exchange above - the kind you'd give an LLM client with orthotomeo's MCP tools registered:

You have access to the orthotomeo MCP tools over a real biblical-text corpus. When I ask a scripture question, answer using the concordance method: pull every relevant occurrence via concord_lemma/concord_phrase - not a remembered sample - and let the unambiguous cases fix the ambiguous ones. Work from what the tools return, not from recall; if a grammatical or lexical claim isn't something you can point to in the returned citations, say so rather than asserting it. This includes when you derive a grammatical form yourself - e.g. lemmatizing a surface-only edition like Swete, which carries no lemma field, rather than reading one from a tool field: that's fine to do, but say explicitly that you did it, distinct from citations the tool verified directly. Stay strictly with the biblical text itself - no commentaries, no modern theological arguments, no ancient/extra-biblical sources unless I explicitly ask for those as a separate, clearly-marked follow-up. Report manuscript attestation (via attestation) as neutral data - a textual variant is something for me to weigh, not something for you to argue for or against. Give me a reference list with brief lexical notes I can take into my own study, not a finished conclusion.

License

Code: MIT. Data is not relicensed by this project - each source keeps its own license as recorded in sources/sources.json (a mix of CC BY 4.0 and Public Domain; see that file for the exact terms and attribution per source). Non-redistributable sources (e.g. a CCAT-derived Rahlfs LXX, if added later) would be user-fetched, never bundled.

来源:README.md,提交 f6276df

工具

12

attestation

Manuscript attestation

Returns the WHNT-style Type/Editions manuscript-tradition columns as neutral text-critical data (e.g. Mark 16:9-20 = Type KO) - which editions carry a word, with no argument for or against a variant.

输入参数book必填wordverse必填corpus必填chapter必填

cite

Format citation

Renders Citations (from any of the above tools) as quoted, fully-attributed Markdown bullets - the only sanctioned bridge from a query result to pastable study-document text.

输入参数citations必填

concord_lemma

Search concordance (lemma)

Complete-or-fail concordance: every words row in corpus whose lemma, dStrong, or (with by="surface") exact inflected surface form matches query. Route lemma/Strong's-number/surface-word lookups here, never by writing SQL or guessing occurrences from memory. This deployment caps one concordance result at 2000 occurrences and refuses anything broader, reporting the exact match count in the error. Call count first when a query might be broad - count is never capped.

输入参数byquery必填corpus必填

concord_phrase

Search concordance (phrase)

Complete-or-fail multi-word concordance: every occurrence, within one verse, of tokens (lemma strings) appearing in order within window intervening words of each other (window=0 = strictly adjacent). This is the tool for a phrase query like εἰς ἄφεσιν. This deployment caps one concordance result at 2000 occurrences and refuses anything broader, reporting the exact match count in the error. Call count first when a query might be broad - count is never capped.

输入参数corpus必填tokens必填window必填

count

Count occurrences

Occurrence tally (total + per-book breakdown) for the identical query concord_lemma would match. count.Total always equals len(concord_lemma(...)) - use this to sanity-check a concordance result, or when only the number matters.

输入参数byquery必填corpus必填

get_passage

Get passage text

Returns get_verse's result for every canonical verse in a contiguous, single-book range, in order - verse boundaries preserved, never concatenated into one blob.

输入参数book必填editions必填end_verse必填end_chapter必填start_verse必填start_chapter必填

get_verse

Get verse text

Returns verbatim verse text with provenance for one canonical reference, one Citation per requested edition (KJV, ASV, WEB, BSB, Brenton).

输入参数book必填verse必填chapter必填editions必填

interlinear

Interlinear reading view

Returns a row-aligned reading view for every word in a verse (or one word, if word is given): original text, transliteration, gloss (via lexicon_lookup), grammar, and manuscript attestation stacked per word - the composed display shape for a study reading view, built on parse and lexicon_lookup rather than any new query. This is the most complete per-word view; use parse or attestation when you want only one of those facets.

输入参数book必填wordverse必填corpus必填chapter必填

lemmatize

List lemmas

Returns the ordered lemma list for a verse (words with no lemma are omitted, not fabricated).

输入参数book必填verse必填corpus必填chapter必填

lexicon_lookup

Lexicon lookup

Resolves a disambiguated Strong's number (dStrong) to its lexicon entry: lemma, transliteration, gloss, and - for a Greek entry only - a fuller definition (Abbott-Smith 1922, Public Domain). A Hebrew entry's definition field is always omitted: it is abridged BDB via Online Bible, which requires permission not yet obtained, so only its gloss is ever returned. Not to be confused with the get_verse/get_passage tools, which resolve a Ref to translated verse text, not a dStrong to a dictionary entry.

输入参数dstrong必填

parse

Parse morphology

Returns dStrong + expanded morphology (via the T6 morph_codes table) for every word in a verse, or one word if word is given. LXX corpora (Swete, OSS-LXX-lemma) are always Flagged - neither carries morphology.

输入参数book必填wordverse必填corpus必填chapter必填

resolve_ref

Resolve reference

Reports, for every per-verse content edition (KJV, ASV, WEB, BSB, Brenton, TAGNT, TAHOT, Swete, OSS-LXX-lemma), whether a canonical reference has a counterpart there and where. Cross-edition divergence (a T4b merge/renumber/divide, or a reference simply missing from an edition) is reported as Caveats - never a silent shift.

输入参数book必填verse必填chapter必填

版本历史

1
  1. v0.1.0最新Sep 16, 2026

评分

已满足适用检查项的 100%

该评分衡量此收录条目的完整程度,依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价,也不表示服务器安全或当前可用:可连通性是带日期的检查结果,评分也不包含安装量或用户评价。

  • 近 30 天内可连通必需25 分
  • 已声明认证方式必需10 分
  • 已列出工具必需15 分
  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分