SFRNai/survivor-library-vectors

Survivor Library vector database

The whole Survivor Library, read, chunked and embedded for search. 13,763 books, 2.8 million scanned pages, 7,430,945 passages, each with a bge-small-en-v1.5 vector (384 dims). Built for the crocus platform's knowledge sidecar, uploaded so anyone can run their own copy.

It comes in two versions. Cleaned (the default) has about 2 million OCR misreadings corrected, each one checked in context, with fresh vectors for every passage that changed. Original is the text exactly as it was first read, kept alongside so nothing is lost. See The cleaned version.

Why this is here

In the world as it stands, there are threats to mankind both looming and distant, some upon us now and others gathering on the far horizon of our shared future.

No one can any longer deny that the incentives governing our collective action lead us steadily toward ends that serve none of us. This, we believe, is the gravest problem facing mankind.

The outlook is bleak. But where we cannot prevent, we can prepare.

Hence the Survivor Library: a growing collection of the old, practical knowledge by which people once fed, sheltered, and healed themselves, kept so that mankind may endure should the infrastructure we now depend upon, for whatever reason, fail us.

This vector set is freely available. Please use it responsibly. The vectors may be used to search both text and meaning, which makes them valuable to local harnesses that reach into this dense knowledge for you.

With thanks to The Librarian at survivorlibrary.com, who gathered and shares the collection.

---

The library itself is the famous collection of old practical knowledge: farming, engineering, medicine, chemistry, a full run of early Scientific American, trades, crafts. If the grid ever goes down, this is the shelf you want.

It comes two ways. Parquet, if you want to load it into anything (pandas, DuckDB, Spark, your own vector database). And a ready-made SQLite database plus vector index, if you want to search it right now with no build step: that's exactly what crocus runs.

The original scans are in the companion repo SFRNai/survivor-library-pdfs, every PDF in the same folders, so you can open the page behind any passage or run your own OCR.

At a glance

Books	13,763 (13,748 read; 15 PDFs wouldn't open)
Subjects	159
Pages	2,803,042: 1,747,347 from the PDF's own text layer, 1,055,695 OCR'd
Passages	7,430,945, about 1,000 characters (≈250 tokens) each
Text	6.7 billion characters
Years	mostly 1800–1928; 49 books before 1800, 742 after 1928, 1,074 undated
Embedder	BAAI/bge-small-en-v1.5, CLS pooling, normalized
Vectors	384 dims, int8 (−127..127), cosine
Versions	cleaned (default): 2,027,977 fixes in 1,223,741 passages; original: as first read
Size	per version: Parquet about 5.4 GB, SQLite + index about 15 GB
PDFs	about 214 GB, in SFRNai/survivor-library-pdfs

What's in it

The big shelves, by book count:

Subject	Books		Subject	Books
scientific american (series 2)	2,801		painting and drawing	147
scientific american (series 1)	710		machinerys reference	141
firearms manuals	676		radio 73 magazine	138
architecture	251		medical diagnostics	134
horses	244		economics	129
astronomy	195		botany	125
law	179		fishing	125
work magazine	177		forging and casting	121
coal and mining	166		farming	120
sewing	158		railroads	119
wood furniture	153		forestry	118
fuels	148		sewage	114

The rest runs from beekeeping and blacksmithing to opium, embalming and hatmaking. The full list is in books.parquet (category).

Files

data/
  passages/train-000NN-of-00015.parquet     cleaned passages: text, where it came from, its vector
  books.parquet                             one row per book
  fixes.parquet                             every correction the clean-up made, with its position
  passages-original-deprecated/
    train-000NN-of-00015.parquet            DEPRECATED: the same passages as first read, original vectors
sqlite/
  library.db                                cleaned SQLite: books, chunks, FTS5 index, plus the
                                            original text of every changed passage and every fix
  vectors.usearch                           USearch HNSW index over the cleaned passages (int8, cosine)
sqlite-original-deprecated/
  library.db, vectors.usearch               DEPRECATED: the original database and index, as first published

You only need one piece. Parquet if you're loading it somewhere else; sqlite/ if you want to search it as is. Grab just what you want with allow_patterns (examples below). The -original-deprecated folders are the text exactly as first read, kept for reference and comparison; use the cleaned default.

Quick start

Read it

from datasets import load_dataset

passages = load_dataset("SFRNai/survivor-library-vectors", split="train", streaming=True)
for row in passages.take(3):
    print(row["title"], row["year"], f"p. {row['page_from']}", row["text"][:200])

books = load_dataset("SFRNai/survivor-library-vectors", "books", split="train")
original = load_dataset("SFRNai/survivor-library-vectors", "passages-original-deprecated", split="train",
                        streaming=True)

streaming=True reads as you go. Leave it off to download all 5.4 GB once and keep it. The default is the cleaned text; ask for passages-original-deprecated for the text as first read.

Query it with SQL

DuckDB reads the Parquet straight off the Hub, no download step:

import duckdb

duckdb.sql("""
    SELECT title, year, page_from, left(text, 300) AS text
    FROM 'hf://datasets/SFRNai/survivor-library-vectors/data/passages/*.parquet'
    WHERE category = 'smithing' AND text ILIKE '%case harden%'
    LIMIT 10
""").show()

Search by meaning (Parquet + numpy)

No index needed. An exact search over one subject is instant. Over the whole library it took 21 seconds on a desktop, reading in batches, so it never needs much RAM.

import numpy as np
import pyarrow.dataset as ds
from huggingface_hub import snapshot_download
from sentence_transformers import SentenceTransformer

root = snapshot_download("SFRNai/survivor-library-vectors", repo_type="dataset", allow_patterns="data/passages/*")
passages = ds.dataset(f"{root}/data/passages", format="parquet")
model = SentenceTransformer("BAAI/bge-small-en-v1.5")

PREFIX = "Represent this sentence for searching relevant passages: "
q = model.encode(PREFIX + "how do I tan leather with oak bark", normalize_embeddings=True)

ids, scores = [], []
for batch in passages.to_batches(columns=["id", "embedding"], filter=ds.field("category") == "leather"):
    emb = batch.column("embedding").values.to_numpy().reshape(-1, 384).astype(np.float32)
    ids.append(batch.column("id").to_numpy())
    scores.append(emb @ q / np.linalg.norm(emb, axis=1))
ids, scores = np.concatenate(ids), np.concatenate(scores)
top = ids[np.argsort(-scores)[:5]]

for row in passages.to_table(filter=ds.field("id").isin(top)).to_pylist():
    print(row["title"], row["year"], f"p. {row['page_from']}", row["text"][:300], "\n")

Drop the filter= to search everything.

Hybrid search, the fast way (SQLite + USearch)

This is what crocus does: full-text and vectors together, fused by rank. Milliseconds a question, and the index is memory-mapped, so it doesn't load 4 GB into RAM.

import mmap
import re
import sqlite3

from huggingface_hub import snapshot_download
from sentence_transformers import SentenceTransformer
from usearch.index import Index

root = snapshot_download("SFRNai/survivor-library-vectors", repo_type="dataset", allow_patterns="sqlite/*")
db = sqlite3.connect(f"{root}/sqlite/library.db")
with open(f"{root}/sqlite/vectors.usearch", "rb") as f:
    vectors_map = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)   # keep this alive as long as the index
index = Index(ndim=384, metric="cos", dtype="i8", connectivity=16)
index.view(vectors_map)
model = SentenceTransformer("BAAI/bge-small-en-v1.5")

PREFIX = "Represent this sentence for searching relevant passages: "
SMALL = {"a", "an", "and", "the", "of", "to", "in", "for", "on", "with", "how", "do", "i", "is", "what", "my"}


def search(question, k=5):
    ranks = {}
    words = [w for w in re.findall(r"[a-z0-9']+", question.lower()) if w not in SMALL]
    if words:
        match = " OR ".join(f'"{w}"' for w in words)
        hits = db.execute("SELECT rowid FROM chunks_fts WHERE chunks_fts MATCH ? ORDER BY bm25(chunks_fts) LIMIT 50",
                          (match,)).fetchall()
        for r, (cid,) in enumerate(hits):
            ranks[cid] = ranks.get(cid, 0) + 1 / (60 + r)
    q = model.encode(PREFIX + question, normalize_embeddings=True)
    for r, cid in enumerate(index.search(q, 50).keys.tolist()):
        ranks[cid] = ranks.get(cid, 0) + 1 / (60 + r)
    top = sorted(ranks, key=ranks.get, reverse=True)[:k]
    return db.execute(f"""SELECT b.title, b.year, c.page_from, c.page_to, c.text
                          FROM chunks c JOIN books b ON b.id = c.book_id
                          WHERE c.id IN ({",".join("?" * len(top))})""", top).fetchall()


for title, year, p1, p2, text in search("how do I tan leather with oak bark"):
    pages = f"p. {p1}" if p1 == p2 else f"pp. {p1}-{p2}"
    print(f"{title} ({year}), {pages}\n{text[:300]}\n")

Plain full-text search works with nothing else installed: SELECT text FROM chunks_fts WHERE chunks_fts MATCH 'forge welding' LIMIT 20.

Opening the index through mmap is on purpose: Index.restore() and Index.view(path) break on Windows for files this big (a 32-bit size read). The mmap way works on every OS.

Open the scan behind a passage

Every book's file is its path in the PDF repo. Fetch just the one you need:

from huggingface_hub import hf_hub_download

file = "library-smithing/standard_blacksmithing_horseshoeing_and_wagon_making_1907.pdf"
pdf = hf_hub_download("SFRNai/survivor-library-pdfs", file, repo_type="dataset")
print(pdf)          # local path; open it at the passage's page_from

Run your own OCR

71% of our passages come from the PDFs' own text layers and 29% from our OCR. If you've got a better OCR model, the scans are all there. Pull one subject (or all 214 GB) and go:

from huggingface_hub import snapshot_download

folder = snapshot_download("SFRNai/survivor-library-pdfs", repo_type="dataset",
                           allow_patterns="library-smithing/*")

books.parquet tells you which books lean hardest on OCR (ocr_pages), which is where a better model pays off first. Keep book_id and file and your text lines up with everything here.

One warning from testing: vision-language OCR models read beautifully and then make things up, especially on dense multi-column pages, where they drop columns or loop on one line (see the comparison at the end of this card). Spot-check numbers against the scan before you trust a new transcription.

The vectors

• Model: BAAI/bge-small-en-v1.5, CLS pooling, L2-normalized, passages truncated at 320 tokens (a passage is about 250, so almost none were cut).
• Queries need the prefix Represent this sentence for searching relevant passages: . Passages were embedded without it. Skip the prefix and results get noticeably worse.
• Use the same model for your questions. A vector from any other model means nothing to this index.
• int8: each number is the normalized float × 127, rounded. To get floats back, divide by 127, then normalize again (rounding leaves the length around 0.95, not 1). If you only rank by cosine, dividing by the length is enough, as in the numpy example. It's a quarter the size of float32, and checked against fresh float32 vectors it keeps 94% of the same top-10 results.
• Checked against stock sentence-transformers: re-embedding 3,000 random passages with SentenceTransformer("BAAI/bge-small-en-v1.5") gives a cosine of 0.997 against the stored vectors. Your questions embedded the normal way line up with this index.
• Loading into a vector database (Qdrant, LanceDB, pgvector, Chroma, FAISS): take embedding, convert to float32, normalize, insert with id as the key.
• Two sets. The cleaned version's 1,223,741 changed passages were re-embedded with the same model, settings and int8 rounding (checked: re-embedding unchanged passages the same way gives 0.995 against the stored vectors, which is int8 rounding on both sides). Everything else keeps its original vector. The original version keeps every original vector. Ids are the same in both, so either index works with either database, but each pair matches its own text best.

Columns

passages (data/passages/*.parquet, and chunks in SQLite)

Column	Type	What it is
id	int64	Passage id, 1 to 7,430,945. Also the key in vectors.usearch
book_id	int32	The book (books.book_id; books.id in SQLite)
title	string	Book title (Parquet only; join books in SQLite)
category	string	Subject shelf, e.g. smithing, canning (Parquet only)
year	int16	Year from the file name; null when there isn't one (Parquet only)
page_from, page_to	int32	PDF pages the passage spans, counting from 1
how	string	text (the PDF's own text layer) or ocr (read from the scan)
text	string	The passage. In passages, with OCR misreadings corrected; in passages-original-deprecated, as first read
embedding	int8[384]	Its vector (Parquet only; vectors.usearch in SQLite)
fixes	int16	How many corrections the clean-up made in this passage (cleaned version only)

fixes (data/fixes.parquet, fixes in the cleaned SQLite)

Column	Type	What it is
passage_id	int64	The passage it was made in
book_id	int32	The book (Parquet only)
start, end	int32	Character span of the original text that was replaced, in the original passage
original	string	What the OCR had, e.g. tliat, firft, boi ler
fixed	string	What it became, e.g. that, first, boiler
rule	string	word (a misread word), join (a word split by a stray space or line-break hyphen), the (l'he → the)

The cleaned SQLite also has chunks_original (id, text): the original text of every passage the clean-up changed. So chunks is the cleaned text, and anything you want as first read is one join away.

books (data/books.parquet, books in SQLite)

Column	Type	What it is
book_id (id)	int32	Book id
title	string	Title: the PDF's own when usable, else from the file name
category	string	Subject shelf
year	int16	Year from the file name, or null
pages	int32	Pages in the PDF
passages	int32	Passages it yielded (0 for the 15 that wouldn't open)
text_pages, ocr_pages	int32	Pages read from the text layer vs OCR'd
size_bytes (size)	int64	PDF size
file	string	Path inside the Survivor Library, e.g. library-smithing/standard_blacksmithing_horseshoeing_and_wagon_making_1907.pdf

How it was built

1. Read. Every page's own text layer was kept when it looked like real text (enough letters, normal word lengths). Pages with none, or with an old scanner's garbage layer, were OCR'd with PP-OCR on a Jetson AGX Orin (TensorRT) plus CPU and DirectML workers on a PC, about 16 pages a second combined.
2. Cleaned. The long s (ſ) and ligatures spelled out, words hyphenated across lines joined, and OCR's "18o5" for "1805" put back (old-style figures make zeros look like o's).
3. Chunked. Pages split into passages of about 1,000 characters, at sentence ends. A passage runs on onto the next page but never across a gap. No overlap.
4. Embedded. bge-small-en-v1.5 on the Orin (TensorRT) with ONNX helpers, into a USearch HNSW index (connectivity 16, int8).
5. Cleaned again. A second, cautious pass corrected common OCR misreadings and re-embedded every passage it changed. That is the default version; see the next section.

The cleaned version

OCR leaves visible noise: "tliat" for that, "whieh" for which, "firft" for first (the old long s read as an f), "boi ler" for boiler. A reader skips over it, but full-text search can't: search "boiler" and you won't find "boi ler". The cleaned version corrects that kind of misreading and nothing else.

What it fixes

• Known OCR misreadings of a single word, letter shapes OCR confuses: li or ii for h, rn for m, e for c, n for u, the long s read as f, "i'" for r, and a few dozen more. Only the misreadings, never a guess from general spelling.
• Words split by a stray space or a line-break hyphen ("con- dition" → condition).
• Stray accents on plain English words ("thís" → this), and l'he → the.

How careful it is

• Only non-words are touched. A word in the dictionary, or common in this library, is never changed. So real old and technical words stay as printed: indorsement, skeps, tuyeres, muriate, usefulnesse.
• No digits, no names. Numbers are never touched, and capitalized words only when they are long and the correction is a common word ("Philadeiphia" → Philadelphia), never short names.
• Every fix must read fluently in place. The corrected word has to appear next to the same neighbouring words elsewhere in the library, on both sides, and fit them clearly better than the original or any other candidate. For short words the whole three-word phrase must appear elsewhere. About a million candidate fixes failed this test and were left alone.
• Nothing is lost. The original text of every changed passage, and every single fix with its position, are in this repo.
• Fresh vectors. Every changed passage was re-embedded with the same model and settings, so the vectors match the cleaned text.

What it did, measured

Corrections made	2,027,977 in 1,223,741 passages (16% of passages; about 1.8 per 1,000 words)
Kinds	1,716,126 misread words, 300,983 rejoined words, 10,868 l'he → the
Checked by hand	440 random fixes: 400 judged in context, 40 against the page scan
Correct	425 of 440 (96.6%)
Wrong, changing the meaning	8 of 440 (1.8%, 95% interval 0.9–3.5%), e.g. "hnuted" → hunted where the page says limited
Wrong, cosmetic	6 of 440, e.g. a capital letter where there shouldn't be one

In plain terms: it corrects about 1.96 million misreadings, and replaces about 37,000 garbled words with the wrong real word. That is roughly 0.03 new meaning errors per 1,000 words, against the 1.9 per 1,000 already in the text (see the comparison below). It is not perfect, which is why the original is kept and every fix is listed.

What it leaves alone. Most OCR noise is still there: misread numbers, garbled tables and indexes, columns read across instead of down, and words too damaged to recover with confidence. On the 41 passages from the comparison below, which we did not look at while building the rules, the clean-up made 9 changes, all correct, and changed nothing that was right. That removed about 1 in 7 of the visible errors there.

Things to know

• It's old advice. Some of it will hurt you: arsenic and mercury remedies, lead paint, no idea about germs in the early books, blasting and chemistry with no safety margin. Great for how things were done; check anything medical or dangerous against a modern source.
• OCR isn't perfect. About 29% of passages came from OCR (how = 'ocr'). Dense 1800s journals, tables and fancy type come out rougher. The cleaned version corrects the commonest misreadings, but much of the noise remains. Full-text search misses words the OCR misread; search by meaning is more forgiving. We measured accuracy against the scans; see the comparison at the end of this card.
• Years come from file names. Mostly right, sometimes not: "Basis of American History 1500-1900" (printed
  1904. is listed as 1500, and a rifle model number shows up as 2027. 1,074 books have no year at all.
• Rights. The library is overwhelmingly public domain (published before 1929 in the US). 742 books are dated after 1928 (73 Magazine, 1930s–60s manuals, US Army courses) and 1,074 have no date, mostly modern firearms owner's manuals. Some of those may still be under copyright. Want only the clear public-domain part? Filter on year <= 1928.
• Page numbers are PDF pages, not the numbers printed in the book. Covers and plates shift them.
• The PDFs live next door, in SFRNai/survivor-library-pdfs. file is each book's path in that repo, so a passage always leads back to its scan.

Comparison with amazingvince/survivor-library-text

Another transcription of the Survivor Library is available: amazingvince/survivor-library-text. We want to thank its author for caring enough to run OCR over the whole collection and to share the result freely, under CC0. Work like that is exactly what keeps a library like this alive, and we recommend that anyone working with this collection look at it too.

This dataset is independent of it. Our text was read from our own copy of the Survivor Library's PDFs (the same files published in SFRNai/survivor-library-pdfs), using each PDF's own text layer and our own PP-OCR pass. No text, file or metadata from that dataset, or from any copy of it, went into this one. We only downloaded it afterwards, to compare.

How the two differ

	This dataset	amazingvince/survivor-library-text
How the text was made	The PDF's own text layer where it is usable (about 62% of pages), PP-OCR for the rest	A vision-language OCR model over the page images (the model isn't named on its card; the output style suggests one)
Shape	7.4 million passages of about 1,000 characters, each with its PDF page numbers	One Markdown file per book (14,387 files, 8.6 GB), with <page_number> markers
Search	bge-small vectors, a USearch index and an FTS5 full-text index, ready to query	Text only; bring your own index
Metadata	Title, subject, year, page counts, OCR share, path to the scan	Subject folder and file name
Extras	Links every passage to its scan in the PDF repo	Written descriptions of pictures, tables kept as HTML tables
Coverage	13,763 books	About 13,970 distinct file names. About 12,800 are in both; it has about 1,200 we don't (mostly newer additions to the library, such as 1930s pamphlets and 1970s issues of 73 Magazine), and we have about 900 it doesn't
Processed	September–October 2026	July 2025

How we measured accuracy

1. Sample. 60 passages drawn at random (fixed seed) from books present in both datasets: 30 where our text came from the PDF's text layer and 30 where it came from our OCR. From each, a 90-word window at a random position.
2. Align. The same window was located in the other transcription by unique three-word anchors, then the two were compared word for word (punctuation and case ignored).
3. Adjudicate. Every word the two disagreed on was settled by reading the page image, rendered straight from the PDF. Each disagreement was scored meaning (a number, date, name or word changed, words added, or three or more words dropped) or cosmetic (visibly broken text a reader would catch: garbled letters, stray accents, split words). The review was AI-assisted with a fixed rubric, and a subset of calls was checked by hand against the scans.
4. Coverage. Separately, for 300 random books in both datasets, we measured how much of each side's text appears in the other (shared three-word runs, in both directions).

41 windows (3,690 words) aligned cleanly and were scored. One more was dropped because the alignment picked the wrong page. The other 18 could not be aligned because the passage wasn't in the other transcription; those are reported separately below.

Results

What the two kinds of error mean. A cosmetic error is text that is visibly broken: "deseriptive", "boi ler", "tó". A reader sees at once that it's wrong and can usually tell what was meant. Its real cost is search: a keyword search for "descriptive" won't find "deseriptive". A meaning error is a wrong word that looks right: 55 printed as 35, "narcotics" as "night sweats". Nothing on the page tells you it's wrong, so it gets believed and passed on. In a library of recipes, doses and measurements, that is the error that matters.

Errors per 1,000 words in the text as first read (passages-original-deprecated), with 95% bootstrap intervals over passages:

	This dataset	amazingvince/survivor-library-text
Meaning errors	1.9 (0.3–4.1)	29.3 (19.8–39.8)
Cosmetic errors	13.8 (6.2–23.6)	9.8 (6.0–14.1)
Passages with at least one meaning error	5 of 41	29 of 41

Another 3.5 per 1,000 words were places where both were wrong. The split by our source was almost identical: our text-layer half 2.1 vs 28.6, our OCR half 1.7 vs 30.0.

What this means. The vision-model text reads more smoothly and fixes letter noise that ours keeps. But it also substitutes plausible words and numbers that are not on the page, and those are hard to spot because the sentence still reads well. Examples, each checked against the scan:

The page says	Vision-model text	This dataset
"with the water at 55° F."	"35"	"55"
"particularly in the males"	"nudes"	"males"
"I tried all means, even narcotics"	"night sweats"	"narcotics"
"After eating heartily, he said he felt much better, and went to sleep"	"After eating hastily, he went to bed without sleeping"	as printed
"In 1810 … a bushel of bunches … one hundred and thirty gallons"	"1816 … a basket of bunches … four hundred and thirty gallons"	as printed

Dense pages. In the 18 passages that couldn't be aligned (14 from Scientific American; 10 indexes or tables), the other transcription never had the passage: it was missing in 15 and rewritten in 3, and that text covered a median of 3% of what is printed on the page, often repeating one line many times. Ours read 9 of those 18 correctly, got the right words but with columns interleaved in 8, and was garbled in 1 (a table of figures). In the 300-book coverage check, ordinary books matched closely both ways (77% and 75% shared runs, about equal length). Scientific American's four-column pages did not: the other transcription was about 30% shorter there and shared only 13% of our runs.

Where ours is weaker. Letter noise, columns read across instead of down on some index pages, and a few books (about 2 in 100 in the coverage sample) where our OCR missed most pages and the other transcription has far more text. Of our 7 meaning errors, most were numbers misread or dropped by our OCR, for example "Diagram No. 19" read as "No. I l".

Since then, we fixed some of ours. The numbers above are for the text as first read. After this comparison we ran the cautious clean-up described in The cleaned version, now the default. On these same 41 passages, which were held out while the rules were built, it made 9 corrections and all 9 were right ("Baromcter" → Barometer, "upwai'd" → upward, "Mercnry" → Mercury …). Cosmetic errors fell from 13.8 to 12.5 per 1,000 words, and 4 more misreadings that the scoring above hadn't counted were fixed too. It introduced no new errors there. Meaning errors stay at 1.9 per 1,000, because most of ours are in numbers, and the clean-up never touches numbers. Across the whole library, the review of 440 random fixes puts the clean-up's own wrong-word rate at about 0.03 per 1,000 words.

Which to use

• For search, citations and anything where a number matters (doses, measurements, dates, quantities), use this dataset (the cleaned default) and check the scan for anything critical.
• For reading, picture descriptions, tables, or the roughly 1,200 books only it has, the other transcription is a good resource.
• Both are free. Use both, and compare them against the scans.

Limits of this study. 60 passages is a small sample, and the intervals above are wide. Adjudication was AI-assisted, with hand checks on a subset. Results are for the July 2025 version of that dataset.

License

The index, vectors and database here are CC0. Do whatever you want with them. The underlying texts are as described under Rights.