Mit Basic Memory können Sie persistentes Wissen durch natürliche Konversationen mit Large Language Models (LLMs) wie Claude aufbauen und gleichzeitig alles in einfachen Markdown-Dateien auf Ihrem Computer speichern. Es verwendet das Model Context Protocol (MCP), damit jedes kompatible LLM Ihre lokale Wissensdatenbank lesen und beschreiben kann.
Website: https://basicmachines.co
Dokumentation: https://memory.basicmachines.co
KI-Assistenten können in einer neuen Konversation Kontext aus lokalen Dateien laden
Notizen werden lokal in Echtzeit als Markdown-Dateien gespeichert
Keine Projektkenntnisse oder spezielle Anleitung erforderlich
https://github.com/user-attachments/assets/a55d8238-8dd0-454a-be4c-8860dbbd0ddc
Related MCP server: memora
# Install with uv (recommended)
uv tool install basic-memory
# Configure Claude Desktop (edit ~/Library/Application Support/Claude/claude_desktop_config.json)
# Add this to your config:
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"mcp"
]
}
}
}
# Now in Claude Desktop, you can:
# - Write notes with "Create a note about coffee brewing methods"
# - Read notes with "What do I know about pour over coffee?"
# - Search with "Find information about Ethiopian beans"
Sie können den gemeinsamen Kontext über Dateien in ~/basic-memory (Standardverzeichnisspeicherort) anzeigen.
Sie können Smithery verwenden, um den Basisspeicher für Claude Desktop automatisch zu konfigurieren:
npx -y @smithery/cli install @basicmachines-co/basic-memory --client claudeDadurch wird Basic Memory installiert und konfiguriert, ohne dass manuelle Änderungen an der Claude Desktop-Konfigurationsdatei erforderlich sind. Der Smithery-Server hostet die MCP-Serverkomponente, während Ihre Daten lokal als Markdown-Dateien gespeichert bleiben.
Die meisten LLM-Interaktionen sind flüchtig – man stellt eine Frage, erhält eine Antwort und alles ist vergessen. Jedes Gespräch beginnt von neuem, ohne den Kontext oder das Wissen aus vorherigen Gesprächen. Aktuelle Workarounds haben Einschränkungen:
Chatverläufe erfassen Gespräche, sind aber kein strukturiertes Wissen
RAG-Systeme können Dokumente abfragen, lassen LLMs jedoch nicht zurückschreiben
Vektordatenbanken erfordern komplexe Setups und befinden sich oft in der Cloud
Wissensgraphen benötigen typischerweise spezielle Werkzeuge zur Pflege
Basic Memory löst diese Probleme mit einem einfachen Ansatz: strukturierte Markdown-Dateien, die sowohl Menschen als auch LLMs lesen und schreiben können. Die wichtigsten Vorteile:
Lokal zuerst: Das gesamte Wissen bleibt in Dateien, die Sie kontrollieren
Bidirektional: Sowohl Sie als auch der LLM lesen und schreiben in dieselben Dateien
Strukturiert und doch einfach: Verwendet bekanntes Markdown mit semantischen Mustern
Durchsuchbarer Wissensgraph: LLMs können Links zwischen Themen folgen
Standardformate: Funktioniert mit vorhandenen Editoren wie Obsidian
Leichtgewichtige Infrastruktur: Nur lokale Dateien, indiziert in einer lokalen SQLite-Datenbank
Mit Basic Memory können Sie:
Führen Sie Gespräche, die auf dem bisherigen Wissen aufbauen
Erstellen Sie strukturierte Notizen während natürlicher Gespräche
Führen Sie Gespräche mit LLMs, die sich an das erinnern, was Sie zuvor besprochen haben
Navigieren Sie semantisch durch Ihren Wissensgraphen
Behalten Sie alles lokal und unter Ihrer Kontrolle
Verwenden Sie vertraute Tools wie Obsidian, um Notizen anzuzeigen und zu bearbeiten
Bauen Sie eine persönliche Wissensbasis auf, die mit der Zeit wächst
Angenommen, Sie beschäftigen sich mit verschiedenen Methoden der Kaffeezubereitung und möchten Ihr Wissen festhalten. So funktioniert es:
Beginnen Sie mit einem normalen Chat:
I've been experimenting with different coffee brewing methods. Key things I've learned:
- Pour over gives more clarity in flavor than French press
- Water temperature is critical - around 205°F seems best
- Freshly ground beans make a huge difference... Gespräch fortsetzen.
Bitten Sie den LLM, Ihnen bei der Strukturierung dieses Wissens zu helfen:
"Let's write a note about coffee brewing methods."LLM erstellt eine neue Markdown-Datei auf Ihrem System (die Sie sofort in Obsidian oder Ihrem Editor sehen können):
---
title: Coffee Brewing Methods
permalink: coffee-brewing-methods
tags:
- coffee
- brewing
---
# Coffee Brewing Methods
## Observations
- [method] Pour over provides more clarity and highlights subtle flavors
- [technique] Water temperature at 205°F (96°C) extracts optimal compounds
- [principle] Freshly ground beans preserve aromatics and flavor
## Relations
- relates_to [[Coffee Bean Origins]]
- requires [[Proper Grinding Technique]]
- affects [[Flavor Extraction]]Die Notiz bettet semantische Inhalte und Links zu anderen Themen über eine einfache Markdown-Formatierung ein.
Sie sehen diese Datei in Echtzeit auf Ihrem Computer im aktuellen Projektverzeichnis (Standard ~/$HOME/basic-memory ).
Die Echtzeitsynchronisierung ist standardmäßig mit der Version v0.12.0 aktiviert
Im Chat mit dem LLM können Sie einen Themenbezug herstellen:
Look at `coffee-brewing-methods` for context about pour over coffeeDas LLM kann nun aus dem Wissensgraphen einen umfassenden Kontext erstellen. Zum Beispiel:
Following relation 'relates_to [[Coffee Bean Origins]]':
- Found information about Ethiopian Yirgacheffe
- Notes on Colombian beans' nutty profile
- Altitude effects on bean characteristics
Following relation 'requires [[Proper Grinding Technique]]':
- Burr vs. blade grinder comparisons
- Grind size recommendations for different methods
- Impact of consistent particle size on extractionJedes zugehörige Dokument kann zu mehr Kontext führen und so ein umfassendes semantisches Verständnis Ihrer Wissensdatenbank aufbauen.
Dadurch entsteht ein wechselseitiger Fluss, bei dem:
Menschen schreiben und bearbeiten Markdown-Dateien
LLMs lesen und schreiben über das MCP-Protokoll
Durch die Synchronisierung bleibt alles konsistent
Alle Daten bleiben in lokalen Dateien.
Unter der Haube, Basisspeicher:
Speichert alles in Markdown-Dateien
Verwendet eine SQLite-Datenbank für die Suche und Indizierung
Extrahiert semantische Bedeutung aus einfachen Markdown-Mustern
Dateien werden zu Entity -Objekten
Jede Entity kann Observations oder Fakten haben, die mit ihr verknüpft sind
Relations verbinden Entitäten miteinander und bilden den Wissensgraphen
Pflegt den aus den Dateien abgeleiteten lokalen Wissensgraphen
Bietet eine bidirektionale Synchronisierung zwischen Dateien und dem Wissensgraphen
Implementiert das Model Context Protocol (MCP) für die KI-Integration
Stellt Tools bereit, mit denen KI-Assistenten den Wissensgraphen durchlaufen und manipulieren können
Verwendet memory://-URLs, um Entitäten über Tools und Konversationen hinweg zu referenzieren
Das Dateiformat ist lediglich Markdown mit einigen einfachen Markierungen:
Jede Markdown-Datei enthält:
title: <Entity title>
type: <The type of Entity> (e.g. note)
permalink: <a uri slug>
- <optional metadata> (such as tags) Beobachtungen sind Fakten zu einem Thema. Sie können hinzugefügt werden, indem eine Markdown-Liste mit einem speziellen Format erstellt wird, das auf eine category , tags mit dem Zeichen "#" und einen optionalen context verweisen kann.
Beobachtungs-Markdown-Format:
- [category] content #tag (optional context)Beispiele für Beobachtungen:
- [method] Pour over extracts more floral notes than French press
- [tip] Grind size should be medium-fine for pour over #brewing
- [preference] Ethiopian beans have bright, fruity flavors (especially from Yirgacheffe)
- [fact] Lighter roasts generally contain more caffeine than dark roasts
- [experiment] Tried 1:15 coffee-to-water ratio with good results
- [resource] James Hoffman's V60 technique on YouTube is excellent
- [question] Does water temperature affect extraction of different compounds differently?
- [note] My favorite local shop uses a 30-second bloom timeBeziehungen sind Verknüpfungen zu anderen Themen. Sie definieren, wie Entitäten im Wissensgraphen miteinander verbunden sind.
Markdown-Format:
- relation_type [[WikiLink]] (optional context)Beispiele für Beziehungen:
- pairs_well_with [[Chocolate Desserts]]
- grown_in [[Ethiopia]]
- contrasts_with [[Tea Brewing Methods]]
- requires [[Burr Grinder]]
- improves_with [[Fresh Beans]]
- relates_to [[Morning Routine]]
- inspired_by [[Japanese Coffee Culture]]
- documented_in [[Coffee Journal]]Klicken Sie für die Ein-Klick-Installation auf eine der folgenden Installationsschaltflächen ...
Mit Basic Memory und VS Code können Sie beim Programmieren ganz einfach Informationen abrufen und speichern. Klicken Sie oben auf die Installationsschaltflächen, um die Einrichtung mit nur einem Klick durchzuführen, oder folgen Sie den unten stehenden Anweisungen zur manuellen Installation.
Fügen Sie den folgenden JSON-Block zu Ihrer Benutzereinstellungsdatei (JSON) in VS Code hinzu. Drücken Sie dazu Ctrl + Shift + P und geben Sie Preferences: Open User Settings (JSON) ein.
{
"mcp": {
"servers": {
"basic-memory": {
"command": "uvx",
"args": ["basic-memory", "mcp"]
}
}
}
}Optional können Sie es einer Datei namens .vscode/mcp.json in Ihrem Arbeitsbereich hinzufügen. Dadurch können Sie die Konfiguration mit anderen teilen.
{
"servers": {
"basic-memory": {
"command": "uvx",
"args": ["basic-memory", "mcp"]
}
}
}Basic Memory wird mithilfe des MCP (Model Context Protocol) erstellt und funktioniert mit der Claude-Desktop-App ( https://claude.ai/ ):
Konfigurieren Sie Claude Desktop für die Verwendung des Basisspeichers:
Bearbeiten Sie Ihre MCP-Konfigurationsdatei (normalerweise unter ~/Library/Application Support/Claude/claude_desktop_config.json für OS X):
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"mcp"
]
}
}
}Wenn Sie ein bestimmtes Projekt verwenden möchten (siehe Mehrere Projekte ), aktualisieren Sie Ihre Claude Desktop-Konfiguration:
{
"mcpServers": {
"basic-memory": {
"command": "uvx",
"args": [
"basic-memory",
"--project",
"your-project-name",
"mcp"
]
}
}
}Synchronisieren Sie Ihr Wissen:
Basic Memory synchronisiert die Dateien in Ihrem Projekt in Echtzeit, wenn Sie manuelle Änderungen vornehmen.
In Claude Desktop kann der LLM jetzt diese Tools verwenden:
write_note(title, content, folder, tags) - Create or update notes
read_note(identifier, page, page_size) - Read notes by title or permalink
build_context(url, depth, timeframe) - Navigate knowledge graph via memory:// URLs
search_notes(query, page, page_size) - Search across your knowledge base
recent_activity(type, depth, timeframe) - Find recently updated information
canvas(nodes, edges, title, folder) - Generate knowledge visualizationsBeispielaufforderungen zum Ausprobieren:
"Create a note about our project architecture decisions"
"Find information about JWT authentication in my notes"
"Create a canvas visualization of my project components"
"Read my notes on the authentication system"
"What have I been working on in the past week?"Weitere Informationen finden Sie in der Dokumentation , unter anderem zu:
AGPL-3.0
Beiträge sind willkommen. Informationen zum lokalen Einrichten des Projekts und zum Einreichen von PRs finden Sie im Beitragsleitfaden .
Mit ♥️ von Basic Machines erstellt
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.
Inputs: project (required), identifier (required), page, depth, +5 more. Returns: result
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.
Inputs: project (required), path, recursive, identifier, +2 more. Returns: result
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. metadata also merges with any other command. Pass expected_checksum (from bm_read) to edit only the revision you read. A missing note is an error; create notes with bm_write.
Inputs: command (required), project (required), identifier (required), content, +7 more. Returns: result
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.
Inputs: project (required), name, page, path, +5 more. Returns: result
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.
Inputs: project (required), glob, page, path, +3 more. Returns: result
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.
Inputs: page, query, output_format. Returns: result
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. Moving into another project is refused: bm_read, bm_write there, then bm_delete.
Inputs: project (required), destination (required), path, identifier, +2 more. Returns: result
Basic Memory projects. command: list (projects, grouped by workspace); create (name, path, optional set_default, workspace); recent (what changed lately in the required project: since, items, paging).
Inputs: command (required), name, page, path, +7 more. Returns: result
Read a Basic Memory note or file by path, permalink, memory:// URL or exact title. Slice a long note with section (a heading), start_line/end_line or max_tokens; line numbers count the whole file, frontmatter included. A text file such as .txt takes start_line/end_line too. include_content=false returns only the metadata and the checksum that bm_write and bm_edit take as expected_checksum. Images come back as images and other binary files as documents. A missing note is an error: find notes with bm_search.
Inputs: project (required), identifier (required), section, end_line, +5 more.
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.
Inputs: command (required), project (required), note_type, threshold, +2 more. Returns: result
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.
Inputs: mode, page, path, items, +18 more. Returns: result
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]]').
Inputs: content (required), project (required), tags, title, +7 more. Returns: result
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 12 tools
There is real overlap among three retrieval tools (bm_find, bm_list, bm_search), but the descriptions explicitly route the agent: bm_list for one folder, bm_find for recursive name/frontmatter matching, bm_search for ranked text/semantic search. Similarly bm_read (one note body) is distinguished from bm_context (graph traversal) and bm_write (full replace) from bm_edit (partial change). Only a small chance of misselection remains for an agent skimming names.
All 12 tools follow a single predictable bm_<word> snake_case pattern with no style mixing. Most suffixes are verbs (find, list, read, write, edit, move, delete, search), but a few are nouns/commands (bm_context, bm_schema, bm_project, bm_man), which is a minor deviation rather than an inconsistency.
Twelve tools sit comfortably in the well-scoped range and each maps to a distinct capability: directory listing, find, search, read, write, edit, move, delete, graph context, schema ops, project ops, and docs. None look like padding, and the surface is not so thin that agents would have to chain workarounds.
Note lifecycle is fully covered (create/replace, read, partial edit, move, delete, plus graph context and search), and bm_schema and bm_project cover schema and project management. Minor gaps: bm_project only supports list/create/recent (no rename or delete of projects), and there is no copy/duplicate operation, though the description notes the read+write+delete workaround.
Personal wiki and memory layer for AI assistants. Persistent, structured memory across sessions.
Persistent memory and knowledge graph for AI assistants — keyword + vector + graph search.
Long-term memory for your AI as a private knowledge graph: facts, people, links, sources.
Turn your notes, links and conversations into a Living Brain your AI tools share and build on.