RAG vs. agent memory: what RAG is, how to add it to Claude Code, and how it differs from Pam Memory

Fair question. RAG is everywhere right now, the word gets applied to basically everything, and honestly the confusion is understandable — both RAG and memory are about giving agents context they don't have by default. But the difference matters more than most people realize, usually around the time they discover their agent has been confidently answering from a three-week-old index.

Here's the breakdown.

They're not competitors. Strong agents use both: RAG for knowledge, memory for continuity.

What is RAG?

RAG gives a language model information it wasn't trained on, at the moment it answers.

Instead of hoping the model memorized your docs, you keep those docs in a searchable index. When a question comes in, you retrieve the most relevant chunks, add them to the prompt, and the model generates a reply from them. Retrieval. Augmented. Generation. That's the whole thing.

It exists because raw LLMs have two real limits: a training cutoff and a context window. RAG handles both by fetching the relevant slice of your knowledge on demand, rather than stuffing everything into the prompt or fine-tuning a new model every time a doc changes.

How RAG actually works

Five steps, same in every implementation:

1. Chunk: Split documents into passages small enough to retrieve precisely — a paragraph, a section.
2. Embeddings: Run each chunk through an embeddings model so similar meaning lands near similar coordinates in vector space.
3. Store: Keep those vectors in a vector database: FAISS, pgvector, Pinecone, whatever fits.
4. Retrieve: Embed the incoming query, pull the nearest chunks by similarity, often with a re-ranking pass.
5. Augment and generate: Paste those chunks into the prompt and let the model answer.

Most of the quality lives in steps 1 and 4. How you chunk, and whether retrieval surfaces the right passage instead of a plausible-looking wrong one. The rest is wiring.

How to connect RAG to Claude Code

Claude Code already reads the files in your project. That's not RAG — that's file access. Real RAG gives Claude Code a retrieval tool over an index you control.

The cleanest way: Model Context Protocol (MCP). You run a small server that exposes a search tool over your vector store, and Claude Code calls it when it needs context.

1. Build the index: Chunk your docs, embed them, load the vectors into a store.
2. Expose retrieval as an MCP server: Wrap the query-embed-search-return flow in a tool — something like search_docs(query) returning matched passages and their sources.
3. Register it:

# register your retrieval MCP server
claude mcp add docs-rag -- node ./mcp-rag-server.js

# confirm it's wired up
claude mcp list

Done. When you ask Claude Code something that needs your knowledge base, it calls search_docs, gets the chunks, and answers from them.

One thing worth knowing before you start: if you only need the model to see your current repo, just let it read files. Reach for RAG when the knowledge is bigger than the context window, lives outside the project, or changes often enough that you want one indexed source of truth rather than hoping the agent reads the right file.

Where RAG stops being enough

RAG does one thing well: finding text relevant to a query. For a random factual question, that's fine. For an agent that's supposed to work alongside you for months, it starts breaking in ways that feel maddening because they're so quiet.

None of this is a design flaw — RAG was never supposed to solve these problems. But people reach for it like it will, and then wonder why their agent still feels amnesiac. This is the gap. Retrieval is a component, part of a bigger system called Memory.

What is Pam Memory?

Pam is a self-onboarding memory for AI agents.

No profile to fill out, no index to hand-build. Pam reads the data you already produce — email, messages, meetings — and constructs a living model of your context: who the people are, what the deals are, what's true now and what changed since last week. It updates as new events arrive. When facts conflict, it acts proactively to resolve them rather than surfacing both and leaving the agent to guess.

The underlying principle is that memory is a system, not a document. A static file goes stale. A static index bloats and can't scope what's relevant. Real memory decides what to store, keeps it current, and writes back what it learns.

RAG vs. Pam Memory, side by side

The analogy I keep coming back to (it's a bit reductive, but it holds up): RAG is a librarian who fetches matching pages from shelves you stocked. Memory is a colleague who's been in the room with you for months. They don't retrieve — they just know. And they remember what happened last Tuesday, including the part where the other version of that contract got superseded.

Do you need both?

Almost always, yes.

When they work together, it stops feeling like you're interrogating a search engine and starts feeling like working with someone who's actually been paying attention. That's the difference worth building toward.

Frequently asked questions