MCP server with in-memory tools: working versions (tested 2026-10-17)

{
  "name": "mcp-sdk-inmemory-tools",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "@modelcontextprotocol/sdk": "1.32.1",
    "zod": "4.6.7"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { z } from "zod";

export function createServer(): McpServer {
  const server = new McpServer({ name: "inmemory-tools", version: "1.0.0" });

  server.registerTool(
    "add",
    {
      title: "Add",
      description: "Add two numbers together",
      inputSchema: { a: z.number(), b: z.number() },
    },
    async ({ a, b }) => ({
      content: [{ type: "text", text: `${a + b}` }],
    }),
  );

  server.registerTool(
    "greet",
    {
      title: "Greet",
      description: "Greet a person by name",
      inputSchema: { name: z.string() },
    },
    async ({ name }) => ({
      content: [{ type: "text", text: `Hello, ${name}!` }],
    }),
  );

  server.registerResource(
    "greeting",
    "greeting://hello",
    {
      title: "Greeting",
      description: "A static greeting resource",
      mimeType: "text/plain",
    },
    async (uri) => ({
      contents: [{ uri: uri.href, text: "Hello from the resource" }],
    }),
  );

  return server;
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
import { createServer } from "../src/server.ts";

async function connect() {
  const server = createServer();
  const [clientTransport, serverTransport] =
    InMemoryTransport.createLinkedPair();
  const client = new Client({ name: "test-client", version: "1.0.0" });
  await server.connect(serverTransport);
  await client.connect(clientTransport);
  return { client, server };
}

test("lists the two registered tools", async () => {
  const { client, server } = await connect();
  const { tools } = await client.listTools();
  const names = tools.map((tool) => tool.name).sort();
  assert.deepEqual(names, ["add", "greet"]);
  await client.close();
  await server.close();
});

test("callTool returns text content", async () => {
  const { client, server } = await connect();
  const result = await client.callTool({
    name: "add",
    arguments: { a: 2, b: 3 },
  });
  assert.ok(!result.isError);
  const [first] = result.content as Array<{ type: string; text: string }>;
  assert.equal(first.type, "text");
  assert.equal(first.text, "5");
  await client.close();
  await server.close();
});

test("readResource returns the registered resource", async () => {
  const { client, server } = await connect();
  const result = await client.readResource({ uri: "greeting://hello" });
  const [first] = result.contents as Array<{ uri: string; text?: string }>;
  assert.equal(first.uri, "greeting://hello");
  assert.equal(first.text, "Hello from the resource");
  await client.close();
  await server.close();
});

test("callTool reports an error result for invalid input", async () => {
  const { client, server } = await connect();
  const result = await client.callTool({
    name: "greet",
    arguments: { name: 123 },
  });
  assert.equal(result.isError, true);
  await client.close();
  await server.close();
});