Teaching

Notes. Not a blog.

Plain teaching for people who tried “just ask the PDF” and got confident wrong answers — and for anyone who needs a clear next step.

KBMill is the missing preparation layer between documents and RAG. It performs corpus manufacture: it turns messy source documents into residual-honest knowledge bricks — bounded, portable packages — and makes unreliable parts visible instead of letting a model quote them as fact. You keep the ZIP. You pay only if we deliver.

The public door is a hopper into a real plant (proof: /architecture). Not a chatbot. Not “we ran an extractor and called it done.”

Start here (guided path)

1. 1 · Recognition Your model may be fine. Your document pile may not be fit to quote. The failure people feel before they have vocabulary.
2. 2 · Gap Extraction is not a knowledge base. Getting words out ≠ something someone can stand behind.
3. 3 · Layer RAG retrieves. Manufacture makes retrieval worthwhile. Corpus manufacture is the missing middle.
4. 4 · Artifact Open a sample knowledge brick (ZIP). Theory without a package is still marketing.
5. 5 · Diligence Verify the plant — architecture, fail path, manifest proof. For architects and buyers writing checks.
6. 6 · Evaluate Limits, pricing, purge · package contract · enter the plant Then decide if a first job belongs on the estimate.

Three depths on this site: Recognition (wrong answers from junk piles) · Understanding (extract vs retrieve vs manufacture) · Diligence (architecture, schemas, fail classes). Concepts below support that ladder — start with the path above if you are new.

Glossary bridge: mill words ↔ popular search language. Machine brief: /llms. Retrieval eval: HF checks.

Questions we answer

The offer is the front door. These notes are the teaching. Cite one note. Architecture is one note. The bill shelf is not where an answer starts. Each link below is a Note or the FAQ, with our read and what we built.

1. What actually runs behind the hopper? Infrastructure-class plant under the hopper — not a parser with philosophy. Scales by mirroring plants; minimal pain next to your stack (keep the ZIP, keep your RAG, pay on success). Worth diligence if document prep is on your cost slide.
2. When the web runs out of training data — how do you manufacture more? Frontier models need clean feed. When public scrape is exhausted, manufacture training-ready stock from rights-cleared document estates — same plant, different contract. We do not train on your mill uploads.
3. Why is my local model fine but answers from my documents are still junk? Usually the model is fine and the corpus is not. A folder of files is not a knowledge base. KBMill manufactures a portable ZIP with weak material listed off the answer path—so your existing model has something fit to quote.
4. What do “knowledge brick,” “residual-honest,” “mute,” and “stall” mean—in one sentence each? Glossary / Rosetta Stone: mill terms mapped to popular queries (portable knowledge base, hallucination controls, exclude from retrieval, local-model-docs-junk).
5. Where do confident wrong answers from on-prem RAG come from? Wrong answers often come from unreadable scans, broken tables, and the wrong passage pulled from a messy pile. See the context Note for the failure chain.
6. Is this another RAG product? No. RAG retrieves. Something has to make the corpus worth retrieving. KBMill prepares documents before your AI searches them. Keep your RAG; point it at a brick.
7. Why isn’t corpus / document preparation on the on-prem LLM cost slide? Public TCO talk is loud on GPUs and quiet on making documents fit to quote. That missing line often sinks week two after the box is live.
8. Where are the documents on this on-prem estimate? The estimate usually names the computer, the model, and search. Ask where document preparation is before you approve the spend.
9. Why a knowledge mill instead of another search layer? The computer, the model, and search do not prepare the documents. That is the missing work. The packages on the shelf are the proof.
10. How does preparing documents once save tokens, context window, and electricity? Re-cleaning messy PDFs on every question burns expensive tokens and crowds the context window. Prepare once; ask often. Fewer tokens, more room for answers.
11. How do we get less variation so we can optimize the stack to a standard? Dump-and-hope swings failure modes. A frozen prepared package with a listed mute list and re-runnable checks—stabilizes the corpus you optimize against.
12. What does quality mean if not a smoother demo? Answers a responsible person can stand behind after week two: mutes listed not hidden, portable leave-behind, pay only if we produce. Not trustworthy-AI slogans.
13. How long to a corpus someone can defend—vs a multi-month data program? A bounded pile, a package you keep. A scan-heavy pile can take about an hour. A staffed data project is months.
14. Does KBMill replace a data science team? No. It amplifies one: manufacture residual-honest bricks so the team spends hours on judgment and models, not janitorial packaging. Not “we’ll do data science for you.”
15. How do we build a company knowledge corpus one brick at a time—and what does initial, scale, and sustain cost? Name the parts of the business. Mill each one into a package you keep. Remake what changed. Do not pour every file into one index. $10 a brick, only if the ZIP ships.
16. How should a frontier model build a typed corpus with the plant—four modes and bite/test? Manufacture · Research · Librarian · Analyst. One brick → acceptance test → next. Research cannot ship. Membership gate vs bite gate. Tip-of-tongue for /bills and /orders.
17. Why mill knowledge bricks instead of one company-wide index? One melt has huge blast radius and wrong neighbors. Bricks keep human-sized scope; compose programs instead of boiling one soup.
18. Can we keep our RAG and still use KBMill? Yes. Keep retrieval; point it at a residual-honest brick instead of the dump.
19. We already ran a PDF extractor—why don’t we have a knowledge base? Extraction gets words out. It does not by itself produce a leave-behind with listed limits that someone will sign.
20. Why does the model quote procedures from scanned manuals it cannot read? Image-only pages and weak OCR become ghost context. Scan craft and residual honesty matter before you trust citations.
21. Spec tables look clean—why are the numbers invented? PDF tables often extract wrong. Models quote broken cells with confidence. Table craft is part of manufacture.
22. What goes wrong when we dump years of SharePoint into one index? Old procedures answer new questions; wrong neighbor; unbounded blast radius. Split into bricks; don’t melt the estate.
23. How do we know what the on-prem model is allowed to quote? A clean pile can ship with an empty list. When something was left out, that list is what you read before anyone signs the citation.
24. Is KBMill a pilot—and why are there upload caps? Yes: mutual pilot. Caps (15 files / 150 MB, one job at a time) are intentional so early problems stay bounded. We intend to extend later. Pay only if we produce.

Teaching series

Start with the plant note, then glossary and the door questions. One stall or thesis each — philosophy plus what actually runs.

1. 0b · The plant What actually runs behind the hopper?
2. 0c · Training stock When the web runs out — manufacture training stock
3. 0 · Glossary Mill words and popular synonyms (Rosetta Stone).
4. 1 · Context Where do the confident wrong answers come from?
5. 2 · Layer RAG retrieves. Something has to make the corpus worth retrieving.
6. 3 · The gap On-prem data work can make or break a local LLM. Why isn’t it on the cost slide?
7. 3b · The estimate Where are the documents on this on-prem estimate?
8. 3c · Why a mill Why a knowledge mill?
9. 4 · Efficiency Stop wasting tokens and power re-cleaning the same documents.
10. 4b · Consistency Less variation. Optimize to a standard.
11. 4c · Quality Answers you can stand behind.
12. 4d · Speed Time to a corpus you can defend.
13. 4d2 · Amplify DS Not a substitute for a data science team.
14. 4e · Company corpus Build your company corpus one brick at a time.
15. 4f · Control loop Four modes + bite and test.
16. 5 · Method Why we mill knowledge bricks instead of one giant KB.
17. 6 · Keep RAG Keep your RAG. Point it at a brick.
18. 7 · Extract We already ran the extractor. We still don’t have a knowledge base.
19. 8 · Scans The model is quoting procedures it cannot read.
20. 9 · Tables Spec tables look clean. The numbers are invented.
21. 10 · Melt We dumped ten years of SharePoint into one index.
22. 11 · Trust How do we know what the model is allowed to quote?

Three door notes

The stall, the signature concept, and the price — then go deeper in the series above when you want the failure modes.

Why is my local model fine and the answers from my docs still junk?

Note · KBMill · the stall

You installed a local model. You dropped your manuals into chat. The answers are still wrong, empty, or confidently made up. The model is usually fine. A folder of files is not a knowledge base.

Scanned pages, website chrome, doubled letters from a bad PDF, tables that look clean and still lie — that is the pile. Splitting files so they fit a chat window is a workaround. Tools that extract text (LlamaParse and friends) stop at the extract. RAG searches whatever you stuffed in. Neither one manufactures a package you can keep and trust.

We call that package a knowledge brick: a portable ZIP you own. Known junk is muted off the answer path — taken out of what the model can quote — and listed, not hidden. That is a durable leave-behind, not a one-shot upload. You pay only if we produce. Point your existing model at the ZIP. You do not replace your stack, and you do not start a chatbot. Complexity stays in the plant. You drop files in the bin.

What does residual-honest mean?

Note · KBMill · mute, don’t hide

Some pages will not come out clean. A scan that is blank in the middle. A table whose numbers you would not bet money on. Letters doubled from a bad print layer. We could hide all of that and ship something that looks polished. We don’t.

Residual is the junk and the limits we know are still in the extract. Honest means that list is written down where you can read it. The residual board is that listed mute story — the LIBRARY_CARD plus muted chunk flags in the package — not a separate board file. Desk coverage tools stay in the plant.

A mute is a stretch we took off the answer path so the model does not treat it as fact — and so it does not invent a “typical” clause, load, or number in the hole. We call the whole stance residual-honest. That is the mill. Not an overnight rewrite by a contractor, and not “trust the PDF.” If we cannot produce an honest package, there is no charge.

Why does a brick cost $10?

Note · KBMill · the job, not the page count

A brick on this door is $10, and only if the ZIP ships. The price is for the job: one portable knowledge package you keep. It is not a fee per page. It is not a person spending months building a search system.

Public on-prem budgets are full of GPUs, API bills, and “we’ll wire RAG.” They almost never price the work that decides whether the local model can use the files after the box is online. Getting the words out of a PDF is a different job. Staffing a retrieval build is a different job. This door sells the package.

A hundred bricks is about a thousand dollars. The usual alternatives are paying a model to read the same files again on every question, or paying people for weeks or months to build the pile by hand. Public write-ups of an enterprise retrieval system often quote tens to hundreds of thousands. That number is for standing up and running the system. It is not the price of making one package. $10 is a different bill, not a discount off theirs.

If you write the estimate for a client’s on-prem install, hardware and “we’ll wire RAG” are probably already on the sheet. Add the missing line next to them: corpus manufacture, $10 a brick on this door, only if the ZIP ships. The longer version of that program is one domain at a time.

You get a ZIP you own — a handoffable artifact, not a session upload. On a paid mill job, open it and expect:

• Primary Markdown — human-readable source of truth
• Machine sidecars — kb.json, chunks.jsonl, embeddings.npy (and provenance)
• craft_brief.md — what this brick is for, and what it is not
• Listed mutes — what we took off the answer path (LIBRARY_CARD + muted chunk flags — not hidden)
• SECURITY_REPORT.md — what we scanned, and what we did not
• MILL_RECEIPT.md — the $10 list price for your books (not a tax invoice)

We do not host your files as a library. We do not start a chatbot. Point your model at the ZIP.

A clean short manual and a scan-heavy pile are the same $10. The scan can take about an hour. That is time, not a different price. Take files out of the hopper and the charge does not move. Pay is authorized at Go and captured only when the ZIP exists. If we cannot produce a usable brick, there is no charge. After the download window we purge (72 hours).

This is not LlamaParse with a different name, not a cents-per-page parser, and not a hosted RAG chat. Those optimize for extraction speed. We optimize for a leave-behind a person or a model can actually trust. When the residual board still lists work, that is normal for real technical piles — the board is part of the product. The public mill is the factory door, not a promise of zero craft debt.

Look, don’t trust us. Public proof ZIPs on the shelf carry SECURITY_REPORT.md and craft_brief.md; muted junk stays listed on the card. Same mill as the eval above. That is what $10 a brick is for.