Yuri Osipov · Founder, SEO & analytics

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

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:

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:

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

TaskTool
The assistant must know your documents, prices, policies — things that changeRAG
Answers depend on chains of relations between entitiesKnowledge graph, GraphRAG
Stable tone of voice, industry terminology, strict output formatFine‑tuning, usually LoRA
Cheaper and faster responses at scaleDistillation into a smaller model via fine‑tuning
All of the above at onceHybrid: 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

Yuri Osipov

Yuri Osipov

Founder, SEO & analytics

Runs Take the Space. Specialises in technical SEO, measurable analytics setups and AI search visibility.

All posts by the author →
Do we need fine‑tuning so the assistant knows our documents?
Usually no. Fine‑tuning changes the model’s weights — it is for skills, tone and format, not for facts. Documents, prices and policies that change over time belong in a retrieval layer (RAG), where an update to the source is instantly reflected in the answers.
What is LoRA, in one sentence?
LoRA freezes the pretrained model and trains only small low‑rank adapter matrices alongside it, so a fine‑tune becomes tens of megabytes instead of tens of gigabytes — cheap to train, easy to store, and swappable per task on the same base model.
When is a graph database better than a vector one?
When the answer depends on chains of relationships rather than on similar‑sounding text: multi‑hop questions over clients, suppliers, contracts, pages or events. A vector store returns fragments that resemble the query; a graph lets you traverse explicit connections and answer questions similarity search cannot even formulate.
Can RAG and fine‑tuning be combined?
Yes, and in production it is the standard combination: RAG supplies current facts and citations, while a LoRA fine‑tune fixes tone, domain terminology and output format so the model uses the retrieved context consistently and correctly.
What is post‑training?
Everything done to a base model after pretraining: instruction tuning, RLHF and preference alignment, plus downstream fine‑tuning for a specific domain. The name matters because it separates general capabilities, which the labs train, from behavior and knowledge adaptation, which is what you control when you adapt a model to your business.

Want a high‑performance website?

Let’s discuss how we can help your business grow.