Obsidian

MCP文档知识

提供方 未标注

文档知识 未标注 OAuth 授权 社区 / 第三方 Claude DesktopClaudeCursorVS Code

自托管MCP服务器,用于Obsidian:支持语义搜索与全文搜索、维基链接图谱、笔记增删改查、OAuth认证,以及自描述的知识库指南。

一句话选型结论

按资料字段整理

Obsidian 属于文档知识类 MCP 服务器,传输方式未标注,OAuth 授权,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式未标注 鉴权OAuth 授权 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 OAuth 授权
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 使用前要准备好OAuth 授权对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Obsidian当前 未标注 未标注 未标注 无 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式OAuth 授权远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

98.6 KB
来自项目仓库与上游目录的原文,未做删改

Obsidian MCP Server

Your agents' memory, in the vault you already have, reachable from
claude.ai, ChatGPT, Claude Code and your phone.

A self-hosted Model Context Protocol
server over an Obsidian vault. Three things it does that the
alternatives mostly don't:

  • Your existing vault, served in place. No imposed note format, no
    sidecar syntax, no "memory" folder you have to adopt. Agents read what
    you read, follow your wikilinks, and pick up your folder layout,
    frontmatter schema and tag conventions from the vault itself.
  • Remote and multi-user. OAuth 2.0 PKCE and API keys, so claude.ai,
    Claude Desktop, Claude mobile, ChatGPT, Claude Code and n8n all read
    and write the same files, each user confined to their own vault root.
  • Writes cannot clobber. expected_hash preconditions refuse an
    edit made from a stale read, every publish is atomic and
    no-clobber by default, deletes go to .trash/, and dry_run returns
    the diff before anything lands.

Connect from Claude Code:```bash
claude mcp add obsidian --transport http \
--url "https://obsidian-mcp.<your-domain>/mcp" \
--header "Authorization: Bearer omcp_..."


In claude.ai, Claude Desktop or ChatGPT, add a custom connector at
`https://obsidian-mcp./mcp` and sign in through the OAuth
consent page. Connect a client has the rest.

Stack: Python 3.12, FastAPI, PostgreSQL with pgvector. Pluggable
embeddings (Ollama bge-m3, or OpenAI `text-embedding-3-{small,large}`).

## Contents

- Why this exists
- A session at the keyboard
- A session away from the keyboard
- What&#x27;s in the box
- vs. other Obsidian MCP servers
  - vs. hosted memory systems
  - vs. an agent with raw file access
- Who this is for
- Control panel
- Quick start
- Upgrading
- Cost expectations
- The self-describing vault
- Multi-user mode
- Configuration
- Architecture
- Project layout
- Development
- Security notes

## Why this exists

There are three things going on here, and they&#x27;re more interesting
together than apart.

### 1. Agent memory that you can actually read

If you let an agent run for a while, it needs memory. Most setups
solve this with an opaque vector store, a SQLite blob, or a managed
&quot;memory&quot; service that you can&#x27;t see into. That works until you want to
know what the agent thinks it knows about you, or you need to correct
something, or you want to understand why it just made a weird
suggestion.

This server gives you a different deal. Agent memory lives as markdown
files in your vault. Folder structure, file names, frontmatter, all
visible. You can open the file in Obsidian and read it. You can edit
it. You can delete it. You can grep it. The agent&#x27;s &quot;memory&quot; is a
human-auditable artifact that sits in the same place as your own
notes, with the same tools available.

The home lab is the use case that sold me on this. My vault has notes
on the rack, the network, and every Home Assistant integration. I can
say &quot;set up a night-light mode in the master bathroom, 1% after 11pm&quot;
and a sysadmin agent finds the right config, makes the change, and
updates the doc in the same pass. Six months later when I&#x27;ve
forgotten how it works, the answer is in the vault, not buried in
some chat history I can&#x27;t search.

The semantic search and wikilink graph still work over that material,
so retrieval is fast and conceptual. But the substrate is files you
own, not a black box.

To be precise about the scope: what the server supplies is
MCP-accessible storage, keyword and semantic search, and graph
operations over markdown notes, for whatever MCP clients you connect.
The agents direct their own reads and writes. There is no extraction
or decay pipeline running behind them, and nothing rewrites a note
because a model judged it stale: an agent remembers something because
it wrote a note, and forgets it because someone deleted one. By late
2026 that is less of a contrarian position than it sounds. Every
vendor&#x27;s consolidation step (the &quot;dreaming&quot; or &quot;sleep-time&quot; job) has
turned into a separate process you can inspect, rather than silent
extraction inside the write path. This server keeps the agent as the
author. The consolidation help it will grow is a hygiene report that
proposes merges and flags duplicates, and never writes
(#359), not
a pipeline that edits your notes while you are not looking.

### 2. A shared memory layer between you and your agents

The other half runs the other way: the vault isn&#x27;t only the agents&#x27;
memory, it&#x27;s mine. I think of my Obsidian vault as my exocortex. The
&quot;big me&quot; that includes notes, calendars, scripts, search, and AI
assistants is substantially more capable than the &quot;small me&quot; of the
biological brain alone. It&#x27;s also where I do most of my thinking,
because writing something down is itself a form of thought.

The problem is that until recently, the vault was passive. I had to go
find things. Agents that wanted to help me had to be briefed from
scratch every session, and they had no way to see what I&#x27;d already
written about a topic.

This server fixes that. Now the same vault feeds my own daily writing
and any agent I plug into it. The agent reads what I read, links what
I link, follows the same wikilinks, sees the same frontmatter. When I
write a project note on Sunday, my Monday-morning briefing agent
already knows about it. When the agent leaves notes from a research
session, they show up in my normal Obsidian search.

A concrete version of this: I&#x27;ll spend a session in Claude Code on a
project, wrap up, push the commits, and then just say &quot;update
Obsidian.&quot; The agent reads the vault guide, figures out where project
notes live in my structure, picks the right format and frontmatter,
and leaves a session log I can later roll into a status report. No
path-passing, no telling it what to write — the conventions are
already in the vault, and it follows them.

That&#x27;s the exocortex idea made concrete: one place that holds
context, and both the human and the agents reading and writing into it
on the same terms.

### 3. The vault follows you

The thing that still surprises me is that this is internet-facing.
Same vault, same notes, reachable from anywhere I happen to be
talking to an agent — Claude in a browser tab, Claude on my phone on
the train, an n8n workflow firing on a schedule, a Claude Code
session on whatever laptop is in front of me. All behind OAuth or a
bearer key, all hitting the same source of truth.

So when I hear an interesting podcast on a commute and want to think
out loud about it with Claude on my phone, the agent isn&#x27;t starting
cold. It can pull up what I&#x27;ve already written on adjacent topics,
surface a note I half-finished six months ago, and at the end of the
conversation suggest updates and write them in. The vault doesn&#x27;t
have to be near me to be the thing I&#x27;m working in. (A session away
from the keyboard walks through
exactly one of these.)

## A session at the keyboard

To make the abstract concrete, a short transcript from a real
session. Tool calls inline; the user types in plain English and the
agent picks the right tool.```
you  &gt; find anything I&#x27;ve written about why retrieval-augmented
       chat is hard

claude
  → semantic_search(query=&quot;why retrieval-augmented chat is hard&quot;)
    • 2025-12-03 - RAG failure modes.md
    • 2025-10-18 - Chunking tradeoffs.md
    • 2024-06-22 - Vector recall vs precision.md

  the closest hit is your December note on RAG failure modes. let
  me see what it&#x27;s connected to.

  → get_neighborhood(path=&quot;2025-12-03 - RAG failure modes.md&quot;,
                     depth=1)
    8 connected notes. notable ones:
    • &quot;Hybrid search&quot; — a re-ranking design you sketched but
      didn&#x27;t ship
    • &quot;Out-of-distribution queries&quot; — a half-finished draft from
      October
    • &quot;Embedding model choice&quot; — links to bge-m3, your current
      model

  you have three connected pieces here: a failure-modes catalog,
  an unshipped hybrid-search sketch, and an abandoned O-O-D draft.
  want me to summarize all three together, or pull up the draft
  so you can decide whether to finish it?

you  &gt; pull up the draft, and tag it #revisit-2026 in frontmatter
       while you&#x27;re there

claude
  → read_note(path=&quot;2025-10-18 - OOD queries (draft).md&quot;)
  → set_frontmatter(
      path=&quot;2025-10-18 - OOD queries (draft).md&quot;,
      updates={&quot;tags&quot;: [&quot;draft&quot;, &quot;rag&quot;, &quot;revisit-2026&quot;]}
    )

  here&#x27;s the draft, and the tag is on. you stopped right before
  the section on confidence thresholds; the open question you
  left yourself was…

Two things to notice. First, the agent didn't need to be told what
folder to look in or what tools to use — it picked them. Second, the
write at the end is structured (set_frontmatter mutating YAML, not
a regex over the file body), so the note round-trips cleanly. The
self-describing vault and the wikilink graph are doing the work that
makes this feel natural.

A session away from the keyboard

The transcript above is the easy case: I'm at a desk, I can see what
the agent is doing, and Obsidian is one alt-tab away. The session that
actually changed how I think about this server had none of that.

I was out walking with a health podcast in my ears — a long one, two
people who clearly disagreed with each other, an hour of it. I had my
phone and no intention of going home to a laptop. So I pulled the
episode's transcript, handed it to Claude on my phone, and we talked
it through while I kept walking: what the actual claim was, which
parts I already had notes on, where it cut against something I'd
decided months ago and written down at the time.

The agent had the vault the whole way. It surfaced what I'd already
written on the topic, flagged that two dates in an older note were
wrong, and asked whether a decision I'd recorded last year still stood
given what the episode argued. By the time I got back it had written
all of it in: the health-related decisions I'd actually landed on
during the walk, the date corrections in the old note, a couple of new
notes on the episode itself — and, because the conversation kept
circling back to it, a durable note on how I decide which experts to
trust on medical questions in the first place. That last one is the
artifact I keep returning to. It wasn't about the episode at all; it
was the reasoning underneath a whole class of decisions, and it now
sits in the vault where the next agent will find it.

I never opened Obsidian. Not on the walk, not when I got home. The
whole session — retrieval, argument, correction, and the writing that
came out of it — went through an agent, and the vault is simply where
it landed. Obsidian is how I check the work afterwards, not how the
work gets done. That inversion is most of the reason this project
looks the way it does.

What's in the box

The server exposes 25 MCP tools across five families, plus the auth
and ops layer around them.

Every tool is published with a title and MCP ToolAnnotations, all
four hints set explicitly: readOnlyHint on the fifteen tools that only
read (search, read, list, graph, check_upload), destructiveHint on
the eight that can replace or remove something (edit_note,
move_note, delete_note, set_frontmatter, write_file,
delete_file, import_from_url, and request_upload, whose link can
overwrite on redemption), openWorldHint on import_from_url only.
create_note and request_download are additive. Clients that honour
annotations run read-only tools without a per-call confirmation (Claude
Code also runs them in parallel) and keep prompting on destructive ones.
They are hints: the server enforces read-only credentials itself,
regardless of what a client does with them. The initialize result also
carries a short instructions paragraph — what the vault is, which tool
to reach for, and the write-safety rules — for clients that load only
tool names at session start. No description exceeds 4,000 characters on
the wire, so none is cut off by a client's description limit.

Search and discovery

  • keyword_search(query, folder?, tags?, frontmatter?, limit=20),
    full-text via PostgreSQL tsvector. A note's title and frontmatter
    aliases rank above its body, so a query that is a note's title finds
    that note first; bare terms are ANDed, and when the full matches do not
    fill the page, partial matches follow tagged match: any; every row
    carries a snippet: with the matches highlighted (or head:, the
    note's opening words, for a title match). The text-search config(s) are
    configurable via FTS_CONFIGS (see
    Full-text search language(s))
  • semantic_search(query, folder?, tags?, frontmatter?, limit=15),
    vector similarity via pgvector, one preview chunk per note
  • list_notes(folder?, limit=50), sorted by modified time
  • get_recent(folder?, limit=20), recently changed, with each
    modification time in UTC (YYYY-MM-DD HH:MM UTC)
  • get_tags(limit=50), tag and count
  • get_vault_guide(), the Obsidian primer plus this vault's
    CLAUDE.md, served live

Read and write

  • read_note(path, section?, offset=0, limit?) returns a structured
    result
    — path, title, tags, frontmatter_yaml and a JSON
    frontmatter view, heading (section reads), content, and
    truncation as data (truncated, offset, next_offset,
    total_chars, outline, notice). Bounded by
    MAX_READ_RESPONSE_CHARS (default 40,000) — see
    Response size limits. section=
    returns one section's body instead of the whole note; offset
    continues a truncated read.
  • create_note(path, content), atomic write, refuses overwrite
  • edit_note(path, …) with four mutually exclusive modes: full
    replace (default), append=True, find=… (with optional
    replace_all), or section= (ATX headings, supports
    Parent/Child path-style and #N ordinal disambiguation).
    dry_run=True returns a unified diff without writing. Legacy clients
    may use operation=&quot;append&quot;; operation=&quot;replace&quot; explicitly selects
    full replace.
  • move_note(from_path, to_path, rewrite_links=False), relocates and
    optionally rewrites incoming [[Old]], [[Old|alias]],
    [[Old#anchor]], ![[Old]], and [[folder/Old]] references in
    source notes
  • delete_note(path, permanent=False), soft-delete to
    .trash/--&lt;8 hex&gt; by default, via a single
    non-replacing rename, so it never overwrites an existing trash entry
    (a filesystem that cannot do that rename makes the soft delete refuse
    with a named error rather than fall back). permanent=True unlinks.
  • set_frontmatter(path, updates, remove?), structured YAML
    mutation. Body is byte-identical when only frontmatter changes.

File access (non-markdown)

Raw read/write/browse of arbitrary vault files (PDFs, images, skill
assets, data files) — distinct peers to the note tools, which stay
markdown-only. Pure byte transport: no server-side PDF/text extraction,
no embedding or indexing of non-markdown files.
- read_file(path, encoding=&quot;auto&quot;, offset=0, limit?), returns
text-like files as text, images as an inline image block that renders
in-client, and other binaries as a base64 string. text/base64
force the form. Refuses files over MAX_FILE_READ_BYTES (default
10 MB); text results are additionally bounded by
MAX_READ_RESPONSE_CHARS and continue via offset. hash_only=True
returns the whole file's content_hash without content; base64 results
include that hash in their header. Text results remain plain text.
- write_file(path, content, encoding=&quot;base64&quot;, overwrite=False),
lands a file in the vault; base64 for binary, text for UTF-8.
No-clobber by default, auto-creates parent dirs, atomic write.
Capped at MAX_FILE_WRITE_BYTES (default 25 MB).
- list_files(folder=&quot;.&quot;, pattern=&quot;*&quot;, recursive=False, limit=200),
ls-style browse of files and subdirectories with size and mtime,
glob-filterable and result-capped.
- delete_file(path, permanent=False), soft-deletes a non-markdown
file to .trash/--&lt;8 hex&gt; with a single
atomic rename. Refuses markdown (that is delete_note), directories,
and symlinks.

All four reuse the path-traversal guard and exclude any path with a
component starting with . (dot-directories and dot-files)
(.obsidian, .git, .trash, …), matching the indexer's visibility
rule.

Guarding edits against stale reads

Pass a read's content_hash as expected_hash when editing, updating
frontmatter, moving or deleting a note, overwriting a raw file, or deleting
a raw file. The canonical token is sha256:&lt;64 lowercase hex&gt;, computed
over the complete raw file bytes; a section or truncated read_note still
returns the whole-file hash. For raw files, use read_file(hash_only=True)
or the base64 header. Do not hash the returned text yourself.

A stale token refuses the operation before mutation, with a final
MCP-REFUSAL JSON line naming stale_precondition and the current hash.
Re-read and reconsider the edit before retrying. Moves bind the source
note only; moves and deletes still allow an in-place edit after their
preflight comparison. Overwrites retain their separate in-call byte check.
Successful publishing writes report a new hash when available.

The argument is optional by default. WRITE_PRECONDITION_REQUIRED=true
requires it on the supported destructive calls; enable this only after
clients supply tokens. Creation is exempt and refuses a supplied token
as no_incumbent. Files above their read cap cannot be guarded.

File transfer

No MCP client can hand a tool the bytes of a file the user is looking
at, so write_file is only usable when the agent already has the
content. These tools close that gap with short-lived capability links,
redeemed over the public /transfer/* routes.
- request_upload(path, overwrite=False, expires_in?), mints a
single-use link bound to exactly one destination path. The human
opens it, picks a file, and it lands at path — nothing else can be
written with it.
- check_upload(upload_id), reports pending / uploading /
completed (with path, size, sha256 and MIME) / unknown (a stream
started and the server never recorded how it ended — read the path
before re-minting) / revoked (the credential or vault root changed
under the link) / expired, scoped to the identity that minted it.
- request_download(path, expires_in?), mints a link the human can
save one vault file from. Usable more than once until it expires, and
bound to the file's exact bytes at mint time.
- import_from_url(url, path, overwrite=False), fetches a public https
asset straight into the vault under an explicit outbound deny policy
(no private, loopback, link-local, metadata or tunnelled addresses,
in any spelling, re-checked at every redirect).

The token travels in the URL fragment, which browsers never send, so
no server-generated request target or access log contains it. Uploads
are claimed before a body byte is read, published atomically with
no-clobber semantics, and bound at mint time to the file state they
were minted against — a link cannot silently undo an edit made while it
was waiting. MCP_HOSTNAME or BASE_URL must be set; without a public
origin the mint tools refuse rather than emit a localhost link.

Wikilink graph

  • get_backlinks(path, limit=50), notes linking TO path
  • get_links(path), outgoing links, both resolved and dangling
  • get_neighborhood(path, depth=1, limit=50), undirected BFS over the
    resolved-link graph, capped at depth ≤ 5 and limit ≤ 200
  • find_related(path, limit=10), semantic neighbors via averaged
    chunk embeddings and pgvector cosine distance, deduped per note
  • find_orphans(folder?, limit=50), notes with zero in or out
    resolved links

Auth and ops

  • API keys with the omcp_ prefix, stored as SHA-256 hashes, with
    read and readwrite permission scopes. Write tools refuse on
    read-only keys.
  • OAuth 2.0 PKCE (S256) flow for public and confidential clients,
    including ChatGPT, Claude Desktop, and claude.ai. Dynamic registration
    defaults to both vault permission levels; the user chooses the actual
    grant on the consent screen.
  • Control panel (Jinja2, hand-written CSS, vendored Chart.js, nonce-based
    CSP) for keys, usage logs,
    indexer status, embedding-provider info, and a danger-zone reset.
  • Every tool call is logged to usage_logs with name, params
    (truncated to 200 chars), duration, response size, and the calling
    credential's name — recorded at call time, so the audit trail
    survives deleting the key or OAuth client it describes.
  • /health is unauthenticated and returns status plus two capability
    fields: transfer_mount_check_available (the kernel supports the
    mount check transfer writes need) and
    vault_named_staging_fallback_active (a write has actually staged
    under a name on this process).
  • /health also carries an indexer object (status, task_running,
    failing_scopes, embedding_failing_scopes,
    max_consecutive_failures, quarantined_notes, last_success_at),
    and the top-level status becomes &quot;degraded&quot; when the indexer task
    has died, any index, embedding or enumeration failure counter — or a
    scope's run of incomplete re-derives — reaches
    INDEXER_DEGRADED_AFTER_FAILURES, or a note is quarantined. The HTTP
    code stays 200
    — a restart cannot repair vault content or a provider
    outage, and Kubernetes uses /health for liveness — so monitor the
    status field
    (a keyword or JSON check for &quot;status&quot;:&quot;ok&quot;), not
    the status code. Counts only: no path, error text or user id.

Every write — note tools, write_file, uploads and imports — stages
the new bytes in a temporary inode, fsyncs them, and only then
publishes. Creation publishes with a kernel-atomic hard link that
refuses to clobber; move_note and the soft delete publish with a
single non-replacing rename; an overwrite is a same-directory rename
onto the destination. The destination directory (and any directory the
call created) is fsynced afterwards, so a crash mid-write can neither
truncate a note nor lose one the server reported as written.

Staging happens in an unnamed inode wherever the filesystem supports
one, so no temporary name is ever visible in the vault. On a mount that
refuses that (some NFS exports do), those writes refuse with an error
naming VAULT_ALLOW_NAMED_STAGING_FALLBACK; setting that flag takes
named staging back on both write paths as a declared, weaker guarantee.
See System requirements.

vs. other Obsidian MCP servers

The field has sorted itself into two shapes since this README was
first written, and the axis that matters is not "lightweight versus
heavy" but where the agent runs relative to the Obsidian app.

Desktop-local. The tool talks to a running Obsidian. The Local
REST API plugin has shipped its own Streamable HTTP MCP server
since 4.0.0 (2026-05-15), and 5.5.0 (2026-10-17) added If-Match
conditional writes and result caps, so it is no longer "glue" but a
real local MCP endpoint. The official Obsidian CLI (1.12)
reads, writes, searches and walks backlinks, and requires the app to
be running. In-app agent plugins sit in the same group. All of these
get the app's own metadata cache for free; none of them work on a
headless box, and none give claude.ai or a phone a way in without you
exposing your desktop.

Headless and remote. The server works on the vault files directly,
wherever they are mounted, with no Obsidian process. This server is one. Vault Cortex (aliasunder,
September 2026) is a single container with OAuth 2.1, SQLite FTS5 plus
sqlite-vec fused by RRF and a local reranker, tasks and daily-note
helpers, and a bundled Obsidian Headless Sync client; one vault per
container, no multi-user. StevenStavrakis/obsidian-mcp v2
(2026-08) is a stdio server with journaled atomic writes,
etag/if_match preconditions and 30-day recovery snapshots, and no
semantic search. jacksteamdev/obsidian-mcp-tools was archived on
2026-05-13 and is dropped from the table.

If Obsidian is open on the machine the agent runs on and you need no
remote access, the official CLI or the REST plugin is the lighter
choice. This server is for the headless, remote, multi-client and
semantic case: nothing on the box but a container and Postgres, and
every client you own hitting the same vault.

As of 2026-10-28:

This server REST plugin MCP Obsidian CLI Vault Cortex StevenStavrakis v2
Runs without Obsidian ✅ — — ✅ ✅
Semantic search ✅ pgvector — — ✅ sqlite-vec + RRF + reranker —
Wikilink graph ✅ backlinks, neighborhood, orphans, related backlinks backlinks, orphans, dead ends backlinks, outgoing, orphans —
Atomic / journaled writes ✅ staged, fsync, no-clobber publish ? ? ✅ temp + rename ✅ journaled, rollback, snapshots
Write preconditions (hash / etag) ✅ expected_hash ✅ If-Match (5.5.0) — — ✅ if_match
Dry-run diff ✅ — — — —
Soft-delete to trash ✅ .trash/ ? ✅ ✅ ✅ 30-day snapshots
Multi-user vault roots ✅ — — — — (multi-vault, one user)
OAuth for claude.ai / ChatGPT ✅ 2.0 PKCE + API keys — (API key) n/a ✅ 2.1 PKCE + DCR n/a (stdio)
Audit log ✅ per call, in the panel ? — server logs transaction journal
Setup tax Postgres + Docker Obsidian + plugin Obsidian 1.12 one container (Sync subscription for the remote image) Node 22

The table reflects each project's documented features on that date,
read from their READMEs and release notes; a ? means I could not
confirm it either way. Verify the specifics before betting on them.

vs. hosted memory systems

The comparison that matters more, now that most of my vault traffic is
agents rather than me, is against memory as a service: your agent
calls an API, the service stores what it's told, and it hands back
what it judges relevant later. mem0, Zep and Letta are the names
people usually reach for. What follows is about that architecture —
memory behind a service boundary — not about any one product's current
feature list, which moves faster than a README can track.

One thing has changed since that paragraph was first true: files
plus search is now the mainstream substrate, not the odd one out.
Letta's MemFS is git-backed markdown; Claude Code's auto-memory is a
MEMORY.md index plus topic files; Anthropic's memory tool is a file
directory; OpenClaw and Hermes keep markdown workspaces. "Readable
markdown memory" on its own no longer sets this server apart. The
closest comparables are Basic Memory (markdown plus a SQLite or
Postgres index, hybrid search, an optional reranker, structured
frontmatter filters; its own folder and note format, AGPL, with a paid
cloud) and doobidoo/mcp-memory-service (self-hosted, remote MCP
over OAuth, opaque memory records rather than files). Against those,
the differences are five, and plain:

  1. The existing vault, served in place, with no imposed folder or
    note format.
  2. Remote and multi-user over OAuth, one vault root per user.
  3. Destructive-write guards: expected_hash, atomic no-clobber
    publish, .trash/, dry-run diffs.
  4. MIT.
  5. No hosted tier, and none planned.

The difference from memory-as-a-service is where the memory lives and
who can open it.

  • Readability. When memory sits behind a service API, reading it
    means whatever endpoint or console the service exposes, in whatever
    shape it stores. Here the memory is the artifact:
    Health/2026-08 - Trusting expertise.md, in a folder, in your
    editor, in grep. There's no gap between what the agent stored and
    what you can look at.
  • Shared with you, and between agents. A memory service is
    generally scoped to an application and its users; the human's own
    writing is a different system. Here it's one corpus. I write into it
    by hand, and every connected client — Claude Desktop, Claude Code,
    Claude on the phone, an n8n workflow — reads and writes the same
    files on the same terms. A note I type on Sunday is context for an
    agent on Monday with no import step.
  • Portability. The exit path from a folder of markdown is cp -r.
    No export format, no migration script, no question about what you'd
    be left holding if a project stopped being maintained. That's a
    property of files, not something this server does for you.
  • Self-description. The rules live in the corpus rather than in
    client config. CLAUDE.md at the vault root tells every agent, on
    its first call, where things go and what frontmatter they carry, so
    conventions are versioned next to the notes they govern.

What the hosted shape buys you in exchange is real, and worth saying
plainly. There's no Postgres to run, no pgvector version to keep
current, no container to babysit — you get a memory layer by adding a
dependency, which is a genuinely better trade for most people. And
systems in that class typically do work this server deliberately
doesn't attempt: pulling facts out of a conversation automatically,
reconciling ones that contradict each other, and scoring relevance or
decaying old memories so they stop crowding out new ones. Here an
agent remembers something because it decided to write a note, and the
judgment about what's worth keeping is the agent's, not the server's.
The consolidation help planned here is a report that proposes and
never writes (#359).
If you want memory that curates itself, that's a fair reason to pick
the other shape.

vs. an agent with raw file access

The other baseline isn't an MCP server at all: point Claude Code, a
generic filesystem MCP, or any agent with file tools straight at the
vault folder. That works — until a write goes wrong. An agent
rewriting a whole file from its memory of an earlier read will
eventually clobber a note, follow a symlink somewhere it shouldn't,
or "tidy up" your .obsidian config. Nothing in a raw file API

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

6 问
答案由本站依据条目字段整理,不引用上游原文
Obsidian 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Obsidian 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Obsidian 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Obsidian 需要 API Key 吗?

资料标注需要OAuth 授权认证,使用前准备好对应凭据,并按最小权限配置。

Obsidian 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Obsidian 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。