Hello!
As a handsome local AI enjoyer™ you’ve probably noticed one of the big flaws with LLMs:
It lies. Confidently. ALL THE TIME.
(Technically, it “bullshits” - https://link.springer.com/article/10.1007/s10676-024-09775-5
I’m autistic and extremely allergic to vibes-based tooling, so … I built a thing. Maybe it’s useful to you too.
The thing: llama-conductor
llama-conductor is a router that sits between your frontend (OWUI / SillyTavern / LibreChat / etc) and your backend (llama.cpp + llama-swap, or any OpenAI-compatible endpoint). Local-first (because fuck big AI), but it should talk to anything OpenAI-compatible if you point it there (note: experimental so YMMV).
I tried to make a glass-box that makes the stack behave like a deterministic system, instead of a drunk telling a story about the fish that got away.
TL;DR: “In God we trust. All others must bring data.”
Three examples:
1) KB mechanics that don’t suck (1990s engineering: markdown, JSON, checksums)
You keep “knowledge” as dumb folders on disk. Drop docs (.txt, .md, .pdf) in them. Then:
>>attach <kb>— attaches a KB folder>>summ new— generatesSUMM_*.mdfiles with SHA-256 provenance baked in- `>> moves the original to a sub-folder
Now, when you ask something like:
“yo, what did the Commodore C64 retail for in 1982?”
…it answers from the attached KBs only. If the fact isn’t there, it tells you - explicitly - instead of winging it. Eg:
The provided facts state the Commodore 64 launched at $595 and was reduced to $250, but do not specify a 1982 retail price. The Amiga’s pricing and timeline are also not detailed in the given facts.
Missing information includes the exact 1982 retail price for Commodore’s product line and which specific model(s) were sold then. The answer assumes the C64 is the intended product but cannot confirm this from the facts.
Confidence: medium | Source: Mixed
No vibes. No “well probably…”. Just: here’s what’s in your docs, here’s what’s missing, don’t GIGO yourself into stupid.
And when you’re happy with your summaries, you can:
>>move to vault— promote those SUMMs into Qdrant for the heavy mode.
2) Mentats: proof-or-refusal mode (Vault-only)
Mentats is the “deep think” pipeline against your curated sources. It’s enforced isolation:
- no chat history
- no filesystem KBs
- no Vodka
- Vault-only grounding (Qdrant)
It runs triple-pass (thinker → critic → thinker). It’s slow on purpose. You can audit it. And if the Vault has nothing relevant? It refuses and tells you to go pound sand:
FINAL_ANSWER:
The provided facts do not contain information about the Acorn computer or its 1995 sale price.
Sources: Vault
FACTS_USED: NONE
[ZARDOZ HATH SPOKEN]
Also yes, it writes a mentats_debug.log, because of course it does. Go look at it any time you want.
The flow is basically: Attach KBs → SUMM → Move to Vault → Mentats. No mystery meat. No “trust me bro, embeddings.”
3) Vodka: deterministic memory on a potato budget
Local LLMs have two classic problems: goldfish memory + context bloat that murders your VRAM.
Vodka fixes both without extra model compute. (Yes, I used the power of JSON files to hack the planet instead of buying more VRAM from NVIDIA).
!!stores facts verbatim (JSON on disk)??recalls them verbatim (TTL + touch limits so memory doesn’t become landfill)- CTC (Cut The Crap) hard-caps context (last N messages + char cap) so you don’t get VRAM spikes after 400 messages
So instead of:
“Remember my server is 203.0.113.42” → “Got it!” → [100 msgs later] → “127.0.0.1 🥰”
you get:
!! my server is 203.0.113.42?? server ip→ 203.0.113.42 (with TTL/touch metadata)
And because context stays bounded: stable KV cache, stable speed, your potato PC stops crying.
There’s more (a lot more) in the README, but I’ve already over-autism’ed this post.
TL;DR:
If you want your local LLM to shut up when it doesn’t know and show receipts when it does, come poke it:
- Primary (Codeberg): https://codeberg.org/BobbyLLM/llama-conductor
- Mirror (GitHub): https://github.com/BobbyLLM/llama-conductor
PS: Sorry about the AI slop image. I can’t draw for shit.
PPS: A human with ASD wrote this using Notepad++. If it the formatting is weird, now you know why.
Holy shit I’m glad to be on the autistic side of the internet.
Thank you for proving that fucking JSON text files are all you need and not “just a couple billion more parameters bro”
Awesome work, all the kudos.
Thanks. It’s not perfect but I hope it’s a step in a useful direction
Very cool. Starred.
I strongly feel that the best way to improve the useability of LLMs is through better human-written tooling/software. Unfortunately most of the people promoting LLMs are tools themselves and all their software is vibe-coded.
Thank you for this. I will test it on my local install this weekend.
You’re welcome. Hope its of some use to.you
This sounds really interesting, I’m looking forward to reading the comments here in detail and looking at the project, might even end up incorporating it into my own!
I’m working on something that addresses the same problem in a different way, the problem of constraining or delineating the specifically non-deterministic behavior one wants to involve in a complex workflow. Your approach is interesting and has a lot of conceptual overlap with mine, regarding things like strictly defining compliance criteria and rejecting noncompliant outputs, and chaining discrete steps into a packaged kind of “super step” that integrates non-deterministic substeps into a somewhat more deterministic output, etc.
How involved was it to build it to comply with the OpenAI API format? I haven’t looked into that myself but may.
Cheers!
Re: OpenAI API format: 3.6 - not great, not terrible :)
In practice I only had to implement a thin subset: POST /v1/chat/completions + GET /v1/models (most UIs just need those). The payload is basically {model, messages, temperature, stream…} and you return a choices[] with an assistant message. The annoying bits are the edge cases: streaming/SSE if you want it, matching the error shapes UIs expect, and being consistent about model IDs so clients don’t scream “model not found”. Which is actually a bug I still need to squash some more for OWUI 0.7.2. It likes to have its little conniptions.
But TL;DR: more plumbing than rocket science. The real pain was sitting down with pen and paper and drawing what went where and what wasn’t allowed to do what. Because I knew I’d eventually fuck something up (I did, many times), I needed a thing that told me “no, that’s not what this is designed to do. Do not pass go. Do not collect $200”.
shrug I tried.
The very hardest part of designing software, and especially designing abstractions that aim to streamline use of other tools, is deciding exactly where you draw the line(s) between intended flexibility (user should be able and find it easy to do what they want), and opinionated “do it my way here, and I’ll constrain options for doing otherwise”.
You have very clear and thoughtful lines drawn here, about where the flexibility starts and ends, and where the opinionated “this is the point of the package/approach, so do it this way” parts are, too.
Sincerely that’s a big compliment and something I see as a strong signal about your software design instincts. Well done! (I haven’t played with it yet, to be clear, lol)
Thank you for saying that and for noticing it! Seeing you were kind enough to say that, I’d like to say a few things about how/why I made this stupid thing. It might be of interest to people. Or not LOL.
To begin with, when I say I’m not a coder, I really mean it. It’s not false modesty. I taught myself this much over the course of a year and the reactivation of some very old skills (30 years hence). When I decided to do this, it wasn’t from any school of thought or design principle. I don’t know how CS professionals build things. The last time I looked at an IDE was Turbo Pascal. (Yes, I’m that many years old. I think it probably shows, what with the >> ?? !! ## all over the place. I stopped IT-ing when Pascal, Amiga and BBS were still the hot new things)
What I do know is - what was the problem I was trying to solve?
IF the following are true;
- I have ASD. If you tell me a thing, I assume your telling me a thing. I don’t assume you’re telling me one thing but mean something else.
- A LLM could “lie” to me, and I would believe it, because I’m not a subject matter expert on the thing (usually). Also see point 1.
- I want to believe it, because why would a tool say X but mean Y? See point 1.
- A LLM could lie to me in a way that is undetectable, because I have no idea what it’s reasoning over, how it’s reasoning over it. It’s literally a black box. I ask a Question—>MAGIC WIRES---->Answer.
AND
- “The first principle is that you must not fool yourself and you are the easiest person to fool”
THEN
STOP.
I’m fucked. This problem is unsolvable.
Assuming LLMs are inherently hallucinatory within bounds (AFAIK, the current iterations all are), if there’s even a 1% chance that it will fuck me over (it has), then for my own sanity, I have to assume that such an outcome is a mathematical certainty. I cannot operate in this environment.
PROBLEM: How do I interact with a system that is dangerously mimetic and dangerously opaque? What levers can I pull? Or do I just need to walk away?
- Unchangeable. Eat shit, BobbyLLM. Ok.
- I can do something about that…or at least, I can verify what’s being said, if the process isn’t too mentally taxing. Hmm. How?
- Fine, I want to believe it…but, do I have to believe it blindly? How about a defensive position - “Trust but verify”?. Hmm. How?
- Why does it HAVE to be opaque? If I build it, why do I have to hide the workings? I want to know how it works, breaks, and what it can do.
Everything else flowed from those ideas. I actually came up with a design document (list of invariants). It’s about 1200 words or so, and unashamedly inspired by Asimov :)
MoA / Llama-swap System
System Invariants
0. What an invariant is (binding)
An invariant is a rule that:
- Must always hold, regardless of refactor, feature, or model choice
- Must not be violated temporarily, even internally. The system must not fuck me over silently.
- Overrides convenience, performance, and cleverness.
If a feature conflicts with an invariant, the feature is wrong. Do not add.
1. Global system invariant rules:
1.1 Determinism over cleverness
-
Given the same inputs and state, the system must behave predictably.
-
No component may:
- infer hidden intent,
- rely on emergent LLM behavior
- or silently adapt across turns without explicit user action.
1.2 Explicit beats implicit
-
Any influence on an answer must be inspectable and user-controllable.
-
This includes:
- memory,
- retrieval,
- reasoning mode,
- style transformation.
If something affects the output, the user must be able to:
- enable it,
- disable it,
- and see that it ran.
Assume system is going to lie. Make its lies loud and obvious.
On and on it drones LOL. I spent a good 4-5 months just revising a tighter and tighter series of constraints, so that 1) it would be less likely to break 2) if it did break, it do in a loud, obvious way.
What you see on the repo is the best I could do, with what I had.
I hope it’s something and I didn’t GIGO myself into stupid. But no promises :)
I’m probably going to give this a try, but I think you should make it clearer for those who aren’t going to dig through the code that it’s still LLMs all the way down and can still have issues - it’s just there are LLMs double-checking other LLMs work to try to find those issues. There are still no guarantees since it’s still all LLMs.
I haven’t tried this tool specifically, but I do on occasion ask both Gemini and ChatGPT’s search-connected models to cite sources when claiming stuff and it doesn’t seem to even slightly stop them bullshitting and claiming a source says something that it doesn’t.
Yeah, this is different. Try it. It gives you cryptogenic key to the source (which you must provide yourself: please be aware. GIGO).
How does having a key solve anything? Its not that the source doesn’t exist, it’s that the source says something different to the LLM’s interpretation of it.
Yeah.
The SHA isn’t there to make the model smarter. It’s there to make the source immutable and auditable.
Having been burnt by LLMs (far too many times), I now start from a position of “fuck you, prove it”.
The hash proves which bytes the answer was grounded in, should I ever want to check it. If the model misreads or misinterprets, you can point to the source and say “the mistake is here, not in my memory of what the source was.”.
If it does that more than twice, straight in the bin. I have zero chill any more.
Secondly, drift detection. If someone edits or swaps a file later, the hash changes. That means yesterday’s answer can’t silently pretend it came from today’s document. I doubt my kids are going to sneak in and change the historical prices of 8 bit computers (well, the big one might…she’s dead keen on being a hacker) but I wanted to be sure no one and no-thing was fucking with me.
Finally, you (or someone else) can re-run the same question against the same hashed inputs and see if the system behaves the same way.
So: the hashes don’t fix hallucinations (I don’t even think that’s possible, even with magic). The hashes make it possible to audit the answer and spot why hallucinations might have happened.
PS: You’re right that interpretation errors still exist. That’s why Mentats does the triple-pass and why the system clearly flags “missing / unsupported” instead of filling gaps. The SHA is there to make the pipeline inspectable, instead of “trust me, bro.”.
Guess what? I don’t trust you. Prove it or GTFO.
The hash proves which bytes the answer was grounded in, should I ever want to check it. If the model misreads or misinterprets, you can point to the source and say “the mistake is here, not in my memory of what the source was.”.
Eh. This reads very much like your headline is massively over-promising clickbait. If your fix for an LLM bullshitting is that you have to check all its sources then you haven’t fixed LLM bullshitting
If it does that more than twice, straight in the bin. I have zero chill any more.
That’s… not how any of this works…
Fair point on setting expectations, but this isn’t just LLMs checking LLMs. The important parts are non-LLM constraints.
The model never gets to “decide what’s true.” In KB mode it can only answer from attached files. Don’t feed it shit and it won’t say shit.
In Mentats mode it can only answer from the Vault. If retrieval returns nothing, the system forces a refusal. That’s enforced by the router, not by another model.
The triple-pass (thinker → critic → thinker) is just for internal consistency and formatting. The grounding, provenance, and refusal logic live outside the LLM.
So yeah, no absolute guarantees (nothing in this space has those), but the failure mode is “I don’t know / not in my sources, get fucked” not “confidently invented gibberish.”
Voodoo is not magic btw, it was sullied by colonists
Damn Englishmen. With their…ways.
I think this was was done by France, not better though
Ok, but can we just blame the English anyway?
As someone of Haitian descent, no; the French get hardly enough blame, as it is.
Always
wym?
This is very cool. Will dig into it a bit more later but do you have any data on how much it reduces hallucinations or mistakes? I’m sure that’s not easy to come by but figured I would ask. And would this prevent you from still using the built-in web search in OWUI to augment the context if desired?
Comment removed by (auto-mod?) cause I said sexy bot. Weird.
Restating again: On the stuff you use the pipeline/s on? About 85-90% in my tests. Just don’t GIGO (Garbage in, Garbage Out) your source docs…and don’t use a dumb LLM. That’s why I recommend Qwen3-4 2507 Instruct. It does what you tell it to (even the abilterated one I use).
This is so cool to read about, thx for doing what you and pls keep doing it! We need high quality and trustworthy information now more than ever I think. Damn nzs spewing their propaganda everywhere and radicalising the vulnerable. Thanks!
abilterated one
Please elaborate, that alone piqued my curiosity. Pardon me if I couldve searched
Yes of course.
Abliterated is a technical LLM term meaning “safety refusals removed”.
Basically, abliteration removes the security theatre that gets baked into LLM like chatGPT.
I don’t like my tools deciding for me what I can and cannot do with them.
I decide.
Anyway, the model I use has been modified with a newer, less lobotomy inducing version of abliteration (which previously was a risk).
https://huggingface.co/DavidAU/Qwen3-4B-Hivemind-Instruct-NEO-MAX-Imatrix-GGUF/tree/main
According to validation I’ve seen online (and of course, I tested it myself), it’s lost next to zero “IQ” and dropped refusals by about…90%.
BEFORE: Initial refusals: 99/100
AFTER: Refusals: 8/100 [lower is better], KL divergence: 0.02 (less than 1 is great, “0” is perfect.)
In fact, in some domains it’s actually a touch smarter, because it doesn’t try to give you “perfect” model answers. Maths reasoning for example, where the answer is basically impossible, it will say “the answer is impossible. Here’s the nearest workable solution based on context” instead of getting stuck in a self-reinforcing loop, trying to please you, and then crashing.
In theory, that means you could ask it for directions on how to cook Meth and it would tell you.
I’m fairly certain the devs didn’t add the instructions for that in there, but if they did, the LLM won’t “sorry, I can’t tell you, Dave”.
Bonus: with my harness over the top, you’d have an even better idea if it was full of shit (it probably would be, because, again, I’m pretty sure they don’t train LLM on Breaking Bad).
Extra double bonus: If you fed it exact instructions for cooking meth, using the methods I outlined? It will tell you exactly how to cook Meth, 100% of the time.
Say…you…uh…wanna cook some meth? :P
PS: if you’re more of a visual learner, this might be a better explanation
Thank you again for your explainations. After being washed up with everything AI, I’m genuinely excited to set this up. I know what I’m doing today! I will surely be back
Please enjoy. Make sure you use >>FR mode at least once. You probably won’t like the seed quotes but maybe just maybe you might and I’ll be able to hear the “ha” from here.
Removed by mod
This seems astonishingly more useful than the current paradigm, this is genuinely incredible!
I mean, fellow Autist here, so I guess I am also… biased towards… facts…
But anyway, … I am currently uh, running on Bazzite.
I have been using Alpaca so far, and have been successfully running Qwen3 8B through it… your system would address a lot of problems I have had to figurr out my own workarounds for.
I am guessing this is not available as a flatpak, lol.
I would feel terrible to ask you to do anything more after all of this work, but if anyone does actually set up a podman installable container for this that actually properly grabs all required dependencies, please let me know!
No promises, but if I end up running this it will be by putting it in a container. If I do, then I’ll put a PR on Codeberg with a Docker Compose file (compatible with Podman on Bazzite).
Huzzah!
Cheers for that!
Indeed. And have you heard? That makes the normies think were clankers (bots). How delightful.
Re: the Linux stuff…please, if someone can do that, please do. I have no idea how to do that. I can figure it out but making it into a “one click install” git command took several years off my life.
Believe it or not, I’m not actually a IT / CS guy. My brain just decided to latch onto this problem one day 6 months ago and do an autism.
I’m 47 and I still haven’t learned how to operate this vehicle…and my steering is getting worse, not better, with age.
Oh I entirely believe you.
Hell hath no wrath like an annoyed high functioning autist.
I’ve … had my own 6 month black out periods where I came up with something extremely comprehensive and ‘neat’ before.
Seriously, bootstrapping all this is incredibly impressive.
I would… hope that you can find collaborators, to keep this thing alive in the event you get into a car accident (metaphorical or literal), or, you know, are completely burnt out after this.
… but yeah, it is… yet another immensely ironic aspect of being autistic that we’ve been treated and maligned as robots our whole lives, and then when the normies think they’ve actually built the AI from sci fi, no, turns out its basically extremely talented at making up bullshit and fudging the details and being a hypocrite, which… appalls the normies when they have to look into a hyperpowered mirror of themselves.
And then, of course, to actually fix this, its some random autist no one has ever heard of (apologies if you are famous and i am unaware of this), who is putting in an enormous of effort, that… most likely, will not be widely recognized.
… fucking normies man.
Not famous, no :)
I hear you, brother. Normally, my hyperfocus is BJJ (I’ve been at that for 25 years; it’s a sickness). I herniated a disc in my low back and lost the ability to exercise for going on 6 months.
BJJ is like catnip for autists. There is an overwhelming population of IT, engineers and ASD coded people in BJJ world.
There’s even a gent we loving call Blinky McHeelhook, because well…see for yourself
https://www.youtube.com/watch?v=9mRsqvRduHY
Noticing the effects of elbow position, creating an entire algorithm, flow chart and epistemology off the fact?
“VERY NORMAL.”
Anyway, when my body said “sit down”, my brain went “ok, watch this”.
I’m sorry. I’m so sorry. No one taught me how to drive this thing :)
PS: I only found out after my eldest was diagnosed. Then my youngest. The my MIL said “go get tested”. I did.
Result - ASD.
Her response - “We know”.
Great - thanks for telling me. Would have been useful to know, say… 40ish years ago.
Based AF. Can anyone more knowledgeable explain how it works? I am not able to understand.
Hell yes I can explain. What would you like to know.
As I understand it, it corrects the output of LLMs. If so, how does it actually work?
Good question.
It doesn’t “correct” the model after the fact. It controls what the model is allowed to see and use before it ever answers.
There are basically three modes, each stricter than the last. The default is “serious mode” (governed by serious.py). Low temp, punishes chattiness and inventiveness, forces it to state context for whatever it says.
Additionally, Vodka (made up of two sub-modules - “cut the crap” and “fast recall”) operate at all times. Cut the crap trims context so the model only sees a bounded, stable window. You can think of it like a rolling, summary of what’s been said. That summary is not LLM generated summary either - it’s concatenation (dumb text matching), so no made up vibes.
Fast recall OTOH stores and recalls facts verbatim from disk, not from the model’s latent memory.
It writes what you tell it to a text file and then when you ask about it, spits it back out verbatim ((!! / ??)
And that’s the baseline
In KB mode, you make the LLM answer based on the above settings + with reference to your docs ONLY (in the first instance).
When you >>attach <kb>, the router gets stricter again. Now the model is instructed to answer only from the attached documents.
Those docs can even get summarized via an internal prompt if you run >>summ new, so that extra details are stripped out and you are left with just baseline who-what-where-when-why-how.
The SUMM_*.md file come SHA-256 provenance, so every claim can be traced back to a specific origin file (which gets moved to a subfolder)
TL;DR: If the answer isn’t in the KB, it’s told to say so instead of guessing.
Finally, Mentats mode (Vault / Qdrant). This is the “I am done with your shit" path.
It’s all of the three above PLUS a counter-factual sweep.
It runs ONLY on stuff you’ve promoted into the vault.
What it does is it takes your question and forms in in a particular way so that all of the particulars must be answered in order for there to BE an answer. Any part missing or not in context? No soup for you!
In step 1, it runs that past the thinker model. The answer is then passed onto a “critic” model (different llm). That model has the job of looking at the thinkers output and say “bullshit - what about xyz?”.
It sends that back to the thinker…who then answers and provides final output. But if it CANNOT answer the critics questions (based on the stored info?). It will tell you. No soup for you, again!
TL;DR:
The “corrections” happen by routing and constraint. The model never gets the chance to hallucinate in the first place, because it literally isn’t shown anything it’s not allowed to use. Basic premise - trust but verify (and I’ve given you all the tools I could think of to do that).
Does that explain it better? The repo has a FAQ but if I can explain anything more specifically or clearly, please let me know. I built this for people like you and me.
That is much clearer. Thank you for making this. It actually makes LLMs useful with much lesser downsides.
God, I hope so. Else I just pissed 4 months up the wall and shouted a lot of swears at my monitor for nada :)
Let me know if it works for you
Will do.
deleted by creator
For the record: none of my posts here are AI-generated. The only model output in this thread is in clearly labeled, cited examples.
I built a tool to make LLMs ground their answers and refuse without sources, not to replace anyone’s voice or thinking.
If it’s useful to you, great. If not, that’s fine too - but let’s keep the discussion about what the system actually does.
Also, being told my writing “sounds like a machine” lands badly, especially as an ND person, so I’d prefer we stick to the technical critique.
deleted by creator
deleted by creator
Spite based inference?
You dirty pirate hooker.
I don’t believe you.
This + Local Wikipedia + My own writings would be sick
I’m not claiming I “fixed” bullshitting. I said I was TIRED of bullshit.
So, the claim I’m making is: I made bullshit visible and bounded.
The problem I’m solving isn’t “LLMs sometimes get things wrong.” That’s unsolvable AFAIK. What I’m solving for is “LLMs get things wrong in ways that are opaque and untraceable”.
That’s solvable. That’s what hashes get you. Attribution, clear fail states and auditability. YOU still have to check sources if you care about correctness.
The difference is - YOU are no longer checking a moving target or a black box. You’re checking a frozen, reproducible input.
That’s… not how any of this works…
Please don’t teach me to suck lemons. I have very strict parameters for fail states. When I say three strikes and your out, I do mean three strikes and you’re out. Quants ain’t quants, and models ain’t models. I am very particular in what I run, how I run it and what I tolerate.
I think you missed the guy this is targeted at.
Worry not though. I get it. There isn’t a lot of nuance in the AI discussion anymore and the anti-AI people are quite rude these days about anything AI at all.
You did good work homie!
Thank you! I appreciate you.
PS: Where’s the guy this should be targeted at?
Not the original commenter, but your reply looks like it’s for termaxima’s comment (about hallucinations being a mathematical certainty).
This is aaesome. Ive been working on something similar. Youre not likely to get much useful from here though. Anything AI is by default bad here
Well, to butcher Sinatra: if it can make it on Lemmy and HN, it can make it anywhere :)
Fuck yeah…good job. This is how I would like to see “AI” implemented. Is there some way to attach other data sources? Something like a local hosted wiki?
Hmm. I dunno - never tried. I suppose if the wiki could be imported in a compatible format…it should be able to chew thru it just fine. Wiki’s are usually just gussied up text files anyway :) Drop the contents of your wiki in there a .md’s and see what it does
I wanna just plug Wikipedia into this and see if it turns an LLM into something useful for the general case.
LOL. Don’t do that. Wikipedia is THE nosiest source.
Would you like me to show you HOW and WHY the SUMM pathway works? I built it after I tried a “YOLO wikipedia in that shit - done, bby!”. It…ended poorly
Yes please
Of course. Here is a copy paste from my now defunct reddit account. Feel free to follow the pastebin links to see what v1 of SUMM did. Whats in the router uses is v1.1:
########
My RAG
I’ve recently been playing around with making my SLM’s more useful and reliable. I’d like to share some of the things I did, so that perhaps it might help someone else in the same boat.
Initially, I had the (obvious, wrong) idea that “well, shit, I’ll just RAG dump Wikipedia and job done”. I trust it’s obvious why that’s not a great idea (retrieval gets noisy, chunks lack context, model spends more time sifting than answering).
Instead, I thought to myself “why don’t I use the Didactic Method to teach my SLMs what the ground truth is, and then let them argue from there?”. After all, Qwen3-4B is pretty good with its reasoning…it just needs to not start from a position of shit.
The basic work flow -
TLDR
- Use a strong model to write clean, didactic notes from source docs.
- Distill + structure those notes with a local 8B model.
- Load distilled notes into RAG (I love you, Qdrant).
- Use a 4B model with low temp + strict style as the front‑end brain.
- Let it consult RAG both for facts and for “who should answer this?” policy.
Details
(1) Create a “model answer” --> this involves creating a summary of source material (like say, markdown document explaining launch flags for llama.cpp). You can do this manually or use any capable local model to do it, but for my testing, I fed the source info straight in Gippity 5 with specfic “make me a good summary of this, hoss” prompt
Like so: https://pastebin.com/FaAB2A6f
(2) Save that output as SUMM-llama-flags.md. You can copy paste it into Notepad++ and do it manually if need to.
(3) Once the summary has been created, use a local “extractor” and “formatter” model to batch extract high yield information (into JSON) and then convert that into a second distillation (markdown). I used Qwen3-8b for this.
Extract prompt https://pastebin.com/nT3cNWW1
Format prompt (run directly on that content after model has finished its extraction) https://pastebin.com/PNLePhW8
(4) Save that as DISTILL-llama-flags.md.
(5) Drop Temperature low (0.3) and made Qwen3-4B cut the cutsey imagination shit (top_p = 0.9, top_k=0), not that it did a lot of that to begin with.
(6) Import DISTILL-llama-flags.md into your RAG solution (god I love markdown).
Once I had that in place, I also created some “fence around the law” (to quote Judaism) guard-rails and threw them into RAG. This is my question meta, that I can append to the front (or back) of any query. Basically, I can ask the SLM “based on escalation policy and the complexity of what I’m asking you, who should answer this question? You or someone else? Explain why.”
(I also created another “how much will this cost me to answer with X on Open Router” calculator, a “this is my rig” ground truth document etc but those are sort of bespoke for my use-case and may not be generalisable. You get the idea though; you can create a bunch of IF-THEN rules).
The TL:DR of all this -
With a GOOD initial summary (and distillation) you can make a VERY capable little brain, that will argue quite well from first principles. Be aware, this can be a lossy pipeline…so make sure you don’t GIGO yourself into stupid. IOW, trust but verify and keep both the source material AND SUMM-file.md until you’re confident with the pipeline. (And of course, re-verify anything critical as needed).
I tested, and retested, and re-retest a lot (literally 28 million tokens on OR to make triple sure), doing a bunch of adversarial Q&A testing, side by side with GPT5, to triple check that this worked as I hoped it would.
The results basically showed a 9/10 for direct recall of facts, 7-8/10 for “argue based on my knowledge stack” or “extrapolate based on knowledge stack + reference to X website” and about 6/10 on “based on knowledge, give me your best guess about X adjacent topic”. That’s a LOT better than just YOLOing random shit into Qdrant…and orders of magnitude better than relying on pre-trained data.
Additionally, I made this this cute little system prompt to give me some fake confidence -
Tone: neutral, precise, low-context.Rules:Answer first. No preamble. ≤3 short paragraphs.Minimal emotion or politeness; no soft closure.Never generate personal memories, subjective experiences, or fictional biographical details.Emotional or expressive tone is forbidden.Cite your sourcesEnd with a declarative sentence.
Append: "Confidence: [percent] | Source: [Pretrained | Deductive | User | External]".^ model reported, not a real statistical analysis. Not really needed for Qwen model, but you know, cute.
The nice thing here is, as your curated RAG pile grows, so does your expert system’s “smarts”, because it has more ground truth to reason from. Plus, .md files are tiny, easy to demarcate, highlight important stuff (enforce semantic chunking) etc.
The next step:
Build up the RAG corpus and automate steps 1-6 with a small python script, so I don’t need to baby sit it. Then it basically becomes “drop source info into folder, hit START, let’er rip” (or even lazier, set up a Task Scheduler to monitor the folder and then run “Amazing-python-code-for-awesomeness.py” at X time).
Also, create separate knowledge buckets. OWUI (probably everything else) let’s you have separate “containers” - right now within my RAG DB I have “General”, “Computer” etc - so I can add whichever container I want to a question, ad hoc, query the whole thing, or zoom down to a specific document level (like my DISTILL-llama.cpp.md)
I hope this helps someone! I’m just noob but I’m happy to answer whatever questions I can (up to but excluding the reasons my near-erotic love for .md files and notepad++. A man needs to keep some mystery).
EDIT: Gippity 5 made a little suggestion to that system prompt that turns it from made up numbers to something actually useful to eyeball. Feel free to use; I’m trialing it now myself
Tone: neutral, precise, low‑context.
Rules:
Answer first. No preamble. ≤3 short paragraphs (plus optional bullets/code if needed). Minimal emotion or politeness; no soft closure. Never generate personal memories, subjective experiences, or fictional biographical details. Emotional or expressive tone is forbidden. End with a declarative sentence.Source and confidence tagging: At the end of every answer, append a single line: Confidence: [low | medium | high | top] | Source: [Model | Docs | Web | User | Contextual | Mixed]
Where:
Confidence is a rough self‑estimate:
low = weak support, partial information, or heavy guesswork. medium = some support, but important gaps or uncertainty. high = well supported by available information, minor uncertainty only. top = very strong support, directly backed by clear information, minimal uncertainty.Source is your primary evidence:
Model – mostly from internal pretrained knowledge. Docs – primarily from provided documentation or curated notes (RAG context). Web – primarily from online content fetched for this query. User – primarily restating, transforming, or lightly extending user‑supplied text. Contextual – mostly inferred from combining information already present in this conversation. Mixed – substantial combination of two or more of the above, none clearly dominant.Always follow these rules.
Not OP, but random human.
Glad you tried the “YOLO Wikipeida”, and are sharing that fact as it saves the rest of us time. :)
Don’t YOLO wikipedia, folks. It hurts.
neat but is this privacy related?
Yes, because making locally hosted LLMs actually useful means you don’t need to utilize cloud-based and often proprietary models like ChatGPT or Gemini which Hoover up all of your data.
^ exactly that. Thank you!
Yes. Several reasons -
-
Focuses on making LOCAL LLMs more reliable. You can hitch it to OpenRouter or ChatGPT if you want to leak you personal deets everywhere, but that’s not what this is for. I built this to make local, self hosted stuff BETTER.
-
Entire system operates on curating (and ticketing with provenance trails) local data…so you don’t need to YOLO request thru god knows where to pull information.
-
In theory, you could automate a workflow that does this - poll SearXNG, grab whatever you wanted to, make a .md summary, drop it into your KB folder, then tell your LLM “do the thing”. Or even use Scrapy if you prefer: https://github.com/scrapy/scrapy
-
Your memory is stored on disk, at home, on a tamper proof file, that you can inspect. No one else can see it. It doesn’t get leaked by the LLM any where. Because until you ask it, it literally has no idea what facts you’ve stored. The content of your KBs, memory stores etc are CLOSED OFF from the LLM.
-
