RAG, fine‑tuning, LoRA and graph memory: what each one is actually for
Every business that orders an AI assistant runs into the same fork: how is the assistant supposed to learn what it needs to know about your company? The answers it gets sound like a menu of buzzwords — fine‑tuning, RAG, vector database, knowledge graph, LoRA, post‑training — and vendor pitches rarely explain the trade‑offs, because there are no universal trade‑offs. Each of these tools answers a different question. Confusing them is expensive: you either retrain the model every time a price changes, or you ship an assistant that confidently invents what it was never taught.
The confusion is understandable. These layers sit on top of each other, so they look interchangeable from the outside. They are not. This article is the map we draw for clients before choosing a stack — and the one we use ourselves.
In short
- Fine‑tuning and post‑training teach skills, not facts. Tone, terminology, output format, latency — yes. Prices, documents and anything that changes — never.
- LoRA made fine‑tuning cheap. Instead of retraining the whole model, you train a small adapter: tens of megabytes instead of tens of gigabytes, swappable per task.
- RAG is the layer for facts. Knowledge lives in your database and is retrieved at question time, so updates apply instantly and answers can carry citations.
- A vector finds what is similar; a graph knows how things connect. Multi‑hop questions over entities and relations are the graph’s territory.
- In production these combine. RAG for facts, LoRA for voice and format, graph memory where relationships matter.
Post‑training teaches skills, not facts
Post‑training is the umbrella term for everything that happens to a base model after its general pretraining: instruction tuning, reinforcement learning from human feedback, and any domain‑specific fine‑tuning on top. The word is worth unpacking because it separates two things that are often blurred: general capabilities, which the model labs train, and behavior, which is what you control when you adapt a model to your business.
Fine‑tuning means changing the weights — the model’s long‑term memory. That is precisely why it is the wrong place for facts that change. A price, a policy clause or a product spec baked into weights goes stale the day the price list is updated, and refreshing it means another training run, another evaluation, another deployment. A model that memorized your catalog will also answer from memory when the catalog is wrong — and it will do so fluently, which is the worst property an assistant can have.
What fine‑tuning is genuinely good at is different:
- a consistent voice: the assistant speaks in your style and in your industry’s vocabulary;
- strict output format: it always produces valid JSON that matches your schema, without prompt gymnastics;
- distillation: a large, slow, expensive teacher model is compressed into a small, fast, cheap student that keeps most of the quality on your specific task.
Skills, not facts. Keep this sentence and half of the terminology fog clears.
LoRA: fine‑tuning suddenly became cheap
The classic objection to fine‑tuning was cost: a full pass updates all weights of a model with billions of parameters, which means serious hardware and a serious bill for every experiment. LoRA (Low‑Rank Adaptation) removed the objection. Instead of touching the base weights, it freezes them and trains only small low‑rank matrices — adapters — inserted alongside. The result is a patch of tens of megabytes that carries the whole behavioral change, versus tens of gigabytes for the full model.
The practical consequences are bigger than they sound. Training fits on a single GPU. Dozens of adapters can live next to one base model — one per client, one per tone, one per language. You can swap a behavior without touching the brain. And with a quantized base (QLoRA) the whole procedure became accessible far beyond datacenter budgets; the original LoRA paper is from 2021, and the ecosystem around it has since become the default way teams customize open models.
LoRA did not change what fine‑tuning is for. It changed how often you can afford it — which, in turn, made the rule from the previous section practical rather than theoretical.
RAG: knowledge lives in your database, not in the model
Retrieval‑Augmented Generation inverts the logic. Instead of pushing facts into weights, you leave them where facts belong — in your own data — and at question time the system retrieves the relevant fragments and hands them to the model as context. The model does not remember your documents; it reads them before answering.
This single inversion resolves the main problems of the previous sections:
- Fresher is free. You update the source once, and the assistant answers from the new version on the next request. No training run in between.
- Answers can show their work. Because the answer is grounded in retrieved fragments, the assistant can cite them, and you can verify it.
- Access control becomes possible. Retrieval happens in your infrastructure, so different users can be served from different slices of the same knowledge base.
The ceiling of RAG is retrieval quality. Vector search finds text that is similar to the question, which is not always text that is relevant to it; chunking fragments knowledge across artificial paragraph boundaries; and if an honest answer requires combining three documents that never mention each other, plain similarity search starts to struggle. Most disappointing RAG demos fail at this layer, not at the model layer.
A vector finds what is similar; a graph knows connections
A vector database answers one kind of question well: which fragments of text resemble this one. For a large share of assistant queries, that is exactly the right primitive. But there is a whole class of questions it cannot even represent, because they are not about similarity — they are about relationships.
Which of our clients is connected to this supplier? Which internal pages link to the article that just lost its rankings? Which of these two contractors share a beneficial owner? To answer, the system has to follow explicit connections between entities — and that is what a graph database stores natively: nodes (companies, people, pages, contracts) and edges (their named relationships), traversable in arbitrary chains.
The practical pattern is GraphRAG: entities and relations are extracted from your corpus into a knowledge graph, and at query time the system retrieves a subgraph — often together with vector search over the same documents — so the model sees not only relevant fragments but the connections between them. Microsoft’s research team published the original GraphRAG approach and it has since become a recognized pattern for corpora where meaning lives in the links, not just in the paragraphs.
A graph pays off when relationships are the substance of the questions: CRMs, logistics, compliance, internal knowledge bases dense with cross‑references. If your corpus is mostly linear prose, a vector store with hybrid search is the simpler and cheaper first step — you can always add the graph layer once the questions demand it.
Choosing a tool
| Task | Tool |
|---|---|
| The assistant must know your documents, prices, policies — things that change | RAG |
| Answers depend on chains of relations between entities | Knowledge graph, GraphRAG |
| Stable tone of voice, industry terminology, strict output format | Fine‑tuning, usually LoRA |
| Cheaper and faster responses at scale | Distillation into a smaller model via fine‑tuning |
| All of the above at once | Hybrid: RAG + LoRA, vector store + graph |
One more rule of thumb that saves budgets: start with RAG. Most “we need fine‑tuning” requests, examined closely, turn out to be “we need our data in the context” requests. Fine‑tuning earns its place later, when voice and format need to be locked down, and the graph earns its place when questions start being asked that similarity search cannot formulate.
How we assemble it
In our own agent projects, the default stack is RAG: the client’s knowledge base lives in a database the client controls, updates apply instantly, and answers stay verifiable. Where the domain is dense with relationships — clients, suppliers, pages, events — a knowledge graph sits next to the vector store and takes the multi‑hop questions. Fine‑tuning through LoRA is reserved for what it is actually good at: a stable voice and a strict output format. The combination is not exotic; it is what production systems converge on once the buzzwords are subtracted.
If you are weighing these options for your own assistant, we build them — and the first conversation is about your data and your questions, not about the model of the month.
In closing
The question is never which technology is better. It is what kind of knowledge your assistant needs to hold: skills, facts or connections. Fine‑tuning holds skills. RAG holds facts. A graph holds connections. Name the knowledge correctly, and the technology chooses itself.
Sources
- LoRA: Low‑Rank Adaptation of Large Language Models — the original paper on adapter‑based fine‑tuning.
- GraphRAG: Unlocking LLM discovery on narrative private data — Microsoft Research on graph‑based retrieval.
Yuri Osipov
Founder, SEO & analytics
Runs Take the Space. Specialises in technical SEO, measurable analytics setups and AI search visibility.