@pragmatic-growth/memory-mcp 3.4.0 → 3.5.0

package/README.md

@@ -37,16 +37,68 @@ For clients that only support stdio (Raycast, local tools):
 }
 ```
 
-## Operating Mode
+## Operating Modes
 
-PG-Memory provides a **personal knowledge base** focused on semantic search and content retrieval:
-- **Core Knowledge**: search, get content, list content, list categories, health check, smart gap logging
-- **AI-Powered**: Automatic question quality evaluation, deduplication, and priority assignment
+PG-Memory supports two operating modes:
 
-All tools are available by default - no special flags required.
+### Read-Only Mode (default, 6 tools)
+Semantic search, content retrieval, and smart gap logging. All tools are available by default.
+
+### Admin Mode (14 tools)
+Full CRUD operations on articles and Q&A records. Enable with:
+```json
+{
+  "env": {
+    "CLERK_API_KEY": "your-api-key",
+    "PG_MEMORY_ADMIN": "true"
+  }
+}
+```
 
 ## Installation
 
+### For Claude Code (`.mcp.json`)
+
+Add to your project's `.mcp.json` or `~/.claude/.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "pg-memory": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "@pragmatic-growth/memory-mcp"],
+      "env": {
+        "CLERK_API_KEY": "your-api-key-here",
+        "PG_MEMORY_ADMIN": "true"
+      }
+    }
+  }
+}
+```
+
+Remove `PG_MEMORY_ADMIN` for read-only mode (6 tools).
+
+### For Claude Desktop (`claude_desktop_config.json`)
+
+macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "pg-memory": {
+      "command": "npx",
+      "args": ["-y", "@pragmatic-growth/memory-mcp"],
+      "env": {
+        "CLERK_API_KEY": "your-api-key-here",
+        "PG_MEMORY_ADMIN": "true"
+      }
+    }
+  }
+}
+```
+
 ### For Raycast
 
 ```json
@@ -79,28 +131,41 @@ CLERK_API_KEY=your-key memory-mcp
 |----------|----------|-------------|
 | `CLERK_API_KEY` | Yes | Clerk API key for authentication |
 | `MCP_SERVER_URL` | No | Custom server URL (default: production) |
+| `PG_MEMORY_ADMIN` | No | Set to `true` to enable admin tools (default: read-only) |
 
-## Available Tools (7 Total)
+## Available Tools
 
-The tool list below reflects the current token-efficient MCP architecture with AI-powered question handling.
+### Read Tools (6, always available)
 
 | Tool | Description |
 |------|-------------|
-| `__IMPORTANT` | Workflow instructions (3-layer pattern: search → get_content → smart_log_gap) |
-| `search_knowledge` | Semantic search across articles (returns metadata only - use get_content for full text) |
-| `get_content` | Retrieve full article content by ID |
-| `smart_log_gap` | AI-evaluated gap logging with deduplication, quality filtering, and priority assignment |
-| `list_content` | Browse articles with filtering (by type, category, status) |
-| `list_categories` | List all knowledge base categories |
-| `health_check` | System health status and statistics |
+| `search` | Unified semantic search across articles + approved Q&A. Returns lightweight results (ID, type, title/question, similarity, date). |
+| `get_article` | Retrieve full article content by ID |
+| `get_qa` | Retrieve a Q&A record by ID (question, answer, status, metadata) |
+| `log_gap` | Smart gap logging with deduplication (>85%), answer detection (>70%), AI quality filtering, and auto-priority |
+| `list_categories` | List all knowledge base categories with content counts |
+| `health_check` | System health status including article counts, Q&A counts, and connection pool stats |
+
+### Admin Tools (8, requires `PG_MEMORY_ADMIN=true`)
+
+| Tool | Description |
+|------|-------------|
+| `list_gaps` | List unanswered knowledge gaps (Q&A with status='gap') |
+| `create_article` | Create a new article with auto-generated embedding |
+| `update_article` | Update an existing article with optional re-embedding |
+| `create_qa` | Create a Q&A record with full control over status and fields |
+| `draft_qa_answer` | Draft an answer for a Q&A record (sets status to 'draft') |
+| `approve_qa` | Approve a Q&A record and generate search embedding |
+| `delete_article` | Permanently delete an article |
+| `delete_qa` | Permanently delete a Q&A record |
 
 ## Architecture Philosophy
 
-**Token Efficiency**: Following claude-mem's pattern, `search_knowledge` returns only metadata (ID, title, similarity). Use `get_content` to fetch full article text on-demand.
+**Unified Search**: `search` queries both articles and approved Q&A in parallel with graceful degradation. Returns metadata only for token efficiency — use `get_article` or `get_qa` for full content.
 
-**AI-Powered Quality**: `smart_log_gap` uses LLM evaluation to filter spam, detect duplicates (>85% similarity), suggest existing answers (>70% match), and auto-assign priority.
+**Q&A Lifecycle**: Questions flow through `gap` → `draft` → `approved` status. Only approved Q&A appears in search results.
 
-**Simplicity**: 7 focused tools instead of 15+ complex ones. Personal knowledge base with intelligent question handling.
+**AI-Powered Quality**: `log_gap` uses LLM evaluation to filter spam, detect duplicates (>85% similarity), suggest existing answers (>70% match), and auto-assign priority.
 
 ## How It Works
 
@@ -116,7 +181,16 @@ This package runs locally as a stdio MCP server and proxies requests to the remo
 
 ## Changelog
 
-### v3.4.0 (Latest)
+### v3.5.0 (Latest)
+- **Two operating modes**: Read-only (6 tools) and Admin (14 tools) via `PG_MEMORY_ADMIN=true`
+- **Unified search**: `search` replaces `search_knowledge`, queries articles + approved Q&A in parallel
+- **Q&A lifecycle**: Full CRUD with `create_qa`, `draft_qa_answer`, `approve_qa`, `delete_qa`
+- **Article management**: `create_article`, `update_article`, `delete_article` admin tools
+- **Smart log_gap**: Re-added deduplication, answer detection, and AI quality filtering
+- **Centralized schemas**: Shared Zod schemas between HTTP and stdio servers
+- **Version alignment**: HTTP server and stdio proxy both report v3.5.0
+
+### v3.4.0
 - **Server URL Update**: Changed default server to `mem-mcp.pragmaticgrowth.com` (API subdomain)
 - **Validation Documentation**: Added constraints to tool descriptions (enforced server-side):
   - `search_knowledge.query`: Minimum 3 characters

package/dist/index.js

@@ -1,232 +1,323 @@
 #!/usr/bin/env node
-/**
- * PG-Memory MCP Stdio Server
- *
- * This is a local stdio MCP server that proxies requests to the
- * remote PG-Memory HTTP server on Railway.
- *
- * Usage:
- *   npx @pragmatic-growth/memory-mcp             # Read-only mode (default)
- *
- * Environment variables:
- *   CLERK_API_KEY - Clerk API key for authentication (required)
- *   MCP_SERVER_URL - Server URL (default: https://mem-mcp.pragmaticgrowth.com/mcp)
- *
- * Authentication:
- *   Uses Clerk API key authentication via X-API-Key header.
- *   Get your API key from the Clerk Dashboard or the app's API Docs page.
- */
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-// Configuration
-const SERVER_URL = process.env.MCP_SERVER_URL || 'https://mem-mcp.pragmaticgrowth.com/mcp';
-const API_KEY = process.env.CLERK_API_KEY;
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../mcp/src/schemas.ts
+import { z } from "zod";
+var searchSchema = z.object({
+  query: z.string().min(3, "Query must be at least 3 characters").describe("Search query"),
+  threshold: z.number().min(0).max(1).optional().default(0.6).describe("Similarity threshold (0-1)"),
+  limit: z.number().min(1).max(50).optional().default(5).describe("Max results")
+});
+var getArticleSchema = z.object({
+  id: z.string().describe("Article ID (e.g., art_...)")
+});
+var getQASchema = z.object({
+  id: z.string().describe("Q&A ID (e.g., qa_...)")
+});
+var logGapSchema = z.object({
+  question: z.string().min(10, "Question must be at least 10 characters").max(2e3).describe("The unanswered question"),
+  context: z.string().max(1e3).optional().describe("Additional context (email subject, sender, etc)"),
+  source: z.enum(["mcp", "email", "chat"]).optional().default("mcp").describe("Question source")
+});
+var listCategoriesSchema = z.object({});
+var healthCheckSchema = z.object({});
+var listGapsSchema = z.object({
+  limit: z.number().min(1).max(100).optional().default(20).describe("Max results"),
+  offset: z.number().min(0).optional().default(0).describe("Pagination offset")
+});
+var createArticleSchema = z.object({
+  title: z.string().min(1).describe("Article title"),
+  content: z.string().min(1).describe("Full article content (markdown)"),
+  summary: z.string().optional().describe("Article summary"),
+  category_id: z.string().optional().describe("Category UUID"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata")
+});
+var updateArticleSchema = z.object({
+  id: z.string().describe("Article ID"),
+  title: z.string().optional().describe("New title"),
+  content: z.string().optional().describe("New content"),
+  summary: z.string().optional().describe("New summary"),
+  category_id: z.string().nullable().optional().describe("New category UUID (null to remove)"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("New metadata")
+});
+var createQASchema = z.object({
+  question: z.string().min(1).describe("The question"),
+  answer: z.string().optional().describe("The answer (optional for gaps)"),
+  status: z.enum(["gap", "draft", "approved"]).optional().default("gap").describe("Q&A status"),
+  source: z.enum(["email", "chat", "mcp", "manual"]).optional().default("manual").describe("Question source"),
+  related_article_id: z.string().optional().describe("Related article ID"),
+  category_id: z.string().optional().describe("Category UUID"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata")
+});
+var draftQAAnswerSchema = z.object({
+  id: z.string().describe("Q&A ID"),
+  answer: z.string().min(1).describe("The drafted answer")
+});
+var approveQASchema = z.object({
+  id: z.string().describe("Q&A ID to approve")
+});
+var deleteArticleSchema = z.object({
+  id: z.string().describe("Article ID to delete")
+});
+var deleteQASchema = z.object({
+  id: z.string().describe("Q&A ID to delete")
+});
+
+// src/index.ts
+var SERVER_URL = process.env.MCP_SERVER_URL || "https://mem-mcp.pragmaticgrowth.com/mcp";
+var API_KEY = process.env.CLERK_API_KEY;
 if (!API_KEY) {
-    console.error('Error: CLERK_API_KEY environment variable is required');
-    console.error('Get your Clerk API key from the Clerk Dashboard or app API Docs page');
-    console.error('Set it in your MCP client configuration under "env"');
-    process.exit(1);
+  console.error("Error: CLERK_API_KEY environment variable is required");
+  console.error("Get your Clerk API key from the Clerk Dashboard or app API Docs page");
+  console.error('Set it in your MCP client configuration under "env"');
+  process.exit(1);
 }
-// HTTP session management
-let sessionId = null;
-let negotiatedProtocolVersion = null;
-/**
- * Make an HTTP request to the remote MCP server.
- * Uses X-API-Key header for Clerk API key authentication.
- */
+var IS_ADMIN = process.env.PG_MEMORY_ADMIN === "true";
+var sessionId = null;
+var negotiatedProtocolVersion = null;
 async function callRemoteServer(method, params) {
-    const headers = {
-        'Content-Type': 'application/json',
-        'X-API-Key': API_KEY, // Safe: already validated above
-    };
-    if (sessionId) {
-        headers['Mcp-Session-Id'] = sessionId;
-    }
-    if (negotiatedProtocolVersion && method !== 'initialize') {
-        headers['Mcp-Protocol-Version'] = negotiatedProtocolVersion;
-    }
-    const body = {
-        jsonrpc: '2.0',
-        id: Date.now(),
-        method,
-        params,
-    };
-    const response = await fetch(SERVER_URL, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-    });
-    // Capture session ID from initialize response
-    const newSessionId = response.headers.get('mcp-session-id');
-    if (newSessionId) {
-        sessionId = newSessionId;
-    }
-    const result = await response.json();
-    if (result.error) {
-        throw new Error(result.error.message);
-    }
-    return result.result;
+  const headers = {
+    "Content-Type": "application/json",
+    "X-API-Key": API_KEY
+    // Safe: already validated above
+  };
+  if (sessionId) {
+    headers["Mcp-Session-Id"] = sessionId;
+  }
+  if (negotiatedProtocolVersion && method !== "initialize") {
+    headers["Mcp-Protocol-Version"] = negotiatedProtocolVersion;
+  }
+  const body = {
+    jsonrpc: "2.0",
+    id: Date.now(),
+    method,
+    params
+  };
+  const response = await fetch(SERVER_URL, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  const newSessionId = response.headers.get("mcp-session-id");
+  if (newSessionId) {
+    sessionId = newSessionId;
+  }
+  const result = await response.json();
+  if (result.error) {
+    throw new Error(result.error.message);
+  }
+  return result.result;
 }
-/**
- * Initialize connection to remote server.
- */
 async function initializeRemoteSession() {
-    const result = await callRemoteServer('initialize', {
-        protocolVersion: '2025-11-25',
-        capabilities: {},
-        clientInfo: {
-            name: 'pg-memory-stdio',
-            version: '3.4.0',
-        },
-    });
-    if (typeof result === 'object' && result && 'protocolVersion' in result) {
-        const protocolVersion = result.protocolVersion;
-        if (protocolVersion) {
-            negotiatedProtocolVersion = protocolVersion;
-        }
+  const result = await callRemoteServer("initialize", {
+    protocolVersion: "2025-11-25",
+    capabilities: {},
+    clientInfo: {
+      name: "pg-memory-stdio",
+      version: "3.5.0"
     }
+  });
+  if (typeof result === "object" && result && "protocolVersion" in result) {
+    const protocolVersion = result.protocolVersion;
+    if (protocolVersion) {
+      negotiatedProtocolVersion = protocolVersion;
+    }
+  }
 }
-/**
- * Create and start the stdio MCP server.
- */
 async function main() {
-    // Initialize remote session first
-    try {
-        await initializeRemoteSession();
+  try {
+    await initializeRemoteSession();
+  } catch (error) {
+    console.error("Failed to connect to remote server:", error);
+    process.exit(1);
+  }
+  const server = new McpServer({
+    name: "pg-memory",
+    version: "3.5.0",
+    description: `PG-Memory knowledge base with ${IS_ADMIN ? "14" : "6"} tools (${IS_ADMIN ? "admin mode" : "read-only mode"})`
+  });
+  server.tool(
+    "search",
+    `Search knowledge base across articles and approved Q&A by semantic similarity.
+Returns lightweight results (ID, type, title/question, similarity, date).
+Use get_article or get_qa to fetch full content.
+ALWAYS call this before answering domain questions.`,
+    searchSchema.shape,
+    async (args) => {
+      const result = await callRemoteServer("tools/call", {
+        name: "search",
+        arguments: args
+      });
+      return result;
     }
-    catch (error) {
-        console.error('Failed to connect to remote server:', error);
-        process.exit(1);
+  );
+  server.tool(
+    "get_article",
+    `Retrieve full content of a knowledge base article by ID.
+Call this after finding relevant items via search.`,
+    getArticleSchema.shape,
+    async (args) => {
+      const result = await callRemoteServer("tools/call", {
+        name: "get_article",
+        arguments: args
+      });
+      return result;
     }
-    // Create local MCP server
-    const server = new McpServer({
-        name: 'pg-memory',
-        version: '3.4.0',
-        description: 'PG-Memory personal knowledge base with AI-powered question handling',
-    });
-    // ============================================================
-    // CORE KNOWLEDGE TOOLS (available in all modes)
-    // ============================================================
-    // Tool 0: __IMPORTANT - Workflow Instructions (pseudo-tool)
-    server.tool('__IMPORTANT', `3-LAYER WORKFLOW FOR QUESTION ANSWERING (ALWAYS FOLLOW):
-
-1. search_knowledge(query) → Get lightweight index with IDs (~50 tokens/result)
-   - Searches articles in knowledge base
-   - Returns: id, title, similarity, date
-   - DO NOT fetch full content yet
-
-2. get_content(id) → Fetch full content for filtered IDs only
-   - Only fetch what you need after reviewing search results
-   - Saves 10x tokens vs fetching all results
-
-3. smart_log_gap(question, context?) → Log unanswered questions
-   - AI evaluates quality, deduplicates, suggests existing answers
-   - Returns: {action: 'logged' | 'duplicate' | 'answered' | 'rejected'}
-   - NEVER log without searching first
-
-CRITICAL RULES:
-- NEVER fetch full content before reviewing search results
-- NEVER log gaps without searching first
-- ALWAYS check for duplicates using similarity`, {}, async () => {
-        const result = await callRemoteServer('tools/call', {
-            name: '__IMPORTANT',
-            arguments: {},
+  );
+  server.tool(
+    "get_qa",
+    `Retrieve a Q&A record by ID. Returns question, answer, status, and metadata.`,
+    getQASchema.shape,
+    async (args) => {
+      const result = await callRemoteServer("tools/call", {
+        name: "get_qa",
+        arguments: args
+      });
+      return result;
+    }
+  );
+  server.tool(
+    "log_gap",
+    `Log an unanswered question as a knowledge gap.
+Creates a Q&A record with status='gap'. Search first before logging.`,
+    logGapSchema.shape,
+    async (args) => {
+      const result = await callRemoteServer("tools/call", {
+        name: "log_gap",
+        arguments: args
+      });
+      return result;
+    }
+  );
+  server.tool(
+    "list_categories",
+    `List all categories in the knowledge base with content counts.`,
+    listCategoriesSchema.shape,
+    async () => {
+      const result = await callRemoteServer("tools/call", {
+        name: "list_categories",
+        arguments: {}
+      });
+      return result;
+    }
+  );
+  server.tool(
+    "health_check",
+    "Check the health status of the knowledge base system including article counts, Q&A counts, and connection pool stats.",
+    healthCheckSchema.shape,
+    async () => {
+      const result = await callRemoteServer("tools/call", {
+        name: "health_check",
+        arguments: {}
+      });
+      return result;
+    }
+  );
+  if (IS_ADMIN) {
+    server.tool(
+      "list_gaps",
+      `[ADMIN] List unanswered knowledge gaps (Q&A with status='gap').`,
+      listGapsSchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "list_gaps",
+          arguments: args
         });
         return result;
-    });
-    // Tool 1: Search Knowledge
-    // @ts-expect-error - SDK type inference depth exceeds TypeScript limit
-    server.tool('search_knowledge', `Search the knowledge base using semantic similarity.
-
-**YOU MUST CALL THIS TOOL** before answering any domain-specific question.
-
-Returns relevant articles with similarity scores.
-Use get_content with the ID to retrieve full content.`, {
-        query: z.string().describe('The question or topic to search for'),
-        limit: z.number().optional().describe('Maximum results to return (default: 5)'),
-        threshold: z.number().optional().describe('Minimum similarity 0-1 (default: 0.55)'),
-    }, async (args) => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'search_knowledge',
-            arguments: args,
+      }
+    );
+    server.tool(
+      "create_article",
+      `[ADMIN] Create a new knowledge base article. Auto-generates embedding from title + summary.`,
+      createArticleSchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "create_article",
+          arguments: args
         });
         return result;
-    });
-    // Tool 2: Get Content
-    server.tool('get_content', `Retrieve complete article content from the knowledge base by ID.
-
-Call this after reviewing search_knowledge results to fetch full content only for relevant articles.`, {
-        id: z.string().describe('Article ID from search results (e.g., art_abc123)'),
-    }, async (args) => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'get_content',
-            arguments: args,
+      }
+    );
+    server.tool(
+      "update_article",
+      `[ADMIN] Update an existing article. Re-generates embedding if title or content changes.`,
+      updateArticleSchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "update_article",
+          arguments: args
         });
         return result;
-    });
-    // Tool 3: Smart Log Gap - AI-evaluated gap logging
-    // @ts-expect-error - SDK type inference depth exceeds TypeScript limit
-    server.tool('smart_log_gap', `Step 3: Log unanswered question with AI evaluation.
-
-SMART BEHAVIORS:
-- Checks for similar existing gaps (>85% = returns duplicate)
-- Checks for matching articles (>70% = suggests existing answer)
-- AI evaluates quality (filters garbage/spam)
-- Auto-assigns priority based on urgency signals
-
-ALWAYS search first before calling this. Do not log without searching.
-
-Returns one of:
-- {action: 'logged', gapId, priority, quality} - Question logged
-- {action: 'duplicate', existingGapId, similarity} - Duplicate detected  
-- {action: 'answered', articleId, title, similarity} - Already answered
-- {action: 'rejected', reason, quality} - Spam/garbage filtered`, {
-        question: z.string().describe('The unanswered question'),
-        context: z.string().optional().describe('Additional context (email subject, sender, etc)'),
-        source: z.enum(['mcp', 'email', 'chat']).optional().describe('Question source (default: mcp)'),
-    }, async (args) => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'smart_log_gap',
-            arguments: args,
+      }
+    );
+    server.tool(
+      "create_qa",
+      `[ADMIN] Create a new Q&A record with full control over status and fields.`,
+      createQASchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "create_qa",
+          arguments: args
         });
         return result;
-    });
-    // Tool 4: List Content
-    server.tool('list_content', `Browse articles in the knowledge base with optional filtering.
-
-Use list_categories first to discover available categories.`, {
-        limit: z.number().optional().describe('Number of items (default: 10, max: 50)'),
-        category: z.string().optional().describe('Filter by category slug'),
-    }, async (args) => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'list_content',
-            arguments: args,
+      }
+    );
+    server.tool(
+      "draft_qa_answer",
+      `[ADMIN] Draft an answer for a Q&A record. Sets status to 'draft' for review.`,
+      draftQAAnswerSchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "draft_qa_answer",
+          arguments: args
         });
         return result;
-    });
-    // Tool 5: Health Check
-    server.tool('health_check', 'Check the health status of the knowledge base system including article counts and connection pool stats.', {}, async () => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'health_check',
-            arguments: {},
+      }
+    );
+    server.tool(
+      "approve_qa",
+      `[ADMIN] Approve a Q&A record. Generates embedding from question+answer for search indexing.`,
+      approveQASchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "approve_qa",
+          arguments: args
         });
         return result;
-    });
-    // Tool 6: List Categories
-    server.tool('list_categories', `List all categories in the knowledge base with content counts.
-Use category slugs with list_content for filtered browsing.`, {}, async () => {
-        const result = await callRemoteServer('tools/call', {
-            name: 'list_categories',
-            arguments: {},
+      }
+    );
+    server.tool(
+      "delete_article",
+      `[ADMIN] Delete an article from the knowledge base. This is permanent.`,
+      deleteArticleSchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "delete_article",
+          arguments: args
         });
         return result;
-    });
-    // Connect via stdio transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
+      }
+    );
+    server.tool(
+      "delete_qa",
+      `[ADMIN] Delete a Q&A record. This is permanent.`,
+      deleteQASchema.shape,
+      async (args) => {
+        const result = await callRemoteServer("tools/call", {
+          name: "delete_qa",
+          arguments: args
+        });
+        return result;
+      }
+    );
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
 }
 main().catch((error) => {
-    console.error('Fatal error:', error);
-    process.exit(1);
+  console.error("Fatal error:", error);
+  process.exit(1);
 });

package/package.json

@@ -1,17 +1,12 @@
 {
   "name": "@pragmatic-growth/memory-mcp",
-  "version": "3.4.0",
-  "description": "Stdio proxy for PG-Memory - connects stdio-based MCP clients (Claude Desktop, Raycast) to your PG-Memory HTTP server using Clerk API key authentication. Personal knowledge base with 7 focused tools including AI-powered question handling with smart deduplication and quality filtering.",
+  "version": "3.5.0",
+  "description": "Stdio proxy for PG-Memory - connects stdio-based MCP clients (Claude Desktop, Raycast) to your PG-Memory HTTP server using Clerk API key authentication. Personal knowledge base with 14 tools (6 read + 8 admin) including articles, Q&A, semantic search, and admin-gated knowledge management.",
   "main": "dist/index.js",
   "bin": {
     "memory-mcp": "dist/index.js"
   },
   "type": "module",
-  "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx src/index.ts"
-  },
   "keywords": [
     "mcp",
     "model-context-protocol",
@@ -31,10 +26,11 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.25.1",
-    "zod": "^3.24.0"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/node": "^20",
+    "tsup": "^8.5.1",
     "tsx": "^4.19.0",
     "typescript": "^5"
   },
@@ -54,5 +50,10 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
   }
-}
+}

package/dist/CLAUDE.md

@@ -1,11 +0,0 @@
-<claude-mem-context>
-# Recent Activity
-
-<!-- This section is auto-generated by claude-mem. Edit content outside the tags. -->
-
-### Jan 16, 2026
-
-| ID | Time | T | Title | Read |
-|----|------|---|-------|------|
-| #26372 | 2:48 AM | ✅ | Committed v3.4.0 release to main branch | ~238 |
-</claude-mem-context>

package/dist/index.d.ts

@@ -1,19 +0,0 @@
-#!/usr/bin/env node
-/**
- * PG-Memory MCP Stdio Server
- *
- * This is a local stdio MCP server that proxies requests to the
- * remote PG-Memory HTTP server on Railway.
- *
- * Usage:
- *   npx @pragmatic-growth/memory-mcp             # Read-only mode (default)
- *
- * Environment variables:
- *   CLERK_API_KEY - Clerk API key for authentication (required)
- *   MCP_SERVER_URL - Server URL (default: https://mem-mcp.pragmaticgrowth.com/mcp)
- *
- * Authentication:
- *   Uses Clerk API key authentication via X-API-Key header.
- *   Get your API key from the Clerk Dashboard or the app's API Docs page.
- */
-export {};