How to add caching to an MCP server for performance

1// src/cache.ts
2export class MemoryCache<T> {
3  private store = new Map<string, { value: T; expiresAt: number }>();
4  private cleanupInterval: NodeJS.Timeout;
5
6  constructor(cleanupMs: number = 60_000) {
7    this.cleanupInterval = setInterval(() => this.cleanup(), cleanupMs);
8  }
9
10  get(key: string): T | undefined {
11    const entry = this.store.get(key);
12    if (!entry) return undefined;
13    if (Date.now() > entry.expiresAt) {
14      this.store.delete(key);
15      return undefined;
16    }
17    return entry.value;
18  }
19
20  set(key: string, value: T, ttlSeconds: number): void {
21    this.store.set(key, {
22      value,
23      expiresAt: Date.now() + ttlSeconds * 1000,
24    });
25  }
26
27  invalidate(key: string): boolean {
28    return this.store.delete(key);
29  }
30
31  invalidatePattern(pattern: RegExp): number {
32    let count = 0;
33    for (const key of this.store.keys()) {
34      if (pattern.test(key)) {
35        this.store.delete(key);
36        count++;
37      }
38    }
39    return count;
40  }
41
42  clear(): void {
43    this.store.clear();
44  }
45
46  private cleanup(): void {
47    const now = Date.now();
48    for (const [key, entry] of this.store) {
49      if (now > entry.expiresAt) this.store.delete(key);
50    }
51  }
52
53  destroy(): void {
54    clearInterval(this.cleanupInterval);
55    this.store.clear();
56  }
57}

1// src/cache-keys.ts
2export function cacheKey(toolName: string, params: Record<string, unknown>): string {
3  const sortedParams = Object.keys(params)
4    .sort()
5    .reduce((acc, key) => {
6      acc[key] = params[key];
7      return acc;
8    }, {} as Record<string, unknown>);
9  return `${toolName}:${JSON.stringify(sortedParams)}`;
10}
11
12// Usage: cacheKey("search_files", { pattern: "*.ts", directory: "src" })
13// Returns: 'search_files:{"directory":"src","pattern":"*.ts"}'

1// src/cached-tool.ts
2import { MemoryCache } from "./cache.js";
3import { cacheKey } from "./cache-keys.js";
4
5const cache = new MemoryCache<unknown>();
6
7interface CacheConfig {
8  ttlSeconds: number;
9  enabled: boolean;
10}
11
12const TOOL_CACHE_CONFIG: Record<string, CacheConfig> = {
13  list_files: { ttlSeconds: 30, enabled: true },
14  read_file: { ttlSeconds: 60, enabled: true },
15  search_files: { ttlSeconds: 120, enabled: true },
16  write_file: { ttlSeconds: 0, enabled: false },  // Never cache writes
17  get_stats: { ttlSeconds: 5, enabled: true },
18};
19
20export function withCache<TParams extends Record<string, unknown>>(
21  toolName: string,
22  handler: (params: TParams) => Promise<unknown>
23): (params: TParams) => Promise<unknown> {
24  return async (params: TParams) => {
25    const config = TOOL_CACHE_CONFIG[toolName];
26    if (!config?.enabled) return handler(params);
27
28    const key = cacheKey(toolName, params);
29    const cached = cache.get(key);
30    if (cached !== undefined) {
31      console.error(`[cache] HIT ${toolName}`);
32      return cached;
33    }
34
35    console.error(`[cache] MISS ${toolName}`);
36    const result = await handler(params);
37    cache.set(key, result, config.ttlSeconds);
38    return result;
39  };
40}
41
42export function invalidateToolCache(toolName: string): void {
43  cache.invalidatePattern(new RegExp(`^${toolName}:`));
44}

1// src/redis-cache.ts
2import Redis from "ioredis";
3
4export class RedisCache<T> {
5  private client: Redis;
6  private prefix: string;
7
8  constructor(redisUrl: string, prefix: string = "mcp:") {
9    this.client = new Redis(redisUrl);
10    this.prefix = prefix;
11  }
12
13  async get(key: string): Promise<T | undefined> {
14    const raw = await this.client.get(this.prefix + key);
15    if (!raw) return undefined;
16    return JSON.parse(raw) as T;
17  }
18
19  async set(key: string, value: T, ttlSeconds: number): Promise<void> {
20    await this.client.set(
21      this.prefix + key,
22      JSON.stringify(value),
23      "EX",
24      ttlSeconds
25    );
26  }
27
28  async invalidate(key: string): Promise<boolean> {
29    const result = await this.client.del(this.prefix + key);
30    return result > 0;
31  }
32
33  async invalidatePattern(pattern: string): Promise<number> {
34    const keys = await this.client.keys(this.prefix + pattern);
35    if (keys.length === 0) return 0;
36    return this.client.del(...keys);
37  }
38
39  async disconnect(): Promise<void> {
40    await this.client.quit();
41  }
42}

1// In your write_file tool handler:
2server.tool(
3  "write_file",
4  "Write content to a file",
5  { filePath: z.string(), content: z.string() },
6  async ({ filePath, content }) => {
7    const p = safePath(ctx.basePath, filePath);
8    if (!p) return errorResult("Path traversal not allowed");
9
10    await fs.writeFile(p, content, "utf-8");
11
12    // Invalidate caches for affected paths
13    const dir = path.dirname(filePath);
14    invalidateToolCache("read_file");   // Clear all read_file cache
15    invalidateToolCache("list_files");  // Clear all list_files cache
16    invalidateToolCache("search_files"); // Search results may have changed
17
18    console.error(`[cache] Invalidated caches after writing ${filePath}`);
19    return textResult(`Wrote ${content.length} bytes to ${filePath}`);
20  }
21);