Skip to content
MCP Shelf

Basic Memory MCP Server

Long-term memory as plain Markdown files you own.

View on GitHub
  • Not yet tested by us
  • ★ 4.4K GitHub stars
  • 15.7K downloads a week
  • Last commit 27 Oct 2026

What is Basic Memory?

Basic Memory is an open source MCP server that gives AI assistants a lasting memory kept as plain Markdown notes on your own computer, which you can read and edit in any editor or Obsidian.

Tools
27
Runs on
Your computer
Licence
AGPL-3.0-or-later
GitHub stars
4.4K

Good for

  • Carrying project context between chats
  • A personal knowledge base the assistant can add to
  • Keeping memory local instead of in a vendor account

You'll need

  • uv (for uvx)

Not yet tested by usWritten from the project's own documentation. We have not run this config ourselves yet.

MCP Shelf take

We started Basic Memory on our own test machine on 26 Oct 2026 and it answered with 27 tools. 21 of the 27 only read; the other 6 can change things. Every tool comes with a useful description, all of them say whether they change things, and the tool list costs about 3,200 tokens of context before you ask a thing. It sits 5th of 16 in its category on our shelf by GitHub stars (4.4K, with 15.7K downloads a week).
MCP Shelf tests: numbers from our own runs, not the README · tested on 26 Oct 2026

What can Basic Memory read and change?

It can read

  • Markdown notes in your Basic Memory project folders
  • A local search index built from them

It can change

  • Creates, edits, moves and deletes Markdown files in those folders
  • Keeps the index in sync when you edit notes by hand

Safer setup: Keep the notes folder in git or a synced drive so you can roll back any edit the AI makes.

Basic Memory in more detail

Basic Memory writes notes as ordinary Markdown in a folder on your machine (by default ~/basic-memory) and indexes the links between them. The assistant can write notes, search them and follow connections in later conversations.

Because the notes are just files, you can open them in Obsidian or any editor and edit them yourself.

Made by
Basic Machines
Latest version
0.24.1 (23 Oct 2026)
PyPI package
basic-memory
Downloads
15.7K a week
Last commit
27 Oct 2026
Setup checked
27 Oct 2026
Page updated
27 Oct 2026

What's in the pod

What tools does Basic Memory have?

We found 27 tools when we started it on 26 Oct 2026. 21 only read. The rest can change things, so keep your app's "ask before each tool call" setting on for them.

Changes things6 tools · Can create, edit, send or delete.

ToolWhat it is for
create_memory_projectStarts a new notes project in a folder you choose.
delete_noteDeletes a note.
delete_projectRemoves a project from Basic Memory without deleting your files.
edit_noteChanges part of a note: append, prepend, swap a section or find and replace.
move_noteMoves or renames a note and keeps its links working.
write_noteCreates or overwrites a Markdown note with facts, tags and links to other notes.

Only reads21 tools · Looks things up and changes nothing.

ToolWhat it is for
basic_memory_diagnosticsReports the installed version, Python and settings, for bug reports.
build_contextFollows links out from a note to gather everything related, so a new chat can pick up the thread.
catPrints a note, or just a section or a range of lines from it.
fetchReturns one note in the format ChatGPT's connector expects.
findLists notes by file name pattern or by frontmatter values such as status.
grepFinds notes that contain given words, or that match by meaning.
list_directoryLists the folders and notes inside a project.
list_memory_projectsLists your notes projects and which one is the default.
list_workspacesLists cloud workspaces you can reach, for team accounts.
lsLists one level of a folder, or all projects at the top.
manLooks up Basic Memory's built-in manual.
read_contentReads a file exactly as stored, including images, without note processing.
read_noteReads a note by title, permalink or memory:// link.
recent_activityShows what changed lately across your notes.
schema_diffSpots where notes of one type have drifted from their schema.
schema_inferSuggests a schema by studying existing notes of one type.
schema_validateChecks notes against the schema written for their type.
searchReturns top matches in the format ChatGPT's connector expects.
search_notesSearches notes, facts and links by keyword, meaning or both, in one project or all of them.
tailLists the most recently changed notes.
view_noteReads a note and asks the client to show it as a formatted document.

Grouped and described by us. The README on GitHub lists the inputs each tool takes.

How clearly it describes its tools to your assistant

Tools with a description
27 of 27
Say if they change things
27 of 27
Context it takes, at least
~3,200 tokens

Every tool says whether it only reads or can change things, so a client can ask before the risky ones.

From the tool list it sent us. The token figure counts names, descriptions and input names; the full schemas your client loads add more.

How do I install Basic Memory?

Install steps from the Basic Memory README

The project's own instructions, copied from its README on GitHub on 28 Oct 2026 under its AGPL-3.0-or-later licence. They are the source of truth; the ready-made configs further down are built from them. The rest of the README is in the README tab.

Get started

Pick the path that fits you. Both run the same product on the same Markdown.

☁️   Cloud 💻   Local install

30 seconds. Sign up, connect your AI client, done.

  • Works in any browser
  • Mobile, web, desktop
  • Cross-device sync built in
  • We handle hosting, backups, snapshots

$15.00/mo locked for life · 7-day free trial · cancel any time

Start free trial →

2 minutes. Install, configure your AI client, run.

  • Free forever (AGPL-3.0)
  • All data on your disk
  • Air-gapped friendly
  • Requires Python via uv
uv tool install basic-memory --prerelease=allow

--prerelease=allow is required: Basic Memory 0.23 depends on a FastMCP 4 pre-release, and uv only accepts pre-releases of transitive dependencies when told to — without the flag it silently installs an older release. The same flag goes on every uvx / uv tool upgrade command below.

For Postgres deployments that store semantic vectors in Milvus, install the first-party optional extra instead:

uv tool install "basic-memory[milvus]" --prerelease=allow

Configure your client ↓

Connect your AI client

If you went the Cloud route, the web app walks you through client connect. The snippets below are for local installs.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["--prerelease=allow", "basic-memory", "mcp"]
    }
  }
}

Restart Claude Desktop. Notes live in ~/basic-memory by default.

Claude Code, Codex CLI, Cursor, VS Code, ChatGPT, Obsidian
Claude Code
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp

For the full memory bridge — session briefings, pre-compaction checkpoints, and the /basic-memory:* commands — also install the Claude Code plugin on top of this.

Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.basic-memory]
command = "uvx"
args = ["--prerelease=allow", "basic-memory", "mcp"]

Codex can keep its default MCP approval behavior, or you can pre-approve eligible Basic Memory tools by adding this server-scoped setting to the same table:

[mcp_servers.basic-memory]
command = "uvx"
args = ["--prerelease=allow", "basic-memory", "mcp"]
default_tools_approval_mode = "approve"

This does not disable Codex approvals globally or expand which Basic Memory projects the server can access. Codex still requires approval for tools that advertise a destructive annotation, including Basic Memory's writes, edits, and deletes. If you installed the Basic Memory Codex plugin, use its plugin-scoped configuration instead.

Cursor

Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["--prerelease=allow", "basic-memory", "mcp"]
    }
  }
}
VS Code

Add to your User Settings (JSON):

{
  "mcp": {
    "servers": {
      "basic-memory": {
        "command": "uvx",
        "args": ["--prerelease=allow", "basic-memory", "mcp"]
      }
    }
  }
}
ChatGPT

Basic Memory exposes OpenAI-compatible search and fetch tools for Custom GPT actions. See the ChatGPT integration guide.

Obsidian

No setup. Point Obsidian at ~/basic-memory (or your project folder) and the same wikilinks, frontmatter, and Markdown your AI writes appear in your graph view. Edit either side — sync handles the rest.

Try a prompt:

"Create a note about our project architecture decisions."
"Find information about JWT auth in my notes."
"What have I been working on this week?"

What you need first

  • uv (for uvx)

Add Basic Memory to your app

Pick your app for a ready-to-paste snippet and where it goes, built from the steps above.

Where it goes: Your terminal, in the project folder

Claude Code
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp

For session briefings and the /basic-memory commands, also install the project's Claude Code plugin with bm install claude-code once the server is connected.

Keep --prerelease=allow: Basic Memory 0.23 depends on a pre-release of FastMCP, and without the flag uv quietly installs an older release.

Checked against the project's own install docs on 27 Oct 2026: basicmachines-co/basic-memory README.

Did this work for you?

Projects change their install steps often. If Basic Memory did not install, or something here no longer matches the project, tell us and we will check it against the README and fix the page.

New to this? See the setup guides for Claude Code, Cursor, Claude Desktop, VS Code, Codex and ChatGPT. If it will not start, test it in MCP Inspector and look up the error in Fixing MCP server errors.

Basic Memory not working? Common fixes

Search misses notes you edited by hand
Run basic-memory reindex, with BASIC_MEMORY_LOG_LEVEL=DEBUG if you need to see why.
Desktop app cannot start uvx
Give the full path from which uvx in the command field, then restart the app.
Notes land in the wrong project
Ask list_memory_projects to see the default, or name the project in your request.

How do I configure Basic Memory?

Names are exactly as the project spells them. Required ones are marked.

SettingWhat it does
uvx basic-memory mcpConfig · requiredThe command a client runs for a local install. Notes live in ~/basic-memory unless you make other projects."args": ["--prerelease=allow", "basic-memory", "mcp"]
BASIC_MEMORY_NO_PROMOSEnvironment variableSet to 1 to hide cloud promotions and switch off telemetry.1
BASIC_MEMORY_LOG_LEVELEnvironment variableHow much it logs: DEBUG, INFO, WARNING or ERROR.DEBUG
BASIC_MEMORY_RERANKER_ENABLEDEnvironment variableSet to true to re-rank search results with a second model for better matches.true
BASIC_MEMORY_FORCE_LOCALEnvironment variableKeep every project on local files even when cloud routing is set up.

Basic Memory FAQ

How do I add Basic Memory to Claude Code?

Run claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp. The --prerelease=allow flag matters: without it uv installs an older release. Notes go to ~/basic-memory by default.

How do I install Basic Memory in Claude Desktop?

Add a basic-memory entry to claude_desktop_config.json with command uvx and args --prerelease=allow, basic-memory and mcp, then restart Claude Desktop. If it cannot start uvx, use the full path that which uvx prints.

Where does Basic Memory keep my notes?

As plain Markdown files on your disk, in ~/basic-memory unless you set up another project folder. You can open, edit or version them yourself in any text editor.

Is Basic Memory free?

Running it locally is free and open source under AGPL-3.0. Basic Memory Cloud, with sync, mobile access and a team workspace, is a paid subscription with a 7-day trial.

Does Basic Memory work with Obsidian?

Yes, with no setup. Point Obsidian at the notes folder and the wikilinks, frontmatter and Markdown the assistant writes show up in your vault and graph view, and edits on either side are shared.

Does Basic Memory work with ChatGPT?

It includes search and fetch tools in the format ChatGPT expects. ChatGPT only connects to remote servers, so follow the project's ChatGPT guide or use the cloud version rather than the local install.

Is Basic Memory safe?

In the local version everything stays on your machine, and the notes are ordinary files you can read to see exactly what the assistant saved. Keep the folder in git or a synced drive so you can roll back an edit you do not like.

Basic Memory or Obsidian MCP?

Basic Memory is built as the assistant's own memory, with linked notes it can follow through memory:// links. An Obsidian server works on a vault you already have. They can share one folder if you want both.

Basic Memory README

This is the project's own README from basicmachines-co/basic-memory, written by Basic Machines, and shared under its AGPL-3.0-or-later licence. We copied it on 28 Oct 2026, so the version on GitHub may be newer.

Skip the install — try Basic Memory in the cloud

Claude, Codex, or Cursor connected in 30 seconds. No Python, no JSON, no terminal. $15.00/mo locked in for life (12.50/mo yearly pricing). 7-day free trial — cancel any time before day 7 if it's not for you. Beta pricing — sign up now and your rate never goes up. OSS users: code BMFOSS takes another 20% off for 3 months.

Start free trial →

Basic Memory Teams is now available!

Give your team a single, shared cloud workspace. Knowledge isn't confined to one person — anything a teammate writes is immediately available to everyone else and to their AI assistants. Edit a note together in real time, hand work off between humans and agents, and build one connected knowledge base instead of scattered copies. Same pricing - start with one user and add more as needed.


Basic Memory

Your AI never forgets again.

Pick up right where you left off — in Claude, Codex, Cursor, ChatGPT, or anything that speaks MCP. Your knowledge lives as Markdown files that both you and your AI can read, write, and search.

  • Local-first. Plain text on your disk. Forever.
  • Two-way. AI and humans write to the same files; sync keeps them in step.
  • A real knowledge graph. Observations and wikilinks compound into context.
  • Semantic search. Find notes by meaning, not just keywords, with optional cross-encoder reranking for higher-quality vector and hybrid results.
  • MCP-native. Works with every major AI client and IDE.
  • Progressive tool discovery. Every tool is tagged with behavior hints (read-only, destructive, idempotent) so agents pick the right tool on demand — no wasted context trying things to see what they do.
  • Cloud, optional. Sync across devices when you want — never required.

Get started

Pick the path that fits you. Both run the same product on the same Markdown.

☁️   Cloud 💻   Local install

30 seconds. Sign up, connect your AI client, done.

  • Works in any browser
  • Mobile, web, desktop
  • Cross-device sync built in
  • We handle hosting, backups, snapshots

$15.00/mo locked for life · 7-day free trial · cancel any time

Start free trial →

2 minutes. Install, configure your AI client, run.

  • Free forever (AGPL-3.0)
  • All data on your disk
  • Air-gapped friendly
  • Requires Python via uv
uv tool install basic-memory --prerelease=allow

--prerelease=allow is required: Basic Memory 0.23 depends on a FastMCP 4 pre-release, and uv only accepts pre-releases of transitive dependencies when told to — without the flag it silently installs an older release. The same flag goes on every uvx / uv tool upgrade command below.

For Postgres deployments that store semantic vectors in Milvus, install the first-party optional extra instead:

uv tool install "basic-memory[milvus]" --prerelease=allow

Configure your client ↓

What people are saying

Basic Memory changed my whole relationship with LLMs. I switched from GPT and Gemini to exclusively Claude and Claude Code because of this integration and am completely revamping all our company's processes around a Basic Memory workflow.

— Alex, TrainerDay

Basic Memory is the missing 'wow' factor in AI chatbots. Now I can't imagine Claude or Claude Code without it.

— Caleb, Caleb Picker Consulting

I don't code without Basic Memory anymore. It's such a time saver to be able to refer to projects I don't currently have active and keep a running log of all my learnings and ProTips.

— @groksrc, Developer

More on basicmemory.com.

Basic Memory Cloud

The hosted version of Basic Memory. Same product, same Markdown files, same MCP tools — we just host the database, run the sync, and put it on your phone.

What you get
  • Every device, same brain. Your knowledge graph on web, mobile, and desktop. No copy-paste between machines.
  • Connect any MCP client. Claude Desktop, Claude Code, Codex, Cursor, ChatGPT (Custom GPTs), VS Code — one-click connect from the web app.
  • Bidirectional sync to local. Edit on your phone, see it in Obsidian on your laptop. rclone-powered with conflict resolution.
  • Snapshots and backups. Point-in-time restore. Browse history. Never lose a note.
  • No lock-in. Your notes are plain Markdown. Export to local Markdown any time — same files, same format, same wikilinks. Cancel anytime, your data stays yours.

Built on WorkOS AuthKit, Neon Postgres, and Tigris S3.

Pricing

$15.00/mo, locked in for the life of your subscription (regular price $19). Sign up during beta and the rate never goes up — as long as you stay subscribed, you keep the price. One plan, no tiers, no surprise upgrades. Unlimited notes, unlimited projects, every feature.

  • 7-day free trial. Cancel any time before day 7 if it's not for you.
  • Cancel anytime after that too — export your notes whenever you want.
  • OSS users: code BMFOSS for another 20% off for 3 months (~$11.40/mo).

Start your 7-day free trial →

Cloud vs. local

Cloud Local
Setup time 30 seconds 2 minutes (requires Python)
Cost $15.00/mo, locked for life (7-day trial) Free
Storage We host (Tigris S3) Your disk
Cross-device sync Built in Manual (Git, Syncthing, etc.)
Mobile access Yes (web + app) No
Air-gapped No Yes
Your data stays yours Yes — export anytime Yes — already there
Source code AGPL-3.0 AGPL-3.0
Snapshots & backups Built in Roll your own

Both paths use the same OSS engine and the same Markdown files. There's no lock-in either way — flip between them when your needs change.

Works with the tools you already use

Client Transport Notes
Cloud web app https Sign in at basicmemory.com — no install
Claude Desktop stdio/https macOS / Windows / Linux
Claude Code stdio/https claude mcp add
Codex stdio/https OpenAI's coding agent
Cursor stdio/https .cursor/mcp.json
VS Code stdio/https Native MCP support
ChatGPT https Custom GPT actions (search / fetch)
Obsidian — Reads/writes the same Markdown directly
Anything MCP stdio/https If it speaks MCP, it works

Official agent packages

This repository is also the canonical home for Basic Memory's host-native agent packages. The core Python package, Claude Code plugin, shared skills, Hermes plugin, and OpenClaw plugin all ship from the same source tree.

Maintainers can verify the whole consolidated surface from the repo root:

just package-check

Package-local justfiles are also available when working inside one host:

just package-check-claude-code
just package-check-skills
just package-check-hermes
just package-check-openclaw
Claude Code plugin

The Claude Code plugin is the bridge between Claude's working memory and Basic Memory — session-start briefings, pre-compaction checkpoints, an opt-in capture output style, and /basic-memory:bm-setup · :remember · :share · :status.

Connect the Basic Memory MCP server first — see Connect your AI client. The plugin's hooks and skills call it, so it's a hard prerequisite. Then install the plugin:

bm install claude-code

That registers the marketplace and installs the plugin through Claude Code. Add --scope project to declare both in the repository's settings for a team, or --dry-run to see the underlying claude plugin commands without running them.

Source: plugins/claude-code.

Shared skills

Framework-agnostic SKILL.md files live in skills/. If your Skills CLI supports repository subdirectory sources:

npx skills add basicmachines-co/basic-memory/skills -g

For Claude and ChatGPT, upload basic-memory.zip or basic-memory-chatgpt.zip from the skills-latest release; see skills/README.md.

If your installed Skills CLI cannot load that source, update the CLI or copy the memory-* directories from skills/ into your agent's skills directory.

Hermes

Hermes keeps its native plugin shape under integrations/hermes:

hermes plugins install basicmachines-co/basic-memory/integrations/hermes

Hermes does not install a plugin's Python dependencies, so also add the mcp package to the Hermes venv — see the plugin README for that step and the supported Hermes releases.

OpenClaw

OpenClaw stays package-native and publishes from integrations/openclaw:

openclaw plugins install @basicmemory/openclaw-basic-memory

Pick up where you left off

https://github.com/user-attachments/assets/a55d8238-8dd0-454a-be4c-8860dbbd0ddc

Connect your AI client

If you went the Cloud route, the web app walks you through client connect. The snippets below are for local installs.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["--prerelease=allow", "basic-memory", "mcp"]
    }
  }
}

Restart Claude Desktop. Notes live in ~/basic-memory by default.

Claude Code, Codex CLI, Cursor, VS Code, ChatGPT, Obsidian
Claude Code
claude mcp add basic-memory -- uvx --prerelease=allow basic-memory mcp

For the full memory bridge — session briefings, pre-compaction checkpoints, and the /basic-memory:* commands — also install the Claude Code plugin on top of this.

Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.basic-memory]
command = "uvx"
args = ["--prerelease=allow", "basic-memory", "mcp"]

Codex can keep its default MCP approval behavior, or you can pre-approve eligible Basic Memory tools by adding this server-scoped setting to the same table:

[mcp_servers.basic-memory]
command = "uvx"
args = ["--prerelease=allow", "basic-memory", "mcp"]
default_tools_approval_mode = "approve"

This does not disable Codex approvals globally or expand which Basic Memory projects the server can access. Codex still requires approval for tools that advertise a destructive annotation, including Basic Memory's writes, edits, and deletes. If you installed the Basic Memory Codex plugin, use its plugin-scoped configuration instead.

Cursor

Add to .cursor/mcp.json (project) or ~/.cursor/mcp.json (global):

{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": ["--prerelease=allow", "basic-memory", "mcp"]
    }
  }
}
VS Code

Add to your User Settings (JSON):

{
  "mcp": {
    "servers": {
      "basic-memory": {
        "command": "uvx",
        "args": ["--prerelease=allow", "basic-memory", "mcp"]
      }
    }
  }
}
ChatGPT

Basic Memory exposes OpenAI-compatible search and fetch tools for Custom GPT actions. See the ChatGPT integration guide.

Obsidian

No setup. Point Obsidian at ~/basic-memory (or your project folder) and the same wikilinks, frontmatter, and Markdown your AI writes appear in your graph view. Edit either side — sync handles the rest.

Try a prompt:

"Create a note about our project architecture decisions."
"Find information about JWT auth in my notes."
"What have I been working on this week?"

What's New

  • Automatic updates. Basic Memory keeps itself up to date for uv tool and Homebrew installs; bm update triggers a manual check.
  • Semantic vector search. Find notes by meaning, not just keywords. Hybrid full-text + vector ranking with FastEmbed embeddings, on SQLite or Postgres.
  • Optional search reranking. Rescore the strongest vector and hybrid candidates with a local FastEmbed cross-encoder or a LiteLLM-backed provider.
  • Schema system. Infer, validate, and diff the structure of your knowledge base with bm_schema(command="infer"), bm_schema(command="validate"), and bm_schema(command="diff").
  • Per-project cloud routing. Route individual projects through the cloud while others stay local, via API key (bm project set-cloud).
  • Explicit note changes. bm_edit updates existing notes; bm_write creates notes and guards against accidental overwrites.
  • Richer search results. Matched chunk text is included so the LLM gets context, not just hits.
  • FastMCP 3.0 + tool annotations. Every tool ships with MCP behavior hints (readOnlyHint, destructiveHint, idempotentHint, openWorldHint) so agents can discover capabilities progressively at runtime instead of guessing or burning tokens.
  • CLI overhaul. --json output for scripting, workspace-aware commands, and an htop-inspired project dashboard.

Full CHANGELOG for v0.18 → v0.20.

Optional cross-encoder reranking

Reranking adds a second relevance pass after vector or hybrid retrieval. It is disabled by default because it adds inference latency and, for the local provider, a first-run model download. Text, title, and permalink searches keep their existing ranking.

Enable the default local FastEmbed reranker:

export BASIC_MEMORY_RERANKER_ENABLED=true

The default model is jinaai/jina-reranker-v1-tiny-en. To use a hosted reranker through LiteLLM instead, first install the optional LiteLLM SDK, then configure it:

export BASIC_MEMORY_RERANKER_ENABLED=true
export BASIC_MEMORY_RERANKER_PROVIDER=litellm
export BASIC_MEMORY_RERANKER_MODEL=cohere/rerank-v3.5
export COHERE_API_KEY=...

The feature fails fast on invalid configuration and does not silently fall back to retrieval order when an enabled provider fails. See the semantic search guide for provider setup, all settings, tuning, pagination, and failure behavior.

Why Basic Memory

Most LLM conversations are ephemeral. You ask a question, get an answer, then everything is forgotten. Workarounds have limits:

  • Chat history captures conversations but isn't structured knowledge.
  • RAG lets the LLM query your documents but not write back to them.
  • Vector DBs need complex infra and usually live in someone else's cloud.
  • Knowledge graphs need specialized tooling to maintain.

Basic Memory takes a simpler path: structured Markdown files that humans and LLMs both read and write.

  • All knowledge stays in plain files you control.
  • Both sides read and write to the same files.
  • Familiar Markdown with semantic patterns — no new format to learn.
  • A traversable graph the LLM can follow link by link.
  • Works with the editors you already use (Obsidian, VS Code, anything).
  • Just files plus a local SQLite index. No servers required.

How it works

You're chatting normally about coffee:

I've been experimenting with brewing methods. Pour over gives more clarity than French press, water at 205°F seems best, and freshly ground beans make a huge difference.

Ask the LLM to capture it:

"Make a note on coffee brewing methods."

A Markdown file appears in your project directory in real time:

---
title: Coffee Brewing Methods
permalink: coffee-brewing-methods
tags: [coffee, brewing]
---

# Coffee Brewing Methods

## Observations
- [method] Pour over highlights subtle flavors over body
- [technique] Water at 205°F (96°C) extracts optimal compounds
- [principle] Freshly ground beans preserve aromatics

## Relations
- relates_to [[Coffee Bean Origins]]
- requires [[Proper Grinding Technique]]
- affects [[Flavor Extraction]]

Next session, the LLM picks up the thread. It follows the relations to surface what you already know about Ethiopian beans and burr grinders, and builds on it instead of starting over. You see the same files in Obsidian or your editor. Edit them by hand — the AI sees your changes too.

Real two-way flow: humans edit Markdown, LLMs read/write through MCP, sync keeps everything consistent, and the source of truth is always your files.

The Markdown format

Each file is an Entity. Entities have Observations (facts about them) and Relations (links to other entities). That's the whole grammar.

Frontmatter
---
title: <Entity title>
type: note
permalink: <uri-slug>
tags: [optional, list]
---
Observations

Facts about the entity. Categories in [brackets], tags with #, optional context in parens.

- [method] Pour over highlights subtle flavors
- [tip] Grind medium-fine for V60 #brewing
- [fact] Lighter roasts contain more caffeine than dark
- [resource] James Hoffmann's V60 technique on YouTube
- [question] How does temperature affect compound extraction?
Relations

Wiki-style links that form the graph. Single-token relation types, or quote multi-word ones.

- pairs_well_with [[Chocolate Desserts]]
- grown_in [[Ethiopia]]
- requires [[Burr Grinder]]
- "pairs well with" [[Dark Chocolate]]

Bare - [[Target]] and prose - Worth checking out [[Target]] index as links_to. Full reference in the docs.

MCP tools

Basic Memory exposes these tools to any MCP client. Every tool is annotated with MCP behavior hints (read-only, destructive, idempotent, open-world) so agents can pick the right one without trial-and-error:

  • Content: bm_write, bm_read, bm_edit, bm_move, bm_delete
  • Search & discovery: bm_search, bm_list, bm_find
  • Knowledge graph: bm_context
  • Projects: bm_project(command="list" | "create" | "recent"); bm_project_delete is separate and requires server opt-in.
  • Schema: bm_schema(command="validate" | "infer" | "diff")
  • Manual: bm_man
  • Cloud connector adapters: search and fetch are registered by Cloud only. Local diagnostics use bm doctor.

Most tools default to text; bm_context defaults to JSON. Pass output_format="json" for structured responses. Project-scoped tools accept a name, workspace/project, or external UUID through project. Use bm_man(page="bm-search(3)") for the installed contract, or see the tool guide. CLI commands retain their shell names.

CLI essentials

# Projects
basic-memory project list
basic-memory project add research ~/research
basic-memory project set-cloud research   # route through cloud
basic-memory project set-local research   # revert

# Config
basic-memory config list                        # all settings, effective values, env overrides
basic-memory config set cli_output_style plain  # validated through the config model
basic-memory config unset cli_output_style      # revert to default

# Health & maintenance
basic-memory status
basic-memory doctor              # report project problems and the commands that fix them
basic-memory tool edit ...  # CLI access to MCP tools
basic-memory update              # check for and install updates

# Imports
basic-memory import claude conversations
basic-memory import chatgpt
basic-memory import memory-json

Routing flags (--local / --cloud) force a target when you're in mixed mode. Full CLI reference in the docs.

Auto-updates

CLI installs check for updates every 24 hours by default and apply them silently (so the MCP server keeps responding).

  • Supported install sources: uv tool, Homebrew
  • Skipped for uvx (ephemeral runtime managed by uv)
  • Manual: bm update (check + apply) or bm update --check (check only)

Disable in ~/.basic-memory/config.json:

{ "auto_update": false }

Telemetry

Minimal, anonymous events to understand the CLI-to-cloud conversion funnel.

What we collect: cloud promo impressions, cloud login attempts and outcomes, promo opt-out events.

What we don't: file contents, note titles, knowledge base data, PII, IP addresses, per-command or per-tool tracking.

Events go to our Umami Cloud instance (open-source, privacy-focused) on a background thread — never blocks the CLI.

Opt out:

export BASIC_MEMORY_NO_PROMOS=1

This disables promos and all telemetry.

Logging

Basic Memory uses Loguru. Defaults vary by entry point:

Entry point Default Why
CLI commands File only Doesn't interfere with command output
MCP server File only Stdout would corrupt JSON-RPC
API server File (local) or stdout (cloud) Docker/cloud uses stdout

Log file: ~/.basic-memory/basic-memory.log (10MB rotation, 10 days retention).

Environment variables
Variable Default Description
BASIC_MEMORY_LOG_LEVEL INFO DEBUG / INFO / WARNING / ERROR
BASIC_MEMORY_CLOUD_MODE false API logs to stdout with structured context
BASIC_MEMORY_FORCE_LOCAL false Force local API routing
BASIC_MEMORY_FORCE_CLOUD false Force cloud API routing
BASIC_MEMORY_EXPLICIT_ROUTING false Mark route selection as explicit
BASIC_MEMORY_ENV dev Set to test for test mode (stderr only)
BASIC_MEMORY_NO_PROMOS false Disable cloud promos and telemetry
BASIC_MEMORY_IMPORT_UPLOAD_MAX_BYTES 104857600 Max uploaded import size
BASIC_MEMORY_LOG_LEVEL=DEBUG basic-memory reindex
tail -f ~/.basic-memory/basic-memory.log

Development

Basic Memory supports SQLite (default, fast, no Docker) and Postgres (via testcontainers — Docker required).

just install          # Install with dev dependencies
just test-sqlite      # All tests, SQLite
just test-postgres    # All tests, Postgres (testcontainers)
just test             # Both backends
just fast-check       # fix/format/typecheck + impacted tests
just doctor           # File <-> DB consistency check (temp config)
just package-check    # Claude Code, skills, Hermes, OpenClaw package checks
just lint
just typecheck        # Pyright (primary)
just typecheck-ty     # ty (supplemental)
just format
just check            # All quality checks
just migration "msg"  # New Alembic migration

Tests use pytest markers: windows, benchmark, smoke. See justfile for the full list.

Contributions welcome — see CONTRIBUTING.md.

License

AGPL-3.0.

Built with ♥️ by Basic Machines

Two peas, one chat

Chat with AI about Basic Memory

Opens a chat primed with Basic Memory’s README and setup docs from this page, or add it in Cursor to use its tools.

The Cursor button opens Cursor and asks before it adds the server. Fill in any keys it needs in Cursor’s MCP settings.

Peas in a pod

What are the alternatives to Basic Memory?

How Basic Memory lines up against its neighbours on the shelf. See every knowledge and work apps server.

  • Basic MemoryThis pea

    Long-term memory as plain Markdown files you own.

    Tools
    27
    Runs on
    Your computer
    Licence
    AGPL-3.0-or-later
    Stars
    4.4K
  • LinkedIn MCP Server

    Read LinkedIn profiles, companies and job posts with your own login.

    Tools
    20
    Runs on
    Your computer
    Licence
    Apache-2.0
    Stars
    4K
  • arXiv MCP Server

    Search arXiv, download papers and read them in full.

    Tools
    19
    Runs on
    Your computer
    Licence
    Apache-2.0
    Stars
    3.2K
  • TradingView MCP

    Prices, indicators, screeners and backtests for stocks, crypto and forex, no account needed.

    Tools
    37
    Runs on
    Your computer or hosted
    Licence
    MIT
    Stars
    5.2K
  • Obsidian MCP

    Search, read and edit the notes in your Obsidian vault.

    Tools
    15
    Runs on
    Your computer
    Licence
    MIT
    Stars
    4.5K
  • Google Workspace MCP

    Gmail, Drive, Calendar, Docs, Sheets and six more Google apps behind one server.

    Tools
    43
    Runs on
    Your computer
    Licence
    MIT
    Stars
    3.4K

Compared head to head: Basic Memory vs Qdrant.

Full docs on GitHubbasicmachines-co/basic-memory

Something wrong on this page? Tell us.

For bots & AI agents

Machine-readable versions of Basic Memory and MCP Shelf. Fetch these instead of parsing this page.

This listing (.md)llms.txtllms-full.txtai.txtFull catalog (.md)API specMCP serverMCP manifestDeveloper docs