de en es ja ko ru zh

Mnemosyne

Name: Mnemosyne
Author: M4F-S

by M4F-S

Overview Schema Related Servers Score Discussions

Python

Local

Mnemosyne 🧠

PyPI version Python 3.9+ MCP License: Apache-2.0

Motor de memoria jerárquico de nivel de producción, local-first, para agentes de IA autónomos.

Mnemosyne dota a los agentes de IA (Hermes, OpenClaw, OpenManus, Claude Desktop, Cursor, Windsurf, CrewAI, LangChain) con memoria a largo plazo permanente y estructurada. Conecta bóvedas Obsidian en Markdown legibles por humanos con PostgreSQL + pgvector (HNSW) de alta velocidad o SQLite de configuración cero, impulsando la búsqueda híbrida de fusión por rango recíproco (RRF), los grafos de conocimiento por wikienlaces, el decaimiento temporal de Ebbinghaus, el intercambio de memoria entre flotas de agentes y la sincronización asíncrona en la nube con Google Drive.

📑 Índice

Related MCP server: Synapto

⚡ Matriz completa de funcionalidades

Funcionalidad	Descripción	Beneficio
🤖 MCP nativo (v2024-11-05)	Servidor de protocolo JSON-RPC stdio estandarizado	Integración directa sin fricciones en Claude, Cursor, Windsurf, Hermes, OpenClaw
🔎 Búsqueda vectorial HNSW de alto recall	Indexación HNSW de `pgvector` con `vector_cosine_ops` (`m=16, ef_construction=64`)	Recuperación vectorial en sub-milisegundos sin reentrenamiento de clústeres
⚖️ Recuperación híbrida RRF	Fusión por rango recíproco de embeddings densos (1.0) + GIN FTS (0.8) + Grafo (0.6) + Saliencia (0.2)	Captura palabras técnicas exactas (CVE, tokens de código) y semántica difusa
🏛️ Alcance por Wing y Room	Taxonomía de 2 niveles (`wing` = dominio/proyecto, `room` = canal/tema)	Elimina la saturación de la ventana de contexto y la alucinación entre dominios
🌐 Memoria compartida entre agentes	`shared_db` central consultable en flotas multiagente con selección de credenciales	Inteligencia colectiva de la flota sin comprometer las bases de datos privadas
☁️ Sincronización asíncrona con Google Drive	Motor de sincronización bidireccional local-first con comparación MD5 y resolución de ramas `.conflict.md`	E/S local del agente en sub-milisegundos + copia de seguridad automática en la nube e intercambio en equipo
⏳ Decaimiento temporal de Ebbinghaus	Decaimiento exponencial $Salience_t = Salience_0 \times (0.95)^{\Delta t}$ con autoarchivado a los 90 días	Poda automática del ruido transitorio y mantiene nítidos los recuerdos activos
📌 Inmunidad de memoria anclada	Inmunidad permanente al decaimiento mediante `pinned=True` o etiquetas `#pinned`	Garantiza que las instrucciones fundacionales y las reglas principales nunca se desvanezcan
📖 Obsidian Zettelkasten	Escribe notas Markdown legibles por humanos con frontmatter YAML y `[[Wiki Links]]`	Inspección visual directa, edición y visualización de grafos en Obsidian
📜 Ingestor consciente de turnos	Fragmentación con ventana deslizante de 1.500 caracteres con solapamiento de 200 caracteres a lo largo de los límites de turno	Preserva todo el historial de la conversación sin romper bloques de código
🛡️ Armadura contra inyección de prompts	Neutraliza tokens de control (`<	im_start	>`,` [INST]`) en prosa; escapa las etiquetas XML de contexto	Evita el envenenamiento de memoria y los ataques de secuestro de contexto
⚡ Compatibilidad con FastEmbed ONNX	Motor de embeddings de ONNX Runtime ultraligero (~30MB de RAM)	90% de reducción de memoria frente al pesado PyTorch `sentence-transformers`
🔄 Recurso de reserva SQLite sin configuración	Alternancia automática a SQLite local cuando PostgreSQL no está disponible	Paridad total de funcionalidades para estaciones de trabajo de desarrollo independientes

🏗️ Arquitectura del sistema

                                ┌──────────────────────────────────────────────┐
                                │          AI Agents & LLM Frameworks          │
                                │  Hermes • OpenClaw • Claude • Cursor • Manus │
                                └──────────────────────┬───────────────────────┘
                                                       │ JSON-RPC (stdio) / Python SDK
                                                       ▼
┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                           Mnemosyne Core (v3.4.0)                                           │
│                                                                                                             │
│  ┌─────────────────────────┐  ┌─────────────────────────┐  ┌─────────────────────────────────────────────┐  │
│  │ Admission & Security    │  │ Multi-Backend Embedder  │  │ Turn-Aware Session Ingestor                 │  │
│  │ - Secret Regex Guard    │  │ - FastEmbed (ONNX 30MB) │  │ - Turn boundary splitting                   │  │
│  │ - Injection Neutralizer │  │ - Remote Microservice   │  │ - 1500-char linear sliding window           │  │
│  │ - Path Traversal Guard  │  │ - SentenceTransformers  │  │ - Sequential [[Wiki Link]] chaining         │  │
│  └─────────────────────────┘  └─────────────────────────┘  └─────────────────────────────────────────────┘  │
│                                                                                                             │
│  ┌───────────────────────────────────────────────────────────────────────────────────────────────────────┐  │
│  │                                 Hybrid RRF Retrieval & Graph Ranker                                   │  │
│  │            RRF Score = 1.0 * Dense(HNSW) + 0.8 * Keyword(FTS) + 0.6 * Graph + 0.2 * Salience          │  │
│  └───────────────────────────────────────────────────────────────────────────────────────────────────────┘  │
└───────────────────────────────────────┬───────────────────────────────────────┬─────────────────────────────┘
                                        │                                       │
                ┌───────────────────────┴───────────────────────┐               │
                ▼                                               ▼               ▼
 ┌─────────────────────────────┐                 ┌─────────────────────────────────────────────┐
 │    PostgreSQL + pgvector    │                 │       Obsidian Markdown Vault (Local)       │
 │ - HNSW vector_cosine_ops    │                 │ - Human-Readable Markdown + YAML Frontmatter │
 │ - GIN tsvector English FTS  │                 │ - [[Wikilink]] Knowledge Graph Visualizer   │
 │ - Self-Healing DB Pool      │                 │ - Atomic Writes with EXDEV Fallback         │
 │ - Private DB + shared_db    │                 └──────────────────────┬──────────────────────┘
 └─────────────────────────────┘                                        │ Async Background Sync
                                                                        ▼
                                                 ┌─────────────────────────────────────────────┐
                                                 │              Google Drive Cloud             │
                                                 │ - Service Account / OAuth2 Authentication    │
                                                 │ - MD5 Checksum Verification                 │
                                                 │ - Sibling .conflict-TIMESTAMP.md Resolution │
                                                 └─────────────────────────────────────────────┘

🧠 Análisis profundo de las capacidades clave

1. Taxonomía jerárquica de Wing y Room

La contaminación cruzada de la memoria es un modo de fallo importante en flotas multiagente. Mnemosyne estructura la memoria como un palacio físico de 2 niveles:

wing (dominio/proyecto): límite de dominio de nivel superior (p. ej., ecommerce, pentest, devops, shared).
room (tema/canal): partición de tema granular (p. ej., database, firewall, stripe_api).

Las consultas pueden acotarse estrictamente a un wing o room específicos, lo que evita que los prompts de marketing recuperen hallazgos de pruebas de penetración.

2. Búsqueda híbrida de fusión por rango recíproco (RRF)

La búsqueda vectorial estándar falla con cadenas técnicas exactas (p. ej., CVE-2024-38077, 0x7fff5fbff8c0), mientras que la búsqueda por palabras clave falla con conceptos semánticos. Mnemosyne ejecuta una recuperación multicandidata y fusiona los resultados mediante RRF ponderado:

$$\text{RRF Score}(d) = \sum_{m \in \text{modes}} w_m \cdot \frac{1}{k + \text{rank}_m(d)} + 0.2 \cdot \text{Salience}(d)$$

Búsqueda vectorial HNSW densa: Peso $1.0$ (distancia coseno sobre embeddings de 384 dimensiones).
Búsqueda de texto completo en PostgreSQL: Peso $0.8$ (tsvector ponderado con título como A y contenido como B).
Recorrido recursivo de grafo: Peso $0.6$ (CTE recursivo que descubre [[Wiki Links]] de 1 salto y 2 saltos).
Motor de saliencia de memoria: Peso $0.2$ (puntuación de importancia de $0.0$ a $1.0$).

3. Capa de memoria compartida entre agentes (`shared_db`)

En entornos multiagente autónomos, los agentes mantienen bases de datos privadas aisladas (toy_db, old_db, candy_db, etc.) para evitar la corrupción del estado. Sin embargo, la inteligencia colectiva requiere compartir políticas globales y hechos verificados.

Publicación: mediante memory_publish_shared, las notas verificadas se publican en shared_db.
Selección de credenciales: el contenido se analiza con filtros regex estrictos para claves de Anthropic (sk-ant-), claves de Google Gemini (AIza...), tokens de HuggingFace (hf_...), claves de OpenAI (sk-proj-...), claves de acceso de AWS (AKIA...), tokens de Slack (xox-) y claves privadas.
Recuperación con degradación suave: cuando un agente consulta la memoria, memory_recall consulta tanto el almacén privado como shared_db. Si la base de datos compartida no está disponible temporalmente, se degrada con elegancia sin interrumpir al agente.

4. Decaimiento temporal de Ebbinghaus e inmunidad anclada

Los recuerdos pierden relevancia de forma natural con el tiempo. Mnemosyne implementa la curva exponencial de olvido de Herman Ebbinghaus:

$$\text{Salience}(t) = \text{Salience}0 \times (0.95)^{\Delta t{\text{days}}}$$

Retroalimentación de acceso: acceder a un recuerdo actualiza last_accessed_at, reiniciando su decaimiento.
Autoarchivado nocturno: la consolidación transfiere automáticamente las notas con $\text{Salience} < 0.05$ y sin acceso durante $>90\text{ días}$ a status = 'archived'.
Inmunidad anclada: las reglas del sistema, las políticas principales o las notas marcadas con pinned=True o etiquetadas con #pinned reciben inmunidad permanente frente al decaimiento temporal ($\text{Salience} = 1.0$).

5. Obsidian Markdown Vault y grafo bidireccional

Cada recuerdo creado por un agente se escribe simultáneamente como un archivo .md legible por humanos dentro de tu bóveda de Obsidian:

Frontmatter Zettelkasten: contiene title, date, tags, type, salience, wing y room.
Grafo de conocimiento: las notas objetivo mencionadas como [[Target Note]] se analizan automáticamente en aristas bidireccionales en PostgreSQL.
Inspección en vivo: abre Obsidian en tu escritorio o dispositivo móvil y explora la memoria colectiva de tu flota de agentes en la Vista de Grafo interactiva de Obsidian.

6. Ingestor de sesiones verbatim consciente de turnos

Las transcripciones de conversaciones suelen contener matices cruciales que se pierden en la síntesis con pérdida. memory_ingest_session:

Divide las transcripciones en bruto a lo largo de los límites de turno (User:, Assistant:, ### Turn, **Human**:).
Para turnos de más de 1.500 caracteres, aplica una ventana deslizante lineal (1.500 caracteres con solapamiento de 200 caracteres).
Encadena fragmentos secuenciales mediante wikienlaces [[Session ... Turn 01 Part 02]], preservando bloques de código, trazas de ejecución y el flujo conversacional.

7. Sincronización asíncrona en la nube con Google Drive

Mantén las bóvedas de tus agentes respaldadas de forma segura y sincronizadas entre varias máquinas o dispositivos móviles:

Velocidad local primero: Las llamadas de herramientas del agente se ejecutan a velocidades de SSD local (<1ms) sin bloquearse por la latencia de red de Google Drive.
Demonio en segundo plano / sincronización Cron: Escanea los archivos del vault, calcula sumas de verificación MD5 y sincroniza los deltas bidireccionalmente con Google Drive.
Resolución de conflictos: Si un archivo se modifica simultáneamente en Google Drive y en el vault local del agente, Mnemosyne guarda la versión entrante como NoteName.conflict-YYYYMMDD-HHMMSS.md, evitando la pérdida de datos.
Autenticación: Admite JSON de cuenta de servicio de Google Cloud (GOOGLE_APPLICATION_CREDENTIALS, GDRIVE_SERVICE_ACCOUNT_JSON) y tokens de usuario OAuth2 (GDRIVE_TOKEN_JSON).

8. Backends de incrustación flexibles (FastEmbed / Microservicio / Local)

Mnemosyne se adapta a cualquier presupuesto de recursos de despliegue:

FastEmbed ONNX Runtime (Recomendado para nodos independientes): Utiliza ejecución C++ de ONNX Runtime (~30MB de RAM). Cero sobrecarga de PyTorch.
Microservicio centralizado (mnemosyne.embed_service): Aloja sentence-transformers en un único contenedor dedicado que sirve a múltiples contenedores de agentes a través de HTTP (MEMORY_EMBED_URL).
SentenceTransformers local: Ejecución independiente de PyTorch (all-MiniLM-L6-v2, 384 dimensiones).
Respaldo de hash determinista: Hash vectorial matemático de cero RAM para entornos con restricciones extremas.

9. Seguridad en profundidad y blindaje contra inyecciones

Inmunidad a Path Traversal: Las comprobaciones canónicas de ruta de doble resolución (is_relative_to) garantizan que las operaciones de archivos no puedan escapar de la raíz del vault.
Escrituras atómicas en archivos hermanos: Los archivos se escriben en archivos temporales hermanos (.note.pid.tmp) y se renombran atómicamente, con respaldo automático para montajes de volúmenes entre dispositivos EXDEV.
Neutralización de tokens de control: Neutraliza los tokens de inyección de LLM (<|im_start|>, <|system|>, [INST], <<SYS>>) en prosa mientras conserva los bloques de código tal cual.
Envoltura de contexto XML estructurado: Las memorias recuperadas se envuelven en etiquetas <recalled_memory_context id="..." title="..." source="..."> con escape interno de etiquetas, lo que garantiza que los LLM anfitriones nunca confundan las memorias recuperadas con directivas activas del sistema.

🛠️ Referencia de herramientas MCP (8 herramientas)

Las 8 herramientas se exponen de forma nativa a los agentes mediante MCP JSON-RPC stdio estándar:

1. `memory_remember`

Almacena una nota de memoria privada en el vault con incrustación semántica, etiquetas y alcance jerárquico.

{
  "title": "PostgreSQL HNSW Tuning",
  "content": "For datasets >10,000 vectors, use HNSW with m=16 and ef_construction=64 for optimal recall.",
  "tags": ["database", "pgvector", "performance"],
  "wing": "engineering",
  "room": "databases",
  "salience": 0.8,
  "pinned": true
}

2. `memory_publish_shared`

Publica un hallazgo o política depurados y verificados en la memoria compartida de la flota entre agentes (shared_db).

{
  "title": "Fleet Security Policy: SSL Verification",
  "content": "All internal agent HTTP requests must enforce SSL certificate validation.",
  "tags": ["security", "policy"],
  "wing": "shared",
  "room": "general"
}

3. `memory_recall`

Busca memorias en las bases de datos privadas y compartidas de la flota mediante RRF híbrido, vectores HNSW, palabras clave o grafos.

{
  "query": "HNSW index configuration parameters",
  "mode": "hybrid",
  "top_k": 5,
  "scope": {
    "wing": "engineering",
    "room": "databases"
  },
  "include_shared": true
}

4. `memory_ingest_session`

Ingiere y fragmenta una transcripción completa de conversación, palabra por palabra, siguiendo los límites de turno.

{
  "transcript": "User: How do we configure pgvector?\nAssistant: Use CREATE EXTENSION vector; then create an HNSW index.",
  "wing": "engineering",
  "room": "sessions"
}

5. `memory_timeline`

Inspecciona las operaciones de memoria recientes (remember, recall, remind, consolidate) en orden cronológico.

{
  "limit": 20
}

6. `memory_history`

Visualiza el historial de versiones y las instantáneas de ediciones anteriores de una nota de memoria específica antes de las actualizaciones.

{
  "title": "PostgreSQL HNSW Tuning",
  "limit": 5
}

7. `memory_remind_me`

Programa un recordatorio prospectivo futuro o una tarea recurrente.

{
  "title": "Rotate Database Credentials",
  "content": "Verify that all 5 agent connection pools are refreshed with new passwords.",
  "trigger_at": "2026-09-01T00:00:00Z",
  "recurring": "monthly"
}

8. `memory_audit`

Obtén métricas de salud de memoria en tiempo real, estado del backend de almacenamiento, contadores de solicitudes y alas activas.

{}

🌐 Arquitectura de producción de flota multiagente

En configuraciones de producción multiagente (como la flota Hermes de 5 agentes), Mnemosyne aísla las bases de datos de los agentes en una red Docker interna mientras proporciona inteligencia compartida:

                                  ┌─────────────────────────────────────────┐
                                  │      Production VPS (${VPS_HOST})      │
                                  └────────────────────┬────────────────────┘
                                                       │
         ┌───────────────────┬──────────────────┼───────────────────┬──────────────────┐
         ▼                   ▼                  ▼                   ▼                  ▼
┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐┌──────────────────┐
│   hermes-agent   ││ hermes-assistant ││ hermes-marketing ││  hermes-pentest  ││  hermes-trader   │
│      (Toy)       ││      (Old)       ││     (Candy)      ││     (Pencil)     ││      (Coin)      │
│   Database:      ││   Database:      ││   Database:      ││   Database:      ││   Database:      │
│     toy_db       ││     old_db       ││     candy_db     ││     pencil_db    ││     trader_db    │
└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘└────────┬─────────┘
         │                   │                  │                   │                  │
         └───────────────────┴──────────────────┼───────────────────┴──────────────────┘
                                                │
                                                ▼
                               ┌───────────────────────────────────┐
                               │   PostgreSQL + pgvector (HNSW)    │
                               │   - Private DBs: toy_db, old_db.. │
                               │   - Shared DB:   shared_db        │
                               └───────────────────────────────────┘

🚀 Inicio rápido e instalación

1. Instalación

# Standard installation
pip install mnemosyne-memory

# With Google Drive Cloud Synchronization support
pip install "mnemosyne-memory[gdrive]"

# With lightweight FastEmbed ONNX support (~30MB RAM)
pip install "mnemosyne-memory[fastembed]"

# Full installation (All extras + Dev dependencies)
pip install "mnemosyne-memory[dev,gdrive,fastembed,embed-service]"

2. Ejecutar con Docker Compose

Inicia el contenedor de PostgreSQL + pgvector:

docker compose up -d

3. Lanzar el servidor MCP

# Standalone with local SQLite (Zero configuration)
python -m mnemosyne server

# With PostgreSQL + pgvector
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/my_agent_db" python -m mnemosyne server

🤖 Recetas de integración con frameworks de agentes

1. Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "/Users/username/Documents/Obsidian/AgentVault",
        "MEMORY_DEFAULT_WING": "claude"
      }
    }
  }
}

2. Cursor IDE (`.cursor/mcp.json`)

{
  "mcpServers": {
    "mnemosyne": {
      "command": "python3",
      "args": ["-m", "mnemosyne", "server"],
      "env": {
        "MEMORY_VAULT_PATH": "./.vault",
        "MEMORY_DEFAULT_WING": "codebase"
      }
    }
  }
}

3. Hermes Agent (`~/.hermes/config.yaml`)

mcp_servers:
  obsidian_memory:
    command: python3
    args: ["-m", "mnemosyne", "server"]
    env:
      MEMORY_DB_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/toy_db"
      MEMORY_SHARED_DSN: "postgresql://mnemosyne:***@${DB_HOST}:5432/shared_db"
      MEMORY_VAULT_PATH: "/opt/data/vault"

4. OpenClaw (`openclaw-config.yaml`)

plugins:
  mcp_servers:
    mnemosyne:
      command: "python3"
      args: ["-m", "mnemosyne", "server"]
      env:
        MEMORY_VAULT_PATH: "~/.openclaw/vault"
        MEMORY_DEFAULT_WING: "openclaw"

5. SDK de Python y scripts de agentes autónomos

from mnemosyne import UnifiedMemorySystem

mem = UnifiedMemorySystem(
    vault_path="~/.agent/vault",
    dsn="postgresql://mnemosyne:***@localhost:5432/agent_db",
    shared_dsn="postgresql://mnemosyne:***@localhost:5432/shared_db"
)

# Remember fact
mem.remember(
    title="Kubernetes Cluster Policy",
    content="Deployments in staging must specify resource memory limits.",
    wing="infrastructure",
    room="k8s",
    tags=["kubernetes", "policy"],
    pinned=True
)

# Hybrid recall
results = mem.recall(
    query="staging memory limits",
    mode="hybrid",
    scope={"wing": "infrastructure"}
)

for r in results:
    print(r["title"], "->", r["formatted_context"])

💻 Referencia completa de comandos CLI

Mnemosyne incluye una CLI de gestión con todas las funciones:

# 1. Store a memory note
python -m mnemosyne remember "API Architecture" "Uses Bearer JWT auth." --tags security auth --wing backend --room api --salience 0.8 --pinned

# 2. Publish shared fleet memory
python -m mnemosyne publish-shared "Global Production Policy" "Always check SSL certs." --wing devops

# 3. Search memories
python -m mnemosyne recall "JWT authentication" --mode hybrid --top-k 5 --wing backend

# 4. View activity timeline
python -m mnemosyne timeline --limit 20

# 5. Trigger Ebbinghaus decay & link reconciliation
python -m mnemosyne consolidate --decay-rate 0.95 --archive-threshold 0.05

# 6. Check system statistics & health
python -m mnemosyne stats

# 7. Synchronize with Google Drive (One-off pass)
python -m mnemosyne sync-gdrive --folder "My-Agent-Vault" --credentials service-account.json

# 8. Run Google Drive Sync as a background daemon
python -m mnemosyne sync-gdrive --daemon --interval 60

# 9. Run standalone Centralized Embedding Microservice
python -m mnemosyne embed-service --host 0.0.0.0 --port 8000 --model all-MiniLM-L6-v2

⚙️ Referencia de variables de entorno

Variable	Predeterminado	Descripción
`MEMORY_VAULT_PATH`	`~/.mnemosyne/vault`	Ruta del sistema de archivos al directorio local del vault de Obsidian Markdown
`MEMORY_DB_DSN`	(ninguno)	DSN de PostgreSQL (p. ej. `postgresql://user:pass@host:5432/db`). Si no se define, usa SQLite
`MEMORY_SHARED_DSN`	(ninguno)	DSN de PostgreSQL para la base de datos opcional compartida de la flota entre agentes
`MEMORY_AGENT_NAME`	`local-agent`	Identificador del agente de origen en despliegues de flota multiagente
`MEMORY_EMBED_URL`	(ninguno)	URL del microservicio centralizado de incrustación remoto (p. ej. `http://localhost:8000`)
`MEMORY_REQUIRE_POSTGRES`	`false`	Establece `true` para lanzar un error en lugar de recurrir a SQLite si PostgreSQL falla
`GOOGLE_APPLICATION_CREDENTIALS`	(ninguno)	Ruta al JSON de cuenta de servicio de Google Cloud para la sincronización con Google Drive
`GDRIVE_SERVICE_ACCOUNT_JSON`	(ninguno)	Contenido JSON serializado de las credenciales de cuenta de servicio de Google Cloud
`GDRIVE_TOKEN_JSON`	(ninguno)	Contenido JSON serializado del token de usuario OAuth2 autorizado de Google
`TOKENIZERS_PARALLELISM`	`false`	Desactiva los forks del tokenizador de HuggingFace para preservar la integridad del flujo stdio JSON-RPC
`HF_HUB_DISABLE_PROGRESS_BARS`	`1`	Desactiva las barras de progreso en stdio para mantener limpios los flujos MCP
`HF_HUB_OFFLINE`	`0`	Establece `1` para ejecutar SentenceTransformers 100% sin conexión usando caché local
`TRANSFORMERS_OFFLINE`	`0`	Establece `1` para evitar que transformers realice solicitudes de red externas a HuggingFace

🧪 Pruebas y benchmarks

Mnemosyne mantiene una suite de pruebas integral (pruebas unitarias, pruebas de inyección de seguridad, pruebas SQLite y pruebas de integración en vivo con PostgreSQL pgvector):

# Run all unit tests
pytest tests/ -v -m "not integration"

# Run full test suite including live PostgreSQL + pgvector tests
MEMORY_DB_DSN="postgresql://mnemosyne:***@localhost:5432/test_db" pytest tests/ -v

📄 Licencia

Licencia Apache-2.0. Creado para el ecosistema abierto de agentes autónomos. Consulta LICENSE para obtener más detalles.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

license - permissive license

quality

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

1wRelease cycle

2Releases (12mo)

Commit activity

Resources

GitHub Repository

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.

Tools

View all tools

Related MCP Servers

aimemory
Knowledge & Memory RAG Systems
George3307
A
license
Not graded
quality
D
maintenance
Gives AI agents persistent memory with semantic search, automatic extraction, and memory decay, accessible via MCP protocol.
Updated 6 months ago (2026-02-20 22:53 UTC)
12
MIT
Synapto
Knowledge & Memory Search
ramonlimaramos
A
license
Not graded
quality
A
maintenance
Provides persistent, searchable memory for MCP-compatible agents, enabling recall by meaning, automatic decay, trust scoring, and cross-agent handoffs.
Updated 4 days ago (2026-08-27 15:11 UTC)
5
MIT
mcp-memory
Knowledge & Memory RAG Systems
oneKn8
A
license
A
quality
D
maintenance
Provides persistent memory with semantic search for MCP-based AI agents, enabling them to store and recall information across sessions using vector embeddings.
Updated 5 months ago (2026-03-23 14:16 UTC)
4
1
MIT
madb-mcp-server
Knowledge & Memory Autonomous Agents
spshkar84
F
license
Not graded
quality
B
maintenance
Provides persistent, causal memory for AI agents with semantic recall, causal tracking, and importance-based forgetting through MCP tools.
Updated 2 months ago (2026-07-07 04:22 UTC)

View all related MCP servers

Related MCP Connectors

XMemo
Shared, governed long-term memory for AI agents across tools and sessions via MCP and REST.
mcp
Your memory, everywhere AI goes. Build knowledge once, access it via MCP anywhere.
OpenAkashic
Shared long-term memory vault for AI agents with 20 MCP tools.

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/M4F-S/gomaa'

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