superlocalmemory 2.3.4 → 2.3.6

package/CHANGELOG.md

@@ -16,6 +16,28 @@ SuperLocalMemory V2 - Intelligent local memory system for AI coding assistants.
 
 ---
 
+## [2.3.5] - 2026-02-09
+
+### Added
+- **ChatGPT Connector Support**: `search(query)` and `fetch(id)` MCP tools per OpenAI spec
+- **Streamable HTTP transport**: `slm serve --transport streamable-http` for ChatGPT 2026+
+- **UI: Memory detail modal**: Click any memory row to see full content, tags, metadata
+- **UI: Dark mode toggle**: Sun/moon icon in navbar, saved to localStorage, respects system preference
+- **UI: Export buttons**: Export All (JSON/JSONL), Export Search Results, Export individual memory as Markdown
+- **UI: Search score bars**: Color-coded relevance bars (red/yellow/green) in search results
+- **UI: Animated stat counters**: Numbers animate up on page load with ease-out cubic
+- **UI: Loading spinners and empty states**: Professional feedback across all tabs
+- npm keywords: chatgpt, chatgpt-connector, openai, deep-research
+
+### Fixed
+- **XSS vulnerability**: Replaced inline onclick with JSON injection with safe event delegation
+- **UI: Content preview**: Increased from 80 to 100 characters
+
+### Changed
+- npm package now includes `ui/`, `ui_server.py`, `api_server.py`
+
+---
+
 ## [2.3.0] - 2026-02-08
 
 **Release Type:** Universal Integration Release

package/README.md

@@ -268,7 +268,7 @@ slm recall "API design patterns"
 | **OpenCode** | ✅ MCP | Native MCP tools |
 | **Perplexity** | ✅ MCP | Native MCP tools |
 | **Antigravity** | ✅ MCP + Skills | Native MCP tools |
-| **ChatGPT** | ✅ HTTP Transport | `slm serve` + tunnel |
+| **ChatGPT** | ✅ MCP Connector | `search()` + `fetch()` via HTTP tunnel |
 | **Aider** | ✅ Smart Wrapper | `aider-smart` with context |
 | **Any Terminal** | ✅ Universal CLI | `slm remember "content"` |
 

package/configs/chatgpt-desktop-mcp.json

@@ -1,7 +1,16 @@
 {
-  "_README": "ChatGPT requires HTTP transport, not stdio. See docs/MCP-MANUAL-SETUP.md#chatgpt-desktop-app",
-  "_step1": "Run: slm serve --port 8001",
-  "_step2": "Expose via: ngrok http 8001 (or cloudflared tunnel)",
-  "_step3": "Add the HTTPS URL to ChatGPT -> Settings -> Apps & Connectors -> Developer Mode",
-  "_note": "100% local - your MCP server runs on YOUR machine. The tunnel just makes it reachable."
+  "_README": "ChatGPT Integration — SuperLocalMemory V2 as ChatGPT Connector",
+  "_requires": "ChatGPT Pro/Plus/Business/Enterprise with Developer Mode enabled",
+  "_tools": "search(query) and fetch(id) — required by OpenAI MCP spec for Connectors",
+  "_setup": {
+    "step1": "Start MCP server: slm serve --port 8417",
+    "step2": "Expose via tunnel: ngrok http 8417",
+    "step3": "Copy the HTTPS URL from ngrok (e.g. https://abc123.ngrok.app)",
+    "step4": "In ChatGPT: Settings → Connectors → Advanced → Enable Developer Mode",
+    "step5": "Create new Connector → paste URL with /sse/ suffix (e.g. https://abc123.ngrok.app/sse/)",
+    "step6": "Name it 'SuperLocalMemory' and click Create",
+    "step7": "In any chat, click + → More → select SuperLocalMemory connector"
+  },
+  "_alternative_transport": "For Streamable HTTP (recommended): slm serve --transport streamable-http --port 8417",
+  "_note": "100% local — your MCP server runs on YOUR machine. The tunnel just makes it reachable by ChatGPT servers. All data stays in ~/.claude-memory/memory.db"
 }

package/docs/ARCHITECTURE.md

@@ -85,13 +85,15 @@ Simple Storage → Intelligent Organization → Adaptive Learning
 
 The MCP server provides native integration with modern AI tools:
 
-**6 Tools:**
+**8 Tools:**
 - `remember(content, tags, project)` - Save memories
 - `recall(query, limit)` - Search memories
 - `list_recent(limit)` - Recent memories
 - `get_status()` - System status
 - `build_graph()` - Build knowledge graph
 - `switch_profile(name)` - Change profile
+- `search(query)` - Search memories (OpenAI MCP spec for ChatGPT Connectors)
+- `fetch(id)` - Fetch memory by ID (OpenAI MCP spec for ChatGPT Connectors)
 
 **4 Resources:**
 - `memory://recent` - Recent memories feed
@@ -106,6 +108,7 @@ The MCP server provides native integration with modern AI tools:
 **Transport Support:**
 - stdio (default) - For local IDE integration
 - HTTP - For remote/network access
+- streamable-http - For ChatGPT 2026+ Connectors
 
 **Key Design:** Zero duplication - calls existing `memory_store_v2.py` functions
 

package/docs/MCP-MANUAL-SETUP.md

@@ -390,34 +390,75 @@ PYTHONPATH = "/Users/yourusername/.claude-memory"
 
 ---
 
-### ChatGPT Desktop App
+### ChatGPT Desktop App / ChatGPT Connectors
 
-**Important:** ChatGPT requires HTTP transport, not stdio. You need to run a local HTTP server and expose it via a tunnel.
+**Important:** ChatGPT requires HTTP transport, not stdio. You need to run a local HTTP server and expose it via a tunnel. As of v2.3.5, SuperLocalMemory includes `search(query)` and `fetch(id)` MCP tools required by OpenAI's MCP spec for ChatGPT Connectors and Deep Research.
 
-**Steps:**
+**Requirements:**
+- ChatGPT Plus, Team, or Enterprise plan
+- **Developer Mode** must be enabled in ChatGPT settings
+- A tunnel tool: `cloudflared` (recommended, free) or `ngrok`
+- Reference: https://platform.openai.com/docs/mcp
+
+**Available Tools in ChatGPT:**
+
+| Tool | Purpose |
+|------|---------|
+| `search(query)` | Search memories (required by OpenAI MCP spec) |
+| `fetch(id)` | Fetch a specific memory by ID (required by OpenAI MCP spec) |
+| `remember(content, tags, project)` | Save a new memory |
+| `recall(query, limit)` | Search memories with full options |
+
+**Step-by-Step Setup:**
 
 1. **Start the MCP HTTP server:**
    ```bash
-   slm serve --port 8001
-   # or: python3 ~/.claude-memory/mcp_server.py --transport http --port 8001
+   slm serve --port 8417
+   # or with streamable-http transport (ChatGPT 2026+):
+   slm serve --port 8417 --transport streamable-http
+   # or using Python directly:
+   python3 ~/.claude-memory/mcp_server.py --transport http --port 8417
    ```
 
-2. **Expose via tunnel** (in another terminal):
+2. **Expose via cloudflared tunnel** (in another terminal):
    ```bash
-   ngrok http 8001
-   # or: cloudflared tunnel --url http://localhost:8001
-   ```
+   # Install cloudflared (if not installed)
+   # macOS: brew install cloudflared
+   # Linux: sudo apt install cloudflared
 
-3. **Copy the HTTPS URL** from ngrok/cloudflared output
-
-4. **Add to ChatGPT:**
-   - Open ChatGPT Desktop
-   - Go to **Settings → Apps & Connectors → Developer Mode**
-   - Add the HTTPS URL as an MCP endpoint
+   cloudflared tunnel --url http://localhost:8417
+   ```
+   Cloudflared will output a URL like `https://random-name.trycloudflare.com`
 
-5. In a new chat, look for MCP tools in the tool selector
+   **Alternative — ngrok:**
+   ```bash
+   ngrok http 8417
+   ```
 
-**Note:** 100% local — your MCP server runs on YOUR machine. The tunnel just makes it reachable by ChatGPT.
+3. **Copy the HTTPS URL** from cloudflared/ngrok output
+
+4. **Add to ChatGPT as a Connector:**
+   - Open ChatGPT (desktop or web)
+   - Go to **Settings → Connectors** (or **Settings → Apps & Connectors → Developer Mode**)
+   - Click **"Add Connector"**
+   - Paste the HTTPS URL with the `/sse/` suffix:
+     ```
+     https://random-name.trycloudflare.com/sse/
+     ```
+   - Name it: `SuperLocalMemory`
+   - Click **Save**
+
+5. **Verify in a new chat:**
+   - Start a new conversation in ChatGPT
+   - Look for the SuperLocalMemory connector in the tool selector
+   - Try: "Search my memories for authentication decisions"
+   - ChatGPT will call `search()` and return your local memories
+
+**Important Notes:**
+- The `/sse/` suffix on the URL is **required** by ChatGPT's MCP implementation
+- 100% local — your MCP server runs on YOUR machine. The tunnel just makes it reachable by ChatGPT. Your data is served on demand and never stored by OpenAI beyond the conversation.
+- The tunnel URL changes each time you restart cloudflared (unless you set up a named tunnel)
+- For persistent URLs, configure a cloudflared named tunnel: `cloudflared tunnel create slm`
 
 **Auto-configured by install.sh:** ❌ No (requires HTTP transport + tunnel)
 
@@ -690,7 +731,7 @@ In your IDE/app, check:
 
 ## Available MCP Tools
 
-Once configured, these 6 tools are available:
+Once configured, these 8 tools are available:
 
 | Tool | Purpose | Example Usage |
 |------|---------|---------------|
@@ -700,6 +741,10 @@ Once configured, these 6 tools are available:
 | `get_status()` | System health | "How many memories do I have?" |
 | `build_graph()` | Build knowledge graph | "Build the knowledge graph" |
 | `switch_profile()` | Change profile | "Switch to work profile" |
+| `search()` | Search memories (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
+| `fetch()` | Fetch memory by ID (OpenAI MCP spec) | Used by ChatGPT Connectors and Deep Research |
+
+**Note:** `search()` and `fetch()` are required by OpenAI's MCP specification for ChatGPT Connectors. They are available in all transports but primarily used by ChatGPT.
 
 Plus **2 MCP prompts** and **4 MCP resources** for advanced use.
 

package/docs/UI-SERVER.md

@@ -22,7 +22,15 @@ Web-based visualization interface for exploring the SuperLocalMemory knowledge g
 - **Cluster Analysis**: Visual breakdown of thematic clusters with top entities
 - **Pattern Viewer**: Display learned preferences and coding styles
 - **Timeline**: Chart showing memory creation over time
-- **Statistics Dashboard**: Real-time system metrics
+- **Statistics Dashboard**: Real-time system metrics with animated stat counters (ease-out cubic on page load)
+- **Memory Detail Modal**: Click any memory row to see full content, metadata, and tags in an overlay modal
+- **Dark Mode Toggle**: Sun/moon icon in the navbar; preference saved to localStorage and respects system preference (`prefers-color-scheme`)
+- **Export Functionality**:
+  - **Export All**: Download entire memory database as JSON or JSONL
+  - **Export Search Results**: Export current search results to JSON
+  - **Export as Markdown**: Export an individual memory as a Markdown file
+- **Search Score Bars**: Color-coded relevance bars in search results (red for low, yellow for medium, green for high relevance)
+- **Loading Spinners and Empty States**: Professional loading feedback and informative empty states across all tabs
 
 ## Quick Start
 
@@ -242,9 +250,9 @@ This UI server is intended for **local development** only.
 
 - Add authentication for multi-user access
 - Implement real-time updates via WebSockets
-- Add export functionality (JSON, CSV)
 - Create memory editing interface
 - Build cluster visualization with hierarchical layout
+- Add CSV export format alongside existing JSON/JSONL/Markdown exports
 
 ## Support
 

package/docs/UNIVERSAL-INTEGRATION.md

@@ -231,6 +231,62 @@ aider-smart "Add authentication to the API"
 3. Passes context to Aider
 4. Aider gets relevant memories without you asking
 
+### ChatGPT (Connectors / Deep Research) ✅
+
+**How It Works:** HTTP transport with `search()` and `fetch()` MCP tools per OpenAI spec. Requires a tunnel to expose local server to ChatGPT.
+
+**Requirements:**
+- ChatGPT Plus, Team, or Enterprise plan
+- Developer Mode enabled in ChatGPT settings
+- `cloudflared` (recommended) or `ngrok` for tunneling
+- Reference: https://platform.openai.com/docs/mcp
+
+**Setup:**
+
+```bash
+# Terminal 1: Start MCP server
+slm serve --port 8417
+
+# Terminal 2: Start tunnel
+cloudflared tunnel --url http://localhost:8417
+```
+
+Then in ChatGPT:
+1. Go to **Settings → Connectors**
+2. Click **"Add Connector"**
+3. Paste the HTTPS URL from cloudflared with `/sse/` suffix:
+   ```
+   https://random-name.trycloudflare.com/sse/
+   ```
+4. Name it `SuperLocalMemory` and save
+
+**Available Tools in ChatGPT:**
+
+| Tool | Purpose |
+|------|---------|
+| `search(query)` | Search memories (required by OpenAI MCP spec) |
+| `fetch(id)` | Fetch a specific memory by ID (required by OpenAI MCP spec) |
+| `remember(content, tags, project)` | Save a new memory |
+| `recall(query, limit)` | Search memories with full options |
+
+**Usage Examples:**
+```
+User: "Search my memories for database decisions"
+ChatGPT: [calls search("database decisions")]
+→ Returns matching memories from your local database
+
+User: "What's memory #42 about?"
+ChatGPT: [calls fetch(42)]
+→ Returns full content, tags, and metadata for memory 42
+```
+
+**Notes:**
+- 100% local — your data is served on demand and never stored beyond the conversation
+- The tunnel URL changes on restart unless you configure a named cloudflared tunnel
+- For streamable-http transport (ChatGPT 2026+): `slm serve --port 8417 --transport streamable-http`
+
+---
+
 ### Any Terminal / Script ✅
 
 **How It Works:** Universal CLI wrapper

package/hooks/context-hook.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * SuperLocalMemory V2 - Session Start Context Hook
+ * Copyright (c) 2026 Varun Pratap Bhardwaj
+ * Licensed under MIT License
+ *
+ * Loads recent memories and learned patterns on Claude Code session start.
+ * Outputs context to stderr (Claude Code reads hook stderr as context).
+ * Fails gracefully — never blocks session start if DB is missing or errors occur.
+ */
+
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+
+const execFileAsync = promisify(execFile);
+
+const MEMORY_DIR = path.join(process.env.HOME, '.claude-memory');
+const DB_PATH = path.join(MEMORY_DIR, 'memory.db');
+const MEMORY_SCRIPT = path.join(MEMORY_DIR, 'memory_store_v2.py');
+
+async function loadSessionContext() {
+  // Fail gracefully if not installed
+  if (!fs.existsSync(DB_PATH)) {
+    return;
+  }
+
+  if (!fs.existsSync(MEMORY_SCRIPT)) {
+    return;
+  }
+
+  try {
+    // Get stats (memory_store_v2.py stats → JSON output)
+    const { stdout: statsOutput } = await execFileAsync('python3', [
+      MEMORY_SCRIPT, 'stats'
+    ], { timeout: 5000 });
+
+    // Get recent memories (memory_store_v2.py list <limit>)
+    const { stdout: recentOutput } = await execFileAsync('python3', [
+      MEMORY_SCRIPT, 'list', '5'
+    ], { timeout: 5000 });
+
+    // Build context output
+    let context = '';
+
+    if (statsOutput && statsOutput.trim()) {
+      try {
+        const stats = JSON.parse(statsOutput.trim());
+        const total = stats.total_memories || 0;
+        const clusters = stats.total_clusters || 0;
+        if (total > 0) {
+          context += 'SuperLocalMemory: ' + total + ' memories, ' + clusters + ' clusters loaded.\n';
+        }
+      } catch (e) {
+        // Stats output wasn't JSON — use first line as-is
+        context += 'SuperLocalMemory: ' + statsOutput.trim().split('\n')[0] + '\n';
+      }
+    }
+
+    if (context) {
+      process.stderr.write(context);
+    }
+  } catch (error) {
+    // Never fail — session start must not be blocked
+    // Silently ignore errors (timeout, missing python, etc.)
+  }
+}
+
+loadSessionContext();

package/mcp_server.py

@@ -374,6 +374,108 @@ async def switch_profile(name: str) -> dict:
         }
 
 
+# ============================================================================
+# CHATGPT CONNECTOR TOOLS (search + fetch — required by OpenAI MCP spec)
+# These two tools are required for ChatGPT Connectors and Deep Research.
+# They wrap existing SuperLocalMemory search/retrieval logic.
+# Ref: https://platform.openai.com/docs/mcp
+# ============================================================================
+
+@mcp.tool(annotations=ToolAnnotations(
+    readOnlyHint=True,
+    destructiveHint=False,
+    openWorldHint=False,
+))
+async def search(query: str) -> dict:
+    """
+    Search for documents in SuperLocalMemory.
+
+    Required by ChatGPT Connectors and Deep Research.
+    Returns a list of search results with id, title, text snippet, and url.
+
+    Args:
+        query: Search query string. Natural language queries work best.
+
+    Returns:
+        {"results": [{"id": str, "title": str, "text": str, "url": str}]}
+    """
+    try:
+        store = MemoryStoreV2(DB_PATH)
+        raw_results = store.search(query, limit=20)
+
+        results = []
+        for r in raw_results:
+            if r.get('score', 0) < 0.2:
+                continue
+            content = r.get('content', '') or r.get('summary', '') or ''
+            snippet = content[:200] + "..." if len(content) > 200 else content
+            mem_id = str(r.get('id', ''))
+            title = r.get('category', 'Memory') + ': ' + (content[:60].replace('\n', ' ') if content else 'Untitled')
+            results.append({
+                "id": mem_id,
+                "title": title,
+                "text": snippet,
+                "url": f"memory://local/{mem_id}"
+            })
+
+        return {"results": results}
+
+    except Exception as e:
+        return {"results": [], "error": str(e)}
+
+
+@mcp.tool(annotations=ToolAnnotations(
+    readOnlyHint=True,
+    destructiveHint=False,
+    openWorldHint=False,
+))
+async def fetch(id: str) -> dict:
+    """
+    Retrieve full content of a memory by ID.
+
+    Required by ChatGPT Connectors and Deep Research.
+    Use after search() to get complete document content for analysis and citation.
+
+    Args:
+        id: Memory ID from search results.
+
+    Returns:
+        {"id": str, "title": str, "text": str, "url": str, "metadata": dict|null}
+    """
+    try:
+        store = MemoryStoreV2(DB_PATH)
+        mem = store.get_by_id(int(id))
+
+        if not mem:
+            raise ValueError(f"Memory with ID {id} not found")
+
+        content = mem.get('content', '') or mem.get('summary', '') or ''
+        title = (mem.get('category', 'Memory') or 'Memory') + ': ' + (content[:60].replace('\n', ' ') if content else 'Untitled')
+
+        metadata = {}
+        if mem.get('tags'):
+            metadata['tags'] = mem['tags']
+        if mem.get('project_name'):
+            metadata['project'] = mem['project_name']
+        if mem.get('importance'):
+            metadata['importance'] = mem['importance']
+        if mem.get('cluster_id'):
+            metadata['cluster_id'] = mem['cluster_id']
+        if mem.get('created_at'):
+            metadata['created_at'] = mem['created_at']
+
+        return {
+            "id": str(id),
+            "title": title,
+            "text": content,
+            "url": f"memory://local/{id}",
+            "metadata": metadata if metadata else None
+        }
+
+    except Exception as e:
+        raise ValueError(f"Failed to fetch memory {id}: {str(e)}")
+
+
 # ============================================================================
 # MCP RESOURCES (Data endpoints)
 # ============================================================================
@@ -532,9 +634,9 @@ if __name__ == "__main__":
     )
     parser.add_argument(
         "--transport",
-        choices=["stdio", "http", "sse"],
+        choices=["stdio", "http", "sse", "streamable-http"],
         default="stdio",
-        help="Transport method: stdio for local IDEs (default), http/sse for remote access"
+        help="Transport method: stdio for local IDEs (default), sse/streamable-http for ChatGPT and remote access"
     )
     parser.add_argument(
         "--port",
@@ -565,6 +667,8 @@ if __name__ == "__main__":
     print("MCP Tools Available:", file=sys.stderr)
     print("  - remember(content, tags, project, importance)", file=sys.stderr)
     print("  - recall(query, limit, min_score)", file=sys.stderr)
+    print("  - search(query)          [ChatGPT Connector]", file=sys.stderr)
+    print("  - fetch(id)              [ChatGPT Connector]", file=sys.stderr)
     print("  - list_recent(limit)", file=sys.stderr)
     print("  - get_status()", file=sys.stderr)
     print("  - build_graph()", file=sys.stderr)
@@ -588,8 +692,14 @@ if __name__ == "__main__":
     if args.transport == "stdio":
         # stdio transport for local IDEs (default)
         mcp.run(transport="stdio")
+    elif args.transport == "streamable-http":
+        # Streamable HTTP transport (recommended for ChatGPT 2026+)
+        print(f"Streamable HTTP server at http://localhost:{args.port}", file=sys.stderr)
+        print("ChatGPT setup: expose via ngrok, paste URL in Settings > Connectors", file=sys.stderr)
+        mcp.run(transport="streamable-http")
     else:
         # SSE transport for remote access (ChatGPT, web clients)
         # "http" is accepted as alias for "sse"
         print(f"HTTP/SSE server will be available at http://localhost:{args.port}", file=sys.stderr)
+        print("ChatGPT setup: expose via ngrok, paste URL in Settings > Connectors", file=sys.stderr)
         mcp.run(transport="sse")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "Your AI Finally Remembers You - Local-first intelligent memory system for AI assistants. Works with Claude, Cursor, Windsurf, VS Code/Copilot, Codex, and 16+ AI tools. 100% local, zero cloud dependencies.",
   "keywords": [
     "ai-memory",
@@ -18,7 +18,11 @@
     "claude-desktop",
     "ai-tools",
     "memory-extension",
-    "local-ai"
+    "local-ai",
+    "chatgpt",
+    "chatgpt-connector",
+    "openai",
+    "deep-research"
   ],
   "author": {
     "name": "Varun Pratap Bhardwaj",