🧬 refactor: Optimize MCP Tool Queries with Server-Centric Architecture

🧬 refactor: Optimize MCP Tool Queries with Server-Centric Architecture

refactor: optimize mcp tool queries by removing redundancy, making server-centric structure, enabling query only when expected, minimize looping/transforming query data, eliminating unused/compute-heavy methods

ci: MCP Server Tools Mocking in Agent Tests

packages/api/src/mcp/MCPManager.ts

@@ -13,7 +13,6 @@ import { ConnectionsRepository } from '~/mcp/ConnectionsRepository';
 import { formatToolContent } from './parsers';
 import { MCPConnection } from './connection';
 import { processMCPEnv } from '~/utils/env';
-import { CONSTANTS } from './enum';
 
 /**
  * Centralized manager for MCP server connections and tool execution.
@@ -78,6 +77,28 @@ export class MCPManager extends UserConnectionManager {
 
     return allToolFunctions;
   }
+  /** Returns all available tool functions from all connections available to user */
+  public async getServerToolFunctions(
+    userId: string,
+    serverName: string,
+  ): Promise<t.LCAvailableTools | null> {
+    if (this.appConnections?.has(serverName)) {
+      return this.serversRegistry.getToolFunctions(
+        serverName,
+        await this.appConnections.get(serverName),
+      );
+    }
+
+    const userConnections = this.getUserConnections(userId);
+    if (!userConnections || userConnections.size === 0) {
+      return null;
+    }
+    if (!userConnections.has(serverName)) {
+      return null;
+    }
+
+    return this.serversRegistry.getToolFunctions(serverName, userConnections.get(serverName)!);
+  }
 
   /**
    * Get instructions for MCP servers
@@ -121,72 +142,6 @@ ${formattedInstructions}
 Please follow these instructions when using tools from the respective MCP servers.`;
   }
 
-  private async loadAppManifestTools(): Promise<t.LCManifestTool[]> {
-    const connections = await this.appConnections!.getAll();
-    return await this.loadManifestTools(connections);
-  }
-
-  private async loadUserManifestTools(userId: string): Promise<t.LCManifestTool[]> {
-    const connections = this.getUserConnections(userId);
-    return await this.loadManifestTools(connections);
-  }
-
-  public async loadAllManifestTools(userId: string): Promise<t.LCManifestTool[]> {
-    const appTools = await this.loadAppManifestTools();
-    const userTools = await this.loadUserManifestTools(userId);
-    return [...appTools, ...userTools];
-  }
-
-  /** Loads tools from all app-level connections into the manifest. */
-  private async loadManifestTools(
-    connections?: Map<string, MCPConnection> | null,
-  ): Promise<t.LCToolManifest> {
-    const mcpTools: t.LCManifestTool[] = [];
-    if (!connections || connections.size === 0) {
-      return mcpTools;
-    }
-    for (const [serverName, connection] of connections.entries()) {
-      try {
-        if (!(await connection.isConnected())) {
-          logger.warn(
-            `[MCP][${serverName}] Connection not available for ${serverName} manifest tools.`,
-          );
-          continue;
-        }
-
-        const tools = await connection.fetchTools();
-        const serverTools: t.LCManifestTool[] = [];
-        for (const tool of tools) {
-          const pluginKey = `${tool.name}${CONSTANTS.mcp_delimiter}${serverName}`;
-
-          const config = this.serversRegistry.parsedConfigs[serverName];
-          const manifestTool: t.LCManifestTool = {
-            name: tool.name,
-            pluginKey,
-            description: tool.description ?? '',
-            icon: connection.iconPath,
-            authConfig: config?.customUserVars
-              ? Object.entries(config.customUserVars).map(([key, value]) => ({
-                  authField: key,
-                  label: value.title || key,
-                  description: value.description || '',
-                }))
-              : undefined,
-          };
-          if (config?.chatMenu === false) {
-            manifestTool.chatMenu = false;
-          }
-          mcpTools.push(manifestTool);
-          serverTools.push(manifestTool);
-        }
-      } catch (error) {
-        logger.error(`[MCP][${serverName}] Error fetching tools for manifest:`, error);
-      }
-    }
-
-    return mcpTools;
-  }
-
   /**
    * Calls a tool on an MCP server, using either a user-specific connection
    * (if userId is provided) or an app-level connection. Updates the last activity timestamp

packages/api/src/mcp/MCPServersRegistry.ts

@@ -2,6 +2,7 @@ import pick from 'lodash/pick';
 import pickBy from 'lodash/pickBy';
 import mapValues from 'lodash/mapValues';
 import { logger } from '@librechat/data-schemas';
+import { Constants } from 'librechat-data-provider';
 import type { MCPConnection } from '~/mcp/connection';
 import type { JsonSchemaType } from '~/types';
 import type * as t from '~/mcp/types';
@@ -9,7 +10,6 @@ import { ConnectionsRepository } from '~/mcp/ConnectionsRepository';
 import { detectOAuthRequirement } from '~/mcp/oauth';
 import { sanitizeUrlForLogging } from '~/mcp/utils';
 import { processMCPEnv, isEnabled } from '~/utils';
-import { CONSTANTS } from '~/mcp/enum';
 
 /**
  * Manages MCP server configurations and metadata discovery.
@@ -127,7 +127,7 @@ export class MCPServersRegistry {
 
     const toolFunctions: t.LCAvailableTools = {};
     tools.forEach((tool) => {
-      const name = `${tool.name}${CONSTANTS.mcp_delimiter}${serverName}`;
+      const name = `${tool.name}${Constants.mcp_delimiter}${serverName}`;
       toolFunctions[name] = {
         type: 'function',
         ['function']: {

packages/api/src/mcp/enum.ts

@@ -1,5 +1,4 @@
 export enum CONSTANTS {
-  mcp_delimiter = '_mcp_',
   /** System user ID for app-level OAuth tokens (all zeros ObjectId) */
   SYSTEM_USER_ID = '000000000000000000000000',
 }