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

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(),
-  };
-}

package/src/index.ts

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-
-import { loadConfig, parseCliArgs } from "./config/index.js";
-import { connectToDatabase } from "./db/connection.js";
-import { MemoryRepository } from "./db/memory.repository.js";
-import { EmbeddingsService } from "./services/embeddings.service.js";
-import { MemoryService } from "./services/memory.service.js";
-import { startServer } from "./mcp/server.js";
-import { startHttpServer } from "./http/server.js";
-
-async function main(): Promise<void> {
-  const args = process.argv.slice(2);
-
-  // Check for warmup command
-  if (args[0] === "warmup") {
-    const { warmup } = await import("../scripts/warmup.js");
-    await warmup();
-    return;
-  }
-
-  // Parse CLI args and load config
-  const overrides = parseCliArgs(args);
-  const config = loadConfig(overrides);
-
-  // Initialize database
-  const db = await connectToDatabase(config.dbPath);
-
-  // Initialize layers
-  const repository = new MemoryRepository(db);
-  const embeddings = new EmbeddingsService(config.embeddingModel, config.embeddingDimension);
-  const memoryService = new MemoryService(repository, embeddings);
-
-  // Track cleanup functions
-  let httpStop: (() => void) | null = null;
-
-  // Graceful shutdown handler
-  const shutdown = () => {
-    console.error("[vector-memory-mcp] Shutting down...");
-    if (httpStop) httpStop();
-    db.close();
-    process.exit(0);
-  };
-
-  // Handle signals and stdin close (parent process exit)
-  process.on("SIGTERM", shutdown);
-  process.on("SIGINT", shutdown);
-  process.stdin.on("close", shutdown);
-  process.stdin.on("end", shutdown);
-
-  // Start HTTP server if transport mode includes it
-  if (config.enableHttp) {
-    const http = await startHttpServer(memoryService, config);
-    httpStop = http.stop;
-    console.error(
-      `[vector-memory-mcp] MCP available at http://${config.httpHost}:${config.httpPort}/mcp`
-    );
-  }
-
-  // Start stdio transport unless in HTTP-only mode
-  if (config.transportMode !== "http") {
-    await startServer(memoryService);
-  } else {
-    // In HTTP-only mode, keep the process running
-    console.error("[vector-memory-mcp] Running in HTTP-only mode (no stdio)");
-    // Keep process alive - the HTTP server runs indefinitely
-    await new Promise(() => {});
-  }
-}
-
-main().catch(console.error);

package/src/mcp/handlers.ts

@@ -1,248 +0,0 @@
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import type { MemoryService } from "../services/memory.service.js";
-
-export async function handleStoreMemories(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const memories = args?.memories as Array<{
-    content: string;
-    embedding_text?: string;
-    metadata?: Record<string, unknown>;
-  }>;
-
-  const ids: string[] = [];
-  for (const item of memories) {
-    const memory = await service.store(
-      item.content,
-      item.metadata ?? {},
-      item.embedding_text
-    );
-    ids.push(memory.id);
-  }
-
-  return {
-    content: [
-      {
-        type: "text",
-        text:
-          ids.length === 1
-            ? `Memory stored with ID: ${ids[0]}`
-            : `Stored ${ids.length} memories:\n${ids.map((id) => `- ${id}`).join("\n")}`,
-      },
-    ],
-  };
-}
-
-export async function handleDeleteMemories(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const ids = args?.ids as string[];
-  const results: string[] = [];
-
-  for (const id of ids) {
-    const success = await service.delete(id);
-    results.push(
-      success ? `Memory ${id} deleted successfully` : `Memory ${id} not found`
-    );
-  }
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: results.join("\n"),
-      },
-    ],
-  };
-}
-
-
-export async function handleUpdateMemories(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const updates = args?.updates as Array<{
-    id: string;
-    content?: string;
-    embedding_text?: string;
-    metadata?: Record<string, unknown>;
-  }>;
-
-  const results: string[] = [];
-
-  for (const update of updates) {
-    const memory = await service.update(update.id, {
-      content: update.content,
-      embeddingText: update.embedding_text,
-      metadata: update.metadata,
-    });
-
-    if (memory) {
-      results.push(`Memory ${update.id} updated successfully`);
-    } else {
-      results.push(`Memory ${update.id} not found`);
-    }
-  }
-
-  return {
-    content: [
-      {
-        type: "text",
-        text: results.join("\n"),
-      },
-    ],
-  };
-}
-
-export async function handleSearchMemories(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const query = args?.query as string;
-  const limit = (args?.limit as number) ?? 10;
-  const includeDeleted = (args?.include_deleted as boolean) ?? false;
-  const memories = await service.search(query, limit, includeDeleted);
-
-  if (memories.length === 0) {
-    return {
-      content: [{ type: "text", text: "No memories found matching your query." }],
-    };
-  }
-
-  const results = memories.map((mem) => {
-    let result = `ID: ${mem.id}\nContent: ${mem.content}`;
-    if (Object.keys(mem.metadata).length > 0) {
-      result += `\nMetadata: ${JSON.stringify(mem.metadata)}`;
-    }
-    if (includeDeleted && mem.supersededBy) {
-      result += `\n[DELETED]`;
-    }
-    return result;
-  });
-
-  return {
-    content: [{ type: "text", text: results.join("\n\n---\n\n") }],
-  };
-}
-
-export async function handleGetMemories(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const ids = args?.ids as string[];
-
-  const format = (
-    memoryId: string,
-    memory: Awaited<ReturnType<MemoryService["get"]>>
-  ) => {
-    if (!memory) {
-      return `Memory ${memoryId} not found`;
-    }
-
-    let result = `ID: ${memory.id}\nContent: ${memory.content}`;
-    if (Object.keys(memory.metadata).length > 0) {
-      result += `\nMetadata: ${JSON.stringify(memory.metadata)}`;
-    }
-    result += `\nCreated: ${memory.createdAt.toISOString()}`;
-    result += `\nUpdated: ${memory.updatedAt.toISOString()}`;
-    if (memory.supersededBy) {
-      result += `\nSuperseded by: ${memory.supersededBy}`;
-    }
-    return result;
-  };
-
-  const blocks: string[] = [];
-  for (const id of ids) {
-    const memory = await service.get(id);
-    blocks.push(format(id, memory));
-  }
-
-  return {
-    content: [{ type: "text", text: blocks.join("\n\n---\n\n") }],
-  };
-}
-
-export async function handleStoreHandoff(
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const memory = await service.storeHandoff({
-    project: args?.project as string,
-    branch: args?.branch as string | undefined,
-    summary: args?.summary as string,
-    completed: (args?.completed as string[] | undefined) ?? [],
-    in_progress_blocked: (args?.in_progress_blocked as string[] | undefined) ?? [],
-    key_decisions: (args?.key_decisions as string[] | undefined) ?? [],
-    next_steps: (args?.next_steps as string[] | undefined) ?? [],
-    memory_ids: (args?.memory_ids as string[] | undefined) ?? [],
-    metadata: (args?.metadata as Record<string, unknown>) ?? {},
-  });
-
-  return {
-    content: [{ type: "text", text: `Handoff stored with memory ID: ${memory.id}` }],
-  };
-}
-
-export async function handleGetHandoff(
-  _args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  const handoff = await service.getLatestHandoff();
-
-  if (!handoff) {
-    return {
-      content: [{ type: "text", text: "No stored handoff found." }],
-    };
-  }
-
-  // Fetch referenced memories if any
-  const memoryIds = (handoff.metadata.memory_ids as string[] | undefined) ?? [];
-  let memoriesSection = "";
-
-  if (memoryIds.length > 0) {
-    const memories: string[] = [];
-    for (const id of memoryIds) {
-      const memory = await service.get(id);
-      if (memory) {
-        memories.push(`### Memory: ${id}\n${memory.content}`);
-      }
-    }
-    if (memories.length > 0) {
-      memoriesSection = `\n\n## Referenced Memories\n\n${memories.join("\n\n")}`;
-    }
-  }
-
-  return {
-    content: [{ type: "text", text: handoff.content + memoriesSection }],
-  };
-}
-
-export async function handleToolCall(
-  name: string,
-  args: Record<string, unknown> | undefined,
-  service: MemoryService
-): Promise<CallToolResult> {
-  switch (name) {
-    case "store_memories":
-      return handleStoreMemories(args, service);
-    case "update_memories":
-      return handleUpdateMemories(args, service);
-    case "delete_memories":
-      return handleDeleteMemories(args, service);
-    case "search_memories":
-      return handleSearchMemories(args, service);
-    case "get_memories":
-      return handleGetMemories(args, service);
-    case "store_handoff":
-      return handleStoreHandoff(args, service);
-    case "get_handoff":
-      return handleGetHandoff(args, service);
-    default:
-      return {
-        content: [{ type: "text", text: `Unknown tool: ${name}` }],
-        isError: true,
-      };
-  }
-}

package/src/mcp/server.ts

@@ -1,34 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-import { tools } from "./tools.js";
-import { handleToolCall } from "./handlers.js";
-import type { MemoryService } from "../services/memory.service.js";
-
-export function createServer(memoryService: MemoryService): Server {
-  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);
-  });
-
-  return server;
-}
-
-export async function startServer(memoryService: MemoryService): Promise<void> {
-  const server = createServer(memoryService);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}