Obsidian AI MCP: Connect an Assistant to Your Vault

Obsidian AI MCP means connecting your AI assistant to your vault using the Model Context Protocol (MCP), a standard that lets a supported app read and update an outside tool during a session. The assistant can search your notes, retrieve specific files, and in some cases write new ones without you copying content into the chat. Tools like fenbs keep the project decisions and current tasks that your AI also needs, separate from the vault notes, so each session can use both.

Obsidian does not ship a first-party MCP server. What exists are community-built servers, most connecting through the Obsidian Local REST API plugin or reading vault files directly from disk. This guide walks through choosing and setting one up, deciding what access to allow, and figuring out what project information belongs in fenbs rather than as a note.

What an Obsidian MCP server actually does

A standard MCP server exposes a list of tools your AI app can call. For an Obsidian server, those tools typically include searching notes by keyword or tag, retrieving the content of a specific note, and optionally creating or updating notes. The assistant calls these tools automatically during a session when you ask something the notes can help answer.

The Local REST API plugin is the most common bridge. It starts a small HTTP server inside Obsidian, and the MCP server calls that API to perform vault operations. A filesystem-based server reads vault markdown files directly, which works without a running Obsidian instance but may miss live edits until you save. See mcp-apps for a broader look at what MCP servers can do.

Choose the right server before connecting

Before installing anything, decide what you want the assistant to do with your vault. Read-only access is simpler and safer; write access is useful for note capture but needs a review step. Check what each server exposes in its README: the list of tools is the clearest guide to what the assistant can call.

• Read-only servers: fewer risks, good for research and retrieval.
• Write-enabled servers: useful for note capture but need review before syncing.
• Filesystem servers: no plugin required, work with vault markdown files on disk.
• REST API servers: richer set of operations, require the Local REST API plugin running.

Set access limits before the first session

Most servers let you restrict access to a specific folder or exclude sensitive folders. Use that option. A vault with personal notes, client records, or private logs should not be fully exposed to an AI session. Create a dedicated working folder and point the server at it, expanding scope only when you have a clear use case.

• Restrict the server's root to the folder the assistant actually needs.
• Disable write access unless you have a specific capture workflow in mind.
• Keep sensitive notes in a separate vault or a folder outside the server's path.
• Test with a small collection of notes before exposing the full vault.

Connect the server to your AI app

Once you choose a server, install it and configure your AI app to use it. Each app that supports MCP has its own setup screen; the Integrations page covers the ones fenbs supports. The configuration usually needs the server's name, the command to start it, and the vault path or API key the REST plugin generated.

Test the connection with a simple request: ask the assistant to list notes in your test folder. If it returns the expected files, the connection works. If it returns nothing or an error, check whether the REST API plugin is enabled in Obsidian and whether the vault path in the configuration is correct.

What to keep in the vault and what to keep in fenbs

Vault notes work well for reference material: research you have collected, templates, documentation, and personal knowledge that accumulates over time. What a vault cannot hold well is the current work record: which project tasks are active, which decisions have been made, and where the last session left things.

Keep those in fenbs. A connected assistant can read fenbs Decisions and rules at the start of a session, check the current task state, and look up a relevant vault note for source material in the same session. The two complement each other. For more on building this kind of combined setup, see what an AI brain is.

How to set this up with fenbs

Connect both your Obsidian MCP server and fenbs to the same AI app, then use the vault for source content and fenbs for project context.

1. Create a free account and add a project for the work that uses the vault. Write a short description of the goal and the vault's role in it.
2. Write Decisions and rules for the access boundaries: which folders the assistant may read, whether it may write, and what to do if a note is ambiguous.
3. Add the project's current tasks so the assistant knows what work is active before searching the vault.
4. Connect both the Obsidian server and fenbs to your AI app via Integrations. Ask the assistant to read the fenbs context before querying the vault.
5. Before each session ends, ask the assistant to save progress in fenbs so the next session knows where to start.

When the connection stops working

A failed connection usually has one of three causes: the REST API plugin is not running in Obsidian, the vault path in the server configuration is wrong, or the server process exited. Check each in that order. If the server uses the Local REST API plugin, confirm the plugin is enabled and Obsidian is open.

• Restart Obsidian and confirm the Local REST API plugin shows as active.
• Verify the vault path or API key in the server configuration matches what the plugin shows.
• Run the server's start command manually in a terminal to see its output and any errors.
• Check the MCP client log in your AI app for connection error details.