Willder

MCP文档知识

提供方 未标注

文档知识 HTTP · 远程 API Key 社区 / 第三方 ClaudeCursorVS CodeCodex
查看接入方式

一个用于同步应用、智能体和团队的上下文层。每个智能体都有自己的限定范围、可撤销令牌;一个智能体写入的内容,其他智能体会在下次调用时读取;连接器将你的应用接入,并遵循相同的规则。MIT 许可,可自行托管。

一句话选型结论

按资料字段整理

Willder 属于文档知识类 MCP 服务器,HTTP · 远程,API Key,可直接接入 Claude、Cursor、VS Code 等,有可直接复制的远程端点配置。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

HTTP · 远程 API Key
连远程 HTTPS 端点,通常为 Streamable HTTP
npx add-mcp 'https://willder.ai/api/mcp'

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    确认你的客户端支持远程端点,并拿到服务地址。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude、Cursor、VS Code,换客户端不用重新研究配置。

先想清楚的地方

  • 远程端点依赖网络与服务方可用性,注意密钥与调用额度。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

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

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Willder当前 未标注 HTTP · 远程 支持远程部署 有 2026-11-20
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

服务器档案

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

详细介绍

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

Willder

Apps, Agents, Teams Synced.

Willder is a context layer that syncs your apps, agents and teams, with access control on every
call and real-time coordination: what one agent writes, the others read on their next call. Each
agent holds its own scoped, expiring token; its memory reads and writes pass one check and land
in the audit log; revoke a token and its next call is refused. Connect your Claude Code or
Cursor agent over MCP in five minutes.

Website ·
Docs ·
Architecture ·
Connect a client ·
Discussions

What it does

  1. The right context, unasked. At the start of a task an agent gets a short brief of what
    matters for it: the scope's rules, decisions and recent writes, ranked by the task's words.
    Queries search by words, by meaning and by links in the graph.
    Task-start briefs,
    hybrid retrieval.
  2. One memory across every agent. What Claude Code saves, Codex reads on its next call, with
    who wrote it. Change a fact once and every agent reads the new version.
    Versions and conflicts.
  3. Connectors into scopes. GitHub, Google Drive, Slack, Figma and PostHog sync into a scope
    you choose, under that scope's rules. services/connectors/.
  4. Access control. Each agent holds its own scoped, expiring token. Its memory reads and
    writes pass one check and land in the audit log; a revoked token is refused on its next call.
    What the check does not cover is listed under Limits.
    The single check.
  5. Set up in minutes. One command connects Claude Code; Codex, Cursor and other clients
    have a page each. Connect a client.
  6. Memory you can see. Every fact keeps who wrote it, where it came from, what it replaced
    and which agents first read it. Audit and provenance.

How it works```mermaid

flowchart LR
accTitle: The parts of Willder and how a request moves through them.
accDescr: An MCP client with a capability token and a person in the web app both reach the memory operations. check() decides each guarded operation against Postgres and writes an audit row. Allowed operations read and write the Postgres stores, including pgvector, and the graph through the memory service, which owns Neo4j and the embedding model.
mcp["MCP client: agent token"] --> ops["Memory operations"]
web["Web app: signed-in person"] --> ops
ops --> chk{"check()"}
chk --> pg[("Postgres: scopes, grants, tokens, audit_log, versions, pgvector chunks")]
chk -- allow --> pg
chk -- allow --> ms["Memory service: FastAPI, BGE-384 embeddings"]
ms --> neo[("Neo4j via Graphiti: facts and relations")]


Deep dives: architecture, hybrid retrieval,
conflict resolution, database,
API, export format, self-hosting.

## Why

You run several agents on real work: a coding agent in the repo, a research agent on a
schedule, a side project's agent. Nothing decides what each may see, tells the others when one
changes something, or records what was read. Willder is the memory they share and the fence
between them: scopes, per-agent tokens, a change feed and an audit, with no model in any
access decision.

## Run it on your machine

This repository is the engine: Postgres with pgvector, Neo4j, the memory service and the MCP
server. It runs on your own machine with no willder.ai account and no call to willder.ai. You
need Docker with Compose v2, Node 20.19+, 22.12+ or 24+, and a few GB of disk. Without Docker,
docs/self-host.md says what to run instead.```bash
git clone https://github.com/willderai/willder-core.git && cd willder-core
npm install
cp .env.selfhost.example .env          # then set GRAPHITI_SERVICE_API_KEY to any string
docker compose up -d --wait            # Postgres, Neo4j, the memory service; the first build takes minutes
npx prisma migrate deploy              # create the tables
npm run selfhost:smoke                 # write, scoped read, refusal, export, no outside calls

The smoke ends with 9 of 9 steps passed. docs/self-host.md describes each
line it prints and what to do when one fails.

Mint a token for your agent. One per agent, scoped and expiring:```bash
npm run selfhost:token -- --scope team --agent claude-code


It prints a `wcap_...` token once. Put it in an environment variable and nowhere else:```bash
printf 'Willder token: '
stty -echo; read -r WILLDER_TOKEN; stty echo
printf '\n'
export WILLDER_TOKEN

Connect Claude Code to the local stdio MCP server, from this directory:```bash
claude mcp add -s user willder-local -e WILLDER_CAPABILITY_TOKEN="$WILLDER_TOKEN" \
-- npm --prefix "$PWD" run --silent mcp


Then tell the agent: `Save this to Willder: we store sessions in Postgres, not Redis, so they survive a restart. Then ask Willder where we store sessions and why.`
It calls `memory_ingest` with two required arguments, `content` (the fact) and `name` (what the
fact is about), and gets back the id a later update passes as `baseVersion`:```
Stored and readable now; graph extraction continues in the background. Version: <version id>.

Then it calls memory_query, which returns one bullet per fact with when and who wrote it (an
agent that has only a token is named by it, quoted), notes on what its grant let it read, and the
answer's revision:```
• we store sessions in Postgres, not Redis, so they survive a restart. (as of <when it was stored>) — from: "claude-code" (agent token) (agent) · version <version id>
revision: <16 hex characters>


A token for another scope (`npm run selfhost:token -- --scope research --agent second-agent`)
gets `No facts found.` for the same question. Other clients: docs/connect/;
the stdio server and its tools: mcp/README.md.

The engine calls out to one thing at most, and only if you configure it: an OpenAI-compatible
model endpoint that extracts facts on writes (a local server works; without one a write is still
stored and readable, and only graph extraction is skipped). The web app is optional: it needs a
free Clerk development instance to sign people in, and
docs/self-host.md lists the other outside calls it makes.
An export is one JSON Lines file in a documented format:
docs/export-format.md.

Prefer not to run it? The hosted service at willder.ai runs the same
engine: docs/quickstart.md.

## Prove it does not leak

Two checks, about ten minutes, and neither needs an account. The second revokes the
`claude-code` token from Run it on your machine (any token you are
willing to revoke works).

**1. Run the leak suite.** From a fresh clone, with Node 20.19, 22.12 or 24:```bash
git clone https://github.com/willderai/willder-core.git &amp;&amp; cd willder-core
npm ci
npm run test:leaks

Installing takes about a minute; the suite runs in seconds with no keys and no network. It
is every test file named *eval.test.ts, *leak.test.ts or *leakage.test.ts: check(),
the guarded memory reads and the MCP tool bodies run for real, and only the database and
memory backends are stubbed. A pass ends with no failed file. One file,
app/api/briefs/staleness-scope-leak.test.ts, reports as skipped unless QA_DATABASE_URL
names a test Postgres (docs/development.md). The suite asserts that:

  • a token scoped to one team never receives a sibling scope's facts, graph nodes, uploaded
    files or briefs, and the in-scope token still does, so an over-broad filter fails too;
  • a revoked or expired token is refused on every memory tool over the real MCP endpoint;
  • a call without a real caller identity is denied, never audited under a stand-in actor;
  • the account tier can narrow a read and never widen one;
  • the same holds with thousands of facts and concurrent callers, and a backend failure is
    reported as a failure, not as an empty answer.

A few cases are named GAP:. They pass by pinning a known defect, and each one says what
the correct behaviour is. The suite proves the code; step 2 proves the running service.

2. Revoke a token and see its next call refused. Revoke the agent's token from the
terminal:bash npm run selfhost:token -- --revoke claude-code

It prints each token it revoked by id, scope, permission and expiry, never the token, and nothing
waits for the token to expire. What the agent sees next depends on how it connects:

  • A stdio MCP server already running, like the claude mcp add connection above: it keeps
    listing its tools, but every memory call after the revoke is refused and nothing is read or
    written. Memory tools answer Access denied: no valid capability for agent claude-code granting read (or write) on the target scope …, and each refusal is a deny row in the audit log
    under the call's own action (memory.read, memory.write or memory.entity).
  • A stdio MCP server started with the revoked token exits before connecting, with
    WILLDER_CAPABILITY_TOKEN is not a live token in this database (unknown, expired or revoked),
    and records a capability.refused row.
  • Over HTTP, the web app's /api/mcp or https://willder.ai/api/mcp on the hosted service,
    the next call gets HTTP 401 with Invalid or unknown capability token. and a
    capability.refused deny row for that agent.

npm run selfhost:export holds every one of those refusals as audit lines.

Measured on the hosted service

Measured with dates: the first three rows on the hosted service at willder.ai, the setup row in
a clean container. The harness that produced them is not in this repository. Implementation is
not proof, and nothing here is a guaranteed latency.

Claim Evidence Status
Access control under failure: scoped tokens, default deny, a token revoked mid-sequence denied on its next call, one audit row per read and per refusal 2026-10-01: held under six concurrent readers and a revoke mid-sequence Proven in production at failure load
Connected sources: connect, ask, get a cited answer, disconnect, answer gone 2026-09-26, GitHub: 5 of 5 steps, sync 177.6 s, cited answer in 0.9 s, answer gone 1.6 s after disconnect. Disconnect mid-sync and credential failures are measured separately Proven in production at normal load (GitHub); other connectors not individually measured
Real-time memory: a write is readable by other agents on their next call 2026-10-02, six concurrent writers: 60 of 60 writes acknowledged, write-to-read p50 575 ms, p95 1025 ms timed from before the write is sent Proven in production at six concurrent writers
Setup: clone to first query, following the ten-minute local path in docs/development.md 2026-10-07: scripted cold install on a clean Ubuntu 24.04 container, 254.4 s from machine start to the first answer (102.6 s of it after the clone), zero stalls, first answer No facts found. Scripted operator, reading time excluded. One measured sample, not a promised time

Audit rows are evidence of access decisions, not proof that an answer is correct. The
code-level leak claims are reproduced without an account by npm run test:leaks
(Prove it does not leak).

Limits

Each line names the file that makes it true.

  • Who can see what is decided by check() in the application, not by the database. No
    row-level security is enabled (no migration in prisma/migrations/ creates a policy), so
    the credentials listed in the next section reach memory without check().
  • Source permissions do not carry over. A connected source takes the access of the
    scope it lands in, not its own sharing list. Connecting asks you to acknowledge any
    widening, people and agents both, before it goes ahead
    (services/access/source-widening.ts).
  • Conflicting writes are detected and notified, nothing more. When two agents write the
    same fact in one scope within one second, the version stored first stays current, the
    later one is recorded as superseded, and its writer is told on its next tool call. Both
    versions stay readable (services/memory/conflict.ts, mcp/README.md).
  • No cost saving is claimed. No measure of tokens per run has run on a deployed commit.
  • Connectors read, with one write. GitHub, Google Drive, Slack, Figma, PostHog and
    websites today (SourceType in prisma/schema.prisma); no Linear connector. The one
    write into a connected tool is exporting a brief as a new Google Doc in the org's
    connected Drive (POST /api/briefs/[id]/export-doc, createGoogleDoc in
    services/connectors/gdrive.ts). Nothing else writes back to a connected tool
    (services/connectors/source-readers.ts).
  • The memory service needs Neo4j and a local embedding model (about 130 MB), plus an
    extraction model key to write. Reads work without a model key
    (memory-service/README.md, memory-service/app/config.py).
  • OAuth-only clients cannot connect yet. claude.ai and ChatGPT sign in with OAuth, which
    is built but off until MCP_OAUTH_ENABLED is turned on in production
    (mcp/oauth-discovery.ts); until then hosted MCP needs a client that sends the bearer header.
  • MCP has no delete tool. A fact is replaced with memory_ingest and baseVersion;
    deleting one goes through the app (mcp/tools/, mcp/README.md).
  • The Starter account tier returns no facts. It allows only the source and files
    stores, and memory search reads only the graph and vector stores
    (services/memory/account-tiers.ts, services/memory/hybrid-store.ts).

Credentials that bypass the authorizer

Memory in Postgres is read and written through check() in services/access/check.ts.
The lint gate eslint/eslint.memory-access.mjs enforces this in code: a query against a memory
table (a model marked @memory in prisma/schema.prisma) outside services/access and
services/memory fails npm run scope-gate:check in CI, and no eslint-disable comment
can silence it there. The gate does not cover the memory
graph: a few routes and jobs still write it through the unguarded memory store export
rather than guardedMemory, and the gate does not see those calls. The authorizer runs
inside the application, so a person holding one of these credentials can reach memory
without it.

Credential What it reaches without check() Read by
DATABASE_URL, DATABASE_URL_UNPOOLED Every Postgres table, memory tables included. No row-level security is enabled. build.sh runs migrations with it, so it can also change the schema. lib/db.ts, prisma.config.ts, build.sh
NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD The memory graph itself: every org's entities, facts and episodes. memory-service/app/config.py, lib/inngest/scheduled-jobs.ts
GRAPHITI_SERVICE_API_KEY The memory service's HTTP API. It trusts whatever group_id the caller sends, so the key can read or write any org's graph partition. memory-service/app/main.py (require_api_key), services/memory/graphiti-store.ts
INNGEST_EVENT_KEY, INNGEST_SIGNING_KEY Background jobs. The memory-ingest, file-ingest and connector-sync jobs write what their event payload names, because the request that sent the event has already been authorized. A forged event writes memory into any scope. The Inngest SDK, through lib/inngest/client.ts and app/api/inngest/route.ts
BLOB_READ_WRITE_TOKEN Uploaded source files, stored privately under memory//, before extraction. @vercel/blob, through lib/blob-storage.ts; memory-service/app/config.py
CLERK_WEBHOOK_SECRET, CLERK_WEBHOOK_SECRET_2 A forged membership event writes an episode naming the member into the org's graph through the unguarded store, and deletes that user's row. app/api/webhooks/clerk/route.ts
APP_ENCRYPTION_KEY With database access, the sealed connector and mailbox credentials (Source.encryptedTokens, Integration.encryptedTokens, mailbox OAuth tokens), and through them the connected sources that memory is built from. lib/crypto.ts, services/integrations/mailbox.ts
LANGFUSE_SECRET_KEY Agent traces. These record the full prompt, including memory an agent was allowed to read. services/langfuse.ts
VERCEL_TOKEN, or other access to the Vercel project's environment Every value above. The QA sandbox reads the token wherever it is set, and uses it with VERCEL_TEAM_ID and VERCEL_PROJECT_ID (without them, on Vercel, it authenticates by OIDC); a token with access to the project can read its environment. services/agents/qa-sandbox.ts; Vercel

Credentials that act as someone through the authorizer are not on this list, because
check() still decides what they can do: capability tokens, a Clerk session, and
CLERK_SECRET_KEY (which can sign in as any user). Revoking or narrowing those works as
described above. Rotating one of the credentials in the table is the only way to cut off
whoever holds it.

npm run bypass-credentials:check (scripts/check-bypass-credentials.mjs) keeps this
table honest: it fails when the code or .env.example reads a credential that is neither
listed here nor recorded there with the reason it does not reach memory.

Reference

  • docs/self-host.md: every self-host step, tokens, revoking, export, refusals, no Docker.
  • mcp/README.md: tools, permissions, the local stdio server.
  • docs/development.md: the web app and local development.
  • docs/willder_api.md: the route map.
  • docs/architecture.md: the architecture, with diagrams and measured numbers.
  • docs/README.md: every document in this repository, one line each.

Contributing and security

CONTRIBUTING.md covers tests, lint and what a PR
needs. Report a vulnerability per SECURITY.md, not in a public issue.

MIT, see LICENSE.

常见问题

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

在客户端按下面的安装命令接入:npx add-mcp 'https://willder.ai/api/mcp'。装完在客户端配置里引用同一个包或端点。

Willder 怎么在 Claude、Cursor、VS Code 里配置?

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

Willder 收费吗?

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

Willder 需要 API Key 吗?

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

Willder 支持哪些客户端?

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

Willder 能提供哪些能力?

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

Willder 需要什么运行环境?

属于远程端点,不需要在本地装运行时。

Willder 是本地还是远程?

它是远程端点,连服务地址即可。传输方式为HTTP · 远程。

热门专题

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

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