Memory, Project Files, and Retrieval: Which One Do You Need?
There are three ways to get information into your AI tools. Each does something different. Here's how to pick the right one.
You’ve explained your situation to the AI for the fourteenth time this month.
Same background, same constraints, same preferences - typed out again because the previous session is gone and this one started blank. Or the opposite problem: the AI had access to everything, but still missed the one document that actually mattered.
There are three ways to get information into AI tools. They do different things, and mixing them up is the reason most AI workflows feel more effortful than they should.
The three options
Conversation context
This is everything in the current chat window. Every message you’ve sent, every response the AI gave, anything you’ve pasted in. The AI sees all of it - for now.
When the conversation ends, it’s gone. Start a new session and you’re back to square one.
Good for: current task context. What you’re working on today, the specific document you’re iterating on, the decision you’re trying to make right now. Things that are only relevant in the moment.
Not good for: anything you’ll need again. Standards, preferences, accumulated knowledge, ongoing project context. If you’re re-typing it, it belongs somewhere else.
Project files and persistent instructions
These are documents the AI reads at the start of every session, before you type anything. Claude Projects lets you upload files and write custom instructions. Cursor uses .cursorrules. Claude Code uses CLAUDE.md. ChatGPT has custom instructions.
The mechanism varies, but the effect is the same: the AI arrives pre-briefed.
Good for: stable context that applies to all your work in a domain. Your role, how you like to communicate, your working norms, the standards you hold yourself to, the ongoing project context that’s always relevant. The stuff you’d tell a new colleague on day one.
Not good for: large document collections (there’s a limit to how much fits), things that change frequently, or information you’d need to search for rather than just have on hand. Packing too much in here dilutes the signal - everything becomes equally prominent, which means nothing is.
Retrieval
Retrieval means the AI searches a document store - your GitHub knowledge base, a file collection, a connected tool - and pulls in the relevant parts before answering. It’s not reading everything upfront; it’s finding what’s needed when it’s needed.
Good for: large collections, things you’d search rather than memorise, information that changes over time (because the source stays current rather than going stale in a project file). Reference material, past decisions, documentation.
Not good for: things that genuinely need to be in every session - use project files for those. Or very small amounts of context that you could just paste in.
Notes vaults
Tools like Obsidian sit slightly to the side of these three options. An Obsidian vault is usually source material: notes, meeting records, research, working thoughts, links, and drafts. It becomes useful to AI when the tool can search it, when you paste from it, or when you connect it through retrieval.
That does not make the vault itself the same as memory. A note that says “follow up with Anna” is not a commitment unless something is tracking it. A note that explains your writing preferences is not a project instruction unless the AI reads it at the start of the session. A useful vault can still be invisible to your AI workflow if there is no pointer to it.
Good for: long-form notes, research, project journals, meeting notes, ideas that benefit from links and history.
Not good for: rules that must be present in every AI session, commitments that need follow-up, blockers that need escalation, or decisions that need to shape future work unless they are surfaced through retrieval or memory.
How to decide
Three questions, in order:
1. Does it need to be in every session? If yes - project files. If no - context or retrieval.
2. Do you need to search it, or does the AI need to read it all? If you need to search - retrieval. If it’s short enough to read in full - context or project files.
3. Is it stable, or does it change? Stable - project files. Changes frequently - retrieval, so the source stays current and you’re not updating a stale document.
A quick map:
| Information | Best home |
|---|---|
| The task you are doing right now | Conversation context |
| Your working style and standing rules | Project files or persistent instructions |
| A large document library | Retrieval |
| Personal notes and research | Notes vault, usually accessed through retrieval |
| Decisions, commitments, blockers, preferences | Structured memory |
A worked example
Say you’re a founder and you want your AI tools to know your company’s context. Here’s where different information belongs:
- “I’m a direct communicator who prefers decisions over options” → project file. Stable, applies to every session.
- “We’re closing a seed round by end of Q3” → project file or context. Ongoing and relevant, but will eventually stop being true.
- “The deck we sent the lead investor last Tuesday” → retrieval. It’s a specific document, large, and you’d search for it rather than want it in every session.
- “What we decided in today’s product meeting about pricing” → context. Today only. Once you’ve captured the decision somewhere permanent, you won’t need it in this form again.
The same information doesn’t always belong in the same place. A decision being made now is context. That same decision, once it’s settled and shapes how you work, belongs in project files or retrieval.
What this looks like in practice
Conversation context: every chat interface you already use - ChatGPT, Claude, Gemini. You’re using this by default; the question is whether you’re relying on it for things that should live elsewhere.
Project files: Claude Projects (upload files, write instructions), Cursor (.cursorrules), Claude Code (CLAUDE.md), ChatGPT custom instructions. Set these up once, update them when your situation changes.
Retrieval: Claude Projects with documents uploaded and search enabled. Tools built specifically for this - 3ngram does cross-session memory plus search over your actual documents, which is why I built it. NotebookLM for document Q&A. A well-structured GitHub repository that AI tools can query.
Get started with a prompt
The fastest way to build a useful project file is to start from what you keep re-explaining. This prompt does the work:
I want to set up a persistent context document for AI sessions about [domain/project].
Here's what I do: [brief description]
Here's what matters: [key facts, constraints, preferences]
Here are things I keep having to re-explain: [list them]
Write me a concise project context document (under 500 words) that covers
the most important things an AI assistant would need to know to help me
effectively. Don't pad it - only include things that actually affect how
it should respond.Run this once. You’ll get a draft project file that handles 80% of your re-explanation problem immediately. Refine it over the next few weeks as you notice gaps.
The habit that compounds
A perfect context system on day one isn’t the goal. The goal is one habit: every time you re-explain something to an AI, ask whether it belongs in your project files.
Most of the time the answer is yes. Each time you act on it, the next session gets a little better. After a month of this, you’re not re-explaining anything - and the quality of what you get back reflects it.
The most practical way to set up retrieval is a structured repository - Using GitHub as a Knowledge Base covers exactly that.
Want to understand how agents use this context in practice? What Are AI Agents covers how agents reason with the context you give them.