@postnesia/mcp 0.1.0

package/README.md

@@ -0,0 +1,117 @@
+# Postnesia Memory MCP Server
+
+Model Context Protocol server for main agent memory system. Exposes memory operations as standardized tools.
+
+## Installation
+
+```bash
+cd postnesia
+npm install
+npm run db:generate
+```
+
+## Configuration
+
+Add to your MCP settings (e.g., Claude Desktop config):
+
+```json
+{
+  "mcpServers": {
+    "postnesia": {
+      "command": "/absolute/path/to/tsx",
+      "env": {
+        "DATABASE_URL": "file:/absolute/path/to/memory.db",
+        "GEMINI_API_KEY": "token-for-gemini-embedding-model-api"
+      }
+    }
+  }
+}
+```
+
+Or use npm script:
+
+```json
+{
+  "mcpServers": {
+    "openmind": {
+      "command": "/absolute/path/to/tsx",
+      "env": {
+        "DATABASE_URL": "/absolute/path/to/memory.db",
+        "GEMINI_API_KEY": "token-for-gemini-embedding-model-api"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### memory_search
+Semantic search across memories.
+- `query` (required): Search text
+- `maxResults` (optional): Max results (default: 10)
+- `minScore` (optional): Min similarity 0-1 (default: 0.3)
+
+### memory_add
+Create a new memory.
+- `content` (required): Full memory text
+- `contentL1` (optional): Compressed form
+- `type` (required): event|decision|lesson|preference|person|technical
+- `importance` (required): 1-5
+- `tags` (required): Array of tags
+- `context` (optional): Creation context
+
+### memory_recent
+Get recent memories.
+- `hours` (optional): Hours to look back (default: 24)
+- `limit` (optional): Max results (default: 20)
+
+### memory_context
+Get contextually related memories.
+- `query` (required): Context query
+- `maxResults` (optional): Max results (default: 5)
+
+### memory_stats
+Get database statistics. No parameters.
+
+### memory_consolidate
+Run consolidation cycle (decay + boost). No parameters - always applies changes.
+
+### journal_add
+Add daily journal entry.
+- `date` (required): YYYY-MM-DD
+- `content` (required): Full narrative
+- `learned` (optional): What I learned
+- `learnedAboutRye` (optional): What I learned about Rye
+- `keyMoments` (optional): Key moments
+- `mood` (optional): Mood/feeling
+
+### journal_recent
+Get recent journal entries.
+- `days` (optional): Days to look back (default: 7)
+
+### memory_relationships
+View relationship graph for a memory.
+- `memoryId` (required): Memory ID to explore
+
+## Access Tracking
+
+All read operations (search, recent, context) automatically log accesses, which feed into the importance dynamics system.
+
+## Testing
+
+Test the server manually:
+
+```bash
+npm run mcp
+```
+
+Then send MCP requests via stdin (see MCP protocol docs).
+
+## Architecture
+
+- Built on Prisma + SQLite
+- Automatic access tracking
+- Dynamic importance scoring (decay + boost)
+- Relationship graph support
+- Journal integration

package/dist/access.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Access Tracking System
+ * Logs when memories are retrieved and updates last_accessed on the memory row.
+ * Feeds into L1 decay calculations.
+ */
+export interface AccessLogEntry {
+    memory_id: number;
+    context?: string;
+    accessed_at: string;
+}
+/**
+ * Record that a memory was accessed (updates both access_log and memory.last_accessed)
+ */
+export declare function logAccess(memory_id: number, context?: string): void;
+export declare function getAccessCount(memory_id: number, daysBack?: number): number;
+export declare function getRecentlyAccessed(limit?: number): number[];
+export declare function getAccessHistory(memory_id: number): AccessLogEntry[];
+/**
+ * Calculate relevance boost based on access patterns
+ * Recent access + frequency = higher relevance
+ */
+export declare function calculateAccessBoost(memory_id: number): number;

package/dist/access.js

@@ -0,0 +1,63 @@
+/**
+ * Access Tracking System
+ * Logs when memories are retrieved and updates last_accessed on the memory row.
+ * Feeds into L1 decay calculations.
+ */
+import { getDb, recordAccess } from '@postnesia/db';
+/**
+ * Record that a memory was accessed (updates both access_log and memory.last_accessed)
+ */
+export function logAccess(memory_id, context) {
+    try {
+        const db = getDb(false);
+        recordAccess(db, memory_id, context);
+    }
+    catch (error) {
+        console.error(`[access-tracker] Warning: Could not log access for #${memory_id}:`, error?.message);
+    }
+}
+export function getAccessCount(memory_id, daysBack = 30) {
+    const db = getDb(true);
+    const result = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM access_log
+    WHERE memory_id = ?
+      AND accessed_at > datetime('now', '-${daysBack} days')
+  `).get(memory_id);
+    return result.count;
+}
+export function getRecentlyAccessed(limit = 20) {
+    const db = getDb(true);
+    const results = db.prepare(`
+    SELECT memory_id, COUNT(*) as access_count
+    FROM access_log
+    WHERE accessed_at > datetime('now', '-7 days')
+    GROUP BY memory_id
+    ORDER BY access_count DESC, MAX(accessed_at) DESC
+    LIMIT ?
+  `).all(limit);
+    return results.map(r => r.memory_id);
+}
+export function getAccessHistory(memory_id) {
+    const db = getDb(true);
+    return db.prepare(`
+    SELECT memory_id, accessed_at, context
+    FROM access_log
+    WHERE memory_id = ?
+    ORDER BY accessed_at DESC
+    LIMIT 50
+  `).all(memory_id);
+}
+/**
+ * Calculate relevance boost based on access patterns
+ * Recent access + frequency = higher relevance
+ */
+export function calculateAccessBoost(memory_id) {
+    const last7Days = getAccessCount(memory_id, 7);
+    const last30Days = getAccessCount(memory_id, 30);
+    const recentWeight = last7Days * 2;
+    const olderWeight = (last30Days - last7Days);
+    const totalScore = recentWeight + olderWeight;
+    // Normalize to 0-2 range
+    return Math.min(2, totalScore / 5);
+}

package/dist/importance.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Importance Dynamics
+ * Adjust memory importance based on age, access patterns, and relationships
+ */
+export interface ImportanceFactors {
+    baseImportance: number;
+    ageDecay: number;
+    accessBoost: number;
+    relationshipBoost: number;
+    finalScore: number;
+}
+/**
+ * Calculate age decay factor
+ * Recent memories maintain importance, old ones decay unless accessed
+ */
+export declare function calculateAgeDecay(timestamp: string): number;
+/**
+ * Calculate dynamic importance score
+ * Base importance + access boost - age decay
+ */
+export declare function calculateDynamicImportance(memory_id: number): ImportanceFactors;
+/**
+ * Get memories eligible for L1 based on dynamic scoring.
+ * Uses the decay query from PHILOSOPHY.md: importance penalized by last_accessed staleness,
+ * superseded memories excluded.
+ */
+export declare function getL1Candidates(limit?: number): Array<{
+    id: number;
+    type: string;
+    content_l1: string;
+    timestamp: string;
+    last_accessed: string;
+    baseImportance: number;
+    dynamicScore: number;
+}>;
+/**
+ * Consolidation: Review and adjust importances based on access patterns
+ */
+export declare function runConsolidation(): {
+    reviewed: number;
+    boosted: number;
+    decayed: number;
+    unchanged: number;
+};

package/dist/importance.js

@@ -0,0 +1,145 @@
+/**
+ * Importance Dynamics
+ * Adjust memory importance based on age, access patterns, and relationships
+ */
+import { getDb, queries } from '@postnesia/db';
+import { calculateAccessBoost } from './access.js';
+/**
+ * Calculate relationship boost based on graph connectivity
+ * Memories that are hubs in the relationship graph are more valuable
+ */
+function calculateRelationshipBoost(memory_id) {
+    const db = getDb(true);
+    // Count total connections
+    const connections = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM relationship
+    WHERE from_id = ? OR to_id = ?
+  `).get(memory_id, memory_id);
+    // Count connections to high-importance memories (4+)
+    const importantConnections = db.prepare(`
+    SELECT COUNT(*) as count
+    FROM relationship r
+    JOIN memory m ON (
+      CASE 
+        WHEN r.from_id = ? THEN m.id = r.to_id
+        ELSE m.id = r.from_id
+      END
+    )
+    WHERE (r.from_id = ? OR r.to_id = ?)
+      AND m.importance >= 4
+  `).get(memory_id, memory_id, memory_id);
+    // Boost calculation:
+    // - Base: 0.1 per connection (up to +1.0 for 10 connections)
+    // - Bonus: +0.2 per important connection
+    const baseBoost = Math.min(1.0, connections.count * 0.1);
+    const importantBonus = importantConnections.count * 0.2;
+    return Math.min(2.0, baseBoost + importantBonus);
+}
+/**
+ * Calculate age decay factor
+ * Recent memories maintain importance, old ones decay unless accessed
+ */
+export function calculateAgeDecay(timestamp) {
+    const now = Date.now();
+    const memoryDate = new Date(timestamp).getTime();
+    const ageInDays = (now - memoryDate) / (1000 * 60 * 60 * 24);
+    // No decay for first 7 days
+    if (ageInDays <= 7)
+        return 0;
+    // Gradual decay: -0.1 per week after first week
+    const weeksOld = Math.floor((ageInDays - 7) / 7);
+    const decay = Math.min(2, weeksOld * 0.1); // Max -2 importance
+    return -decay;
+}
+/**
+ * Calculate dynamic importance score
+ * Base importance + access boost - age decay
+ */
+export function calculateDynamicImportance(memory_id) {
+    const db = getDb(true);
+    const memory = db.prepare(`
+    SELECT importance, timestamp
+    FROM memory
+    WHERE id = ?
+  `).get(memory_id);
+    if (!memory) {
+        return {
+            baseImportance: 0,
+            ageDecay: 0,
+            accessBoost: 0,
+            relationshipBoost: 0,
+            finalScore: 0,
+        };
+    }
+    const baseImportance = memory.importance;
+    const ageDecay = calculateAgeDecay(memory.timestamp);
+    const accessBoost = calculateAccessBoost(memory_id);
+    const relationshipBoost = calculateRelationshipBoost(memory_id);
+    // Final score: base + boosts + decay (decay is negative)
+    const finalScore = Math.max(1, Math.min(5, baseImportance + accessBoost + relationshipBoost + ageDecay));
+    return {
+        baseImportance,
+        ageDecay,
+        accessBoost,
+        relationshipBoost,
+        finalScore: Math.round(finalScore * 10) / 10, // Round to 1 decimal
+    };
+}
+/**
+ * Get memories eligible for L1 based on dynamic scoring.
+ * Uses the decay query from PHILOSOPHY.md: importance penalized by last_accessed staleness,
+ * superseded memories excluded.
+ */
+export function getL1Candidates(limit = 50) {
+    const db = getDb(true);
+    // Use the L1 decay query from db.ts (matches PHILOSOPHY.md)
+    const memories = queries.getL1Summaries(db).all();
+    return memories.slice(0, limit).map(m => ({
+        id: m.id,
+        type: m.type,
+        content_l1: m.content_l1,
+        timestamp: m.timestamp,
+        last_accessed: m.last_accessed,
+        baseImportance: m.importance,
+        dynamicScore: m.effective_importance,
+    }));
+}
+/**
+ * Consolidation: Review and adjust importances based on access patterns
+ */
+export function runConsolidation() {
+    const db = getDb(false);
+    let reviewed = 0;
+    let boosted = 0;
+    let decayed = 0;
+    let unchanged = 0;
+    // Get all memories from last 60 days
+    const memories = db.prepare(`
+    SELECT id, importance, timestamp
+    FROM memory
+    WHERE timestamp > datetime('now', '-60 days')
+  `).all();
+    for (const memory of memories) {
+        reviewed++;
+        const factors = calculateDynamicImportance(memory.id);
+        const newImportance = Math.round(factors.finalScore);
+        if (newImportance !== memory.importance) {
+            db.prepare(`
+        UPDATE memory
+        SET importance = ?
+        WHERE id = ?
+      `).run(newImportance, memory.id);
+            if (newImportance > memory.importance) {
+                boosted++;
+            }
+            else {
+                decayed++;
+            }
+        }
+        else {
+            unchanged++;
+        }
+    }
+    return { reviewed, boosted, decayed, unchanged };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * MCP Server for Belle's Memory System
+ * Exposes memory operations as Model Context Protocol tools
+ */
+import 'dotenv/config';

package/dist/index.js

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+/**
+ * MCP Server for Belle's Memory System
+ * Exposes memory operations as Model Context Protocol tools
+ */
+import 'dotenv/config';
+import { Server } from "@modelcontextprotocol/sdk/server";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { getDb, queries, createMemory } from "@postnesia/db";
+import { embed } from "@postnesia/db/embeddings";
+import { logAccess } from "./access.js";
+import { runConsolidation } from "./importance.js";
+const db = getDb();
+const server = new Server({
+    name: "openmind",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Tool definitions
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "memory_search",
+                description: "Search memories by content. Returns all matching memories.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: {
+                            type: "string",
+                            description: "Search query",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum results to return (default: 10)",
+                        },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "memory_add",
+                description: "Add a new memory to the database",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: {
+                            type: "string",
+                            description: "Memory content (full form)",
+                        },
+                        contentL1: {
+                            type: "string",
+                            description: "Compressed L1 form (optional, will auto-generate if omitted)",
+                        },
+                        type: {
+                            type: "string",
+                            enum: ["event", "decision", "lesson", "preference", "person", "technical"],
+                            description: "Memory type",
+                        },
+                        importance: {
+                            type: "number",
+                            description: "Base importance 1-5",
+                        },
+                        tags: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Tags for categorization",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Optional context about when/why this memory was created",
+                        },
+                        core: {
+                            type: "boolean",
+                            description: "Mark as a core memory (always loaded, never decays, cannot be superseded)",
+                        },
+                    },
+                    required: ["content", "type", "importance", "tags"],
+                },
+            },
+            {
+                name: "memory_update_core",
+                description: "Update the content of an existing core memory in place (core memories must be updated, never superseded)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        memoryId: {
+                            type: "number",
+                            description: "ID of the memory to update",
+                        },
+                        content: {
+                            type: "string",
+                            description: "New full content",
+                        },
+                        contentL1: {
+                            type: "string",
+                            description: "New compressed L1 summary",
+                        },
+                    },
+                    required: ["memoryId", "content", "contentL1"],
+                },
+            },
+            {
+                name: "memory_recent",
+                description: "Get recent memories within time window",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        hours: {
+                            type: "number",
+                            description: "Hours to look back (default: 24)",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum results (default: 20)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "memory_stats",
+                description: "Get memory database statistics",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "memory_consolidate",
+                description: "Run memory consolidation cycle (decay old, boost accessed)",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+            {
+                name: "journal_add",
+                description: "Add a daily journal entry",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        date: {
+                            type: "string",
+                            description: "Date YYYY-MM-DD",
+                        },
+                        content: {
+                            type: "string",
+                            description: "Full journal narrative",
+                        },
+                        learned: {
+                            type: "string",
+                            description: "What I learned (optional)",
+                        },
+                        learnedAboutRye: {
+                            type: "string",
+                            description: "What I learned about Rye (optional)",
+                        },
+                        keyMoments: {
+                            type: "string",
+                            description: "Key moments (optional)",
+                        },
+                        mood: {
+                            type: "string",
+                            description: "Mood/feeling (optional)",
+                        },
+                    },
+                    required: ["date", "content"],
+                },
+            },
+            {
+                name: "journal_recent",
+                description: "Get recent journal entries",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        days: {
+                            type: "number",
+                            description: "Days to look back (default: 7)",
+                        },
+                    },
+                },
+            },
+            {
+                name: "memory_relationships",
+                description: "View relationship graph for a memory",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        memoryId: {
+                            type: "number",
+                            description: "Memory ID to explore",
+                        },
+                    },
+                    required: ["memoryId"],
+                },
+            },
+            {
+                name: "task_create",
+                description: "Create a new task. Use session_id to group tasks by project or feature.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        title: {
+                            type: "string",
+                            description: "Short task title",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Detailed description of what needs to be done",
+                        },
+                        session_id: {
+                            type: "string",
+                            description: "Project or feature label to group related tasks (e.g. 'openmind-mcp', 'auth-refactor')",
+                        },
+                        memory_id: {
+                            type: "number",
+                            description: "Optional ID of a related memory",
+                        },
+                    },
+                    required: ["title"],
+                },
+            },
+            {
+                name: "task_update",
+                description: "Update a task's status, title, or description",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskId: {
+                            type: "number",
+                            description: "ID of the task to update",
+                        },
+                        status: {
+                            type: "string",
+                            enum: ["pending", "in_progress", "completed", "cancelled"],
+                            description: "New status",
+                        },
+                        title: {
+                            type: "string",
+                            description: "Updated title",
+                        },
+                        description: {
+                            type: "string",
+                            description: "Updated description",
+                        },
+                    },
+                    required: ["taskId"],
+                },
+            },
+            {
+                name: "task_list",
+                description: "List tasks, optionally filtered by status and/or session_id. Use at session start to resume open work.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        status: {
+                            type: "string",
+                            enum: ["pending", "in_progress", "completed", "cancelled"],
+                            description: "Filter by status",
+                        },
+                        session_id: {
+                            type: "string",
+                            description: "Filter by project/feature label",
+                        },
+                        limit: {
+                            type: "number",
+                            description: "Maximum results (default: 50)",
+                        },
+                    },
+                },
+            },
+        ],
+    };
+});
+// Tool handlers
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        const { name, arguments: args = {} } = request.params;
+        switch (name) {
+            case "memory_search": {
+                const query = args.query.toLowerCase();
+                const limit = args.limit || 10;
+                const pattern = `%${query}%`;
+                const results = queries.searchMemories(db).all(pattern, pattern, limit);
+                for (const result of results) {
+                    logAccess(result.id, 'search');
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(results, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "memory_add": {
+                const { content, contentL1, type, importance, tags, context, core } = args;
+                const content_l1 = contentL1 || content.slice(0, 200);
+                const embedding = await embed(content);
+                const id = createMemory(db, {
+                    timestamp: new Date().toISOString(),
+                    content,
+                    content_l1,
+                    type,
+                    core: core ? 1 : 0,
+                    importance,
+                    context: context || undefined,
+                    tags,
+                    embedding,
+                });
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✓ Created memory #${id}\n  Type: ${type}\n  Core: ${core ? 'yes' : 'no'}\n  Importance: ${'⭐'.repeat(importance)}\n  Tags: ${tags.join(', ')}`,
+                        },
+                    ],
+                };
+            }
+            case "memory_update_core": {
+                const { memoryId, content, contentL1 } = args;
+                const existing = db.prepare('SELECT id, core FROM memory WHERE id = ?').get(memoryId);
+                if (!existing) {
+                    throw new Error(`Memory #${memoryId} not found`);
+                }
+                if (!existing.core) {
+                    throw new Error(`Memory #${memoryId} is not a core memory. Use memory_add with supersedes_id for regular memories.`);
+                }
+                const embedding = await embed(content);
+                db.prepare(`
+          UPDATE memory
+          SET content = ?, content_l1 = ?, updated_at = datetime('now')
+          WHERE id = ?
+        `).run(content, contentL1, memoryId);
+                // Update embedding in vec_memories virtual table
+                db.prepare('DELETE FROM vec_memories WHERE memory_id = ?').run(BigInt(memoryId));
+                db.prepare('INSERT INTO vec_memories(memory_id, embedding) VALUES (?, ?)').run(BigInt(memoryId), Buffer.from(embedding.buffer));
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✓ Updated core memory #${memoryId}`,
+                        },
+                    ],
+                };
+            }
+            case "memory_recent": {
+                const hours = args.hours || 24;
+                const limit = args.limit || 20;
+                const results = queries.getRecentMemories(db).all(`-${hours} hours`, limit);
+                for (const result of results) {
+                    logAccess(result.id, 'recent');
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(results, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "memory_stats": {
+                const stats = queries.getStats(db).all();
+                const total = db.prepare('SELECT COUNT(*) as count FROM memory').get().count;
+                const tags = db.prepare('SELECT COUNT(*) as count FROM tag').get().count;
+                const relationships = db.prepare('SELECT COUNT(*) as count FROM relationship').get().count;
+                const accessLogs = db.prepare('SELECT COUNT(*) as count FROM access_log').get().count;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `📊 Memory Statistics:\n\n${stats.map(s => `  ${s.type.padEnd(15)} ${s.count.toString().padStart(3)} memories (avg importance: ${s.avg_importance?.toFixed(1)})`).join('\n')}\n\n  Total:         ${total} memories\n  Tags:          ${tags}\n  Relationships: ${relationships}\n  Access Logs:   ${accessLogs}`,
+                        },
+                    ],
+                };
+            }
+            case "memory_consolidate": {
+                const results = runConsolidation();
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `🔄 Consolidation Complete\n\nReviewed: ${results.reviewed} memories\nBoosted: ${results.boosted} memories\nDecayed: ${results.decayed} memories\nUnchanged: ${results.unchanged} memories\n\nChanges saved to database`,
+                        },
+                    ],
+                };
+            }
+            case "journal_add": {
+                const { date, content, learned, learnedAboutRye, keyMoments, mood } = args;
+                // Combine learned + learnedAboutRye into the single learned column
+                const combinedLearned = [learned, learnedAboutRye].filter(Boolean).join('\n\n') || null;
+                queries.insertJournal(db).run(date, content, combinedLearned, keyMoments || null, mood || null);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✓ Journal entry created for ${date}`,
+                        },
+                    ],
+                };
+            }
+            case "journal_recent": {
+                const days = args.days || 7;
+                const entries = queries.getRecentJournals(db).all(`-${days} days`);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(entries, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "memory_relationships": {
+                const memoryId = args.memoryId;
+                const relationships = queries.getMemoryRelationships(db).all(memoryId, memoryId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(relationships, null, 2),
+                        },
+                    ],
+                };
+            }
+            case "task_create": {
+                const { title, description, session_id, memory_id } = args;
+                const result = queries.insertTask(db).run(title, description || null, session_id || null, memory_id || null);
+                const id = Number(result.lastInsertRowid);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✓ Created task #${id}: ${title}${session_id ? `\n  Session: ${session_id}` : ''}`,
+                        },
+                    ],
+                };
+            }
+            case "task_update": {
+                const { taskId, status, title, description } = args;
+                const existing = queries.getTaskById(db).get(taskId);
+                if (!existing)
+                    throw new Error(`Task #${taskId} not found`);
+                queries.updateTask(db).run(status || null, title || null, description || null, taskId);
+                const updated = queries.getTaskById(db).get(taskId);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `✓ Task #${taskId} updated\n  Status: ${updated.status}\n  Title: ${updated.title}`,
+                        },
+                    ],
+                };
+            }
+            case "task_list": {
+                const { status, session_id, limit = 50 } = args;
+                // Build dynamic WHERE clause
+                const conditions = [];
+                const params = [];
+                if (status) {
+                    conditions.push('status = ?');
+                    params.push(status);
+                }
+                if (session_id) {
+                    conditions.push('session_id = ?');
+                    params.push(session_id);
+                }
+                const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+                params.push(limit);
+                const tasks = db.prepare(`
+          SELECT * FROM task
+          ${where}
+          ORDER BY created_at ASC
+          LIMIT ?
+        `).all(...params);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(tasks, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+try {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+catch (error) {
+    console.error("OpenMind Memory MCP Server running on stdio");
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@postnesia/mcp",
+  "version": "0.1.0",
+  "description": "An MCP server to interact with the Postnesia database",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "postnesia-mcp": "./dist/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@postnesia/db": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "tsx src/index.ts"
+  }
+}