Summary of "Claude Code + Karpathy's Obsidian = New Meta"
Core idea: “Obsidian memory” for Claude Code to prevent amnesia
The video discusses a setup popularized by Andrej Karpathy: using Claude Code + Obsidian to build a “self-updating” long-term memory system.
The goal is to reduce:
- Context loss (Claude forgetting earlier details)
- Hallucinations / confident incorrectness by giving Claude a persistent, editable knowledge base
How the Obsidian RAG / “LLM wiki” system works
Claude maintains a knowledge system inside an Obsidian vault, built from Markdown files:
- Claude creates/maintains a directory of Markdown (MD) files in Obsidian.
- Claude also maintains an index/corresponding catalog (e.g., an
index.mmd) so Claude can:- find relevant pages
- open and cross-reference them
- update notes
- append to a log (e.g.,
log.md)
Obsidian’s visual layer (e.g., graph view) provides a way to browse relationships between notes/topics, framed as “a personal Wikipedia.”
Product features / workflow emphasized
Easy editing & updating
Claude writes MD pages in a format that humans can later edit. As new sources arrive, updates propagate into the wiki.
Compounding effect (incremental improvement over time)
Traditional RAG:
- query
- retrieve chunks
- answer
- effectively “forget” next time
This system:
- when a new source is added, Claude updates many related wiki pages (described as ~10–15 pages per new source)
- future queries then start from an increasingly improved base
3-layer architecture (as described in the video)
-
Raw sources folder Inputs like URLs, PDFs, transcripts, web clips, etc.
-
Wiki folder Claude-generated MD summaries/notes.
-
Rule/schema file A “rule book” guiding Claude’s behavior and conventions.
Tutorial-style implementation steps (highlights)
- Download and set up Obsidian (including graph view and dark mode).
- Configure attachment handling for local media:
- set a fixed “attachment folder path”
- use a workflow to download images/attachments when clipping content
- Use Claude Code to scaffold the wiki:
- create a project folder
- run Claude code with a prompt to “create the structure”
Ingestion
- Add URLs and ask Claude to scrape content (including text + images).
- Use Obsidian Web Clipper to clip web pages directly into a chosen vault/folder template.
Maintenance loop
Every “couple weeks,” run a linting/maintenance step to find:
- contradictions
- orphan pages
- stale claims
- other issues humans tend to miss
What the system is good for (use cases suggested)
The system is presented as useful for “mini wikis” per domain/project, such as:
- book companion
- research deep dives
- team/business wiki
- personal life wiki
Example demo (described by the video):
- building a personal life / decision-making wiki (using sources like “high agency” content)
- then asking for advice with referenced files
Limitations of Obsidian RAG (main analysis section)
The speaker argues that hype coverage misses important scaling/architecture problems. Key limitations include:
-
Index and index files grow over time
claude.md/indexincrease token usage for browsing/searching- token/cost rises as file counts increase (with illustrative scaling examples)
-
No true semantic search
- retrieval is described as more “topic/category-based” than embedding/semantic matching
-
Summary drift / staleness
- summaries can become outdated as the wiki evolves
-
Not ideal for large datasets
- it’s framed as workable for small to early/medium knowledge bases
- it can become expensive or painful around larger scales (e.g., 10,000 files as an example threshold)
Proposed fix: blend Obsidian with Pinecone + “4-part memory” framing
The video recommends separating:
- stuff that changes
- stuff that doesn’t
Suggested approach:
- Keep changing / reasoning-oriented notes in Obsidian.
- Put large archives with exact recall needs (e.g., YouTube transcripts) into Pinecone.
Why Pinecone is argued to be cheaper
- Ingestion is one-time: store vectors + embeddings
- Queries use “nearest neighbor” (top-K) to retrieve relevant exact text snippets
- Claude doesn’t have to load an ever-growing Obsidian index/context window in the same way
Retrieval tradeoff described
- Pinecone: closer to “perfect recall” of exact text via similarity search, but less suited to graph-style reasoning
- Obsidian: supports graph/structure reasoning, but retrieval scaling can be costly
Final architecture: identity + workspace + warehouse (+ extra research tool)
The video frames a sustainable system as multiple layers:
- Identity / rules:
claude.md-style file (voice, instructions, “about me”) -
Workshop: Obsidian wiki Active projects, decision logs, and linked reasoning
-
Warehouse: Pinecone Transcripts, archives, and content that shouldn’t change
Additional tool mentioned:
- NotebookLM as an auxiliary deep-research step that can then be added back into long-term memory if desired.
Main speakers / sources
- Andrej Karpathy (referenced as origin/inspiration for the viral idea)
- Jack Roberts (speaker; author/creator of the video content and guide)
Category
Technology
Share this summary
Is the summary off?
If you think the summary is inaccurate, you can reprocess it with the latest model.