Practical notes: Local LLMs for Graph RAG Extraction: The Mid-2026 Re-Benchmark

The following notes reconstruct a practical path around “Local LLMs for Graph RAG Extraction: The Mid-2026 Re-Benchmark”. Emphasis stays on contracts, checks, and drop-in code placeholders rather than motivational framing.

Five months later, you re-ran everything — and the famous “7B floor” turned out to be a decoding artifact.

When working through the Five months later you stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

The claim you wanted to break

When working through the The claim you wanted stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Prefer small, testable units over sprawling scripts. When a step fails, the failure should point at a single responsibility rather than a tangled pipeline. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

It did

When working through the It did stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

  Phi-4-mini 3.8B                  Parse-OK rate   Strict schema-valid
 -------------------------------- --------------- ---------------------
  Unconstrained, open extraction   22%             0%
  Unconstrained, schema-guided     33%             0%
  Constrained, open extraction     100%            100%
  Constrained, schema-guided       100%            100%

The trap nobody warned me about: thinking mode eats structured output

When working through the The trap nobody warned stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn.

  Qwen3.5-4B, schema-guided        Parse-OK   Output tokens/doc   Median latency
 --------------------------------- ---------- ------------------- ----------------
  Thinking default, unconstrained   33%        10,142              94.0s
  Thinking on, constrained          0%         649                 6.3s
  Thinking off, constrained         100%       599                 5.8s

Constraints don’t just fix validity — they fix behavior

When working through the Constraints don t just stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Cache stable system instructions and tool schemas. Re-sending identical preamble is a common source of burn. When working through the Constraints don t just stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Prefer small, testable units over sprawling scripts. When a step fails, the failure should point at a single responsibility rather than a tangled pipeline.

The money table

The The money table stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion. Budget tokens per turn and per session. Agentic tools expand context aggressively; hard caps keep demos from becoming surprise invoices.

  Model                    med s/doc   tok/s   hrs/1k docs   local electricity   hosted-small API    frontier API
 ------------------------ ----------- ------- ------------- ------------------- ------------------- --------------
  Qwen3.5-4B (think off)   5.8         123     1.6           $0.17               $0.08               $9.73
  Qwen3.5-9B (think off)   6.3         91      1.8           $0.18               $0.08               $8.72
  Gemma 4 E4B              6.6         106     1.8           $0.19               $0.08               $9.75
  Gemma 3 12B              8.4         79      2.3           $0.25               $0.08               $9.34
  Mistral Small 3.2        13.6        52      3.8           $0.40               $0.14               $11.81
  Phi-4-mini 3.8B          10.0        219     2.8           $0.29               $0.06               $6.28

Honest scope, and what’s next

The Honest scope and what stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments. Budget tokens per turn and per session. Agentic tools expand context aggressively; hard caps keep demos from becoming surprise invoices.

What actually works, mid-2026 edition

The What actually works mid-2026 stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Keep configuration outside application code. Environment files, secret stores, and feature flags belong in one place operators can audit without reading the whole graph. Budget tokens per turn and per session. Agentic tools expand context aggressively; hard caps keep demos from becoming surprise invoices. The What actually works mid-2026 stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Prefer small, testable units over sprawling scripts. When a step fails, the failure should point at a single responsibility rather than a tangled pipeline.

References

For the References stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Treat this stage as a contract between inputs and validated outputs. Name the artifacts, define success checks, and refuse silent partial completion. Prefer structured outputs with schema validation over free-form prose when the next step is code or a tool call.

Operational checklist

For the Operational checklist stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state.

Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish.

Prefer structured outputs with schema validation over free-form prose when the next step is code or a tool call.

Measure recall on a fixed question set before tuning prompts. Prompt churn rarely fixes a weak retrieval surface.

Freeze a golden set before changing prompts or models. Moving both the system and the yardstick hides regressions.

Add a smoke test that exercises the critical path in CI with fixtures, not live paid APIs, whenever budgets allow.

Before promoting the stack, freeze versions, capture a golden transcript for the critical path, and confirm rollback steps. Shared environments need rate limits, tenancy checks, and a clear owner for secret rotation. Prefer boring reliability over clever one-off demos.

Batch note for 5f36b3d19383: keep provider keys out of the repo, set a per-session token ceiling, and store transcripts next to the eval fixtures so later model swaps stay comparable.

The hardening note 0 stage works best when treated as a measurable surface. Capture one golden transcript, one failure case, and the rollback note before expanding scope. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish.

Hardening detail 0/773: measure wall time, error class, and token spend for this note, then decide whether to keep the change based on a fixed question set rather than anecdote.

For the hardening note 0 stage, define the inputs, the owner of the step, and the exit criteria before changing code. Operators should be able to re-run the step from a known checkpoint without guessing hidden state. Record timings and token or query cost next to functional results. Cost visibility early prevents surprise bills when the path moves from demo to shared environments.

Hardening detail 0/792: measure wall time, error class, and token spend for this note, then decide whether to keep the change based on a fixed question set rather than anecdote.

When working through the hardening note 1 stage, write down the contract first: required inputs, success signal, and what happens on partial failure. That checklist keeps later code changes honest. Document the happy path and the recovery path together. Retries, human gates, and dead-letter handling are part of the product, not later polish.

Hardening detail 1/792: measure wall time, error class, and token spend for this note, then decide whether to keep the change based on a fixed question set rather than anecdote.