de en es ko ru zh

mnemon-mcp

Name: mnemon-mcp
Author: nikitacometa

by nikitacometa

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

mnemon-mcp

npm version Node.js License: MIT

Persistentes, geschichtetes Gedächtnis für KI-Agenten. Lokal zuerst. Keine Cloud. Eine einzige SQLite-Datei.

Landingpage · npm · GitHub

Dein KI-Agent vergisst nach jeder Sitzung alles. Mnemon behebt das.

Es gibt jedem MCP-kompatiblen Client – OpenClaw, Claude Code, Cursor, Windsurf oder deinem eigenen – ein strukturiertes Langzeitgedächtnis, das in einer einzigen SQLite-Datenbank auf deinem Rechner liegt. Keine API-Schlüssel, keine Cloud, keine Telemetrie. Einfach npm install und dein Agent erinnert sich.

Warum ein geschichtetes Gedächtnis?

Flache Key-Value-Stores behandeln „was gestern passiert ist“ genauso wie „committe niemals ohne Tests“. Das ist falsch – verschiedene Arten von Wissen haben unterschiedliche Lebensdauern und Zugriffsmuster.

Mnemon organisiert Erinnerungen in vier Ebenen:

Ebene	Was gepeichert wird	Zugriff	Lebensdauer
Episodisch	Ereignisse, Sitzungen, Journalbucheinträge	Nach Datum oder Zeitraum	Verfällt (30-Tage-Halbwertszeit)
Semantisch	Fakten, Präferenzen, Beziehungen	Nach Thema oder Entität	Stabil
Prozedural	Regeln, Arbeitsabläufe, Konventionen	Beim Start geladen	Ändert sich selten
Ressource	Referenzmaterial, Buchnotizen	Auf Abruf	Verfällt langsam (90 Tage)

Ein Journalbucheintrag von letztem Dienstag und eine Regel, die sich nie ändert, leben in verschiedenen Ebenen – weil sie das sollten.

Related MCP server: persistent-kb-mcp

Retrieval-Qualität

Das Retrieval wird gegen einen Golden-Set mit 50 Fällen auf einem echten, zweisprachigen (RU/EN) Korpus mit 797 Erinnerungen gemessen – über den echten MCP-Server, nicht über eine Neuimplementierung. Aktuelle Zahlen (Methodik & Verlauf):

Metrik	FTS-only	Vector-only	Hybrid (RRF)
Composite-Score	88.9	89.2	91.7
Recall@5	0.907	0.898	0.919
MRR	0.817	0.832	0.878
nDCG@5	0.816	0.828	0.869
Negative precision	1.000	1.000	1.000

Hybrid schlägt beide Einzelansätze – genau das ist das Argument für die Fusion: Die lexikalische Suche hat den besseren Ro-Recall, die Vektorsuche das besere Ranking, und RRF erhält beide, statt sie durch Mittelung zu verlieren.

Das Auswertungsdokument zeigt auch die Fehlstellen auf – Score-Abdrift bei wachsendem Korpus, den von der Auswertung aufgespürten BM25-Feld-Gewichtungs-Bug, die zwei Fälle, in denen Fusion weiterhin gegenüber reiner lexikalischer Suche verliert, und das, was der Golden-Set nicht abdecket. Zahlen, die du nicht prüfen kannst, sind Marketing; lies, wie sie erzeugt werden.

Architektur

flowchart LR
    C["MCP client<br/>Claude Code · Cursor · …"] -- "stdio / HTTP" --> T["10 tools · 4 resources · 3 prompts"]
    T --> R["retrieval pipeline<br/>FTS5 · vector · RRF fusion"]
    T --> M["memories + supersede chains"]
    I["KB import pipeline<br/>markdown → memories"] --> M
    M -- triggers --> F["FTS5 index (stemmed EN+RU)"]
    R --> F
    R --> V["sqlite-vec (optional, BYOK)"]

Eine SQLite-Datei enthält Erinnerungen, den FTS5-Index und den optionalen Vektorindex. Schreibzugriffe laufen über Transaktionen durch die Invariante der Ersetzungskette gewahrt wird; Lesezugriffe nutzen die gestufte Retrieval-Pipeline, die unter Suche beschrieben ist.

Das vollständige Bild – Modülgrenzen, Schreib-/Lesenspfade, Invarianten und bekannte Einschränkungen – findest du in docs/ARCHITECTURE.md. Design-Entscheidungen sind als ADRs dokumentiert: SQLite+FTS-Kern, hybrides RRF-Retrieval, synchrone Treiber, Layer-Speichermodell.

Schnellstart

Installation

npm install -g mnemon-mcp

Oder aus dem Quellcode:

git clone https://github.com/nikitacometa/mnemon-memory-mcp.git
cd mnemon-memory-mcp && npm install && npm run build

MCP-Client konfigurieren

openclaw mcp register mnemon-mcp --command="mnemon-mcp"

Oder füge ~/.openclaw/mcp_config.json hinzu:

{
  "mnemon-mcp": {
    "command": "mnemon-mcp"
  }
}

Füge ~/.claude/mcp.json hinzu:

{
  "mcpServers": {
    "mnemon-mcp": {
      "command": "mnemon-mcp"
    }
  }
}

Füge es zur MCP-Konfiguration deines Clients hinzu:

{
  "mcpServers": {
    "mnemon-mcp": {
      "command": "mnemon-mcp"
    }
  }
}

Verwende den vollständigen Pfad zum kompilierten Einstiegspunkt:

{
  "mnemon-mcp": {
    "command": "node",
    "args": ["/absolute/path/to/mnemon-mcp/dist/index.js"]
  }
}

Verifizierung

echo '{"jsonrpc":"2.0","method":"tools/list","id":1}' | mnemon-mcp

Du solltest 10 Tools in der Antwort sehen. Die Datenbank (~/.mnemon-mcp/memory.db) wird beim ersten Lauf automatisch erzeugt.

Das war es. Dein Agent hat jetzt ein persistentes Gedächtnis.

Was es kann

10 MCP-Tools

Werkzeug	Funktionalität
`memory_add`	Speichert eine Erinnerung mit Ebene, Entität, Konfidenz, Immerg und optionalem TTL
`memory_search`	Volltextsuche oder exakte Suche mit Filtern nach Ebene, Entität, Datum, Scope, Konfidenz
`memory_update`	In-Place-Update oder erstellt einen versionierten Ersatz (Ersetzungskette)
`memory_delete`	Löscht eine Erinnerung; reaktiviert ggf. den Vorgänger
`memory_inspect`	Ebene-Statistiken abrufen oder Versionsgeschichte einer Erinnerung verfolgen
`memory_export`	Export nach JSON, Markdown oder Claude-Format mit Filtern
`memory_health`	Diagnosen: abgelaufene Einträge, verwaiste Ketten, ungeeignete Erinnerungen; optional GC
`memory_session_start`	Startet eine Agentensitzung – gibt Sitzungs-ID zum Gruppieren von Erinnerungen zurück
`memory_session_end`	Beendet eine Sitzung mit optionaler Zusammenfassung; das gibt Dauer und Anzahl zurück
`memory_session_list`	Listet Sitzungen mit Filtern nach Client, Projekt oder aktive Status

MCP-Ressourcen und Prompts

Ressourcen – Live-Daten, die dein Agent lesen kann:

URI	Rückgabezahl
`memory://stats`	Aggregierte Statistiken pro Ebene
`memory://recent`	Erinnerungen, die in den letzten 24h erstellt/aktualisiert wurden
`memory://layer/{layer}`	Alle aktiven Erinnerungen in einer Ebene
`memory://entity/{name}`	Alle aktiven Erinnerungen zu einer Entität

Prompts – vorgefertigte Arbeitsabläufe:

Prompt	Zweck
`recall`	„Erzähl mir alles, was du über X weißt“
`context-load`	Relevnten Kontext laden, bevor du eine Aufgabe beginnst
`journal`	Einen strukturierten Tagebucheintrag erstellen

Suche

Vier Modi, alle unterstützen Filter nach Ebene / Entität / Scope / Datum / Konfidenz:

FTS-Modus (Standard ohne Embeddings) filter? — tokenisierte Volltextsuche mit BM25-Ranking. Mehrwort-Abfragen verwenden UND; bei zu wenigen Ergebnissen wird ODER mit Punktabzug ergänzusammenhält. Die progressive UND-Aufflockung probiert die drei spezifischsten Begriffe, bevor sie auf komplettes ODER fällt.

Hybrid-Modus (Standard bei Embedding-Konfiguration) – kombiniert FTS5 + Vektorbas via Reciprocal Rank Fusion. Er erkennt quoted Ausdrücke (z. B. 'Essentialism') und führt gewichtige Unterabfragen für die Kreuzreferenzsuche durch.

Vektor-Modus – reine Kosinus-Ähnlichkeitssuche bei Übernahmen.

Exakter Modus – LIKE-Substring-Match für präzise wörtliche Suche.

Scores: bm25 × (0.3 + 0.7 × importance) × decay(layer) × recency

Recency-Boot: 1 / (1 + daysSince / 365) – bemillt kürzlich erstellte Erinnerungen leicht, ohne ältere zu abzustrafen.

Stemming

Snowball-Stemmer wird sowohl bei der Indexierung als auch bei der Abfrage für Englisch und Deutsch angewendet. So matcht z. B. "running" auch "runs" und "книги" auch "книга". Stoppwörter werden beim Abfragenfilter verbessert, um die Präzision zu erhöhen.

Faktenversionierung

Wissen entwickelt sich. Mnemon löscht alte Fakten nicht, sondern verkettet sie:

v1: "Team uses React 17"  →  superseded_by: v2
v2: "Team uses React 19"  →  supersedes: v1 (active)

Die Suche gibt nur die neueste Version zurück. memory_inspect mit include_history: true zeigt die volle Kette. memory_delete reaktiviert den Vorgänger – nichts ist verloren.

Vektorsuche (optional, BYOK)

Aktiviere semantische Ähnlichkeits suche über deine eigene Embedding-API:

# OpenAI
MNEMON_EMBEDDING_PROVIDER=openai MNEMON_EMBEDDING_API_KEY=sk-... mnemon-mcp

# Ollama (local, free)
MNEMON_EMBEDDING_PROVIDER=ollama mnemon-mcp

Das schaft zwei zusätzlich Recherche-Modi frei:

mode: "vector" – reine Kosinus-Ähnlichkeitssuche
mode: "hybrid" – FTS5 + Vektor über Reciprocal Rank Fusion kombiniert

Erfordert sqlite-vec (wird als optionale Abhängigkeit installiert). Neue Erinnerungen werden beim Hinzufügen in Embedding übersetzt; bestehende können nachgerüstet werden.

Variable	Standardwerte	Beschreibung
`MNEMON_EMBEDDING_PROVIDER`	—	`openai` oder `ollama` (nicht gesetzt = deaktiviert)
`MNEMON_EMBEDDING_API_KEY`	—	API-Schlüssel (für OpenAI erforderlich)
`MNEMON_EMBEDDING_MODEL`	`text-embedding-3-small` / `nomic-embed-text`	Modellname
`MNEMON_EMBEDDING_DIMENSIONS`	`1024` / `768`	Vektor-Dimensionen
`MNEMON_OLLAMA_URL`	`http://localhost:11434`	IOllama-Endpunkt

Importieren einer Wissensdatenbank

Hast du einen Ordner mit Markdown-Dateien? Importiere sie gebündelt:

cp config.example.json ~/.mnemon-mcp/config.json   # edit this first
npm run import:kb -- --kb-path /path/to/your/kb     # incremental (skips unchanged files)

Die Konfiguration weist Glob-Muster den Speicher-eben zu:

{
  "owner_name": "your-name",
  "extra_stop_words": [],
  "mappings": [
    {
      "glob": "journal/*.md",
      "layer": "episodic",
      "entity_type": "user",
      "entity_name": "$owner",
      "importance": 0.6,
      "split": "h2"
    },
    {
      "glob": "people/*.md",
      "layer": "semantic",
      "entity_type": "person",
      "entity_name": "from-heading",
      "importance": 0.8,
      "split": "h3"
    }
  ]
}

Konfigurationsfelder

Feld	Typ	Beschreibung
`owner_name`	string	Dein Name – für `$owner`-Substitution in `entity_name` verwendet
`extra_stop_words`	string []	Wörter, die aus FTS-Abfragen herausgefilteretzt werden (z. B. Formen deines Namens)
`glob`	string	Dateimuster, das gematcht wird
`layer`	string	Zielebene der Speicherung
`entity_type`	string	`user` / `person` / `project` / `concept` / `file` / `rule` / `tool`
`entity_name`	string	Literaler Name, `"$owner"` oder `"from-heading"` (aus H2/H3 extrahiert)
`split`	string	`"whole"` (eine Erinnerung pro Datei), `"h2"` oder `"h3"` (an Überschriften geteilt)
`importance`	number	0.0–1.0, beeinflusst das Suchranking
`confidence`	number	0.0–1.0, in der Suche filterbar
`scope`	string	Optionaler Namespace

HTTP-Transport

Für Remote- oder Multi-Client-Setups:

MNEMON_AUTH_TOKEN=your-secret MNEMON_HOST=0.0.0.0 MNEMON_PORT=3000 npm run start:http

Endpoint	Beschreibung
`POST /mcp`	MCP JSON-RPC (Bearer-Auth, wenn Token gesetzt)
`GET /health`	`{"status":"ok","version":"..."}`

Bindet standardmäßig an 127.0.0.1. Für die Bindung an einen anderen Host ist MNEMON_AUTH_TOKEN erforderlich — der Server weigert sich, den Speicher ohne Authentifizierung im Netzwerk verfügbar zu machen (mit MNEMON_ALLOW_INSECURE_HTTP=1 in einem vertrauenswürdigen Netzwerk überschreibbar). Ratenbegrenzung (standardmäßig 100 Anfragen/min/IP), optionales CORS, Body-Limit von 1 MB, timing-sichere Authentifizierung, sauberes Herunterfahren bei SIGTERM.

Konfigurationsreferenz

Variable	Standard	Beschreibung
`MNEMON_DB_PATH`	`~/.mnemon-mcp/memory.db`	Datenbankpfad
`MNEMON_KB_PATH`	`.`	Wurzelverzeichnis der Wissensdatenbank für den Import
`MNEMON_CONFIG_PATH`	`~/.mnemon-mcp/config.json`	Pfad zur Importkonfiguration
`MNEMON_AUTH_TOKEN`	—	Bearer-Token für den HTTP-Transport
`MNEMON_HOST`	`127.0.0.1`	Bindungsadresse für den HTTP-Transport
`MNEMON_PORT`	`3000`	Port für den HTTP-Transport
`MNEMON_CORS_ORIGIN`	—	CORS `Access-Control-Allow-Origin` (keine CORS-Header, sofern nicht gesetzt)
`MNEMON_RATE_LIMIT`	`100`	Maximale Anfragen pro Minute und IP (0 = aus)

Tool-Referenz

Parameter	Type	Required	Description
`content`	string	Ja	Speichertext (max. 100K Zeichen)
`layer`	string	Ja	`episodic` / `semantic` / `procedural` / `resource`
`title`	string	Nein	Kurzer Titel (max. 500 Zeichen)
`entity_type`	string	Nein	`user` / `project` / `person` / `concept` / `file` / `rule` / `tool`
`entity_name`	string	Nein	Entitätsname zum Filtern
`confidence`	number	Nein	0.0–1.0 (Standard: 0.8)
`importance`	number	Nein	0.0–1.0 (Standard: 0.5)
`scope`	string	Nein	Namespace (Standard: `global`)
`source_file`	string	Nein	Pfad der Quelldatei — löst automatisches Ersetzen (Supersede) übereinstimmender Einträge aus
`ttl_days`	number	Nein	Nach N Tagen automatisch ablaufen lassen
`valid_from` / `valid_until`	string	Nein	Zeitfenster für Fakten (ISO 8601)

Parameter	Type	Required	Description
`query`	string	Ja	Suchtext
`mode`	string	Nein	`fts` (Standard), `exact`, `vector`, `hybrid`
`layers`	string[]	Nein	Nach Ebenen filtern
`entity_name`	string	Nein	Nach Entität filtern (unterstützt Aliase)
`scope`	string	Nein	Nach Namespace filtern
`date_from` / `date_to`	string	Nein	Datumsbereich (ISO 8601)
`as_of`	string	Nein	Temporaler Faktenfilter — Fakten, die zu diesem Datum gültig sind
`min_confidence`	number	Nein	Mindestkonfidenz
`min_importance`	number	Nein	Mindestwichtigkeit
`limit`	number	Nein	Maximale Ergebnisse (Standard: 10, max. 100)
`offset`	number	Nein	Offset für die Paginierung

Parameter	Type	Required	Description
`id`	string	Ja	Speicher-ID
`content`	string	Nein	Neuer Inhalt
`title`	string	Nein	Neuer Titel
`confidence`	number	Nein	Neue Konfidenz
`importance`	number	Nein	Neue Wichtigkeit
`supersede`	boolean	Nein	`true` = versionierte Ersetzung; `false` (Standard) = In-place-Änderung
`new_content`	string	Nein	Inhalt für den ersetzenden Eintrag

Parameter	Type	Required	Description
`id`	string	Ja	Speicher-ID. Reaktiviert den Vorgängereintrag, wenn der Eintrag Teil einer Ersetzungskette ist

Parameter	Type	Required	Description
`id`	string	Nein	Speicher-ID (für aggregierte Statistiken weglassen)
`layer`	string	Nein	Statistiken nach Ebene filtern
`entity_name`	string	Nein	Statistiken nach Entität filtern
`include_history`	boolean	Nein	Ersetzungskette anzeigen

Parameter	Type	Required	Description
`format`	string	Ja	`json` / `markdown` / `claude-md`
`layers`	string[]	Nein	Nach Ebenen filtern
`scope`	string	Nein	Nach Namespace filtern
`date_from` / `date_to`	string	Nein	Datumsbereich
`limit`	number	Nein	Maximale Einträge (Standard: alle, max. 10K)

Parameter	Type	Required	Description
`cleanup`	boolean	Nein	`true` = abgelaufene Einträge bereinigen (Standard: nur melden)

Gibt zurück: Status (healthy / warning / degraded), Statistiken pro Ebene, abgelaufene Einträge, verwaiste Ketten, Anzahl veralteter Einträge bzw. Einträge mit niedriger Konfidenz, Anzahl bereinigter Einträge bei cleanup=true.

Parameter	Type	Required	Description
`client`	string	Ja	Client-Kennung (z. B. `claude-code`, `cursor`, `api`)
`project`	string	Nein	Projektbereich für diese Sitzung
`meta`	object	Nein	Zusätzliche Sitzungsmetadaten

Gibt zurück: id (Sitzungs-UUID), started_at (ISO 8601).

Parameter	Type	Required	Description
`id`	string	Ja	ID der zu beendenden Sitzung
`summary`	string	Nein	Zusammenfassung dessen, was erreicht wurde (max. 10K Zeichen)

Gibt zurück: id, ended_at, duration_minutes, memories_count.

Parameter	Type	Required	Description
`limit`	number	Nein	Maximale Sitzungen (Standard: 20, max. 100)
`client`	string	Nein	Nach Client filtern
`project`	string	Nein	Nach Projekt filtern
`active_only`	boolean	Nein	Nur nicht beendete Sitzungen zurückgeben (Standard: false)

Gibt zurück: ein Array von Sitzungen mit id, client, project, started_at, ended_at, summary, memories_count.

So schneidet es im Vergleich ab

	mnemon-mcp	mem0	basic-memory	Engram	Anthropic KG
Architektur	SQLite FTS5 + Vektor	Cloud API + Qdrant	Markdown + Vektor	SQLite FTS5	JSON-Datei
Speicherstruktur	4 typisierte Ebenen	Flach	Flach	Flach + Sitzungen	Graph
Suche	FTS5 + hybrides RRF	Semantisch	Hybrid	FTS5	Exakt
Faktenversionierung	Ersetzungsketten	Teilweise	Nein	Nein	Nein
Stemming	EN + RU (Snowball)	Nur EN	Nur EN	Keine	Keine
Embeddings	BYOK (OpenAI / Ollama)	Integriert	FastEmbed	Keine	Keine
Abhängigkeiten	Keine erforderlich	Qdrant, Neo4j	Python 3.12	Go-Binary	Keine
Cloud erforderlich	Nein	Ja	Nein	Nein	Nein
Kosten	Kostenlos	$19–249/mo	Kostenlos	Kostenlos	Kostenlos
Einrichtung	`npm install -g`	Docker + API-Schlüssel	pip + Abhängigkeiten	Go install	Integriert
Lizenz	MIT	Apache 2.0	AGPL	MIT	MIT

Erweiterte Wettbewerbsanalyse mit Quellen: docs/COMPETITORS.md.

Entwicklung

npm run dev        # run via tsx (no build step)
npm run build      # TypeScript → dist/
npm run lint       # eslint (flat config)
npm test           # vitest — unit + integration + MCP dispatch + HTTP transport + hybrid RRF
npm run bench      # performance benchmarks
npm run db:backup  # backup database

CI führt Build, Lint und Tests unter Node 20 und 22 aus; danach wird der kompilierte Server per Smoke-Test über echtes JSON-RPC getestet (tools/list muss exakt dem Tool-Set entsprechen).

Stack: TypeScript 5.9 (Strict-Modus), better-sqlite3, @modelcontextprotocol/sdk, Snowball-Stemmer, Zod, vitest.

Siehe CONTRIBUTING.md für Code-Richtlinien.

Design-Prinzipien

Standardmäßig air-gapped — keinerlei Telemetrie, jemals. Ab Werk verlässt nichts die Maschine; die einzige Komponente, die mit dem Netzwerk kommuniziert, ist der optionale Embedder, und nur mit dem von Ihnen konfigurierten Anbieter (einschließlich eines lokalen Ollama).
Einzelne Datei — eine SQLite-Datenbank, kein Betriebsaufwand, sofortige Sicherung per Dateikopie.
Deterministische Suche — FTS5, nicht Embeddings, ist die Standardeinstellung. Interpretierbar, reproduzierbar, keine GPU erforderlich.
Strukturiert statt flach — Ebenen kodieren Zugriffsmuster; Ablöseketten kodieren Zeit.
Minimal — 4 Produktionsabhängigkeiten. Funktioniert überall, wo Node läuft.
Gemessen, nicht behauptet — Retrieval-Änderungen werden anhand eines Golden Sets bewertet, Regressionen inklusive.

Lizenz

MIT

This server cannot be installed

license - permissive license

Not graded

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

–Releases (12mo)

Commit activity

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Servers

tartarus-mcp
Knowledge & Memory Search
saluca-labs
A
license
Not graded
quality
C
maintenance
A local-first MCP memory server providing persistent, searchable memory for AI agents, powered by SQLite.
Updated 2 days ago (2026-08-19 17:35 UTC)
5
1
Apache 2.0
persistent-kb-mcp
Knowledge & Memory Search
0x67108864
A
license
Not graded
quality
D
maintenance
A local-first MCP server providing persistent, searchable knowledge base via SQLite, enabling AI agents to save and recall facts across sessions without cloud dependencies.
Updated 3 months ago (2026-05-11 17:09 UTC)
MIT
local-memory-mcp
Knowledge & Memory RAG Systems
smankoo
A
license
Not graded
quality
D
maintenance
A local-first long-term memory system for AI coding agents, exposed as an MCP server.
Updated 5 months ago (2026-03-26 23:12 UTC)
131
MIT
universal-memory-mcp
Knowledge & Memory AI & Machine Learning
hz1ulqu01gmnZH4
A
license
A
quality
C
maintenance
Persistent memory MCP server for AI agents, using SQLite with hybrid keyword and semantic search for long-term memory storage.
Updated a month ago (2026-07-11 05:32 UTC)
5
Do What The F*ck You Want To Public

View all related MCP servers

Related MCP Connectors

Tempreon — Personal AI Memory
Person-owned, portable AI memory as a remote MCP server, readable and writable by any MCP client.
Motecloud Memory
Cloud-hosted MCP server for durable AI memory
XMemo
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.

View all MCP Connectors

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/nikitacometa/mnemon-memory-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

mnemon-mcp

Warum ein geschichtetes Gedächtnis?

Retrieval-Qualität

Architektur

Schnellstart

Installation

MCP-Client konfigurieren

Verifizierung

Was es kann

10 MCP-Tools

MCP-Ressourcen und Prompts

Suche

Stemming

Faktenversionierung

Vektorsuche (optional, BYOK)

Importieren einer Wissensdatenbank

Konfigurationsfelder

HTTP-Transport

Konfigurationsreferenz

Tool-Referenz

So schneidet es im Vergleich ab

Entwicklung

Design-Prinzipien

Lizenz

Maintenance

Resources

Looking for Admin?

Related MCP Servers

tartarus-mcp

persistent-kb-mcp

local-memory-mcp

universal-memory-mcp

Related MCP Connectors

Latest Blog Posts

MCP directory API