Connect Claude Desktop to Your Memory (TypeScript MCP Server)

mkdir my-memory-mcp && cd my-memory-mcp
npm init -y
npm install @neo4j-labs/agent-memory @modelcontextprotocol/sdk
npm install --save-dev typescript tsx @types/node

{
  "type": "module",
  "scripts": {
    "start": "tsx src/server.ts"
  }
}

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 { MemoryClient } from "@neo4j-labs/agent-memory";
import {
  createMemoryTools,
  handleMemoryToolCall,
} from "@neo4j-labs/agent-memory/mcp";

async function main() {
  // Reads MEMORY_API_KEY from the environment Claude Desktop passes in.
  const memory = new MemoryClient();

  const tools = createMemoryTools();

  const server = new Server(
    { name: "my-memory-mcp", version: "0.1.0" },
    { capabilities: { tools: {} } },
  );

  // Tell Claude what tools we expose.
  server.setRequestHandler(ListToolsRequestSchema, async () => ({
    tools: tools.map((t) => ({
      name: t.name,
      description: t.description,
      inputSchema: t.inputSchema,
    })),
  }));

  // Route every tool call through `handleMemoryToolCall`, which dispatches
  // to the right MemoryClient method based on the tool name.
  server.setRequestHandler(CallToolRequestSchema, async (req) => {
    const result = await handleMemoryToolCall(
      memory,
      req.params.name,
      (req.params.arguments ?? {}) as Record<string, unknown>,
    );
    return {
      content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
    };
  });

  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("my-memory-mcp listening on stdio");
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});

MEMORY_API_KEY=nams_xxx npm start

{
  "mcpServers": {
    "neo4j-memory": {
      "command": "npx",
      "args": ["tsx", "/absolute/path/to/my-memory-mcp/src/server.ts"],
      "env": {
        "MEMORY_API_KEY": "nams_..."
      }
    }
  }
}

memory_create_conversation
memory_add_messages
memory_get_context
memory_search_messages
memory_search_entities
memory_get_entity
memory_add_entity
memory_get_entity_history
memory_record_step
memory_record_tool_call
memory_get_trace
memory_explain_decision

I'm Alice. I work at Acme Corp as a software engineer. I love writing Rust
and I'm allergic to peanuts.

Please remember this and confirm what you stored.

I've stored the following in your memory:

- **Entity**: Alice (person) — software engineer at Acme Corp
- **Entity**: Acme Corp (organization)
- **Preference** (programming): Loves writing Rust
- **Preference** (dietary): Allergic to peanuts

You can ask me to recall any of this in a future conversation.

What do you remember about me?

// In src/server.ts, replace the ListToolsRequestSchema handler with:

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    ...tools.map((t) => ({
      name: t.name,
      description: t.description,
      inputSchema: t.inputSchema,
    })),
    {
      name: "current_time",
      description: "Returns the current UTC time as an ISO 8601 string.",
      inputSchema: {
        type: "object",
        properties: {},
        required: [],
      },
    },
  ],
}));

// Update the CallToolRequestSchema handler:

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name === "current_time") {
    return {
      content: [{ type: "text", text: new Date().toISOString() }],
    };
  }
  const result = await handleMemoryToolCall(
    memory,
    req.params.name,
    (req.params.arguments ?? {}) as Record<string, unknown>,
  );
  return {
    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
  };
});

What's the current UTC time, and store it as a fact for me.