Build a Permanent AI Memory with Obsidian + Claude Code
AI assistants such as Claude are excellent at understanding questions, writing code, analyzing information, and helping with projects. However, there is an important challenge when we work with AI over a long period:
How can the AI remember our projects, decisions, documentation, preferences, and previous work across many sessions?
One increasingly useful solution is combining Obsidian with Claude and Claude Code.
Obsidian can act as a persistent knowledge base, while Claude acts as the intelligent layer that reads, searches, understands, and updates that knowledge.
In simple terms:
Obsidian stores the knowledge.
Claude understands and uses the knowledge.
MCP or direct file access connects them.
This creates something similar to a long-term external memory system for AI.
1. What Is Obsidian?
Obsidian is a knowledge-management and note-taking application built around Markdown files (.md).
Unlike many cloud note applications, an Obsidian workspace—called a Vault—is essentially a folder containing ordinary files.
For example:
AI-Memory/
│
├── Projects/
├── Knowledge/
├── Decisions/
├── People/
├── Tutorials/
├── Daily-Notes/
├── AI-Memory/
└── CLAUDE.md
A note might simply be:
# Restaurant Agent Project
## Technology
Backend: Python + Flask
Database: SQLite
Frontend: HTML, CSS and JavaScript
## Current Status
Version 5 is under development.
## Next Step
Configure SMTP email confirmation.
Because these are ordinary Markdown files, they are readable not only by Obsidian but also by development tools and AI agents with appropriate file access.
This makes Obsidian especially interesting as an AI knowledge base.
2. What Does “Permanent AI Memory” Mean?
The phrase permanent memory needs some clarification.
It does not mean Claude’s neural network is permanently retrained with everything you tell it.
Instead, information is stored outside the model in persistent files.
For example:
Claude
↓
searches memory
↓
Obsidian Vault
↓
Markdown files
↓
projects / decisions / knowledge / history
When Claude needs information, it can retrieve the appropriate files.
This approach is often called external memory, persistent memory, or a knowledge base.
The important difference is persistence.
A conversation may eventually end, but a file such as:
Projects/restaurant-agent.md
can remain on your computer for years.
A future Claude session can read the file again.
3. Why Combine Claude and Obsidian?
Claude provides reasoning and language intelligence.
Obsidian provides durable information storage and organization.
Together they can form a powerful knowledge system.
For example, suppose you have worked on a software project for six months.
Instead of repeatedly explaining:
The application uses Flask.
We selected PostgreSQL.
Reservations are stored in the database.
SMTP is used for confirmation emails.
The frontend is multilingual.
The next task is deployment.
you could store those facts in your project memory.
Claude could later retrieve them when working on the project.
This reduces repeated explanations and makes long-running AI-assisted projects easier to continue.
4. Claude Memory vs. Obsidian Memory
These concepts should not be confused.
Claude products can have their own context, project instructions, and memory-related features.
An Obsidian-based memory system is different.
The information belongs to your own files.
For example:
Obsidian Vault
│
├── personal knowledge
├── software projects
├── research
├── decisions
├── documentation
└── AI memory
Claude accesses the information when needed.
One advantage is transparency: you can open the memory yourself and see exactly what has been stored.
You can also correct or delete information manually.
5. The Architecture
A basic architecture can look like this:
USER
│
▼
CLAUDE
│
Claude Code
│
▼
MCP / File Access
│
▼
OBSIDIAN VAULT
│
┌──────────────┼──────────────┐
▼ ▼ ▼
Projects Knowledge Memory
│ │ │
▼ ▼ ▼
project.md ai-notes.md decisions.md
Claude is the reasoning engine.
Obsidian is the persistent storage.
The connection between them can be implemented in several ways, including direct file access from Claude Code or an MCP integration.
6. What Is MCP?
MCP stands for Model Context Protocol.
MCP provides a standardized way for AI applications to communicate with external tools and information sources.
Conceptually:
Claude
│
▼
MCP Client
│
▼
Obsidian MCP Server
│
▼
Obsidian Vault
Depending on the MCP server used, Claude may receive tools for operations such as:
search_notes()
read_note()
create_note()
update_note()
list_notes()
Claude can therefore work with the knowledge base instead of requiring you to copy and paste everything into a conversation.
MCP integrations for Obsidian are generally community-developed, so the exact installation commands and capabilities depend on the implementation you choose.
7. A Simpler Option: Claude Code + Obsidian Files
MCP is not always necessary.
There is an even simpler concept.
Claude Code can work with files, while an Obsidian vault consists primarily of Markdown files.
Therefore, you can create an Obsidian vault such as:
C:\AI\AI-Memory
and run Claude Code where it has access to that directory.
Claude can then work directly with the Markdown files.
A CLAUDE.md file can provide instructions explaining how the knowledge base should be used.
For many developers, this is a good place to start before introducing additional MCP infrastructure.
8. Installing Obsidian
First install Obsidian from the official website:
Install the desktop application for Windows, macOS, or Linux.
After installation, start Obsidian.
Choose:
Create new vault
Give it a name such as:
AI-Memory
For example, on Windows you might store it under:
C:\AI\AI-Memory
Obsidian will create the vault and you can begin adding Markdown notes.
9. Create a Good Memory Structure
A structured vault is much more useful than hundreds of unrelated notes.
For example:
AI-Memory/
│
├── 00-Inbox/
│
├── 01-Profile/
│
├── 02-Projects/
│
├── 03-Knowledge/
│
├── 04-Decisions/
│
├── 05-Procedures/
│
├── 06-Daily-Notes/
│
├── 07-Archive/
│
└── CLAUDE.md
Profile
Store stable working information and preferences.
Example:
01-Profile/
developer-profile.md
preferences.md
Projects
Each project can have its own directory.
02-Projects/
Restaurant-Agent/
FlightFinder/
AI-Agent/
A project could contain:
Restaurant-Agent/
overview.md
architecture.md
decisions.md
tasks.md
problems.md
session-history.md
This makes retrieval much easier.
10. Install Claude Code
Claude Code is Anthropic’s coding agent and command-line development environment.
Use Anthropic’s current official installation instructions rather than copying an old installation command from a tutorial, because installation methods can change.
Claude Code official documentation
After installation, verify that Claude Code works from your terminal.
For example:
claude
Sign in when requested.
You can then start Claude Code from the folder containing your vault or from a project that has controlled access to the vault.
11. Create CLAUDE.md
One of the most useful files in this architecture is:
CLAUDE.md
This file gives Claude instructions about the workspace.
For example:
# AI Memory Instructions
This Obsidian vault is my persistent knowledge base.
## Startup
Before beginning substantial work:
1. Read the relevant project overview.
2. Read the project's decisions file.
3. Read its current tasks.
4. Search the knowledge base when additional context is required.
## Memory Rules
Store important long-term information such as:
- architecture decisions
- project status
- important solutions
- recurring preferences
- configuration decisions
- unresolved problems
- completed milestones
Do not store:
- passwords
- API keys
- access tokens
- credit card information
- unnecessary private information
## After Important Work
Update the relevant project files with:
- what was completed
- important decisions
- unresolved issues
- recommended next step
This gives Claude a repeatable memory workflow.
12. How a Session Can Work
Imagine that yesterday you worked on a restaurant application.
The memory contains:
# Restaurant Agent Status
Current version: V5
Completed:
- Flask backend
- SQLite database
- reservation form
- booking reference generation
- email confirmation code
Next task:
Configure and test real SMTP using STARTTLS on port 587.
Tomorrow you open Claude Code.
Instead of explaining everything again, Claude reads the project memory.
You can simply say:
Continue the Restaurant Agent project.
Claude can inspect the stored project state and continue from the documented next step.
That is the practical benefit of persistent external memory.
13. Adding MCP
Direct file access is often enough, but MCP can provide a more structured connection between Claude and Obsidian.
Several community implementations exist for this purpose.
A typical architecture is:
Claude Code
│
▼
MCP
│
▼
Obsidian integration
│
▼
AI-Memory Vault
Some implementations combine an Obsidian Local REST API plugin with an MCP server, while others operate directly on the vault filesystem.
Because these are third-party integrations, always check the project’s documentation, recent updates, permissions, and security model before installation.
14. Testing the Memory
After connecting Claude to the vault, start with harmless test information.
Create:
02-Projects/TestProject/overview.md
Add:
# Test Project
Project name: Memory Test
Technology: Python
Current version: Version 3
Next task: Add database support.
Then ask Claude:
Read the TestProject memory and tell me the current version and next task.
The expected answer should be based on the note:
Current version: Version 3
Next task: Add database support.
Now test writing.
Ask:
Update the project memory:
database support has been completed.
The next task is authentication.
Review the resulting file.
It should now contain the updated project state.
This simple test verifies the basic memory loop:
WRITE → STORE → CLOSE SESSION → REOPEN → RETRIEVE
15. Build a Memory Index
As the vault grows, Claude should not have to read every file during every session.
Create:
memory-index.md
For example:
# Memory Index
## Projects
- [[Restaurant-Agent/overview]]
- [[FlightFinder/overview]]
- [[AI-Agent/overview]]
## Knowledge
- [[Claude]]
- [[MCP]]
- [[Python]]
- [[Flask]]
- [[AI-Agents]]
## Important Decisions
- [[Architecture-Decisions]]
- [[Deployment-Decisions]]
## Current Work
- [[Current-Tasks]]
Claude can first inspect this lightweight map and then load only relevant information.
This becomes increasingly important as the knowledge base grows.
16. Obsidian Links Make the Memory More Powerful
Obsidian supports internal links such as:
[[Claude Code]]
[[MCP]]
[[Restaurant Agent]]
[[Python]]
This allows knowledge to become interconnected.
For example:
Restaurant Agent
│
├── Python
├── Flask
├── SQLite
├── SMTP
└── Claude Code
Instead of creating isolated documents, you gradually build a network of related knowledge.
17. Daily AI Memory
Another useful technique is maintaining daily notes.
For example:
06-Daily-Notes/
2026-09-16.md
2026-09-17.md
2026-09-18.md
A daily note could contain:
# 2026-09-18
## Restaurant Agent
Configured SMTP.
Email sending works successfully.
## FlightFinder
Investigated live flight availability.
## AI Research
Studied Obsidian + Claude persistent memory.
## Next Tasks
- Test restaurant email errors
- Continue FlightFinder
- Improve AI memory architecture
These notes provide a chronological history of work.
18. Session Summaries
At the end of an important Claude session, you can ask:
Summarize today's work and update the project memory.
Record:
- what we completed
- decisions we made
- problems remaining
- next step
Claude can turn a long session into a concise persistent record.
For example:
## Session 2026-09-18
Completed:
SMTP configuration.
Decision:
Use STARTTLS.
Remaining:
Production email credentials.
Next:
Test confirmation emails in production.
The next Claude session can begin from this information.
19. Memory Should Be Selective
A common mistake is storing everything.
More memory does not automatically mean better AI.
Useful memory should contain information likely to matter again.
Good candidates include:
- project architecture
- important decisions
- project status
- conventions
- solutions to difficult problems
- requirements
- reusable procedures
- unresolved issues
- next steps
Avoid filling the knowledge base with thousands of trivial conversational details.
The goal is:
persistent useful knowledge, not permanent clutter.
20. Security Is Extremely Important
Connecting an AI agent to your personal knowledge base introduces security considerations.
Do not casually give an AI unrestricted access to your entire computer.
Prefer a dedicated directory such as:
C:\AI\AI-Memory
rather than broad access to:
C:\
Do not store secrets such as:
passwords
API keys
bank information
authentication tokens
private keys
inside ordinary memory notes.
Also remember that community Obsidian plugins and MCP servers are third-party software. Review their source, permissions, maintenance history, and documentation before giving them access to an important vault.
Keep backups of the vault before allowing automated tools to make extensive changes.
21. A Better Production Architecture
As your system becomes larger, consider separating different kinds of memory.
AI-Memory/
│
├── Profile/
│ └── working-preferences.md
│
├── Projects/
│ ├── Restaurant-Agent/
│ ├── FlightFinder/
│ └── AI-Agent/
│
├── Knowledge/
│ ├── Python/
│ ├── AI/
│ ├── Databases/
│ └── Cloud/
│
├── Decisions/
│
├── Procedures/
│
├── Daily/
│
├── Archive/
│
└── memory-index.md
This provides several memory layers.
Long-Term Memory
Stable information that remains useful for months or years.
Project Memory
Architecture, status, decisions, and tasks for individual projects.
Working Memory
Information related to current work.
Historical Memory
Daily notes and previous session summaries.
Knowledge Memory
Reusable technical knowledge and research.
This resembles how a real AI memory architecture separates different types of information.
22. Obsidian + Claude vs. RAG
Developers familiar with AI may notice similarities to Retrieval-Augmented Generation (RAG).
They are related concepts.
A simple Obsidian system might search Markdown files directly.
A more advanced system could add:
Obsidian
↓
Document parser
↓
Chunks
↓
Embeddings
↓
Vector database
↓
Semantic search
↓
Claude
Possible vector databases include systems such as Chroma, Qdrant, Pinecone, or PostgreSQL with pgvector.
For a personal knowledge base, however, you usually do not need to start with this complexity.
Start with:
Obsidian
+
Markdown
+
Claude Code
+
CLAUDE.md
Then add MCP and semantic retrieval when the size of the knowledge base makes them useful.
23. Example: Software Development Memory
Imagine developing a restaurant application with Claude.
The project memory might become:
Restaurant-Agent/
│
├── overview.md
├── architecture.md
├── database.md
├── frontend.md
├── backend.md
├── email.md
├── deployment.md
├── decisions.md
├── bugs.md
└── current-task.md
Claude can inspect current-task.md first.
If the task concerns email, it reads:
email.md
If a database question appears, it reads:
database.md
This is much more efficient than loading the entire project history into every prompt.
24. Example Workflow
A normal working day could look like this.
Start Claude Code:
cd C:\AI\AI-Memory
claude
Then say:
Continue Restaurant Agent.
Read its project memory first.
Claude retrieves the project context.
You work together.
At the end say:
Update the Restaurant Agent memory with today's important work,
decisions, unresolved problems and next task.
Claude updates the appropriate Markdown files.
The following day:
Continue Restaurant Agent from the last recorded state.
The workflow becomes:
START
↓
READ MEMORY
↓
WORK
↓
MAKE DECISIONS
↓
UPDATE MEMORY
↓
END SESSION
↓
START NEW SESSION
↓
READ MEMORY
That loop is the foundation of persistent AI-assisted work.
25. Advantages
Combining Obsidian with Claude can provide several advantages.
Persistent project knowledge
Important information survives individual AI sessions.
Human-readable memory
Everything remains ordinary Markdown that you can inspect yourself.
Editable memory
Incorrect information can be corrected manually.
Local-first organization
Your vault can remain under your control on your own computer.
Project continuity
Claude can resume long-running projects using documented project state.
Knowledge connections
Obsidian links allow related information to form a connected knowledge graph.
Extensibility
The architecture can later incorporate MCP, search, embeddings, RAG, databases, agents, and automation.
26. Limitations
The system is powerful, but it is important to understand what it is not.
Obsidian does not magically give Claude infinite context.
Claude still has a finite context window.
Instead, the vault provides potentially very large persistent storage, while retrieval determines which pieces enter Claude’s working context.
Therefore:
Storage can be very large.
Active model context is still limited.
This is why good indexing and selective retrieval matter.
Another limitation is accuracy.
If incorrect information is stored in the vault, Claude may later rely on it.
Important memories should therefore remain reviewable.
27. The Bigger Idea: Your Personal AI Knowledge Layer
The most interesting part of this architecture is not Obsidian itself.
The bigger concept is creating an AI-controlled knowledge layer that remains independent of individual conversations.
Today:
Claude → Obsidian
Tomorrow the same knowledge base could potentially be used by:
Claude
ChatGPT
local AI models
custom AI agents
automation systems
RAG applications
MCP clients
Your knowledge becomes a reusable resource rather than information trapped inside one conversation.
The architecture becomes:
YOUR KNOWLEDGE
│
Obsidian Vault
│
Persistent Memory
│
┌────────────┼────────────┐
▼ ▼ ▼
Claude AI Agents Local AI
│ │ │
└────────────┼────────────┘
▼
ACTIONS
This is an important direction in modern AI development: combining powerful models with persistent, structured, user-controlled knowledge.
28. Conclusion
Obsidian + Claude can provide a practical foundation for long-term AI memory.
Obsidian supplies the persistent knowledge store.
Claude supplies reasoning and intelligence.
Claude Code supplies direct interaction with files and development workflows.
MCP can provide a structured bridge between the AI and external tools.
Together:
Obsidian
+
Claude
+
Claude Code
+
MCP
=
Persistent AI Knowledge System
The most important principle is that Claude does not need to permanently memorize everything internally.
Instead, it needs a reliable way to store, find, read, and update the right information when needed.
For developers building long-running projects, AI agents, research systems, or personal knowledge assistants, this approach can turn isolated AI conversations into a continuously evolving knowledge system.
This post is part of AI Memory & Knowledge Systems – step by step