Server profile

Basic Memory MCP Server

Basic Memory gives AI clients persistent knowledge stored as Markdown that people can also edit. It combines linked notes, semantic search, and optional cloud collaboration.

Server facts

Basic Memory MCP Server

Tech

Runtime / language
pythonPython
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
4,249
Last commit
Data as of

Tags

  • Knowledge Graph
  • Local First
  • Markdown
  • Semantic Search

Overview

Basic Memory turns Markdown notes into shared working knowledge for people and AI assistants. Instead of keeping useful information only inside a conversation, it lets compatible clients read, write, and search files that remain accessible in ordinary editors. Observations and wikilinks connect those notes into a graph, while semantic retrieval complements full-text search. The local setup uses files on disk with a SQLite index, and the README also describes vector search on SQLite or Postgres using FastEmbed embeddings. Obsidian can work directly with the same Markdown, frontmatter, and links.

Local operation is free under AGPL-3.0 and requires Python 3.12 or newer. The documented stdio launch uses uvx, with configuration examples for Claude Desktop, Claude Code, Codex, Cursor, and VS Code. An optional paid cloud version handles hosting, cross-device synchronization, backups, snapshots, and mobile access. Teams adds a shared workspace and collaborative note editing. Local users instead arrange their own synchronization and backups. The engine exposes behavior annotations to help agents discover tools, along with note editing and schema inspection capabilities. Separate host integrations can add session briefings or checkpoints, but the Claude Code plugin requires the MCP connection first. The distinction is straightforward: Markdown remains the knowledge format, while local or hosted operation determines how it is maintained and shared.

Install & configure

Requirements

  • Python 3.12+
  • uv / uvx
  • An MCP-compatible client
Documented launch / install command
uvx basic-memory mcp

This is the local client configuration from the README. Notes default to ~/basic-memory. Optional cloud onboarding is separate; no cloud MCP endpoint is specified in the supplied README.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Desktop configuration
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ],
      "env": {}
    }
  }
}

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ],
      "env": {}
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "basic-memory": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ],
      "env": {}
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "basic-memory": {
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ],
      "env": {}
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "basic-memory": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "basic-memory",
        "mcp"
      ],
      "env": {}
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

Source: repository README. Tool descriptions are a documented snapshot, not a live capability check.

ToolWhat it does
searchSearch knowledge through the documented ChatGPT-compatible action interface.
fetchRetrieve knowledge through the documented ChatGPT-compatible action interface.
schema_inferInfer the structure of a knowledge base.
schema_validateCheck knowledge against its schema.
schema_diffCompare knowledge-base structure changes.
edit_noteEdit notes, including append and prepend operations.
write_noteWrite a note with protection against unintended overwrites.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Keep architecture decisions available across AI sessions.
  • Search notes by meaning rather than exact wording.
  • Use Obsidian and an AI assistant on the same knowledge files.
  • Share team notes through the optional cloud workspace.

Strengths

  • Human-readable Markdown remains editable outside the AI client.
  • Local-first operation does not require cloud hosting.
  • Combines graph links with full-text and vector search.
  • Optional hosted backups and collaboration.

Limitations

  • Local users manage their own backups and cross-device sync.
  • Cloud hosting is a paid option.
  • The local install requires Python.

Frequently asked questions

No. The local engine is free and supports offline, air-gapped use.

The README gives ~/basic-memory as the default location.

Yes. Obsidian can open the same Markdown directory and use its wikilinks and frontmatter.

No. The plugin requires an existing Basic Memory MCP connection.

The README identifies AGPL-3.0 for both local and cloud source code.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers

MCP Server for Obsidian

Memory & Knowledge

MCP Server for Obsidian connects assistants to an Obsidian vault through the Local REST API plugin. It supports note discovery, reading, search, targeted insertion, appending, and deletion for conversational knowledge workflows.

Notion MCP Server

Memory & Knowledge

Connect an MCP client to the Notion API to work with pages and data sources. This local server supports Markdown content operations, but Notion now prioritizes its separate remote MCP service.

Memory Bank MCP Server

Memory & Knowledge

Manage project memory files through an MCP assistant using a shared storage root. The server separates projects and provides file discovery, reading, creation, and updates for memory-bank workflows.

MCP Knowledge Graph

Memory & Knowledge

Keep assistant memories as local entities, relationships, and facts across conversations. MCP Knowledge Graph supports project-specific and global JSONL stores, optional topic databases, and explicit memory editing tools.

Grounded Docs MCP Server

Memory & Knowledge

Grounded Docs MCP Server builds a documentation index that coding assistants can query by library version. It ingests websites, repositories, packages, and local files, with CLI, Web UI, and MCP access.

Context Portal MCP (ConPort)

Memory & Knowledge

Context Portal stores structured project memory for AI assistants in a workspace-specific SQLite database. It tracks decisions, progress, architecture, and custom context, with relationships and semantic search for retrieval.

Qdrant MCP Server

Memory & Knowledge

Qdrant MCP Server stores information and retrieves relevant memories through semantic search. It connects MCP clients to a Qdrant service or a local database path.

Obsidian MCP Server

Memory & Knowledge

Obsidian MCP Server gives assistants note reading, search, and targeted editing in an Obsidian vault. It includes tag and frontmatter management, optional path restrictions, and stdio or streamable HTTP operation.