Guide · · 11 min read

How to Use Obsidian as Your Personal AI Memory

What you will learn

AI tools are powerful, but they are also forgetful. Every new conversation starts from zero. The model does not know your projects, your preferences, your codebase, your writing style, or the decisions you made last Tuesday. You end up repeating yourself constantly, re-explaining context that should already be established.

To be fair, some AI tools are getting better at remembering. Claude has a memory feature. ChatGPT has one too. But these come with caveats worth understanding. They are typically paid features, available only on higher subscription tiers. The memory is controlled by the provider, not by you. You cannot export it, edit it in bulk, or move it to a competing tool. And it is selective; the model decides what to remember based on its own criteria, which may not match what you consider important.

This guide shows you how to use Obsidian, a free, open-source note-taking application, as a personal memory layer for your AI work. By the end, you will have a system that stores your context, your prompts, your learnings, and your project knowledge in a format you own and control, ready to feed into any AI tool whenever you need it. Not a replacement for built-in memory features, but a foundation underneath them that you actually own.

This is not a theoretical exercise. I use this system daily across software development, business strategy, writing, and several other domains. It works.

Prerequisites

You will need Obsidian installed on your computer. It is free for personal use and available on Mac, Windows, Linux, iOS, and Android. Download it from obsidian.md.

You will also need an AI tool you use regularly. This guide is model-agnostic. It works with Claude, ChatGPT, Gemini, or any other tool that accepts text input. The whole point is that your memory lives outside any single vendor.

Some familiarity with Markdown is helpful but not essential. If you can write a heading with ## and a bullet point with -, you know enough.

Why Obsidian

There are many note-taking tools. Obsidian is particularly well suited to this task for several reasons.

Your notes are plain Markdown files stored locally on your computer. There is no proprietary format, no cloud dependency, no vendor lock-in. If Obsidian disappeared tomorrow, you would still have a folder full of perfectly readable text files.

The linking system lets you connect notes to each other, building a web of relationships between your projects, your prompts, your learnings, and your reference material. This mirrors how context actually works: nothing exists in isolation.

It syncs across devices. Obsidian Sync is a paid option, but you can also sync your vault via iCloud, Dropbox, Google Drive, or Git. This means the context you capture on your phone during a morning walk is available on your laptop when you sit down to work.

It is extensible. Community plugins add functionality without compromising the core simplicity. Several plugins are directly relevant to AI workflows.

And critically, it is local-first. Your data stays on your devices unless you choose otherwise. For anyone who cares about data sovereignty, and you should, this matters.

Step 1: Create your vault structure

Open Obsidian and create a new vault. Call it whatever makes sense to you. Inside it, create the following folder structure:

AI/
  prompts/
  context/
  learnings/
  projects/
Templates/

The AI/prompts/ folder will hold your reusable prompt templates. The AI/context/ folder stores persistent context documents about you, your work, and your preferences. The AI/learnings/ folder captures insights and patterns you discover while working with AI. The AI/projects/ folder holds project-specific context that you feed into conversations.

The Templates/ folder will hold Obsidian templates for quickly creating new notes in a consistent format.

Step 2: Build your personal context document

This is the most important file in the system. Create a new note in AI/context/ called About Me.md. This is a structured document that describes who you are, what you do, and how you work. It is designed to be pasted into AI conversations to give the model the background it needs.

Write it in the second person, as if you are briefing a new colleague. Include:

  • Your role and responsibilities. What you do day to day. What domains you work across.
  • Your technical environment. Languages, frameworks, platforms, and tools you use.
  • Your preferences. Coding style, communication style, formatting preferences, tools you favour.
  • Your constraints. Budget limitations, compliance requirements, team size, deadlines.
  • Your values. Open-source preferences, accessibility requirements, ethical considerations.

Keep it factual and concise. Aim for 300 to 500 words. This is not a biography. It is operational context.

Update this document whenever something significant changes. New role, new tech stack, new project. The document should always reflect your current reality.

Step 3: Create project context notes

For each significant project you work on, create a note in AI/projects/. A good project context note includes:

  • What the project is. One paragraph summary.
  • Current status. What has been done, what remains.
  • Technical details. Stack, architecture, key dependencies, database schema, API endpoints.
  • Decisions made. Important choices and the reasoning behind them. This is the context AI tools lose between conversations.
  • Known issues. Bugs, limitations, technical debt.
  • Relevant files and paths. Where things live in the codebase.

When you start an AI conversation about a project, paste the relevant project context note in at the beginning. The model now has the background it needs without you explaining it from scratch.

As the project evolves, update the context note. I find it useful to spend two minutes at the end of each working session updating the project note with whatever changed. Future you, and future AI conversations, will thank you for it.

Step 4: Build a prompt library

Every time you write a prompt that works well, save it. Create a note in AI/prompts/ with a descriptive name like Code Review Prompt.md or Meeting Summary Prompt.md.

A good prompt template note includes:

  • The prompt itself. The exact text you send to the AI.
  • What it is for. A one-line description of the use case.
  • Which models it works well with. You will find that some prompts perform differently across models.
  • Variables. Mark the parts that change each time with clear placeholders like [PROJECT NAME] or [CODE TO REVIEW].
  • Notes on what to watch for. Any quirks, common mistakes the model makes, or adjustments needed for specific situations.

Over time, this library becomes enormously valuable. Instead of crafting prompts from memory each time, you pull a tested template and customise it. Your results become more consistent and your process becomes transferable. If you ever switch AI providers, your prompt library comes with you.

Step 5: Capture your learnings

Every AI user accumulates knowledge about what works and what does not. Most people keep this knowledge in their heads, which means it is fragile, incomplete, and unavailable to colleagues.

Create notes in AI/learnings/ for patterns you discover. These might include:

  • "Claude handles long code files better if you break them into sections and reference them by name."
  • "For data analysis tasks, providing a sample of the expected output format dramatically improves results."
  • "GPT tends to over-complicate SQL queries. Always ask it to simplify after the first attempt."

These notes do not need to be long. A few sentences per learning is fine. The value is in having them written down and searchable rather than floating in your memory.

Step 6: Use templates for consistency

Obsidian's Templates core plugin lets you insert pre-formatted content into new notes. Set up templates for each note type in your AI workflow.

In Obsidian's settings, go to Core Plugins, enable Templates, and set the template folder to Templates/. Then create template files:

Templates/AI Prompt Template.md:

## Purpose
[What this prompt is for]

## Prompt
[The prompt text]

## Best with
[Which AI models work well with this]

## Variables
[Parts that change each time]

## Notes
[Quirks, tips, things to watch for]

Templates/AI Project Context.md:

## Summary
[One paragraph description]

## Status
[Current state of the project]

## Technical Details
[Stack, architecture, key dependencies]

## Decisions
[Important choices and reasoning]

## Known Issues
[Bugs, limitations, debt]

## Key Files
[Where things live]

When you create a new note, use the keyboard shortcut (Ctrl/Cmd + T on most setups) to insert the relevant template. This keeps your notes consistent and ensures you capture the right information every time.

Step 7: Link everything together

Obsidian's linking is what turns a collection of notes into a knowledge base. Use double-bracket links Note Name to connect related content.

Your project context note should link to the prompts you use with that project. Your learning notes should link to the projects where you discovered them. Your personal context document should link to your active projects.

This linking serves two purposes. First, it makes navigation fast. When you are about to start an AI conversation about a project, you open the project note and everything related is one click away. Second, it makes your knowledge visible. Obsidian's graph view shows you the connections between your notes, which can reveal patterns and gaps you would not otherwise notice.

Getting AI tools to write directly to your vault

This is where the workflow becomes genuinely powerful. Rather than copying AI outputs into your vault manually, you can set up many AI tools to read from and write to your Obsidian vault directly.

I use this approach daily. Claude, through its computer use and filesystem features, can access my vault, read my style guides and project context, and save outputs straight into the correct folder. The article you are reading now was written this way.

The specifics depend on the tool, but the common approaches are:

Claude with MCP (Model Context Protocol). Anthropic's MCP allows Claude to connect to local file systems. With an MCP server configured to access your vault folder, Claude can read your context notes, reference your prompt library, and write new files directly into your vault structure. This is currently the most capable integration available.

Claude Projects. Claude's Projects feature lets you upload reference documents that persist across conversations. You can upload your personal context document and key project notes as project knowledge. This is simpler to set up than MCP but the files are copies rather than live references, so they need updating manually when the originals change.

ChatGPT with file access. ChatGPT's Code Interpreter and file upload features allow you to share vault files for reference, though writing back to your local filesystem requires additional tooling.

Local models with file access. If you run open-source models locally through tools like Ollama or LM Studio, you can script direct read and write access to your vault since everything is on the same machine.

Obsidian plugins. Community plugins like Smart Connections and various AI assistant plugins can call AI APIs from within Obsidian itself, keeping everything inside the application. Results vary, but the ecosystem is maturing quickly.

The key principle is this: your vault becomes the single source of truth, and the AI tools connect to it rather than the other way around. You are not copying your knowledge into each vendor's platform. You are giving them access to a knowledge base you control.

Practical use cases

Starting a coding session

Open your project context note. Copy the summary, current status, and technical details. Paste it into your AI conversation as the opening context. Then ask your question. The model now understands the project without a ten-minute preamble.

Onboarding a new AI tool

When you try a new AI model or switch providers, your entire context library comes with you. Paste your personal context document into the first conversation. Pull in the project context you need. Use your tested prompts. Your productivity with the new tool ramps up in minutes rather than weeks.

Delegating AI tasks to a colleague

If someone else needs to use AI for one of your projects, send them the project context note and the relevant prompt templates. They now have everything they need to get useful results without reverse-engineering your workflow.

Reviewing and improving your AI process

Periodically browse your learnings folder. Look for patterns. Are you making the same corrections repeatedly? That suggests a prompt needs refining. Are certain types of tasks consistently producing poor results? That suggests you need a different approach, or perhaps a different model.

Protecting against vendor lock-in

Because everything lives in plain text files on your computer, you are never locked into any AI provider. Your context, your prompts, and your learnings are yours. If Claude doubles its prices tomorrow, you take your Obsidian vault to GPT and carry on working. The knowledge transfers because it is stored in a format you own.

This matters more than it might seem. Built-in memory features from AI providers are convenient, but they create a subtle dependency. The more an AI tool remembers about you, the harder it becomes to switch. Your Obsidian vault ensures that the knowledge lives with you, not with the provider. Use the built-in memory features if they help, but treat your vault as the canonical version.

Common issues and fixes

The context note is too long to paste. If a project grows complex, create a condensed version of the context note specifically for AI conversations. Keep the full version for your reference and a trimmed version (under 500 words) for pasting into chats.

Notes get stale. Set a recurring reminder, weekly or fortnightly, to review your active project notes and personal context. Stale context is worse than no context because it actively misleads the model.

Too many prompts to manage. Use Obsidian's tagging system. Tag prompts by domain (#coding, #writing, #analysis) and by model (#claude, #gpt, #gemini). This makes finding the right prompt fast even as the library grows.

Sync conflicts across devices. If using cloud sync rather than Obsidian Sync, occasional conflicts can occur when editing the same file on multiple devices. The simplest fix is to avoid editing the same note on two devices within a short window. If a conflict does occur, Obsidian will usually create a duplicate file that you can merge manually.

What to do next

Start small. Create your personal context document today. It takes fifteen minutes and it will improve every AI conversation you have from tomorrow onwards. Add a project context note for whatever you are currently working on. Save the next prompt that works well.

The system grows naturally from there. Within a few weeks you will have a personal AI memory that makes you measurably faster and more consistent, that works with any model, and that belongs entirely to you.

Your AI tools will forget everything by tomorrow. Your Obsidian vault will not.

guide obsidian ai-workflow memory context