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:

1. query
2. retrieve chunks
3. answer
4. 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)

1. Raw sources folder Inputs like URLs, PDFs, transcripts, web clips, etc.

2. Wiki folder Claude-generated MD summaries/notes.

3. 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:

1. Index and index files grow over time

   • claude.md / index increase token usage for browsing/searching
   • token/cost rises as file counts increase (with illustrative scaling examples)

2. No true semantic search

   • retrieval is described as more “topic/category-based” than embedding/semantic matching

3. Summary drift / staleness

   • summaries can become outdated as the wiki evolves

4. 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)