v1.2 (beta)

Author: nullure

.env.example

@@ -111,49 +111,75 @@ LOCAL_MODEL_PATH=/path/to/your/local/model
 # --------------------------------------------
 
 # ============================================
-# PERFORMANCE TIER (Auto-detected or Manual)
+# PERFORMANCE TIER (Manual Configuration Required)
 # ============================================
-# OpenMemory automatically detects your hardware and selects the optimal tier.
-# You can override this by setting OM_TIER manually.
+# OpenMemory requires you to manually set the performance tier.
+# Set OM_TIER to one of: hybrid, fast, smart, or deep
 #
 # Available Tiers:
 #
+# HYBRID - Keyword + Synthetic embeddings (256-dim) with BM25 ranking
+#         • Recall: ~100% (exact keyword matching)  • QPS: 800-1000  • RAM: 0.5GB/10k memories
+#         • Best for: Exact searches, documentation, code search, personal knowledge
+#         • Features: Exact phrase matching, BM25 scoring, n-gram matching, 100% accuracy
+#         • Use when: You need guaranteed exact matches and keyword-based retrieval
+#
 # FAST  - Synthetic embeddings only (256-dim)
 #         • Recall: ~70-75%  • QPS: 700-850  • RAM: 0.6GB/10k memories
 #         • Best for: Local apps, VS Code extensions, low-end hardware
-#         • Auto-selected: < 4 CPU cores or < 8GB RAM
+#         • Use when: < 4 CPU cores or < 8GB RAM
 #
 # SMART - Hybrid embeddings (256-dim synthetic + 128-dim compressed semantic = 384-dim)
 #         • Recall: ~85%  • QPS: 500-600  • RAM: 0.9GB/10k memories
 #         • Best for: Production servers, AI copilots, mid-range hardware
-#         • Auto-selected: 4-7 CPU cores and 8-15GB RAM
+#         • Use when: 4-7 CPU cores and 8-15GB RAM
 #
 # DEEP  - Full AI embeddings (1536-dim OpenAI/Gemini)
 #         • Recall: ~95-100%  • QPS: 350-400  • RAM: 1.6GB/10k memories
-#         • Best for: Cloud deployments, high-accuracy systems, research
-#         • Auto-selected: 8+ CPU cores and 16+ GB RAM
+#         • Best for: Cloud deployments, high-accuracy systems, semantic research
+#         • Use when: 8+ CPU cores and 16+ GB RAM
 #
-# Leave commented to auto-detect, or set manually:
-# OM_TIER=fast
-# OM_TIER=smart
-# OM_TIER=deep
-
-OM_MIN_SCORE=0.3
-OM_DECAY_LAMBDA=0.02
+# REQUIRED: Set your tier (no auto-detection):
+OM_TIER=hybrid
 
-# Decay interval in minutes
-# Testing: 0.5 (30s) for rapid benchmarks
-# Development: 5 (5min) for realistic decay testing
-# Production: 10 (10min) for optimal throughput (3% batch = less disk pressure)
-# Recommended: 5-10 minutes to balance decay accuracy vs overhead
-OM_DECAY_INTERVAL_MINUTES=10
+# Keyword Matching Settings (HYBRID tier only)
+# Boost multiplier for keyword matches (default: 2.5)
+OM_KEYWORD_BOOST=2.5
+# Minimum keyword length for matching (default: 3)
+OM_KEYWORD_MIN_LENGTH=3
 
-# Decay ratio (percentage of memories to decay per run, 0.01-0.1)
-# Lower = more stable variance, higher = faster decay propagation
-OM_DECAY_RATIO=0.03
+OM_MIN_SCORE=0.3
 
-# Sleep between segment processing (ms) to avoid lock contention
-OM_DECAY_SLEEP_MS=200
+# ============================================
+# Smart Decay Settings (Time-Based Algorithm)
+# ============================================
+# Decay interval in minutes - how often the decay cycle runs
+# The new algorithm uses time-based decay with daily lambda rates (hot=0.005/day, warm=0.02/day, cold=0.05/day)
+# Unlike batch-based systems, running more frequently doesn't increase decay speed
+# Decay is calculated from: decay_factor = exp(-lambda * days_since_access / (salience + 0.1))
+#
+# Recommended intervals:
+# • Testing: 30 minutes (for rapid validation)
+# • Development: 60-120 minutes (balanced testing)
+# • Production: 120-180 minutes (optimal - captures meaningful decay deltas while minimizing overhead)
+#
+# At 2-3 hours: hot tier decays ~0.04-0.06%, warm ~0.16-0.24%, cold ~0.4-0.6% per cycle
+OM_DECAY_INTERVAL_MINUTES=120
+
+# Number of parallel decay worker threads (default: 3)
+OM_DECAY_THREADS=3
+# Cold tier threshold - memories below this salience get fingerprinted (default: 0.25)
+OM_DECAY_COLD_THRESHOLD=0.25
+# Reinforce memory salience when queried (default: true)
+OM_DECAY_REINFORCE_ON_QUERY=true
+# Enable regeneration of cold memories on query hits (default: true)
+OM_REGENERATION_ENABLED=true
+# Maximum vector dimensions (default: 1536)
+OM_MAX_VECTOR_DIM=1536
+# Minimum vector dimensions for compression (default: 64)
+OM_MIN_VECTOR_DIM=64
+# Number of summary compression layers 1-3 (default: 3)
+OM_SUMMARY_LAYERS=3
 
 # Full Semantic Graph MVP Settings
 # Use summary-only storage (≤300 chars, intelligent extraction)

.gitignore

@@ -360,3 +360,4 @@ dist
 !.yarn/versions
 
 benchmark
+temp

CHANGELOG.md

@@ -1,9 +1,19 @@
 # Changelog
 
-## [Unreleased]
+## 1.2
 
 ### Added
 
+- **HYBRID Tier Performance Mode**
+
+  - New tier achieving 100% keyword match accuracy with synthetic embeddings
+  - BM25 scoring algorithm for relevance ranking
+  - Exact phrase matching with case-insensitive search
+  - N-gram keyword extraction (unigrams, bigrams, trigrams)
+  - Performance: 800-1000 QPS, 0.5GB RAM per 10k memories
+  - Configurable via `OM_TIER=hybrid`, `OM_KEYWORD_BOOST`, `OM_KEYWORD_MIN_LENGTH`
+  - Best for: Documentation search, code search, technical references
+
 - **Memory Compression Engine**: Auto-compresses chat/memory content to reduce tokens and latency
 
   - 5 compression algorithms: whitespace, filler, semantic, aggressive, balanced
@@ -50,6 +60,23 @@
 
 ### Fixed
 
+- **MCP Tool Names (Breaking Change)**: Changed from dot notation to underscores for Windsurf IDE compatibility
+
+  - `openmemory.query` → `openmemory_query`
+  - `openmemory.store` → `openmemory_store`
+  - `openmemory.reinforce` → `openmemory_reinforce`
+  - `openmemory.list` → `openmemory_list`
+  - `openmemory.get` → `openmemory_get`
+  - Complies with MCP naming rule: `^[a-zA-Z0-9_-]{1,64}$`
+
+- **PostgreSQL Custom Table Name**: Fixed hardcoded `memories` table in `openmemory://config` resource
+  - Now correctly uses `OM_PG_TABLE` environment variable
+  - Exports `memories_table` from database module with fully-qualified name
+  - Fixes "relation 'memories' does not exist" error with custom table names
+  - Works for both PostgreSQL (with schema) and SQLite
+
+### Fixed
+
 - VS Code extension connection issues (health endpoint)
 - MCP protocol integration for AI tools
 - Extension now properly passes MCP flag to all writers

IDE/README.md

@@ -27,7 +27,8 @@ Backend server required.
 
 - `openmemory.backendUrl`: Backend URL (default: `http://localhost:8080`)
 - `openmemory.apiKey`: API key for auth (optional)
-- `openmemory.useMCP`: Use MCP protocol mode (default: `false`)
+- `openmemory.useMCP`: Use MCP protocol mode (default: `false`) - connects to backend MCP server with tools: `openmemory_query`, `openmemory_store`, `openmemory_list`, `openmemory_get`, `openmemory_reinforce`
+- `openmemory.mcpServerPath`: Path to backend MCP server (default: `backend/dist/ai/mcp.js`)
 
 ## Commands
 

IDE/src/extension.ts

@@ -123,11 +123,11 @@ async function auto_link_all() {
             const mcpPath = await writeMCPConfig(backend_url, api_key);
             configs.push(mcpPath);
         }
-        configs.push(await writeCursorConfig(backend_url, api_key, use_mcp));
-        configs.push(await writeClaudeConfig(backend_url, api_key, use_mcp));
-        configs.push(await writeWindsurfConfig(backend_url, api_key, use_mcp));
-        configs.push(await writeCopilotConfig(backend_url, api_key, use_mcp));
-        configs.push(await writeCodexConfig(backend_url, api_key, use_mcp));
+        configs.push(await writeCursorConfig(backend_url, api_key, use_mcp, mcp_server_path));
+        configs.push(await writeClaudeConfig(backend_url, api_key, use_mcp, mcp_server_path));
+        configs.push(await writeWindsurfConfig(backend_url, api_key, use_mcp, mcp_server_path));
+        configs.push(await writeCopilotConfig(backend_url, api_key, use_mcp, mcp_server_path));
+        configs.push(await writeCodexConfig(backend_url, api_key, use_mcp, mcp_server_path));
 
         const mode = use_mcp ? 'MCP protocol' : 'Direct HTTP';
         vscode.window.showInformationMessage(`✅ Auto-linked OpenMemory to AI tools (${mode})`);

IDE/src/writers/claude.ts

@@ -15,14 +15,15 @@ export interface ClaudeConfig {
     api_key?: string;
 }
 
-export function generateClaudeConfig(backendUrl: string, apiKey?: string, useMCP = false): ClaudeConfig {
+export function generateClaudeConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): ClaudeConfig {
     if (useMCP) {
+        const backendMcpPath = mcpServerPath || path.join(process.cwd(), 'backend', 'dist', 'ai', 'mcp.js');
         return {
             mcpServers: {
                 openmemory: {
                     command: 'node',
-                    args: [path.join(os.homedir(), '.mcp', 'memory.mcp.json')],
-                    env: apiKey ? { OPENMEMORY_API_KEY: apiKey } : undefined
+                    args: [backendMcpPath],
+                    env: apiKey ? { OM_API_KEY: apiKey } : undefined
                 }
             }
         };
@@ -36,15 +37,15 @@ export function generateClaudeConfig(backendUrl: string, apiKey?: string, useMCP
     return config;
 }
 
-export async function writeClaudeConfig(backendUrl: string, apiKey?: string, useMCP = false): Promise<string> {
+export async function writeClaudeConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): Promise<string> {
     const claudeDir = path.join(os.homedir(), '.claude', 'providers');
     const configFile = path.join(claudeDir, 'openmemory.json');
 
     if (!fs.existsSync(claudeDir)) {
         fs.mkdirSync(claudeDir, { recursive: true });
     }
 
-    const config = generateClaudeConfig(backendUrl, apiKey, useMCP);
+    const config = generateClaudeConfig(backendUrl, apiKey, useMCP, mcpServerPath);
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
 
     return configFile;

IDE/src/writers/codex.ts

@@ -21,19 +21,19 @@ export interface CodexConfig {
     };
 }
 
-export function generateCodexConfig(backendUrl: string, apiKey?: string, useMCP = false): CodexConfig {
+export function generateCodexConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): CodexConfig {
     if (useMCP) {
-        const mcpConfigPath = path.join(os.homedir(), '.mcp', 'memory.mcp.json');
+        const backendMcpPath = mcpServerPath || path.join(process.cwd(), 'backend', 'dist', 'ai', 'mcp.js');
         const config: CodexConfig = {
             mcpServers: {
                 openmemory: {
                     command: 'node',
-                    args: [mcpConfigPath]
+                    args: [backendMcpPath]
                 }
             }
         };
         if (apiKey) {
-            config.mcpServers!.openmemory.env = { OPENMEMORY_API_KEY: apiKey };
+            config.mcpServers!.openmemory.env = { OM_API_KEY: apiKey };
         }
         return config;
     }
@@ -54,15 +54,15 @@ export function generateCodexConfig(backendUrl: string, apiKey?: string, useMCP
     };
 }
 
-export async function writeCodexConfig(backendUrl: string, apiKey?: string, useMCP = false): Promise<string> {
+export async function writeCodexConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): Promise<string> {
     const codexDir = path.join(os.homedir(), '.codex');
     const configFile = path.join(codexDir, 'context.json');
 
     if (!fs.existsSync(codexDir)) {
         fs.mkdirSync(codexDir, { recursive: true });
     }
 
-    const config = generateCodexConfig(backendUrl, apiKey, useMCP);
+    const config = generateCodexConfig(backendUrl, apiKey, useMCP, mcpServerPath);
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
 
     return configFile;

IDE/src/writers/copilot.ts

@@ -17,19 +17,19 @@ export interface CopilotConfig {
     };
 }
 
-export function generateCopilotConfig(backendUrl: string, apiKey?: string, useMCP = false): CopilotConfig {
+export function generateCopilotConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): CopilotConfig {
     if (useMCP) {
-        const mcpConfigPath = path.join(os.homedir(), '.mcp', 'memory.mcp.json');
+        const backendMcpPath = mcpServerPath || path.join(process.cwd(), 'backend', 'dist', 'ai', 'mcp.js');
         const config: CopilotConfig = {
             name: 'OpenMemory',
             type: 'mcp',
             mcpServer: {
                 command: 'node',
-                args: [mcpConfigPath]
+                args: [backendMcpPath]
             }
         };
         if (apiKey) {
-            config.mcpServer!.env = { OPENMEMORY_API_KEY: apiKey };
+            config.mcpServer!.env = { OM_API_KEY: apiKey };
         }
         return config;
     }
@@ -50,15 +50,15 @@ export function generateCopilotConfig(backendUrl: string, apiKey?: string, useMC
     return config;
 }
 
-export async function writeCopilotConfig(backendUrl: string, apiKey?: string, useMCP = false): Promise<string> {
+export async function writeCopilotConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): Promise<string> {
     const copilotDir = path.join(os.homedir(), '.github', 'copilot');
     const configFile = path.join(copilotDir, 'openmemory.json');
 
     if (!fs.existsSync(copilotDir)) {
         fs.mkdirSync(copilotDir, { recursive: true });
     }
 
-    const config = generateCopilotConfig(backendUrl, apiKey, useMCP);
+    const config = generateCopilotConfig(backendUrl, apiKey, useMCP, mcpServerPath);
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
 
     return configFile;

IDE/src/writers/cursor.ts

@@ -15,14 +15,15 @@ export interface CursorConfig {
     };
 }
 
-export function generateCursorConfig(backendUrl: string, apiKey?: string, useMCP = false): CursorConfig {
+export function generateCursorConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): CursorConfig {
     if (useMCP) {
+        const backendMcpPath = mcpServerPath || path.join(process.cwd(), 'backend', 'dist', 'ai', 'mcp.js');
         return {
             name: 'OpenMemory',
             type: 'mcp',
             mcp: {
-                server: path.join(os.homedir(), '.mcp', 'memory.mcp.json'),
-                tools: ['queryMemory', 'searchMemory', 'getPatterns', 'storeMemory']
+                server: backendMcpPath,
+                tools: ['openmemory_query', 'openmemory_store', 'openmemory_list', 'openmemory_get', 'openmemory_reinforce']
             }
         };
     }
@@ -44,15 +45,15 @@ export function generateCursorConfig(backendUrl: string, apiKey?: string, useMCP
     };
 }
 
-export async function writeCursorConfig(backendUrl: string, apiKey?: string, useMCP = false): Promise<string> {
+export async function writeCursorConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): Promise<string> {
     const cursorDir = path.join(os.homedir(), '.cursor', 'context_providers');
     const configFile = path.join(cursorDir, 'openmemory.json');
 
     if (!fs.existsSync(cursorDir)) {
         fs.mkdirSync(cursorDir, { recursive: true });
     }
 
-    const config = generateCursorConfig(backendUrl, apiKey, useMCP);
+    const config = generateCursorConfig(backendUrl, apiKey, useMCP, mcpServerPath);
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
 
     return configFile;

IDE/src/writers/windsurf.ts

@@ -11,12 +11,13 @@ export interface WindsurfConfig {
     };
 }
 
-export function generateWindsurfConfig(backendUrl: string, apiKey?: string, useMCP = false): WindsurfConfig {
+export function generateWindsurfConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): WindsurfConfig {
     if (useMCP) {
+        const backendMcpPath = mcpServerPath || path.join(process.cwd(), 'backend', 'dist', 'ai', 'mcp.js');
         return {
             contextProvider: 'openmemory-mcp',
             mcp: {
-                configPath: path.join(os.homedir(), '.mcp', 'memory.mcp.json')
+                configPath: backendMcpPath
             }
         };
     }
@@ -29,15 +30,15 @@ export function generateWindsurfConfig(backendUrl: string, apiKey?: string, useM
     return config;
 }
 
-export async function writeWindsurfConfig(backendUrl: string, apiKey?: string, useMCP = false): Promise<string> {
+export async function writeWindsurfConfig(backendUrl: string, apiKey?: string, useMCP = false, mcpServerPath?: string): Promise<string> {
     const windsurfDir = path.join(os.homedir(), '.windsurf', 'context');
     const configFile = path.join(windsurfDir, 'openmemory.json');
 
     if (!fs.existsSync(windsurfDir)) {
         fs.mkdirSync(windsurfDir, { recursive: true });
     }
 
-    const config = generateWindsurfConfig(backendUrl, apiKey, useMCP);
+    const config = generateWindsurfConfig(backendUrl, apiKey, useMCP, mcpServerPath);
     fs.writeFileSync(configFile, JSON.stringify(config, null, 2));
 
     return configFile;