Basic Memory MCP Server
Read, write and search a persistent Markdown knowledge graph of notes through Basic Memory's official MCP server.
What is the Basic Memory MCP Server?
The Basic Memory MCP server gives AI agents structured, permission-aware access to Basic Memory through the Model Context Protocol. With 26 pre-built actions, agents can read, create, and update Basic Memory data on behalf of authorized users.
Willow ships the Basic Memory MCP server as part of an enterprise control plane. Every call runs behind SSO (Okta, Azure AD), enforces RBAC and least-privilege at runtime, writes to a full audit trail, and integrates with Splunk and Loki for SIEM visibility. Connect from Claude Desktop, Claude Code, Cursor, ChatGPT, VS Code, n8n, or any custom agent. Install once, distribute org-wide, and see exactly how Basic Memory is being used by every AI agent in your stack.
Tools
bm_context
Follow the Basic Memory knowledge graph from a note: the note, its observations, and the notes its relations reach, up to `depth` hops (1-5). `identifier` is a path, permalink, memory:// URL, or a pattern such as 'specs/*'. `since` limits related results to recent changes. `compact` returns the graph without note bodies; read chosen notes with bm_read.
bm_delete
Delete a Basic Memory note (`identifier`) or a directory (`path`). A directory delete removes every file under it and needs `recursive=true`. Pass `expected_checksum` (from bm_read) to delete a note only if it is still the revision you read. A note that does not exist is an error. This cannot be undone.
bm_find
Find files in a Basic Memory project, recursively. With `name`, match file names against a glob ('*meeting*'). With `filters`, match notes by frontmatter, e.g. {"status": "active"} or {"priority": {"$in": ["high"]}}, and with `fields` return just those frontmatter values per note. `path` limits the search to a folder. For ranked text or meaning search, use bm_search.
bm_list
List one folder of a Basic Memory project: its subfolders, then its files with title, date and id. `project` is required; '/' lists its root. Discover projects with bm_project(command='list'). Filter files with `glob` and order them with `sort`. For a recursive search by name or frontmatter, use bm_find. Use this when the assistant needs a directory listing as data. To let the user browse folders visually, call `bm_open` with `view="folders"`.
bm_man
Read the Basic Memory manual. With no arguments, the index of every page. `page` reads one page: 'bm-search(3)' for an MCP tool, 'grep(1)' for a shell command; a tool name such as 'bm_search' works too. `query` lists the pages that mention every word given, like `man -k`.
bm_move
Move or rename a Basic Memory note (`identifier`) or a directory (`path`) within its project. `destination` is the new project-relative path; ending it with '/' moves into that folder under the current name ('archive/'). A note keeps its file extension ('.markdown' may become '.md'). Pass `expected_checksum` (from bm_read) to move a note only if it is still the revision you read. `destination_project` moves into another project: the note is written there as a new note (new id, its own history, links not rewritten) and deleted here; a directory moves note by note.
bm_schema
Basic Memory note schemas (Picoschema). `command`: validate notes against their schema (one `note_type`, one note by `identifier`, or every type that has a schema); infer a schema from the notes of a `note_type`; diff a `note_type`'s notes against its schema to find drift. A schema is a note with type: schema whose `entity` field names the note type it describes.
bm_search
Search a Basic Memory project, ranked by relevance. `query` supports quoted phrases, AND/OR/NOT and tag:name. `mode` picks hybrid (the default when semantic search is available), text, semantic, title or permalink (globs with *). Narrow with `filters` (frontmatter), `note_types`, `items` (notes, observations, relations) and `since`. `lines` returns the matching lines of each hit with that many lines of context, like grep. `path` limits the search to a folder; `identifier` searches one note. Scope every search with `project` (one project), `projects` (a list), or `all_projects=true`. Read full notes with bm_read. Use this when the assistant needs search results as data. To show interactive search results to the user, call `bm_open` with `view="search"`.
bm_write
Create or replace a Basic Memory note. Give a file path as `identifier` ('notes/plan.md'), or `title` plus `directory`. With a path the file lands exactly there and the title comes from the content's frontmatter, then `title`, then the file name. An existing note is an error unless `overwrite=true`; pass `expected_checksum` (from bm_read) to replace only the revision you read. To change part of a note use bm_edit. Content may hold frontmatter, observations ('- [category] fact #tag') and relations ('- relation_type [[Other Note]]').
bm_log
Read the Basic Memory workspace log: who changed which notes (created, updated, moved, deleted), folder and project changes, indexing, imports and agent runs, with who did each when known. Newest first, metadata only, with an opaque nextCursor to resume from. Each event has only the fields that say what happened; pass full=true for every field, including ids, checksums and app links. To read what a note says, use bm_read. For recently changed notes' content, use bm_project(command='recent', project='<project>'). Discover projects with bm_project(command='list').
search_note_mentions
Find authorized Cloud notes for the composer mention picker.
bm_open
Open the Basic Memory app when the user wants to open, browse, navigate, or interact with their notes visually: the notes gallery, a specific note or folder, search, or graph. Do not use only to retrieve information for the assistant's answer; use the data tools instead. The default workspace and project resolve automatically, so do not list projects first.
bm_read
Read a Basic Memory note or file by path, permalink, memory:// URL or exact title. Open review comments and suggestions come back as threads beside the prose (review_mode='raw' returns the stored bytes). Slice a long note with `section`, `start_line`/`end_line` or `max_tokens`. `versions=true` lists the note's stored versions and `version` reads one. `view='text'` shows what a reader sees, with ::bm-* components rendered. `include_content=false` returns only the metadata and the checksum that bm_write and bm_edit take as expected_checksum. A missing note is an error: find notes with bm_search. Use `bm_read` when the assistant needs note content to answer, summarize, compare, quote, or reason about it. `bm_read` does not open the Basic Memory interface; use `bm_open` when the user wants to see or navigate it.
bm_edit
Change part of an existing Basic Memory note. `command`: append or prepend `content`; find_replace `find_text` with `content` (exact text, which must occur `expected_replacements` times, default 1); replace_section, insert_before_section or insert_after_section for a `section` heading ('Decisions', 'Auth/Decisions', 'Decisions[1]', as bm_read takes it); set_metadata to merge `metadata` into the frontmatter without touching the body. Open review comments and suggestions are kept as they are; an edit that would change one is refused, so decide it with bm_review first. Pass `expected_checksum` (from bm_read) to edit only the revision you read. A missing note is an error; create notes with bm_write.
bm_project
Basic Memory projects and this Cloud workspace. `command`: list (projects, grouped by workspace); create (`name`, `path`, optional `set_default`, `workspace`); recent (what changed lately: `since` (default 7d), `items`, paging; recent requires `project`; use bm_project(command='list') to discover projects); info (how to register for Basic Memory Cloud and start a trial; if project or note tools fail, send the user to the Basic Memory app, then retry); usage (the workspace's credit usage, for owners and admins: `workspace`, `since` and `until` days (default the current billing period), `group_by`; partner staff: `customer`). List projects only when the assistant needs project metadata or the user asks for their projects. Do not list them as a prerequisite to `bm_open`; the interactive app resolves the default project itself.
bm_review
Comment on, suggest changes to, reply to, resolve, accept or reject review items on a Basic Memory note. First call bm_read, which shows the note's prose and its open review threads. Use command='comment' or 'suggest' with an exact prose anchor; command='reply' or 'resolve' with a review_id; and command='accept' or 'reject' for a pending suggestion. On 'suggest', body is the reason for the change and is saved as the first reply on the suggestion thread. Do not write CriticMarkup yourself. The tool attributes new records to the detected MCP client and saves each command atomically with checksum conflict protection. Accept and reject require the revision_checksum returned by bm_read because they change the document projection.
query_comark_for_widget
Run a bounded, project-scoped Comark query for the interactive app.
search_notes_for_widget
Search Basic Memory for the interactive search-results widget.
load_note_for_widget
Load one exact workspace/project/note identity for an MCP App.
load_note_image_for_widget
Load one project-local note image for the sandboxed MCP App.
check_note_revision_for_widget
Check whether one exact mounted note changed since a known checksum.
resolve_note_for_widget
Resolve a textual Basic Memory note identifier for an MCP App.
save_note_for_widget
Save one user-confirmed Markdown draft from the Basic Memory note widget.
load_projects_for_widget
Load project roots for the interactive location picker.
list_notes_for_widget
List one project or folder page for the interactive notes gallery.
load_knowledge_graph_for_widget
Load one project topology and its graph insights for the interactive app.
Customize Tools
Edit descriptions, modify arguments, select tools, or add new ones
Set Up Your Basic Memory MCP Server in Minutes
Add the following configuration to your MCP client. Authentication is handled via OAuth. Compatible with Claude Desktop, Claude Code, Cursor, ChatGPT, VS Code, n8n, and any MCP-compatible agent.
Claude Desktop
{
"mcpServers": {
"willow-basic-memory-official": {
"type": "http",
"url": "https://<org>.mcp-s.com/mcp/mcp/basic-memory-official"
}
}
}Cursor
{
"mcpServers": {
"willow-basic-memory-official": {
"type": "http",
"url": "https://<org>.mcp-s.com/mcp/mcp/basic-memory-official"
}
}
}Claude Code
claude mcp add willow-basic-memory-official --transport http https://<org>.mcp-s.com/mcp/mcp/basic-memory-officialn8n
{
"url": "https://<org>.mcp-s.com/mcp/mcp/basic-memory-official",
"method": "POST"
}Or click "Install with Willow" above to set up automatically with SSO and RBAC preconfigured.
Enterprise Governance for Basic Memory
Willow adds the layer Basic Memory and every other SaaS doesn't ship out of the box: every call runs behind SSO (Okta, Azure AD), enforces RBAC and least-privilege at runtime, writes to full audit logs, and detects shadow AI usage across your stack. One MCP gateway. Any agent. Every tool.
Basic Memory MCP Server FAQ
What is the Basic Memory MCP server?
The Basic Memory MCP server is a Model Context Protocol implementation that lets AI agents like Claude, Cursor, and ChatGPT read and write Basic Memory data through a standardized interface. Willow hosts and governs this server so enterprises can roll it out without a security review backlog.
How is Willow's Basic Memory MCP server different from the official one?
The official Basic Memory MCP server is scoped to a single user's account and does not include enterprise governance. Willow's version adds SSO, RBAC, audit logging, shadow AI detection, and centralized control over which actions agents can take across the entire org.
Which AI clients work with the Basic Memory MCP server?
Claude Desktop, Claude Code, Cursor, ChatGPT, VS Code with MCP support, n8n, and any custom agent built with OpenAI Agents SDK, LangChain, Vercel AI SDK, or Anthropic SDK.
Is the Basic Memory MCP server secure? How does Willow handle authentication?
Every call runs behind your existing SSO (Okta, Azure AD). Per-user OAuth scopes the agent to exactly what that user can do in Basic Memory, nothing more. No credentials reach the LLM. Every action writes to an audit trail.
Can I limit which Basic Memory actions agents can take?
Yes. Willow lets you scope agents to specific actions, specific projects, or specific environments. Toggle actions on or off in the dashboard, or enforce policy via infrastructure-as-code through GitHub.
How do I detect shadow Basic Memory MCP servers in my org?
Willow's browser extension and discovery service surface unmanaged MCP servers, skills, and AI agents across the org. If a developer installed an unapproved Basic Memory MCP locally, you'll see it.
What does the Basic Memory MCP server cost?
Pricing depends on org size and deployment model (SaaS, dedicated cloud, self-host). See withwillow.ai/pricing or contact sales for a quote.
How do I install the Basic Memory MCP server with Willow?
Install via the Willow Connect Panel in one click, or paste the JSON snippet above into your Claude Desktop, Cursor, or Claude Code config. SSO and RBAC inherit from your existing Willow setup.
Compare Willow MCP Gateway
See how Willow stacks up against other MCP platforms on governance, security, and enterprise readiness.
Your agents are already in the wild.
Give them a Basecamp. Go from AI chaos to AI work, in minutes.