@prmichaelsen/remember-mcp 0.1.0

package/dist/tools/create-memory.d.ts

@@ -0,0 +1,94 @@
+/**
+ * remember_create_memory tool
+ * Creates a new memory in the user's collection
+ */
+import type { ContentType, MemoryContext } from '../types/memory.js';
+/**
+ * Tool definition for remember_create_memory
+ */
+export declare const createMemoryTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            content: {
+                type: string;
+                description: string;
+            };
+            title: {
+                type: string;
+                description: string;
+            };
+            type: {
+                type: string;
+                description: string;
+                default: ContentType;
+            };
+            weight: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+            trust: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            references: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            template_id: {
+                type: string;
+                description: string;
+            };
+            skip_template_suggestion: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Create memory arguments
+ */
+export interface CreateMemoryArgs {
+    content: string;
+    title?: string;
+    type?: ContentType;
+    weight?: number;
+    trust?: number;
+    tags?: string[];
+    references?: string[];
+    template_id?: string;
+    skip_template_suggestion?: boolean;
+    structured_content?: Record<string, any>;
+}
+/**
+ * Create memory result
+ */
+export interface CreateMemoryResult {
+    memory_id: string;
+    created_at: string;
+    message: string;
+}
+/**
+ * Handle remember_create_memory tool
+ */
+export declare function handleCreateMemory(args: CreateMemoryArgs, userId: string, context?: Partial<MemoryContext>): Promise<string>;
+//# sourceMappingURL=create-memory.d.ts.map

package/dist/tools/delete-memory.d.ts

@@ -0,0 +1,47 @@
+/**
+ * remember_delete_memory tool
+ * Delete a memory from the user's collection
+ */
+/**
+ * Tool definition for remember_delete_memory
+ */
+export declare const deleteMemoryTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            memory_id: {
+                type: string;
+                description: string;
+            };
+            delete_relationships: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Delete memory arguments
+ */
+export interface DeleteMemoryArgs {
+    memory_id: string;
+    delete_relationships?: boolean;
+}
+/**
+ * Delete memory result
+ */
+export interface DeleteMemoryResult {
+    memory_id: string;
+    deleted: boolean;
+    relationships_deleted?: number;
+    message: string;
+}
+/**
+ * Handle remember_delete_memory tool
+ */
+export declare function handleDeleteMemory(args: DeleteMemoryArgs, userId: string): Promise<string>;
+//# sourceMappingURL=delete-memory.d.ts.map

package/dist/tools/search-memory.d.ts

@@ -0,0 +1,88 @@
+/**
+ * remember_search_memory tool
+ * Search memories using hybrid semantic + keyword search
+ */
+import type { SearchOptions } from '../types/memory.js';
+/**
+ * Tool definition for remember_search_memory
+ */
+export declare const searchMemoryTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            alpha: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+            };
+            limit: {
+                type: string;
+                description: string;
+                minimum: number;
+                maximum: number;
+                default: number;
+            };
+            offset: {
+                type: string;
+                description: string;
+                minimum: number;
+                default: number;
+            };
+            filters: {
+                type: string;
+                description: string;
+                properties: {
+                    types: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    tags: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                    weight_min: {
+                        type: string;
+                        description: string;
+                    };
+                    trust_min: {
+                        type: string;
+                        description: string;
+                    };
+                    date_from: {
+                        type: string;
+                        description: string;
+                    };
+                    date_to: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+            include_relationships: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+/**
+ * Handle remember_search_memory tool
+ */
+export declare function handleSearchMemory(args: SearchOptions, userId: string): Promise<string>;
+//# sourceMappingURL=search-memory.d.ts.map

package/dist/types/memory.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Memory type definitions for remember-mcp
+ */
+/**
+ * Content types for memories
+ * Based on agent/design/content-types-expansion.md
+ */
+export type ContentType = 'code' | 'note' | 'documentation' | 'reference' | 'todo' | 'checklist' | 'project' | 'goal' | 'habit' | 'email' | 'conversation' | 'meeting' | 'person' | 'article' | 'webpage' | 'social' | 'image' | 'video' | 'audio' | 'transcript' | 'presentation' | 'spreadsheet' | 'pdf' | 'screenplay' | 'recipe' | 'idea' | 'quote' | 'journal' | 'memory' | 'event' | 'bookmark' | 'form' | 'location' | 'invoice' | 'contract' | 'system' | 'action' | 'audit' | 'history';
+/**
+ * GPS coordinates
+ */
+export interface GPSCoordinates {
+    latitude: number;
+    longitude: number;
+    accuracy?: number;
+    altitude?: number;
+    timestamp: string;
+}
+/**
+ * Address information
+ */
+export interface Address {
+    formatted: string;
+    street?: string;
+    city?: string;
+    state?: string;
+    country?: string;
+    postal_code?: string;
+    timezone?: string;
+}
+/**
+ * Location information (from platform cookies)
+ */
+export interface Location {
+    gps: GPSCoordinates | null;
+    address: Address | null;
+    source: 'gps' | 'ip' | 'manual' | 'cached' | 'unavailable';
+    confidence: number;
+    is_approximate: boolean;
+}
+/**
+ * Conversation participant
+ */
+export interface Participant {
+    user_id: string;
+    role: 'user' | 'assistant' | 'system';
+    name?: string;
+}
+/**
+ * Source information
+ */
+export interface Source {
+    type: 'conversation' | 'import' | 'inference' | 'manual' | 'api';
+    platform?: string;
+    client?: string;
+    version?: string;
+}
+/**
+ * Environment information
+ */
+export interface Environment {
+    location?: Location;
+    device?: string;
+    user_agent?: string;
+}
+/**
+ * Context information about how/when memory was created
+ */
+export interface MemoryContext {
+    conversation_id?: string;
+    conversation_title?: string;
+    turn_number?: number;
+    summary?: string;
+    participants?: Participant[];
+    timestamp: string;
+    timezone?: string;
+    source: Source;
+    environment?: Environment;
+    tags?: string[];
+    notes?: string;
+}
+/**
+ * Core Memory interface
+ * Based on agent/design/requirements-enhancements.md
+ */
+export interface Memory {
+    id: string;
+    user_id: string;
+    doc_type: 'memory';
+    content: string;
+    title?: string;
+    summary?: string;
+    type: ContentType;
+    weight: number;
+    trust: number;
+    confidence?: number;
+    location: Location;
+    context: MemoryContext;
+    relationships: string[];
+    access_count: number;
+    last_accessed_at?: string;
+    access_frequency?: number;
+    created_at: string;
+    updated_at: string;
+    version: number;
+    tags: string[];
+    category?: string;
+    references?: string[];
+    template_id?: string;
+    template_version?: string;
+    structured_content?: Record<string, any>;
+    base_weight: number;
+    computed_weight?: number;
+}
+/**
+ * Relationship interface
+ * Stored in same collection as memories with doc_type: "relationship"
+ */
+export interface Relationship {
+    id: string;
+    user_id: string;
+    doc_type: 'relationship';
+    memory_ids: string[];
+    relationship_type: string;
+    observation: string;
+    strength: number;
+    confidence: number;
+    context: MemoryContext;
+    created_at: string;
+    updated_at: string;
+    version: number;
+    tags: string[];
+}
+/**
+ * Union type for documents in Memory collection
+ */
+export type MemoryDocument = Memory | Relationship;
+/**
+ * Partial memory for updates
+ */
+export type MemoryUpdate = Partial<Omit<Memory, 'id' | 'user_id' | 'doc_type' | 'created_at' | 'version'>>;
+/**
+ * Partial relationship for updates
+ */
+export type RelationshipUpdate = Partial<Omit<Relationship, 'id' | 'user_id' | 'doc_type' | 'created_at' | 'version'>>;
+/**
+ * Search filters
+ */
+export interface SearchFilters {
+    types?: ContentType[];
+    tags?: string[];
+    weight_min?: number;
+    weight_max?: number;
+    trust_min?: number;
+    trust_max?: number;
+    date_from?: string;
+    date_to?: string;
+    location_near?: GPSCoordinates;
+    location_radius_meters?: number;
+    has_relationships?: boolean;
+}
+/**
+ * Search options
+ */
+export interface SearchOptions {
+    query: string;
+    alpha?: number;
+    filters?: SearchFilters;
+    include_relationships?: boolean;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Search result
+ */
+export interface SearchResult {
+    memories: Memory[];
+    relationships?: Relationship[];
+    total: number;
+    offset: number;
+    limit: number;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/weaviate/client.d.ts

@@ -0,0 +1,39 @@
+import { WeaviateClient } from 'weaviate-client';
+/**
+ * Initialize Weaviate client
+ */
+export declare function initWeaviateClient(): Promise<WeaviateClient>;
+/**
+ * Get Weaviate client instance
+ */
+export declare function getWeaviateClient(): WeaviateClient;
+/**
+ * Test Weaviate connection
+ */
+export declare function testWeaviateConnection(): Promise<boolean>;
+/**
+ * Sanitize user_id for collection name
+ * Weaviate collection names must start with uppercase letter and contain only alphanumeric
+ */
+export declare function sanitizeUserId(userId: string): string;
+/**
+ * Get collection name for user's memories
+ */
+export declare function getMemoryCollectionName(userId: string): string;
+/**
+ * Get collection name for user's templates
+ */
+export declare function getTemplateCollectionName(userId: string): string;
+/**
+ * Get collection name for user's audit logs
+ */
+export declare function getAuditCollectionName(userId: string): string;
+/**
+ * Check if collection exists
+ */
+export declare function collectionExists(collectionName: string): Promise<boolean>;
+/**
+ * Close Weaviate client connection
+ */
+export declare function closeWeaviateClient(): Promise<void>;
+//# sourceMappingURL=client.d.ts.map

package/dist/weaviate/client.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=client.spec.d.ts.map

package/dist/weaviate/schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Weaviate schema definitions for remember-mcp
+ * Based on agent/design/weaviate-collection-strategy.md
+ */
+/**
+ * Create Memory collection schema for a user
+ *
+ * This collection stores BOTH memories AND relationships using doc_type discriminator.
+ * This unified approach enables:
+ * - Single query for memories with relationships
+ * - Semantic search across both memories and relationship observations
+ * - Better RAG context (LLM gets memories + connections together)
+ *
+ * @param userId - User identifier
+ */
+export declare function createMemoryCollection(userId: string): Promise<void>;
+/**
+ * Ensure Memory collection exists for user (lazy creation)
+ */
+export declare function ensureMemoryCollection(userId: string): Promise<void>;
+/**
+ * Get Memory collection for user
+ */
+export declare function getMemoryCollection(userId: string): import("weaviate-client").Collection<undefined, string, undefined>;
+/**
+ * Delete Memory collection for user (use with caution!)
+ */
+export declare function deleteMemoryCollection(userId: string): Promise<void>;
+//# sourceMappingURL=schema.d.ts.map

package/esbuild.build.js

@@ -0,0 +1,60 @@
+import * as esbuild from 'esbuild';
+import { execSync } from 'child_process';
+
+// Build server (standalone)
+await esbuild.build({
+  entryPoints: ['src/server.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: 'dist/server.js',
+  sourcemap: true,
+  external: [
+    'weaviate-client',
+    '@prmichaelsen/firebase-admin-sdk-v8',
+    '@modelcontextprotocol/sdk'
+  ],
+  banner: {
+    js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);"
+  },
+  alias: {
+    '@': './src'
+  }
+});
+
+// Build server factory (bundled for library usage)
+await esbuild.build({
+  entryPoints: ['src/server-factory.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: 'dist/server-factory.js',
+  sourcemap: true,
+  external: [
+    'weaviate-client',
+    '@prmichaelsen/firebase-admin-sdk-v8',
+    '@modelcontextprotocol/sdk'
+  ],
+  banner: {
+    js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);"
+  },
+  alias: {
+    '@': './src'
+  }
+});
+
+console.log('✓ JavaScript bundles built');
+
+// Generate TypeScript declarations
+console.log('Generating TypeScript declarations...');
+try {
+  execSync('tsc --emitDeclarationOnly --outDir dist', { stdio: 'inherit' });
+  console.log('✓ TypeScript declarations generated');
+} catch (error) {
+  console.error('✗ Failed to generate TypeScript declarations');
+  process.exit(1);
+}
+
+console.log('✓ Build complete');

package/esbuild.watch.js

@@ -0,0 +1,25 @@
+import * as esbuild from 'esbuild';
+
+const ctx = await esbuild.context({
+  entryPoints: ['src/server.ts'],
+  bundle: true,
+  platform: 'node',
+  target: 'node20',
+  format: 'esm',
+  outfile: 'dist/server.js',
+  sourcemap: true,
+  external: [
+    'weaviate-client',
+    'firebase-admin',
+    '@modelcontextprotocol/sdk'
+  ],
+  banner: {
+    js: "import { createRequire } from 'module'; const require = createRequire(import.meta.url);"
+  },
+  alias: {
+    '@': './src'
+  }
+});
+
+await ctx.watch();
+console.log('👀 Watching for changes...');

package/jest.config.js

@@ -0,0 +1,31 @@
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/*.spec.ts'],
+  moduleFileExtensions: ['ts', 'js'],
+  collectCoverage: true,
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.spec.ts',
+    '!src/**/*.e2e.ts',
+    '!src/index.ts',
+    '!src/types/**/*.ts',
+  ],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.ts$': [
+      'ts-jest',
+      {
+        useESM: true,
+      },
+    ],
+  },
+};

package/jest.e2e.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/*.e2e.ts'],
+  testTimeout: 30000, // 30 seconds for real API calls
+  roots: ['<rootDir>/src'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.spec.ts',
+    '!src/**/*.e2e.ts',
+    '!src/types/**/*.ts',
+    '!src/index.ts',
+  ],
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/src/$1',
+  },
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@prmichaelsen/remember-mcp",
+  "version": "0.1.0",
+  "description": "Multi-tenant memory system MCP server with vector search and relationships",
+  "main": "dist/server.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./factory": {
+      "types": "./dist/server-factory.d.ts",
+      "import": "./dist/server-factory.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/prmichaelsen/remember-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/prmichaelsen/remember-mcp/issues"
+  },
+  "homepage": "https://github.com/prmichaelsen/remember-mcp#readme",
+  "scripts": {
+    "build": "node esbuild.build.js",
+    "build:watch": "node esbuild.watch.js",
+    "clean": "rm -rf dist",
+    "dev": "tsx watch src/server.ts",
+    "start": "node dist/server.js",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:e2e": "jest --config jest.e2e.config.js",
+    "test:e2e:watch": "jest --config jest.e2e.config.js --watch",
+    "test:all": "npm test && npm run test:e2e",
+    "lint": "eslint src/**/*.ts",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "memory",
+    "vector-search",
+    "weaviate",
+    "firebase"
+  ],
+  "author": "Patrick Michaelsen",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.4",
+    "@prmichaelsen/firebase-admin-sdk-v8": "^2.2.0",
+    "dotenv": "^16.4.5",
+    "weaviate-client": "^3.2.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.11.19",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "esbuild": "^0.20.0",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "tsx": "^4.7.1",
+    "typescript": "^5.3.3"
+  }
+}