Basisspeicher

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

Setzen Sie Ihr Gespräch genau dort fort, wo Sie aufgehört haben

• 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: memento-mcp

Schnellstart

# 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.

Alternative Installation über Smithery

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 claude

Dadurch 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.

Glama.ai

Warum Basisspeicher?

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

So funktioniert es in der Praxis

Angenommen, Sie beschäftigen sich mit verschiedenen Methoden der Kaffeezubereitung und möchten Ihr Wissen festhalten. So funktioniert es:

1. 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.

2. 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.

3. 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

4. Im Chat mit dem LLM können Sie einen Themenbezug herstellen:

Look at `coffee-brewing-methods` for context about pour over coffee

Das 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 extraction

Jedes 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.

Technische Umsetzung

Unter der Haube, Basisspeicher:

1. Speichert alles in Markdown-Dateien

2. Verwendet eine SQLite-Datenbank für die Suche und Indizierung

3. 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

4. Pflegt den aus den Dateien abgeleiteten lokalen Wissensgraphen

5. Bietet eine bidirektionale Synchronisierung zwischen Dateien und dem Wissensgraphen

6. Implementiert das Model Context Protocol (MCP) für die KI-Integration

7. Stellt Tools bereit, mit denen KI-Assistenten den Wissensgraphen durchlaufen und manipulieren können

8. 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:

Frontmatter

title: <Entity title>
type: <The type of Entity> (e.g. note)
permalink: <a uri slug>

- <optional metadata> (such as tags) 

Beobachtungen

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 time

Beziehungen

Beziehungen 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]]

Verwendung mit VS Code

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.

Manuelle 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"]
    }
  }
}

Verwendung mit Claude Desktop

Basic Memory wird mithilfe des MCP (Model Context Protocol) erstellt und funktioniert mit der Claude-Desktop-App ( https://claude.ai/ ):

1. 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"
      ]
    }
  }
}

2. Synchronisieren Sie Ihr Wissen:

Basic Memory synchronisiert die Dateien in Ihrem Projekt in Echtzeit, wenn Sie manuelle Änderungen vornehmen.

3. 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 visualizations

5. Beispielaufforderungen 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

Weitere Informationen finden Sie in der Dokumentation , unter anderem zu:

• Vollständiges Benutzerhandbuch

• CLI-Tools

• Verwalten mehrerer Projekte

• Importieren von Daten aus OpenAI/Claude-Projekten

Lizenz

AGPL-3.0

Beiträge sind willkommen. Informationen zum lokalen Einrichten des Projekts und zum Einreichen von PRs finden Sie im Beitragsleitfaden .

Sternengeschichte

Mit ♥️ von Basic Machines erstellt