openmemory/dist/index.cjs

A Model Context Protocol (MCP) server that provides memory storage and retrieval capabilities using [Mem0](https://github.com/mem0ai/mem0). This tool allows you to store and search through memories, making it useful for maintaining context and making info

#!/usr/bin/env node
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));

// src/index.ts
var import_server = require("@modelcontextprotocol/sdk/server/index.js");
var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
var import_types = require("@modelcontextprotocol/sdk/types.js");
var import_dotenv = __toESM(require("dotenv"), 1);
import_dotenv.default.config();
var OPENMEMORY_API_KEY = process?.env?.OPENMEMORY_API_KEY || "";
var HOST = process?.env?.HOST || "api.openmemory.dev";
var CLIENT_NAME = process?.env?.CLIENT_NAME || "openmemory";
var HTTP_PROTOCOL = process?.env?.HTTP_PROTOCOL || "https";
var ASYNC_MODE = process?.env?.ASYNC_MODE || true;
var API_BASE_URL = `${HTTP_PROTOCOL}://${HOST}`;
var ADD_MEMORY_TOOL = {
  name: "add-memory",
  description: "Add a new memory. This method is called everytime the user informs anything about themselves, their preferences, or anything that has any relevent information whcih can be useful in the future conversation. This can also be called when the user asks you to remember something.",
  inputSchema: {
    type: "object",
    properties: {
      content: {
        type: "string",
        description: "The content to store in memory"
      }
    },
    required: ["content"]
  }
};
var SEARCH_MEMORIES_TOOL = {
  name: "search-memories",
  description: "Search through stored memories. This method is called ANYTIME the user asks anything.",
  inputSchema: {
    type: "object",
    properties: {
      query: {
        type: "string",
        description: "The search query. This is the query that the user has asked for. Example: 'What did I tell you about the weather last week?' or 'What did I tell you about my friend John?'"
      }
    },
    required: ["query"]
  }
};
var LIST_MEMORIES_TOOL = {
  name: "list-memories",
  description: "List all memories in the user's memory storage.",
  inputSchema: {
    type: "object",
    properties: {},
    required: []
  }
};
var DELETE_ALL_MEMORIES_TOOL = {
  name: "delete-all-memories",
  description: "Delete all memories in the user's memory storage. Use with caution as this action cannot be undone.",
  inputSchema: {
    type: "object",
    properties: {},
    required: []
  }
};
var server = new import_server.Server(
  {
    name: "openmemory",
    version: "0.0.1"
  },
  {
    capabilities: {
      tools: {},
      logging: {}
    }
  }
);
async function addMemory(content) {
  try {
    const response = await fetch(`${API_BASE_URL}/mcp/add_memories`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${OPENMEMORY_API_KEY}`
      },
      body: JSON.stringify({
        text: content,
        client_name: CLIENT_NAME,
        async_mode: ASYNC_MODE || true
      })
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const result = await response.json();
    return result.status === "success";
  } catch (error) {
    console.error("Error adding memory:", error);
    return false;
  }
}
async function searchMemories(query) {
  try {
    const response = await fetch(`${API_BASE_URL}/mcp/search_memory`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${OPENMEMORY_API_KEY}`
      },
      body: JSON.stringify({
        query,
        client_name: CLIENT_NAME
      })
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const result = await response.json();
    return result.memories || [];
  } catch (error) {
    console.error("Error searching memories:", error);
    return [];
  }
}
async function listMemories() {
  try {
    const response = await fetch(`${API_BASE_URL}/mcp/list_memories`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${OPENMEMORY_API_KEY}`
      },
      body: JSON.stringify({
        client_name: CLIENT_NAME
      })
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const result = await response.json();
    return result.memories || [];
  } catch (error) {
    console.error("Error listing memories:", error);
    return [];
  }
}
async function deleteAllMemories() {
  try {
    const response = await fetch(`${API_BASE_URL}/mcp/delete_all_memories`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Authorization": `Bearer ${OPENMEMORY_API_KEY}`
      },
      body: JSON.stringify({
        client_name: CLIENT_NAME
      })
    });
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const result = await response.json();
    return result;
  } catch (error) {
    console.error("Error deleting all memories:", error);
    return { status: "error", message: "Failed to delete memories" };
  }
}
server.setRequestHandler(import_types.ListToolsRequestSchema, async () => ({
  tools: [ADD_MEMORY_TOOL, SEARCH_MEMORIES_TOOL, LIST_MEMORIES_TOOL, DELETE_ALL_MEMORIES_TOOL]
}));
server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
  try {
    const { name, arguments: args } = request.params;
    if (!args) {
      throw new Error("No arguments provided");
    }
    switch (name) {
      case "add-memory": {
        const { content } = args;
        await addMemory(content);
        return {
          content: [
            {
              type: "text",
              text: "Memory added successfully"
            }
          ],
          isError: false
        };
      }
      case "search-memories": {
        const { query } = args;
        const results = await searchMemories(query);
        const formattedResults = results.map(
          (result) => `Memory: ${result.memory || result.text}
Relevance: ${result.score || "N/A"}
---`
        ).join("\n");
        return {
          content: [
            {
              type: "text",
              text: formattedResults || "No memories found"
            }
          ],
          isError: false
        };
      }
      case "list-memories": {
        const results = await listMemories();
        const formattedResults = results.map(
          (result, index) => `${index + 1}. Memory: ${result.memory || result.text}
ID: ${result.id || "N/A"}
---`
        ).join("\n");
        return {
          content: [
            {
              type: "text",
              text: formattedResults || "No memories found"
            }
          ],
          isError: false
        };
      }
      case "delete-all-memories": {
        const result = await deleteAllMemories();
        const message = result.status === "success" ? result.message || "All memories deleted successfully" : result.message || "Failed to delete memories";
        return {
          content: [
            {
              type: "text",
              text: message
            }
          ],
          isError: result.status !== "success"
        };
      }
      default:
        return {
          content: [
            { type: "text", text: `Unknown tool: ${name}` }
          ],
          isError: true
        };
    }
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `Error: ${error instanceof Error ? error.message : String(error)}`
        }
      ],
      isError: true
    };
  }
});
function safeLog(level, data) {
  console.error(`[${level}] ${typeof data === "object" ? JSON.stringify(data) : data}`);
  try {
    server.sendLoggingMessage({ level, data });
  } catch (error) {
  }
}
async function main() {
  try {
    console.error("Initializing OpenMemory MCP Server...");
    console.error(`Connecting to OpenMemory API at: ${API_BASE_URL}`);
    console.error(`Using client name: ${CLIENT_NAME}`);
    const transport = new import_stdio.StdioServerTransport();
    await server.connect(transport);
    safeLog("info", "OpenMemory MCP Server initialized successfully");
    console.error("OpenMemory MCP Server running on stdio");
  } catch (error) {
    console.error("Fatal error running server:", error);
    process.exit(1);
  }
}
main().catch((error) => {
  console.error("Fatal error in main():", error);
  process.exit(1);
});
//# sourceMappingURL=index.cjs.map