🧠 Feature Request: Sistema de Memoria Local Integrada

[olivermontes]

🎯 Visión General

Implementar un sistema de memoria local nativo en Levante que permita a los usuarios mantener contexto persistente a través de conversaciones y compartir esta memoria con otros sistemas de AI mediante un MCP Server integrado.

💡 Inspiración & Referencias

Esta propuesta se inspira en sistemas como:

• [OpenMemory MCP](https://mem0.ai/openmemory-mcp) - Memoria local first con interfaz unificada
• [Mem0](https://github.com/mem0ai/mem0) - Capa inteligente de memoria para agentes AI
• [Knowledge Graph Memory MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/memory) - Grafo de conocimiento persistente
• [Universal MCP Memory Service](https://github.com/doobidoo/mcp-memory-service) - Búsqueda semántica multi-cliente

🚨 Problema Actual

Los usuarios de Levante experimentan pérdida de contexto entre sesiones:

Escenarios Reales

• Desarrollo: "Ya te expliqué mi arquitectura de proyecto hace 3 días..."
• Productividad: "Mis preferencias de formato, mi flujo de trabajo, siempre las tengo que repetir"
• Multi-herramienta: "Usar Claude Desktop + Cursor + Levante = repetir contexto 3 veces"
• Proyectos largos: "Perdemos toda la historia de decisiones técnicas"

🎯 Objetivos del Sistema

🏠 Local-First & Privacidad

• ✅ Toda la memoria queda en el dispositivo del usuario
• ✅ Zero telemetría - coherente con principios de Levante
• ✅ Control total sobre qué se guarda y qué se comparte
• ✅ Cifrado local para datos sensibles

🔗 Interoperabilidad MCP

• ✅ MCP Server nativo para compartir memoria con otras herramientas
• ✅ Compatible con Claude Desktop, Cursor, VS Code, etc.
• ✅ API estándar siguiendo protocolo MCP
• ✅ Bridge entre ecosistema Levante y herramientas externas

🎨 Experiencia de Usuario Integrada

• ✅ UI nativa dentro de Levante para gestionar memoria
• ✅ Automático - guarda contexto relevante sin fricción
• ✅ Búsqueda inteligente - encuentra información por contexto
• ✅ Control granular - decide qué sistemas pueden acceder

🏗️ Arquitectura Propuesta

Componentes Principales

1. 🧠 Memory Engine (Core)

interface MemoryEngine {
  // Storage & Retrieval
  store(memory: Memory, metadata: Metadata): Promise<string>
  search(query: string, filters?: Filters): Promise<Memory[]>
  retrieve(id: string): Promise<Memory | null>
  
  // Context Management  
  getConversationContext(chatId: string): Promise<Memory[]>
  updateContext(chatId: string, newMemories: Memory[]): Promise<void>
  
  // Cross-session
  getProjectMemories(projectId: string): Promise<Memory[]>
  getUserPreferences(userId: string): Promise<Preferences>
}

2. 📊 Multi-Engine Storage Architecture

🥇 RECOMENDADO: SQLite-Graph + Vector (Bundled by Default)

• [SQLite con capacidades de grafo](https://github.com/jchristn/LiteGraph) + Vector search nativo
• Graph traversal con Recursive CTEs
• Knowledge graph con Nodes + Edges tables
• Vector embeddings para similarity search
• JSON metadata para categorización flexible
• ✅ Zero config | ✅ 15MB bundle | ✅ Graph + Vector | ✅ Perfect para Electron

-- Native graph structure in SQLite
CREATE TABLE memory_nodes (
  id TEXT PRIMARY KEY,
  type TEXT,           -- 'user', 'project', 'decision'  
  content TEXT,
  vector_embedding F32_BLOB(384),  -- Semantic search
  metadata JSON        -- Flexible properties
);

CREATE TABLE memory_edges (
  from_node TEXT, to_node TEXT, 
  relation_type TEXT,  -- 'belongs_to', 'caused_by', 'related_to'
  weight REAL,
  FOREIGN KEY (from_node) REFERENCES memory_nodes(id)
);

🥈 Opción B: Kuzu Graph (Optional Download ~80MB)

• Kuzu - Embedded graph database optimizada para performance
• Native Cypher queries + graph algorithms built-in
• Columnar storage con multi-core parallelism
• Advanced analytics: community detection, centrality measures
• ✅ Máximo performance | ✅ Advanced algorithms | ⚠️ Requires compilation

🥉 Opción C: TypeDB (External Installation)

• TypeDB - Conceptual modeling database
• TypeQL - Declarative, functional, strongly-typed queries
• Reasoning engine con inference automática
• ✅ Conceptual reasoning | ⚠️ 300MB+ overhead | ❌ Complex bundling

🎯 Estrategia Progressive Enhancement:

interface MemoryEngine {
  // Start simple (bundled)
  core: SQLiteGraphEngine,     // Always available, 15MB
  
  // Scale up (optional)  
  advanced?: KuzuEngine,       // Download when needed, 80MB
  external?: TypeDBConnection  // Connect to external installation
}

3. 🔌 MCP Server Integrado

{
  "mcpServers": {
    "levante-memory": {
      "command": "levante",
      "args": ["--mcp-memory-server"],
      "env": {
        "LEVANTE_MEMORY_PORT": "8765",
        "LEVANTE_MEMORY_ACCESS": "read-write"
      }
    }
  }
}

4. 🎨 UI de Gestión de Memoria

┌─────────────────────────────────────────────┐
│  🧠 Gestión de Memoria - Levante            │
├─────────────────────────────────────────────┤
│                                             │
│  📊 Resumen                                 │
│  • 342 memorias almacenadas                 │
│  • 12 proyectos activos                     │
│  • 5 sistemas conectados via MCP            │
│                                             │
│  🔍 [Buscar en memorias...]                │
│                                             │
│  📁 Categorías                              │
│  ├─ 💼 Proyectos (145)                      │
│  ├─ ⚙️  Preferencias (23)                   │
│  ├─ 🎯 Decisiones Técnicas (67)             │
│  ├─ 📝 Notas & Ideas (89)                   │
│  └─ 🔗 Recursos & Enlaces (18)              │
│                                             │
│  🌐 Conexiones MCP                          │
│  ├─ Claude Desktop     ✅ Conectado         │
│  ├─ VS Code + Cursor   ✅ Conectado         │
│  └─ Custom Tool        ⚠️  Pendiente         │
│                                             │
│  ⚙️  [Configuración de Privacidad]          │
│                                             │
└─────────────────────────────────────────────┘

🛠️ Funcionalidades Clave

Memoria Automática Inteligente

• Extracción automática de información relevante durante conversaciones
• Categorización inteligente (proyecto, preferencias, decisiones técnicas)
• Deduplicación - evita guardar información repetida
• Contextual memory - agrupa información relacionada

Búsqueda Semántica + Graph Traversal

// SQLite-Graph: Vector + Graph combinados  
memory.search("cómo configuré el deployment") 
// → 1. Vector similarity en memory_nodes
// → 2. Graph traversal para context relacionado
// → 3. Combina resultados por relevancia

// Native graph traversal con SQL
memory.graphTraversal(`
  WITH RECURSIVE related_memories(node_id, depth, path) AS (
    SELECT id, 0, json_array(id) FROM memory_nodes 
    WHERE content MATCH 'deployment configuration'
    
    UNION ALL
    
    SELECT e.to_node, rm.depth + 1, json_insert(rm.path, '$[' || rm.depth + 1 || ']', e.to_node)
    FROM related_memories rm
    JOIN memory_edges e ON rm.node_id = e.from_node
    WHERE rm.depth < 3
  )
  SELECT n.content, rm.path FROM related_memories rm
  JOIN memory_nodes n ON rm.node_id = n.id
`)

// Kuzu: Advanced Cypher queries (cuando se descarga)
memory.cypher(`
  MATCH (me:User)-[:WORKED_ON]->(proj:Project)-[:HAS_DECISION]->(decision)
  WHERE decision.content CONTAINS "deployment"
  RETURN decision, proj, 
         algo.betweennessCentrality(decision) as importance
`)

// Auto-selection: Levante elige el engine óptimo
memory.search("mis preferencias de código", { 
  autoOptimize: true,  // SQLite-Graph vs Kuzu según query complexity
  context: "project_ecommerce" 
})

Control de Acceso Granular

interface AccessControl {
  // Por aplicación
  allowedClients: string[]        // ["claude", "cursor", "vscode"]
  
  // Por tipo de memoria  
  privateMemories: string[]       // IDs que nunca se comparten
  projectMemories: ProjectAccess  // Acceso por proyecto
  
  // Por tiempo
  memoryRetention: Duration       // Auto-expire memorias antiguas
  
  // Audit trail
  accessLog: AccessEvent[]        // Quién accedió a qué y cuándo
}

Sincronización Cross-Tools

• Real-time sync entre Levante y herramientas conectadas
• Conflict resolution cuando múltiples tools modifican memoria
• Version control para memoria importante
• Backup & restore automático

🎨 Casos de Uso Específicos

📋 Caso 1: Desarrollo de Software

Usuario en Levante:
"Estoy trabajando en una API REST con Express y PostgreSQL"

Sistema guarda:
- Stack tecnológico: Express.js, PostgreSQL
- Proyecto: "API REST Project"  
- Contexto: desarrollo backend

Más tarde en VS Code:
Claude accede via MCP → "Veo que estás usando Express y Postgres..."

🎯 Caso 2: Gestión de Proyectos

Levante guarda automáticamente:
- Decisiones arquitecturales
- Problemas encontrados y soluciones
- Links de documentación importantes
- Configuraciones específicas del proyecto

Cursor o Claude Desktop pueden acceder:
- "Basándome en tus decisiones previas sobre microservicios..."
- "El problema de CORS que resolviste la semana pasada..."

🔧 Caso 3: Preferencias Personales

Usuario define en Levante:
- "Prefiero TypeScript sobre JavaScript"
- "Uso Prettier con 2 espacios"  
- "Mi estructura de folders preferida es..."

Todas las herramientas MCP-conectadas recuerdan:
- Generan código siguiendo estas preferencias
- Sugieren soluciones acordes al estilo preferido

🚀 Implementación por Fases

Fase 1: SQLite-Graph Core System (Q1 2025)

• SQLite-Graph implementation - nodes, edges, traversal con CTEs
• Vector search integration - F32_BLOB embeddings nativo
• Memory extraction automática con graph relationships
• Graph visualization UI - mostrar conexiones entre memorias
• Basic analytics - centrality measures, memory clusters

Fase 2: MCP Integration + Graph API (Q2 2025)

• MCP Server con graph capabilities expuestas
• Graph-aware queries via MCP protocol
• External tool connectivity - graph context sharing
• Visual graph inspector - debug memory relationships

Fase 3: Advanced Graph Features (Q3 2025)

• Kuzu integration - optional download para power users
• Advanced algorithms: community detection, pathfinding
• Hybrid queries - combine SQLite-Graph + Kuzu seamlessly
• Performance optimization - query planner, indexing strategies

Fase 4: Intelligence + Analytics (Q4 2025)

• Graph-based reasoning - infer connections automáticamente
• Memory consolidation usando graph structure
• Advanced analytics UI - memory insights, relationship patterns
• Export capabilities - GraphML, Cypher, etc.

🔧 Consideraciones Técnicas

Storage & Performance

SQLite-Graph + Vector Architecture:

interface MemoryGraphEngine {
  // Core graph operations (always available)
  addNode(content: string, type: NodeType): Promise<Node>
  addEdge(from: string, to: string, relation: string): Promise<Edge>
  traverse(startId: string, depth: number): Promise<Path[]>
  
  // Vector search integrated
  semanticSearch(query: string, limit: number): Promise<Node[]>
  findSimilarInContext(query: string, contextId: string): Promise<Node[]>
  
  // Graph analytics  
  getCentrality(nodeId: string): Promise<number>
  findCommunities(): Promise<Community[]>
  getShortestPath(fromId: string, toId: string): Promise<Path>
}

// Performance characteristics
const performance = {
  nodes: "~1M nodes sin degradación",
  edges: "~5M edges, traversal <50ms", 
  vectors: "384-dim embeddings, search <10ms",
  bundleSize: "15MB total overhead",
  startup: "<100ms cold start"
}

Progressive Enhancement Strategy:

• SQLite-Graph: Bundled, covers 95% de casos de uso perfectamente
• Kuzu optional: Download para graph analytics avanzados (community detection, advanced algorithms)
• TypeDB external: Connect para reasoning conceptual avanzado

Auto-scaling Approach:

// Smart query routing
const executeQuery = (query: GraphQuery): Promise<Results> => {
  if (query.requiresAdvancedAnalytics && kuzuAvailable) {
    return kuzu.execute(query);
  }
  return sqliteGraph.execute(query); // Default, always available
}

Privacidad & Seguridad

• Encryption at rest para datos sensibles
• Process isolation para MCP server
• Audit logs de todos los accesos
• User consent explícito para compartir

Integraciones

// API compatibility layer
interface LevanteMemoryMCP extends MCPStandard {
  tools: {
    add_memory: (content: string, metadata: Metadata) => Promise<string>
    search_memory: (query: string, limit?: number) => Promise<Memory[]>
    get_context: (project: string) => Promise<ProjectContext>
    list_memories: (filters?: Filters) => Promise<Memory[]>
  }
}

🎯 Diferenciadores de Levante

vs OpenMemory/Mem0

• ✅ Nativo en Levante - no requiere Docker separado
• ✅ UI integrada - gestión desde la misma app
• ✅ Multi-provider AI - funciona con todos los proveedores de Levante
• ✅ Zero-config - funciona out-of-the-box

vs Sistemas Existentes

vs OpenMemory/Mem0

• ✅ Nativo en Levante - no requiere Docker separado
• ✅ Multi-engine flexibility - SQLite-Vec, TypeDB, Kuzu según necesidad
• ✅ UI integrada - gestión desde la misma app
• ✅ Auto-scaling - upgrade path de simple a avanzado

vs Traditional Graph + Vector Separation

• ✅ Unified storage - graph + vectors en mismo SQLite file
• ✅ Zero latency - no network calls entre vector DB y graph DB
• ✅ Simplified architecture - una sola dependency vs múltiples
• ✅ Atomic transactions - consistency entre graph y vector data

vs Dedicated Graph DBs (Neo4j, ArangoDB)

• ✅ Embedded - no server management required
• ✅ Electron-friendly - single .db file, easy bundling
• ✅ SQL familiarity - developers ya conocen el query language
• ✅ Vector-native - built-in semantic search capabilities

vs Cloud Memory Services

• ✅ Zero latency - todo local, no network calls
• ✅ No vendor lock-in - standard SQLite, exportable anywhere
• ✅ Cost-effective - no monthly fees, resources bajo control
• ✅ Privacy-first - coherente con filosofía Levante

🚀 Technical Advantages Únicos de Levante:

• Graph + Vector unificado: Única app que combina ambos natively en SQLite
• Progressive enhancement: Start simple → upgrade cuando needed
• Electron-optimized: Diseñado específicamente para desktop apps
• MCP-native: Graph relationships compartidas via MCP protocol

🤔 Preguntas para la Comunidad

UX & Funcionalidad

1. ¿Qué tipo de información les gustaría que se recordara automáticamente?
2. ¿Prefieren control manual sobre qué se guarda, o automático con opt-out?
3. ¿Qué nivel de granularidad esperan en el control de acceso?

Integración

4. ¿Qué herramientas externas son prioritarias para conectar via MCP?
5. ¿Les interesa poder "importar" memoria desde otros sistemas?
6. ¿Deberíamos soportar múltiples "perfiles" de memoria? (trabajo, personal, etc.)

Técnico

7. ¿Les convence SQLite-Graph como solución principal?

   • Bundled by default: Graph + Vector en 15MB
   • Kuzu optional: Advanced analytics via download
   • Familiar SQL: CTEs para graph traversal

8. ¿Qué graph features son prioritarias?

   • Basic traversal: Find related memories
   • Centrality measures: Identify important memories
   • Community detection: Group related contexts
   • Pathfinding: Connect ideas across projects

9. ¿Nivel de recursos aceptable?

   • SQLite-Graph: ~15MB bundle, <100ms queries
   • Kuzu optional: ~80MB download, advanced algorithms

10. ¿Interés en graph visualization?

    • Memory relationship maps
    • Project knowledge graphs
    • Interactive exploration UI

📈 Métricas de Éxito

• Adopción: % usuarios que activan memoria local
• Retención: Uso continuado del sistema de memoria
• Integración: # herramientas externas conectadas via MCP
• Satisfacción: Feedback sobre utilidad y privacidad
• Performance: Tiempo de búsqueda, uso de recursos

🤝 Oportunidades de Contribución

Core Development

• SQLite-Graph engine - nodes/edges schema, CTE traversals
• Vector integration - F32_BLOB embeddings, similarity search
• MCP graph protocol - expose graph capabilities via MCP
• Graph visualization - D3.js components para memory relationships

Base de Datos y Grafos

• Algoritmos de grafos - centralidad, detección de comunidades, búsqueda de rutas
• Optimización de consultas - estrategias de indexado, ajuste de rendimiento
• Integración con Kuzu - descarga opcional para analytics avanzados
• Herramientas de migración - importar/exportar formatos de datos de grafo

IA y ML

• Razonamiento basado en grafos - inferir conexiones entre memorias
• Optimización de embeddings - modelos locales, ajuste de búsqueda vectorial
• Consolidación de memoria - fusionar nodos similares usando estructura de grafo
• Extracción de contexto - detección automática de relaciones
• Algoritmos de categorización inteligente - clasificación automática de contenido

Integraciones

• Testing con herramientas MCP populares
• Documentation y guías de configuración
• Example projects mostrando flujos de trabajo
• Community feedback sobre casos de uso

---

¿Qué les parece esta visión de memoria integrada para Levante? ¿Creen que agregará valor significativo al ecosistema? 🚀

Esta funcionalidad posicionaría a Levante como la única herramienta que combina:

• ✅ Multi-provider AI - OpenRouter, Vercel AI Gateway, Ollama, etc.
• ✅ Privacy-first design - zero telemetría, local storage
• ✅ Native Graph + Vector memory - SQLite-based, bundled by default
• ✅ MCP ecosystem compatibility - share graph context across tools
• ✅ Progressive enhancement - simple → advanced según necesidades

🎯 TL;DR - Estrategia Recomendada:

1. Ship con SQLite-Graph bundled (~15MB) - graph + vector unificado
2. Kuzu como optional download (~80MB) - advanced graph analytics
3. MCP Server nativo - comparte graph context con otras herramientas
4. Zero-config experience - funciona perfectamente out-of-the-box

Unique selling proposition: "La única app AI que combina privacy, memory y graph intelligence en un solo paquete embeddable." 🚀