@aeriondyseti/vector-memory-mcp 0.9.0-dev.2 → 0.9.0-dev.3

package/src/config/index.ts

@@ -1,75 +0,0 @@
-import arg from "arg";
-import { join } from "path";
-
-export type TransportMode = "stdio" | "http" | "both";
-
-export interface Config {
-  dbPath: string;
-  embeddingModel: string;
-  embeddingDimension: number;
-  httpPort: number;
-  httpHost: string;
-  enableHttp: boolean;
-  transportMode: TransportMode;
-}
-
-export interface ConfigOverrides {
-  dbPath?: string;
-  httpPort?: number;
-  enableHttp?: boolean;
-  transportMode?: TransportMode;
-}
-
-// Defaults - always use repo-local .vector-memory folder
-const DEFAULT_DB_PATH = join(process.cwd(), ".vector-memory", "memories.db");
-const DEFAULT_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
-const DEFAULT_EMBEDDING_DIMENSION = 384;
-const DEFAULT_HTTP_PORT = 3271;
-const DEFAULT_HTTP_HOST = "127.0.0.1";
-
-function resolvePath(path: string): string {
-  return path.startsWith("/") ? path : join(process.cwd(), path);
-}
-
-export function loadConfig(overrides: ConfigOverrides = {}): Config {
-  const transportMode = overrides.transportMode ?? "stdio";
-  // HTTP enabled by default (needed for hooks), can disable with --no-http
-  const enableHttp = overrides.enableHttp ?? true;
-
-  return {
-    dbPath: resolvePath(overrides.dbPath ?? DEFAULT_DB_PATH),
-    embeddingModel: DEFAULT_EMBEDDING_MODEL,
-    embeddingDimension: DEFAULT_EMBEDDING_DIMENSION,
-    httpPort: overrides.httpPort ?? DEFAULT_HTTP_PORT,
-    httpHost: DEFAULT_HTTP_HOST,
-    enableHttp,
-    transportMode,
-  };
-}
-
-/**
- * Parse CLI arguments into config overrides.
- */
-export function parseCliArgs(argv: string[]): ConfigOverrides {
-  const args = arg(
-    {
-      "--db-file": String,
-      "--port": Number,
-      "--no-http": Boolean,
-
-      // Aliases
-      "-d": "--db-file",
-      "-p": "--port",
-    },
-    { argv, permissive: true }
-  );
-
-  return {
-    dbPath: args["--db-file"],
-    httpPort: args["--port"],
-    enableHttp: args["--no-http"] ? false : undefined,
-  };
-}
-
-// Default config for imports that don't use CLI args
-export const config = loadConfig();

package/src/db/connection.ts

@@ -1,11 +0,0 @@
-import * as lancedb from "@lancedb/lancedb";
-import { mkdirSync } from "fs";
-import { dirname } from "path";
-
-export async function connectToDatabase(dbPath: string): Promise<lancedb.Connection> {
-  // Ensure directory exists
-  mkdirSync(dirname(dbPath), { recursive: true });
-
-  const db = await lancedb.connect(dbPath);
-  return db;
-}

package/src/db/memory.repository.ts

@@ -1,115 +0,0 @@
-import * as lancedb from "@lancedb/lancedb";
-import { TABLE_NAME, memorySchema } from "./schema.js";
-import {
-  type Memory,
-  type VectorRow,
-  DELETED_TOMBSTONE,
-} from "../types/memory.js";
-
-export class MemoryRepository {
-  constructor(private db: lancedb.Connection) {}
-
-  private async getTable() {
-    const names = await this.db.tableNames();
-    if (names.includes(TABLE_NAME)) {
-      return await this.db.openTable(TABLE_NAME);
-    }
-    // Create with empty data to initialize schema
-    return await this.db.createTable(TABLE_NAME, [], { schema: memorySchema });
-  }
-
-  async insert(memory: Memory): Promise<void> {
-    const table = await this.getTable();
-    await table.add([
-      {
-        id: memory.id,
-        vector: memory.embedding,
-        content: memory.content,
-        metadata: JSON.stringify(memory.metadata),
-        created_at: memory.createdAt.getTime(),
-        updated_at: memory.updatedAt.getTime(),
-        superseded_by: memory.supersededBy,
-      },
-    ]);
-  }
-
-  async upsert(memory: Memory): Promise<void> {
-    const table = await this.getTable();
-    const existing = await table.query().where(`id = '${memory.id}'`).limit(1).toArray();
-
-    if (existing.length === 0) {
-      return await this.insert(memory);
-    }
-
-    await table.update({
-      where: `id = '${memory.id}'`,
-      values: {
-        vector: memory.embedding,
-        content: memory.content,
-        metadata: JSON.stringify(memory.metadata),
-        created_at: memory.createdAt.getTime(),
-        updated_at: memory.updatedAt.getTime(),
-        superseded_by: memory.supersededBy,
-      },
-    });
-  }
-
-  async findById(id: string): Promise<Memory | null> {
-    const table = await this.getTable();
-    const results = await table.query().where(`id = '${id}'`).limit(1).toArray();
-
-    if (results.length === 0) {
-      return null;
-    }
-
-    const row = results[0];
-    
-    // Handle Arrow Vector type conversion
-    // LanceDB returns an Arrow Vector object which is iterable but not an array
-    const vectorData = row.vector as any;
-    const embedding = Array.isArray(vectorData) 
-      ? vectorData 
-      : Array.from(vectorData) as number[];
-
-    return {
-      id: row.id as string,
-      content: row.content as string,
-      embedding,
-      metadata: JSON.parse(row.metadata as string),
-      createdAt: new Date(row.created_at as number),
-      updatedAt: new Date(row.updated_at as number),
-      supersededBy: row.superseded_by as string | null,
-    };
-  }
-
-  async markDeleted(id: string): Promise<boolean> {
-    const table = await this.getTable();
-    
-    // Verify existence first to match previous behavior (return false if not found)
-    const existing = await table.query().where(`id = '${id}'`).limit(1).toArray();
-    if (existing.length === 0) {
-      return false;
-    }
-
-    const now = Date.now();
-    await table.update({
-      where: `id = '${id}'`,
-      values: {
-        superseded_by: DELETED_TOMBSTONE,
-        updated_at: now,
-      },
-    });
-
-    return true;
-  }
-
-  async findSimilar(embedding: number[], limit: number): Promise<VectorRow[]> {
-    const table = await this.getTable();
-    const results = await table.vectorSearch(embedding).limit(limit).toArray();
-
-    return results.map((r) => ({
-      id: r.id as string,
-      distance: r._distance as number,
-    }));
-  }
-}

package/src/db/schema.ts

@@ -1,34 +0,0 @@
-import {
-  Schema,
-  Field,
-  FixedSizeList,
-  Float32,
-  Utf8,
-  Timestamp,
-  TimeUnit,
-} from "apache-arrow";
-
-export const TABLE_NAME = "memories";
-
-export const memorySchema = new Schema([
-  new Field("id", new Utf8(), false),
-  new Field(
-    "vector",
-    new FixedSizeList(384, new Field("item", new Float32())),
-    false
-  ),
-  new Field("content", new Utf8(), false),
-  new Field("metadata", new Utf8(), false), // JSON string
-  new Field(
-    "created_at",
-    new Timestamp(TimeUnit.MILLISECOND),
-    false
-  ),
-  new Field(
-    "updated_at",
-    new Timestamp(TimeUnit.MILLISECOND),
-    false
-  ),
-  new Field("superseded_by", new Utf8(), true), // Nullable
-]);
-

package/src/http/mcp-transport.ts

@@ -1,255 +0,0 @@
-/**
- * MCP HTTP Transport Handler
- *
- * Provides StreamableHTTP transport for MCP over HTTP.
- * and other HTTP-based MCP clients to connect to the memory server.
- *
- * This implementation handles the MCP protocol directly using Hono's streaming
- * capabilities, since StreamableHTTPServerTransport expects Node.js req/res objects.
- */
-
-import { Hono } from "hono";
-import { streamSSE } from "hono/streaming";
-import { randomUUID } from "node:crypto";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  type JSONRPCMessage,
-  type JSONRPCRequest,
-  type JSONRPCNotification,
-} from "@modelcontextprotocol/sdk/types.js";
-import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-
-import { tools } from "../mcp/tools.js";
-import { handleToolCall } from "../mcp/handlers.js";
-import type { MemoryService } from "../services/memory.service.js";
-
-interface Session {
-  server: Server;
-  serverTransport: InstanceType<typeof InMemoryTransport>;
-  clientTransport: InstanceType<typeof InMemoryTransport>;
-  pendingResponses: Map<string | number, (response: JSONRPCMessage) => void>;
-  sseClients: Set<(message: JSONRPCMessage) => void>;
-}
-
-/**
- * Creates MCP routes for a Hono app.
- *
- * Uses InMemoryTransport internally and bridges to HTTP/SSE manually,
- * since StreamableHTTPServerTransport requires Node.js req/res objects.
- */
-export function createMcpRoutes(memoryService: MemoryService): Hono {
-  const app = new Hono();
-
-  // Store active sessions by session ID
-  const sessions: Map<string, Session> = new Map();
-
-  /**
-   * Creates a new MCP server instance configured with memory tools.
-   */
-  async function createSession(): Promise<Session> {
-    const server = new Server(
-      { name: "vector-memory-mcp", version: "0.6.0" },
-      { capabilities: { tools: {} } }
-    );
-
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return { tools };
-    });
-
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      return handleToolCall(name, args, memoryService);
-    });
-
-    // Create linked in-memory transports
-    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-
-    // Connect server to its transport
-    await server.connect(serverTransport);
-
-    const session: Session = {
-      server,
-      serverTransport,
-      clientTransport,
-      pendingResponses: new Map(),
-      sseClients: new Set(),
-    };
-
-    // Handle messages from server (responses and notifications)
-    clientTransport.onmessage = (message: JSONRPCMessage) => {
-      // Check if this is a response to a pending request
-      if ("id" in message && message.id !== undefined) {
-        const resolver = session.pendingResponses.get(message.id);
-        if (resolver) {
-          resolver(message);
-          session.pendingResponses.delete(message.id);
-          return;
-        }
-      }
-
-      // Otherwise, broadcast to SSE clients (notifications)
-      for (const sendToClient of session.sseClients) {
-        sendToClient(message);
-      }
-    };
-
-    return session;
-  }
-
-  /**
-   * Handle POST requests - session initialization and message handling
-   */
-  app.post("/mcp", async (c) => {
-    const sessionId = c.req.header("mcp-session-id");
-    const body = await c.req.json();
-
-    let session: Session | undefined;
-    let newSessionId: string | undefined;
-
-    if (sessionId && sessions.has(sessionId)) {
-      // Reuse existing session
-      session = sessions.get(sessionId)!;
-    } else if (isInitializeRequest(body)) {
-      // New session initialization
-      newSessionId = randomUUID();
-      session = await createSession();
-      sessions.set(newSessionId, session);
-      console.error(`[vector-memory-mcp] MCP session initialized: ${newSessionId}`);
-    } else {
-      // Invalid request - no session ID and not an initialize request
-      return c.json(
-        {
-          jsonrpc: "2.0",
-          error: {
-            code: -32000,
-            message: "Invalid session. Send initialize request without session ID to start.",
-          },
-          id: body.id ?? null,
-        },
-        400
-      );
-    }
-
-    // Send message to server and wait for response
-    const response = await sendAndWaitForResponse(session, body);
-
-    // Include session ID header for new sessions
-    if (newSessionId) {
-      c.header("mcp-session-id", newSessionId);
-    }
-
-    return c.json(response);
-  });
-
-  /**
-   * Handle GET requests - SSE stream for server-to-client notifications
-   */
-  app.get("/mcp", async (c) => {
-    const sessionId = c.req.header("mcp-session-id");
-
-    if (!sessionId || !sessions.has(sessionId)) {
-      return c.json(
-        {
-          jsonrpc: "2.0",
-          error: { code: -32000, message: "Invalid or missing session ID" },
-          id: null,
-        },
-        400
-      );
-    }
-
-    const session = sessions.get(sessionId)!;
-
-    return streamSSE(c, async (stream) => {
-      // Register this SSE client
-      const sendMessage = (message: JSONRPCMessage) => {
-        stream.writeSSE({
-          data: JSON.stringify(message),
-          event: "message",
-        });
-      };
-
-      session.sseClients.add(sendMessage);
-
-      // Keep connection open
-      try {
-        // Send a ping every 30 seconds to keep connection alive
-        while (true) {
-          await stream.sleep(30000);
-          await stream.writeSSE({ event: "ping", data: "" });
-        }
-      } finally {
-        session.sseClients.delete(sendMessage);
-      }
-    });
-  });
-
-  /**
-   * Handle DELETE requests - session termination
-   */
-  app.delete("/mcp", async (c) => {
-    const sessionId = c.req.header("mcp-session-id");
-
-    if (!sessionId || !sessions.has(sessionId)) {
-      return c.json(
-        {
-          jsonrpc: "2.0",
-          error: { code: -32000, message: "Invalid or missing session ID" },
-          id: null,
-        },
-        400
-      );
-    }
-
-    const session = sessions.get(sessionId)!;
-
-    // Close transports
-    await session.clientTransport.close();
-    await session.serverTransport.close();
-    await session.server.close();
-
-    sessions.delete(sessionId);
-    console.error(`[vector-memory-mcp] MCP session closed: ${sessionId}`);
-
-    return c.json({ success: true });
-  });
-
-  return app;
-}
-
-/**
- * Send a message to the server and wait for its response.
- */
-async function sendAndWaitForResponse(
-  session: Session,
-  message: JSONRPCRequest | JSONRPCNotification
-): Promise<JSONRPCMessage> {
-  return new Promise((resolve) => {
-    // Register response handler for requests (messages with id)
-    if ("id" in message && message.id !== undefined) {
-      session.pendingResponses.set(message.id, resolve);
-    }
-
-    // Send message to server
-    session.clientTransport.send(message);
-
-    // For notifications (no id), resolve immediately with empty response
-    if (!("id" in message) || message.id === undefined) {
-      resolve({ jsonrpc: "2.0" } as JSONRPCMessage);
-    }
-  });
-}
-
-/**
- * Check if a message is an initialize request.
- */
-function isInitializeRequest(body: unknown): boolean {
-  return (
-    typeof body === "object" &&
-    body !== null &&
-    "method" in body &&
-    (body as { method: string }).method === "initialize"
-  );
-}

package/src/http/server.ts

@@ -1,190 +0,0 @@
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import type { MemoryService } from "../services/memory.service.js";
-import type { Config } from "../config/index.js";
-import { isDeleted } from "../types/memory.js";
-import { createMcpRoutes } from "./mcp-transport.js";
-import type { Memory } from "../types/memory.js";
-
-export interface HttpServerOptions {
-  memoryService: MemoryService;
-  config: Config;
-}
-
-// Track server start time for uptime calculation
-const startedAt = Date.now();
-
-export function createHttpApp(memoryService: MemoryService, config: Config): Hono {
-  const app = new Hono();
-
-  // Enable CORS for local development
-  app.use("/*", cors());
-
-  // Mount MCP routes for StreamableHTTP transport
-  const mcpApp = createMcpRoutes(memoryService);
-  app.route("/", mcpApp);
-
-  // Health check endpoint with config info
-  app.get("/health", (c) => {
-    return c.json({
-      status: "ok",
-      timestamp: new Date().toISOString(),
-      pid: process.pid,
-      uptime: Math.floor((Date.now() - startedAt) / 1000),
-      config: {
-        dbPath: config.dbPath,
-        embeddingModel: config.embeddingModel,
-        embeddingDimension: config.embeddingDimension,
-      },
-    });
-  });
-
-  // Search endpoint
-  app.post("/search", async (c) => {
-    try {
-      const body = await c.req.json();
-      const query = body.query;
-      const limit = body.limit ?? 10;
-
-      if (!query || typeof query !== "string") {
-        return c.json({ error: "Missing or invalid 'query' field" }, 400);
-      }
-
-      const memories = await memoryService.search(query, limit);
-
-      return c.json({
-        memories: memories.map((m) => ({
-          id: m.id,
-          content: m.content,
-          metadata: m.metadata,
-          createdAt: m.createdAt.toISOString(),
-        })),
-        count: memories.length,
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return c.json({ error: message }, 500);
-    }
-  });
-
-  // Store endpoint
-  app.post("/store", async (c) => {
-    try {
-      const body = await c.req.json();
-      const { content, metadata, embeddingText } = body;
-
-      if (!content || typeof content !== "string") {
-        return c.json({ error: "Missing or invalid 'content' field" }, 400);
-      }
-
-      const memory = await memoryService.store(
-        content,
-        metadata ?? {},
-        embeddingText
-      );
-
-      return c.json({
-        id: memory.id,
-        createdAt: memory.createdAt.toISOString(),
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return c.json({ error: message }, 500);
-    }
-  });
-
-  // Delete endpoint
-  app.delete("/memories/:id", async (c) => {
-    try {
-      const id = c.req.param("id");
-      const deleted = await memoryService.delete(id);
-
-      if (!deleted) {
-        return c.json({ error: "Memory not found" }, 404);
-      }
-
-      return c.json({ deleted: true });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return c.json({ error: message }, 500);
-    }
-  });
-
-  // Get latest handoff
-  app.get("/handoff", async (c) => {
-    try {
-      const handoff = await memoryService.getLatestHandoff();
-
-      if (!handoff) {
-        return c.json({ error: "No handoff found" }, 404);
-      }
-
-      // Fetch referenced memories if any
-      const memoryIds = (handoff.metadata.memory_ids as string[] | undefined) ?? [];
-      const referencedMemories: Array<{ id: string; content: string }> = [];
-
-      for (const id of memoryIds) {
-        const memory = await memoryService.get(id);
-        if (memory && !isDeleted(memory)) {
-          referencedMemories.push({ id: memory.id, content: memory.content });
-        }
-      }
-
-      return c.json({
-        content: handoff.content,
-        metadata: handoff.metadata,
-        referencedMemories,
-        updatedAt: handoff.updatedAt.toISOString(),
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return c.json({ error: message }, 500);
-    }
-  });
-
-  // Get single memory
-  app.get("/memories/:id", async (c) => {
-    try {
-      const id = c.req.param("id");
-      const memory = await memoryService.get(id);
-
-      if (!memory || isDeleted(memory)) {
-        return c.json({ error: "Memory not found" }, 404);
-      }
-
-      return c.json({
-        id: memory.id,
-        content: memory.content,
-        metadata: memory.metadata,
-        createdAt: memory.createdAt.toISOString(),
-        updatedAt: memory.updatedAt.toISOString(),
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      return c.json({ error: message }, 500);
-    }
-  });
-
-  return app;
-}
-
-export async function startHttpServer(
-  memoryService: MemoryService,
-  config: Config
-): Promise<{ stop: () => void }> {
-  const app = createHttpApp(memoryService, config);
-
-  const server = Bun.serve({
-    port: config.httpPort,
-    hostname: config.httpHost,
-    fetch: app.fetch,
-  });
-
-  console.error(
-    `[vector-memory-mcp] HTTP server listening on http://${config.httpHost}:${config.httpPort}`
-  );
-
-  return {
-    stop: () => server.stop(),
-  };
-}