Supercharge your knowledge management - integrating Obsidian MCP with Claude

Staying organised in Obsidian can feel like a full-time job, especially when your notes start multiplying across projects, ideas, and domains. Imagine you’re working on a long-term research project. You’ve got dozens of notes scattered across different folders: meeting summaries, article highlights, draft outlines, and to-do lists. Manually curating and connecting them is time-consuming.

Now, imagine asking your AI assistant: “Summarise my notes on cognitive science from last month and create a dashboard of key insights in my Obsidian.” And it does exactly that.

By integrating Claude with Obsidian using the Model Context Protocol (MCP), this kind of interaction becomes possible. Claude can read, organise, and restructure your Obsidian vault, generate summaries, build dashboards, and surface insights, all without leaving your workspace. This guide walks you through setting up the Claude-MCP integration, so your AI assistant becomes a true thinking partner inside Obsidian.

What you’ll learn

Setting up the Obsidian MCP server to connect with Claude
Configuring Obsidian’s REST API for secure integration
Creating the proper Claude configuration for the MCP tools
Practical applications like vault restructuring and dashboard creation
Troubleshooting common integration issues
Advanced use cases and combinations with other MCP servers

Prerequisites

Before we begin, ensure you have:

Claude Desktop app installed
Obsidian installed and a vault created (or use an existing one)
Python is installed on your system
UV package manager installed (a faster alternative to pip)
Basic familiarity with JSON configuration and file paths

Let’s get into it

Understanding the architecture

The integration works through a client-server architecture:

Claude's desktop acts as the MCP client, sending requests to access your notes
MCP-Obsidian serves as the MCP server, handling these requests
Obsidian REST API provides the backend connection to your vault

When Claude needs to read or write to your Obsidian vault, it sends a structured request through the MCP protocol to the MCP-Obsidian server, which then communicates with Obsidian through its REST API. This architecture allows Claude to perform operations like creating notes, establishing connections, and organising your knowledge base.

Part 1: Setting up Obsidian

Installing the REST API plugin

Obsidian doesn’t have a built-in REST API, so we’ll need to install a community plugin:

Open Obsidian and your desired vault
Go to Settings → Community plugins
If this is your first plugin, turn on Community Plugins by clicking the toggle
Click Browse and search for “REST API”
Install the plugin named “Local REST API” and enable it

Obtaining the API key

Once the REST API plugin is installed:

Go to Settings → REST API
You’ll see an API key displayed (it’s a long string of characters)
Click to copy this key, we’ll need it for the MCP-Obsidian server
Note: The API key is sensitive information. When using it locally, security concerns are minimal, but avoid sharing it publicly

Part 2: Installing the MCP-Obsidian server

Now we’ll set up the MCP-Obsidian server that will bridge Claude and your Obsidian vault:

Open a terminal or command prompt
Install UV if you haven’t already:
‍

curl -LsSf https://astral.sh/uv/install.sh | sh

‍

or for macOS with Homebrew:
‍

brew install uv

‍

Clone the MCP-Obsidian repository:

git clone https://github.com/MarkusPfundstein/mcp-obsidian.git
cd mcp-obsidian

‍

Create a .env file in the repository folder to store your Obsidian API key:

echo "OBSIDIAN_API_KEY=your_api_key_here" > .env

‍

Replace your_api_key_here with the API key you copied from Obsidian.

Note the full path to the cloned repository, you’ll need this for the Claude configuration. For example: /Users/username/claude-mcp-configs/mcp-obsidian

Part 3: Configuring Claude for MCP integration

Now we’ll configure Claude to connect to the MCP-Obsidian server:

Open the Claude Desktop app
Go to Settings → Developer → Edit config
This will open the config.json file, where we’ll add our MCP-Obsidian configuration
Add or modify the configuration for MCP-Obsidian:
‍

{
      "model": "claude-3-5-sonnet",
      "mcpServers": [
        {
          "name": "obsidian",
          "command": "/opt/homebrew/bin/uv run -m mcp_obsidian.main",
          "cwd": "/Users/username/claude-mcp-configs/mcp-obsidian",
          "env": {}
        }
      ]
    }

‍

Important notes about this configuration:

-Replace /opt/homebrew/bin/uv with the path to your uv installation (find it using which uv in the terminal)

-Replace /Users/username/claude-mcp-configs/mcp-obsidian with the path to your cloned repository

-The order of arguments is critical, note the run command comes before the -m mcp_obsidian.main parameter

-If you’re using uvx instead of uv (as in some cases), adjust accordingly

Save the config file and restart Claude Desktop

Critical configuration troubleshooting

One of the most common issues (which I personally encountered) is incorrect argument order in the uv command. The correct pattern is:
‍

uv run [options] script [script_arguments]

‍

If you see an error like the unrecognised subcommand '/Users/your/path', it likely means the arguments are in the wrong order. Ensure that the run comes before your script path or module.

Part 4: Testing the integration

After restarting Claude, let’s verify that the integration is working:

Look for the tool icon in the Claude interface, indicating available MCP tools (there should be 8 tools from the Obsidian MCP)
Try a simple test query like: Create a new file in my Obsidian vault called "test.md" with the content "This is a test file created by Claude."

Claude will ask for permission to use the MCP tool. You can allow it for just this chat or for all chats
Check your Obsidian vault to see if the file was created

If everything worked correctly, you should see the new file in your Obsidian vault. Congratulations! You’ve successfully integrated Claude with Obsidian.

Part 5: Real-world use cases

Vault restructuring and organisation

One of the most powerful applications is having Claude analyse and restructure your Obsidian vault. I’ve used this to:

Reorganise files into logical categories (Personal and Work)
Create consistent folder structures for different projects
Organise technical documentation
Implement better organisational systems for my notes

For example, ask Claude:

Analyse my vault structure and suggest a better organisation for my Work/Projects folder. Create necessary folders and move files accordingly.

‍

Creating dashboard notes

Claude excels at creating dashboards that provide quick access to important information:

Create a Professional Dashboard for my Work section that links to all important project folders, reference materials, and technical documentation.

This automatically creates a centralised dashboard with:

Links to active projects
Categorized resources
Quick access to frequently used files
Status overviews for ongoing work

Implementing organisational frameworks

Claude can help implement and maintain structured organisational frameworks like the PARA method (Projects, Areas, Resources, Archives):

Analyse my vault and reorganise it according to the PARA method. Create appropriate folders and README files for each section.

This creates a well-structured vault with:

Projects folder for time-bound activities
The Areas folder for ongoing responsibilities
Resources folder for reference materials
Archives folder for completed or inactive items

Template management and consistency

I’ve used the integration to maintain consistent templates throughout my vault:

Create a template for project notes that includes sections for objectives, status, and key resources.

Claude can then apply these templates consistently across your vault, ensuring standardised note structures.

Part 6: Integration with other MCP servers

The true power of this setup emerges when combined with other MCP servers:

Memory MCP + Obsidian MCP

I’ve found this combination particularly powerful. Memory MCP allows Claude to remember details about your vault structure, preferences, and past interactions across sessions. With both servers enabled:
‍

{
  "model": "claude-3-5-sonnet",
  "mcpServers": [
    {
      "name": "obsidian",
      "command": "/opt/homebrew/bin/uv run -m mcp_obsidian.main",
      "cwd": "/Users/username/claude-mcp-configs/mcp-obsidian",
      "env": {}
    },
    {
      "name": "memory",
      "command": "node /path/to/memory/dist/main.js",
      "cwd": "/path/to/memory",
      "env": {
        "MEMORY_PATH": "/Users/username/claude-mcp-configs/memory.json"
      }
    }
  ]
}

‍

This allows Claude to:

Remember your vault organisation preferences over time
Recall previous restructuring work, it’s done
Understand your organisational patterns
Provide more consistent organisational suggestions

SequentialThinking MCP + Obsidian MCP

When working with complex vault organisations, adding SequentialThinking MCP enables Claude to:

Break down complex vault reorganisation tasks into discrete steps
Plan methodical reorganisation of large vaults
Design sophisticated dashboard structures
Provide step-by-step reasoning for organisational decisions

This is particularly useful when working with large vaults containing technical documentation or multiple projects that require careful organisation and dashboard creation.

Part 7: Advanced tips and best practices

Create a dedicated Claude project

For optimal results, create a dedicated Claude project specifically for Obsidian interaction:

In Claude Desktop, create a new Project named “Obsidian Note Taker”
Add project instructions like:

Use the Obsidian MCP tools as much as possible to help me organise and enhance my knowledge base. Always look for opportunities to create meaningful connections between notes and maintain a consistent structure.

This ensures Claude is proactively using the Obsidian tools whenever appropriate

Security considerations

While the integration is powerful, keep these security considerations in mind:

Only expose the vault directories you’re comfortable with Claude accessing
Consider using a separate test vault initially before connecting your main knowledge base
Regularly check what files Claude has created or modified
Be cautious about sharing your configuration with others

Path specifications

When working with files in your vault, be clear and specific about paths:

Use relative paths from the vault root: Work/Projects/ProjectA/notes.md
For new files, specify the complete path: Create a new file at Personal/Ideas/concept.md
If using multiple vaults, always specify which vault you’re referring to

Troubleshooting

Claude can’t find the MCP tools

If the tools icon doesn’t appear or shows fewer than expected tools:

Check your config.json for syntax errors
Verify the paths to uv and your MCP-Obsidian repository
Ensure the API key in your .env file matches the one from Obsidian
Try running the command manually in your terminal to check for errors

Permission issues

If Claude asks for permission repeatedly or can’t connect:

Check that the REST API plugin is enabled in Obsidian
Verify that Obsidian is running when you make requests
Try restarting both Claude and Obsidian

Path resolution problems

If Claude can’t find or create files at the specified paths:

Check that you’re using paths relative to the vault root
Ensure parent directories exist before creating files in them
Verify that the vault location is correct in your configuration

Conclusion

Integrating Claude with Obsidian via the Model Context Protocol (MCP) turns a personal knowledge base into an intelligent, adaptive system. You get the best of both worlds: Obsidian’s local-first, markdown-based structure and Claude’s ability to interpret, organise, and act on that structure in real-time. This isn’t just about productivity hacks, it’s about scaling your thinking.

With this setup, Claude becomes more than a passive assistant. It actively collaborates with you, restructuring folders based on content patterns, generating context-aware dashboards, auto-tagging new notes, and even maintaining consistent naming conventions across your vault. It reduces friction at every layer of knowledge management.

This integration has reshaped how I work in Obsidian. I now spend more time writing, connecting ideas, and thinking, and less time dragging files, fixing folder chaos, or building manual indexes. Claude automatically surfaces related notes, groups them into logical hierarchies, and keeps evolving the structure as the vault grows.

Over time, the system adapts to your workflow. For instance, it can learn that you prefer project notes grouped by quarter or that you separate deep research from meeting summaries. You can also script custom automation through Claude to generate weekly digests, build project timelines from scattered notes, or convert raw thoughts into structured documentation.

The more you use it, the more it becomes your second brain, organised not by rules, but by understanding.

Resources

‍