fix OOM for notion-toolathlon. (#1332)

Author: xiangkaiz

mcp_servers/notion_toolathlon/scripts/start-server.ts

@@ -5,7 +5,7 @@ import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/
 import { randomBytes } from 'node:crypto'
 import express from 'express'
 
-import { initProxy, ValidationError } from '../src/init-server.js'
+import { initProxy, preloadSpec, ValidationError } from '../src/init-server.js'
 
 /**
  * Extract Notion token from request header.
@@ -134,6 +134,10 @@ Examples:
     await proxy.connect(new StdioServerTransport())
     return proxy.getServer()
   } else if (transport === 'http') {
+    // Pre-load and pre-compute the OpenAPI spec and tools once at startup
+    // to avoid re-parsing on every request (major memory optimization)
+    await preloadSpec(specPath, baseUrl)
+
     // Use Streamable HTTP transport
     const app = express()
     app.use(express.json())

mcp_servers/notion_toolathlon/src/init-server.ts

@@ -4,7 +4,7 @@ import path from 'node:path'
 import { OpenAPIV3 } from 'openapi-types'
 import OpenAPISchemaValidator from 'openapi-schema-validator'
 
-import { MCPProxy } from './openapi-mcp-server/mcp/proxy.js'
+import { MCPProxy, precomputeTools, type PrecomputedTools } from './openapi-mcp-server/mcp/proxy.js'
 
 export class ValidationError extends Error {
   constructor(public errors: any[]) {
@@ -42,9 +42,21 @@ async function loadOpenApiSpec(specPath: string, baseUrl: string | undefined): P
   }
 }
 
-export async function initProxy(specPath: string, baseUrl: string | undefined, options: { pageIds?: string[]; pageUrls?: string[]; notionToken?: string } = {}) {
-  const openApiSpec = await loadOpenApiSpec(specPath, baseUrl)
-  const proxy = new MCPProxy('Notion API', openApiSpec, options)
+let cachedSpec: OpenAPIV3.Document | null = null
+let cachedPrecomputed: PrecomputedTools | null = null
+
+/**
+ * Pre-load the OpenAPI spec and precompute tools once at startup.
+ * This avoids re-parsing and re-converting on every request.
+ */
+export async function preloadSpec(specPath: string, baseUrl: string | undefined): Promise<void> {
+  cachedSpec = await loadOpenApiSpec(specPath, baseUrl)
+  cachedPrecomputed = precomputeTools(cachedSpec)
+  console.log('OpenAPI spec and tools pre-computed successfully')
+}
 
+export async function initProxy(specPath: string, baseUrl: string | undefined, options: { pageIds?: string[]; pageUrls?: string[]; notionToken?: string } = {}) {
+  const openApiSpec = cachedSpec ?? await loadOpenApiSpec(specPath, baseUrl)
+  const proxy = new MCPProxy('Notion API', openApiSpec, options, cachedPrecomputed ?? undefined)
   return proxy
 }

mcp_servers/notion_toolathlon/src/openapi-mcp-server/client/http-client.ts

@@ -29,24 +29,44 @@ export class HttpClientError extends Error {
   }
 }
 
+/**
+ * Initialize the OpenAPI client from a spec. This is expensive (parses and
+ * validates the entire spec) so the result should be cached and reused.
+ */
+export function initApiClient(
+  baseUrl: string,
+  openApiSpec: OpenAPIV3.Document | OpenAPIV3_1.Document,
+): Promise<AxiosInstance> {
+  // @ts-expect-error
+  const client = new (OpenAPIClientAxios.default ?? OpenAPIClientAxios)({
+    definition: openApiSpec,
+    axiosConfigDefaults: {
+      baseURL: baseUrl,
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'notion-mcp-server',
+      },
+    },
+  })
+  return client.init()
+}
+
 export class HttpClient {
   private api: Promise<AxiosInstance>
-  private client: OpenAPIClientAxios
-
-  constructor(config: HttpClientConfig, openApiSpec: OpenAPIV3.Document | OpenAPIV3_1.Document) {
-    // @ts-expect-error
-    this.client = new (OpenAPIClientAxios.default ?? OpenAPIClientAxios)({
-      definition: openApiSpec,
-      axiosConfigDefaults: {
-        baseURL: config.baseUrl,
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'notion-mcp-server',
-          ...config.headers,
-        },
-      },
-    })
-    this.api = this.client.init()
+  private perRequestHeaders: Record<string, string>
+
+  /**
+   * Create an HttpClient. If a cachedApi is provided, reuses the already-initialized
+   * axios instance (avoids expensive re-parsing of the spec on every request).
+   */
+  constructor(config: HttpClientConfig, openApiSpec: OpenAPIV3.Document | OpenAPIV3_1.Document, cachedApi?: Promise<AxiosInstance>) {
+    this.perRequestHeaders = config.headers || {}
+
+    if (cachedApi) {
+      this.api = cachedApi
+    } else {
+      this.api = initApiClient(config.baseUrl, openApiSpec)
+    }
   }
 
   private async prepareFileUpload(operation: OpenAPIV3.OperationObject, params: Record<string, any>): Promise<FormData | null> {
@@ -152,12 +172,14 @@ export class HttpClient {
     try {
       // If we have form data, we need to set the correct headers
       const hasBody = Object.keys(bodyParams).length > 0
-      const headers = formData
+      const contentHeaders = formData
         ? formData.getHeaders()
         : { ...(hasBody ? { 'Content-Type': 'application/json' } : { 'Content-Type': null }) }
       const requestConfig = {
         headers: {
-          ...headers,
+          ...contentHeaders,
+          // Inject per-request auth headers (e.g. per-user Notion token)
+          ...this.perRequestHeaders,
         },
       }
 

mcp_servers/notion_toolathlon/src/openapi-mcp-server/mcp/proxy.ts

@@ -2,7 +2,8 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js'
 import { CallToolRequestSchema, JSONRPCResponse, ListToolsRequestSchema, Tool } from '@modelcontextprotocol/sdk/types.js'
 import { JSONSchema7 as IJsonSchema } from 'json-schema'
 import { OpenAPIToMCPConverter } from '../openapi/parser.js'
-import { HttpClient, HttpClientError } from '../client/http-client.js'
+import { HttpClient, HttpClientError, initApiClient } from '../client/http-client.js'
+import type { AxiosInstance } from 'axios'
 import { OpenAPIV3 } from 'openapi-types'
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js'
 import { PageAccessController } from '../auth/page-access-control.js'
@@ -30,6 +31,34 @@ export interface MCPProxyOptions {
   notionToken?: string
 }
 
+/**
+ * Pre-computed tools, lookup, and cached API client from OpenAPI spec.
+ * These are expensive to compute and should be done once at startup.
+ */
+export interface PrecomputedTools {
+  tools: Record<string, NewToolDefinition>
+  openApiLookup: Record<string, OpenAPIV3.OperationObject & { method: string; path: string }>
+  cachedApi: Promise<AxiosInstance>
+}
+
+/**
+ * Pre-compute tools and initialize the API client from an OpenAPI spec.
+ * Call once at startup to avoid expensive re-parsing on every request.
+ */
+export function precomputeTools(openApiSpec: OpenAPIV3.Document): PrecomputedTools {
+  const converter = new OpenAPIToMCPConverter(openApiSpec)
+  const { tools, openApiLookup } = converter.convertToMCPTools()
+
+  const baseUrl = openApiSpec.servers?.[0]?.url
+  if (!baseUrl) {
+    throw new Error('No base URL found in OpenAPI spec')
+  }
+
+  const cachedApi = initApiClient(baseUrl, openApiSpec)
+
+  return { tools, openApiLookup, cachedApi }
+}
+
 // import this class, extend and return server
 export class MCPProxy {
   private server: Server
@@ -38,7 +67,7 @@ export class MCPProxy {
   private openApiLookup: Record<string, OpenAPIV3.OperationObject & { method: string; path: string }>
   private pageAccessController: PageAccessController | null = null
 
-  constructor(name: string, openApiSpec: OpenAPIV3.Document, options: MCPProxyOptions = {}) {
+  constructor(name: string, openApiSpec: OpenAPIV3.Document, options: MCPProxyOptions = {}, precomputed?: PrecomputedTools) {
     this.server = new Server({ name, version: '1.0.0' }, { capabilities: { tools: {} } })
     const baseUrl = openApiSpec.servers?.[0].url
     if (!baseUrl) {
@@ -50,6 +79,7 @@ export class MCPProxy {
         headers: this.parseHeadersFromEnv(options.notionToken),
       },
       openApiSpec,
+      precomputed?.cachedApi,
     )
 
     // Initialize page access control if needed
@@ -61,11 +91,16 @@ export class MCPProxy {
       })
     }
 
-    // Convert OpenAPI spec to MCP tools
-    const converter = new OpenAPIToMCPConverter(openApiSpec)
-    const { tools, openApiLookup } = converter.convertToMCPTools()
-    this.tools = tools
-    this.openApiLookup = openApiLookup
+    // Use pre-computed tools if available, otherwise compute them
+    if (precomputed) {
+      this.tools = precomputed.tools
+      this.openApiLookup = precomputed.openApiLookup
+    } else {
+      const converter = new OpenAPIToMCPConverter(openApiSpec)
+      const { tools, openApiLookup } = converter.convertToMCPTools()
+      this.tools = tools
+      this.openApiLookup = openApiLookup
+    }
 
     this.setupHandlers()
   }

mcp_servers/notion_toolathlon/src/openapi-mcp-server/openapi/parser.ts

@@ -20,6 +20,7 @@ type FunctionParameters = {
 export class OpenAPIToMCPConverter {
   private schemaCache: Record<string, IJsonSchema> = {}
   private nameCounter: number = 0
+  private componentSchemaCache: Record<string, IJsonSchema> | null = null
 
   constructor(private openApiSpec: OpenAPIV3.Document | OpenAPIV3_1.Document) {}
 
@@ -250,11 +251,15 @@ export class OpenAPIToMCPConverter {
   }
 
   private convertComponentsToJsonSchema(): Record<string, IJsonSchema> {
+    if (this.componentSchemaCache) {
+      return this.componentSchemaCache
+    }
     const components = this.openApiSpec.components || {}
     const schema: Record<string, IJsonSchema> = {}
     for (const [key, value] of Object.entries(components.schemas || {})) {
       schema[key] = this.convertOpenApiSchemaToJsonSchema(value, new Set())
     }
+    this.componentSchemaCache = schema
     return schema
   }
   /**