Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🛠️ refactor: Consolidate MCP Tool Caching (#9172)
Danny Avilada4aa3749302
diff --git a/api/cache/getLogStores.js b/api/cache/getLogStores.jsindex 675e16a76a..dfb2017448 100644--- a/api/cache/getLogStores.js+++ b/api/cache/getLogStores.js@@ -31,7 +31,6 @@ const namespaces = {[CacheKeys.SAML_SESSION]: sessionCache(CacheKeys.SAML_SESSION),[CacheKeys.ROLES]: standardCache(CacheKeys.ROLES),- [CacheKeys.MCP_TOOLS]: standardCache(CacheKeys.MCP_TOOLS),[CacheKeys.CONFIG_STORE]: standardCache(CacheKeys.CONFIG_STORE),[CacheKeys.STATIC_CONFIG]: standardCache(CacheKeys.STATIC_CONFIG),[CacheKeys.PENDING_REQ]: standardCache(CacheKeys.PENDING_REQ),diff --git a/api/server/controllers/PluginController.js b/api/server/controllers/PluginController.jsindex 06b4585a03..0329834ad9 100644--- a/api/server/controllers/PluginController.js+++ b/api/server/controllers/PluginController.js@@ -6,9 +6,15 @@ const {filterUniquePlugins,convertMCPToolsToPlugins,} = require('@librechat/api');-const { getCustomConfig, getCachedTools } = require('~/server/services/Config');+const {+ getCachedTools,+ setCachedTools,+ mergeUserTools,+ getCustomConfig,+} = require('~/server/services/Config');+const { loadAndFormatTools } = require('~/server/services/ToolService');const { availableTools, toolkits } = require('~/app/clients/tools');-const { getMCPManager, getFlowStateManager } = require('~/config');+const { getMCPManager } = require('~/config');const { getLogStores } = require('~/cache');const getAvailablePluginsController = async (req, res) => {@@ -22,6 +28,7 @@ const getAvailablePluginsController = async (req, res) => {/** @type {{ filteredTools: string[], includedTools: string[] }} */const { filteredTools = [], includedTools = [] } = req.app.locals;+ /** @type {import('@librechat/api').LCManifestTool[]} */const pluginManifest = availableTools;const uniquePlugins = filterUniquePlugins(pluginManifest);@@ -47,45 +54,6 @@ const getAvailablePluginsController = async (req, res) => {}};-function createServerToolsCallback() {- /**- * @param {string} serverName- * @param {TPlugin[] | null} serverTools- */- return async function (serverName, serverTools) {- try {- const mcpToolsCache = getLogStores(CacheKeys.MCP_TOOLS);- if (!serverName || !mcpToolsCache) {- return;- }- await mcpToolsCache.set(serverName, serverTools);- logger.debug(`MCP tools for ${serverName} added to cache.`);- } catch (error) {- logger.error('Error retrieving MCP tools from cache:', error);- }- };-}--function createGetServerTools() {- /**- * Retrieves cached server tools- * @param {string} serverName- * @returns {Promise<TPlugin[] | null>}- */- return async function (serverName) {- try {- const mcpToolsCache = getLogStores(CacheKeys.MCP_TOOLS);- if (!mcpToolsCache) {- return null;- }- return await mcpToolsCache.get(serverName);- } catch (error) {- logger.error('Error retrieving MCP tools from cache:', error);- return null;- }- };-}-/*** Retrieves and returns a list of available tools, either from a cache or by reading a plugin manifest file.*@@ -101,11 +69,18 @@ function createGetServerTools() {const getAvailableTools = async (req, res) => {try {const userId = req.user?.id;+ if (!userId) {+ logger.warn('[getAvailableTools] User ID not found in request');+ return res.status(401).json({ message: 'Unauthorized' });+ }const customConfig = await getCustomConfig();const cache = getLogStores(CacheKeys.CONFIG_STORE);const cachedToolsArray = await cache.get(CacheKeys.TOOLS);const cachedUserTools = await getCachedTools({ userId });- const userPlugins = convertMCPToolsToPlugins({ functionTools: cachedUserTools, customConfig });+ const userPlugins =+ cachedUserTools != null+ ? convertMCPToolsToPlugins({ functionTools: cachedUserTools, customConfig })+ : undefined;if (cachedToolsArray != null && userPlugins != null) {const dedupedTools = filterUniquePlugins([...userPlugins, ...cachedToolsArray]);@@ -113,31 +88,47 @@ const getAvailableTools = async (req, res) => {return;}+ /** @type {Record<string, FunctionTool> | null} Get tool definitions to filter which tools are actually available */+ let toolDefinitions = await getCachedTools({ includeGlobal: true });+ let prelimCachedTools;++ // TODO: this is a temp fix until app config is refactored+ if (!toolDefinitions) {+ toolDefinitions = loadAndFormatTools({+ adminFilter: req.app.locals?.filteredTools,+ adminIncluded: req.app.locals?.includedTools,+ directory: req.app.locals?.paths.structuredTools,+ });+ prelimCachedTools = toolDefinitions;+ }++ /** @type {import('@librechat/api').LCManifestTool[]} */let pluginManifest = availableTools;if (customConfig?.mcpServers != null) {try {const mcpManager = getMCPManager();- const flowsCache = getLogStores(CacheKeys.FLOWS);- const flowManager = flowsCache ? getFlowStateManager(flowsCache) : null;- const serverToolsCallback = createServerToolsCallback();- const getServerTools = createGetServerTools();- const mcpTools = await mcpManager.loadManifestTools({- flowManager,- serverToolsCallback,- getServerTools,- });- pluginManifest = [...mcpTools, ...pluginManifest];+ const mcpTools = await mcpManager.loadAllManifestTools(userId);+ const mcpToolsRecord = mcpTools.reduce((acc, tool) => {+ pluginManifest.push(tool);+ acc[tool.pluginKey] = tool;+ if (!toolDefinitions[tool.pluginKey]) {+ toolDefinitions[tool.pluginKey] = tool;+ }+ return acc;+ }, prelimCachedTools ?? {});+ await mergeUserTools({ userId, cachedUserTools, userTools: mcpToolsRecord });} catch (error) {logger.error('[getAvailableTools] Error loading MCP Tools, servers may still be initializing:',error,);}+ } else if (prelimCachedTools != null) {+ await setCachedTools(prelimCachedTools, { isGlobal: true });}- /** @type {TPlugin[]} */+ /** @type {TPlugin[]} Deduplicate and authenticate plugins */const uniquePlugins = filterUniquePlugins(pluginManifest);-const authenticatedPlugins = uniquePlugins.map((plugin) => {if (checkPluginAuth(plugin)) {return { ...plugin, authenticated: true };@@ -146,8 +137,7 @@ const getAvailableTools = async (req, res) => {}});- const toolDefinitions = (await getCachedTools({ includeGlobal: true })) || {};-+ /** Filter plugins based on availability and add MCP-specific auth config */const toolsOutput = [];for (const plugin of authenticatedPlugins) {const isToolDefined = toolDefinitions[plugin.pluginKey] !== undefined;@@ -163,41 +153,36 @@ const getAvailableTools = async (req, res) => {const toolToAdd = { ...plugin };- if (!plugin.pluginKey.includes(Constants.mcp_delimiter)) {- toolsOutput.push(toolToAdd);- continue;- }-- const parts = plugin.pluginKey.split(Constants.mcp_delimiter);- const serverName = parts[parts.length - 1];- const serverConfig = customConfig?.mcpServers?.[serverName];-- if (!serverConfig?.customUserVars) {- toolsOutput.push(toolToAdd);- continue;- }-- const customVarKeys = Object.keys(serverConfig.customUserVars);-- if (customVarKeys.length === 0) {- toolToAdd.authConfig = [];- toolToAdd.authenticated = true;- } else {- toolToAdd.authConfig = Object.entries(serverConfig.customUserVars).map(([key, value]) => ({- authField: key,- label: value.title || key,- description: value.description || '',- }));- toolToAdd.authenticated = false;+ if (plugin.pluginKey.includes(Constants.mcp_delimiter)) {+ const parts = plugin.pluginKey.split(Constants.mcp_delimiter);+ const serverName = parts[parts.length - 1];+ const serverConfig = customConfig?.mcpServers?.[serverName];++ if (serverConfig?.customUserVars) {+ const customVarKeys = Object.keys(serverConfig.customUserVars);+ if (customVarKeys.length === 0) {+ toolToAdd.authConfig = [];+ toolToAdd.authenticated = true;+ } else {+ toolToAdd.authConfig = Object.entries(serverConfig.customUserVars).map(+ ([key, value]) => ({+ authField: key,+ label: value.title || key,+ description: value.description || '',+ }),+ );+ toolToAdd.authenticated = false;+ }+ }}toolsOutput.push(toolToAdd);}+const finalTools = filterUniquePlugins(toolsOutput);await cache.set(CacheKeys.TOOLS, finalTools);- const dedupedTools = filterUniquePlugins([...userPlugins, ...finalTools]);-+ const dedupedTools = filterUniquePlugins([...(userPlugins ?? []), ...finalTools]);res.status(200).json(dedupedTools);} catch (error) {logger.error('[getAvailableTools]', error);diff --git a/api/server/controllers/PluginController.spec.js b/api/server/controllers/PluginController.spec.jsindex 89dfd72e4b..07dd02b1d7 100644--- a/api/server/controllers/PluginController.spec.js+++ b/api/server/controllers/PluginController.spec.js@@ -13,15 +13,18 @@ jest.mock('@librechat/data-schemas', () => ({jest.mock('~/server/services/Config', () => ({getCustomConfig: jest.fn(),getCachedTools: jest.fn(),+ setCachedTools: jest.fn(),+ mergeUserTools: jest.fn(),}));jest.mock('~/server/services/ToolService', () => ({getToolkitKey: jest.fn(),+ loadAndFormatTools: jest.fn(),}));jest.mock('~/config', () => ({getMCPManager: jest.fn(() => ({- loadManifestTools: jest.fn().mockResolvedValue([]),+ loadAllManifestTools: jest.fn().mockResolvedValue([]),})),getFlowStateManager: jest.fn(),}));@@ -50,6 +53,7 @@ const {convertMCPToolsToPlugins,getToolkitKey,} = require('@librechat/api');+const { loadAndFormatTools } = require('~/server/services/ToolService');describe('PluginController', () => {let mockReq, mockRes, mockCache;@@ -310,7 +314,7 @@ describe('PluginController', () => {// Mock the MCP manager to return toolsconst mockMCPManager = {- loadManifestTools: jest.fn().mockResolvedValue(mcpManagerTools),+ loadAllManifestTools: jest.fn().mockResolvedValue(mcpManagerTools),};require('~/config').getMCPManager.mockReturnValue(mockMCPManager);@@ -379,10 +383,8 @@ describe('PluginController', () => {await getAvailableTools(mockReq, mockRes);- expect(convertMCPToolsToPlugins).toHaveBeenCalledWith({- functionTools: null,- customConfig: null,- });+ // When cachedUserTools is null, convertMCPToolsToPlugins is not called+ expect(convertMCPToolsToPlugins).not.toHaveBeenCalled();});it('should handle when getCachedTools returns undefined', async () => {@@ -399,10 +401,8 @@ describe('PluginController', () => {await getAvailableTools(mockReq, mockRes);- expect(convertMCPToolsToPlugins).toHaveBeenCalledWith({- functionTools: undefined,- customConfig: null,- });+ // When cachedUserTools is undefined, convertMCPToolsToPlugins is not called+ expect(convertMCPToolsToPlugins).not.toHaveBeenCalled();});it('should handle cachedToolsArray and userPlugins both being defined', async () => {@@ -500,6 +500,15 @@ describe('PluginController', () => {toolkit: true,};+ // Ensure req.app.locals is properly mocked+ mockReq.app = {+ locals: {+ filteredTools: [],+ includedTools: [],+ paths: { structuredTools: '/mock/path' },+ },+ };+mockCache.get.mockResolvedValue(null);getCachedTools.mockResolvedValue({});convertMCPToolsToPlugins.mockReturnValue([]);@@ -508,6 +517,9 @@ describe('PluginController', () => {getToolkitKey.mockReturnValue(undefined);getCustomConfig.mockResolvedValue(null);+ // Mock loadAndFormatTools to return an empty object when toolDefinitions is null+ loadAndFormatTools.mockReturnValue({});+// Mock getCachedTools second call to return nullgetCachedTools.mockResolvedValueOnce({}).mockResolvedValueOnce(null);diff --git a/api/server/routes/__tests__/mcp.spec.js b/api/server/routes/__tests__/mcp.spec.jsindex 243711d764..25d17c51de 100644--- a/api/server/routes/__tests__/mcp.spec.js+++ b/api/server/routes/__tests__/mcp.spec.js@@ -1,9 +1,10 @@-const { MongoMemoryServer } = require('mongodb-memory-server');+const express = require('express');const request = require('supertest');const mongoose = require('mongoose');-const express = require('express');+const { MongoMemoryServer } = require('mongodb-memory-server');jest.mock('@librechat/api', () => ({+ ...jest.requireActual('@librechat/api'),MCPOAuthHandler: {initiateOAuthFlow: jest.fn(),getFlowState: jest.fn(),@@ -44,6 +45,10 @@ jest.mock('~/server/services/Config', () => ({loadCustomConfig: jest.fn(),}));+jest.mock('~/server/services/Config/mcpToolsCache', () => ({+ updateMCPUserTools: jest.fn(),+}));+jest.mock('~/server/services/MCP', () => ({getMCPSetupData: jest.fn(),getServerConnectionStatus: jest.fn(),@@ -759,8 +764,10 @@ describe('MCP Routes', () => {require('~/cache').getLogStores.mockReturnValue({});const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');getCachedTools.mockResolvedValue({});setCachedTools.mockResolvedValue();+ updateMCPUserTools.mockResolvedValue();const response = await request(app).post('/api/mcp/test-server/reinitialize');@@ -776,7 +783,14 @@ describe('MCP Routes', () => {'test-user-id','test-server',);- expect(setCachedTools).toHaveBeenCalled();+ expect(updateMCPUserTools).toHaveBeenCalledWith({+ userId: 'test-user-id',+ serverName: 'test-server',+ tools: [+ { name: 'tool1', description: 'Test tool 1', inputSchema: { type: 'object' } },+ { name: 'tool2', description: 'Test tool 2', inputSchema: { type: 'object' } },+ ],+ });});it('should handle server with custom user variables', async () => {@@ -803,8 +817,10 @@ describe('MCP Routes', () => {);const { getCachedTools, setCachedTools } = require('~/server/services/Config');+ const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');getCachedTools.mockResolvedValue({});setCachedTools.mockResolvedValue();+ updateMCPUserTools.mockResolvedValue();const response = await request(app).post('/api/mcp/test-server/reinitialize');diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.jsindex 5931ca02f6..0a068cd8fd 100644--- a/api/server/routes/mcp.js+++ b/api/server/routes/mcp.js@@ -3,7 +3,7 @@ const { MCPOAuthHandler } = require('@librechat/api');const { Router } = require('express');const { getMCPSetupData, getServerConnectionStatus } = require('~/server/services/MCP');const { findToken, updateToken, createToken, deleteTokens } = require('~/models');-const { setCachedTools, getCachedTools } = require('~/server/services/Config');+const { updateMCPUserTools } = require('~/server/services/Config/mcpToolsCache');const { getUserPluginAuthValue } = require('~/server/services/PluginService');const { CacheKeys, Constants } = require('librechat-data-provider');const { getMCPManager, getFlowStateManager } = require('~/config');@@ -142,33 +142,12 @@ router.get('/:serverName/oauth/callback', async (req, res) => {`[MCP OAuth] Successfully reconnected ${serverName} for user ${flowState.userId}`,);- const userTools = (await getCachedTools({ userId: flowState.userId })) || {};-- const mcpDelimiter = Constants.mcp_delimiter;- for (const key of Object.keys(userTools)) {- if (key.endsWith(`${mcpDelimiter}${serverName}`)) {- delete userTools[key];- }- }-const tools = await userConnection.fetchTools();- for (const tool of tools) {- const name = `${tool.name}${Constants.mcp_delimiter}${serverName}`;- userTools[name] = {- type: 'function',- ['function']: {- name,- description: tool.description,- parameters: tool.inputSchema,- },- };- }-- await setCachedTools(userTools, { userId: flowState.userId });-- logger.debug(- `[MCP OAuth] Cached ${tools.length} tools for ${serverName} user ${flowState.userId}`,- );+ await updateMCPUserTools({+ userId: flowState.userId,+ serverName,+ tools,+ });} else {logger.debug(`[MCP OAuth] System-level OAuth completed for ${serverName}`);}@@ -396,29 +375,12 @@ router.post('/:serverName/reinitialize', requireJwtAuth, async (req, res) => {}if (userConnection && !oauthRequired) {- const userTools = (await getCachedTools({ userId: user.id })) || {};-- const mcpDelimiter = Constants.mcp_delimiter;- for (const key of Object.keys(userTools)) {- if (key.endsWith(`${mcpDelimiter}${serverName}`)) {- delete userTools[key];- }- }-const tools = await userConnection.fetchTools();- for (const tool of tools) {- const name = `${tool.name}${Constants.mcp_delimiter}${serverName}`;- userTools[name] = {- type: 'function',- ['function']: {- name,- description: tool.description,- parameters: tool.inputSchema,- },- };- }-- await setCachedTools(userTools, { userId: user.id });+ await updateMCPUserTools({+ userId: user.id,+ serverName,+ tools,+ });}logger.debug(diff --git a/api/server/services/Config/index.js b/api/server/services/Config/index.jsindex ad25e57998..aafb2dcb4f 100644--- a/api/server/services/Config/index.js+++ b/api/server/services/Config/index.js@@ -1,6 +1,7 @@const { config } = require('./EndpointService');const getCachedTools = require('./getCachedTools');const getCustomConfig = require('./getCustomConfig');+const mcpToolsCache = require('./mcpToolsCache');const loadCustomConfig = require('./loadCustomConfig');const loadConfigModels = require('./loadConfigModels');const loadDefaultModels = require('./loadDefaultModels');@@ -17,5 +18,6 @@ module.exports = {loadAsyncEndpoints,...getCachedTools,...getCustomConfig,+ ...mcpToolsCache,...getEndpointsConfig,};diff --git a/api/server/services/Config/mcpToolsCache.js b/api/server/services/Config/mcpToolsCache.jsnew file mode 100644index 0000000000..bd21807cd5--- /dev/null+++ b/api/server/services/Config/mcpToolsCache.js@@ -0,0 +1,142 @@+const { logger } = require('@librechat/data-schemas');+const { CacheKeys, Constants } = require('librechat-data-provider');+const { getCachedTools, setCachedTools } = require('./getCachedTools');+const { getLogStores } = require('~/cache');++/**+ * Updates MCP tools in the cache for a specific server and user+ * @param {Object} params - Parameters for updating MCP tools+ * @param {string} params.userId - User ID+ * @param {string} params.serverName - MCP server name+ * @param {Array} params.tools - Array of tool objects from MCP server+ * @returns {Promise<void>}+ */+async function updateMCPUserTools({ userId, serverName, tools }) {+ try {+ const userTools = await getCachedTools({ userId });++ const mcpDelimiter = Constants.mcp_delimiter;+ for (const key of Object.keys(userTools)) {+ if (key.endsWith(`${mcpDelimiter}${serverName}`)) {+ delete userTools[key];+ }+ }++ for (const tool of tools) {+ const name = `${tool.name}${Constants.mcp_delimiter}${serverName}`;+ userTools[name] = {+ type: 'function',+ ['function']: {+ name,+ description: tool.description,+ parameters: tool.inputSchema,+ },+ };+ }++ await setCachedTools(userTools, { userId });++ const cache = getLogStores(CacheKeys.CONFIG_STORE);+ await cache.delete(CacheKeys.TOOLS);+ logger.debug(`[MCP Cache] Updated ${tools.length} tools for ${serverName} user ${userId}`);+ } catch (error) {+ logger.error(`[MCP Cache] Failed to update tools for ${serverName}:`, error);+ throw error;+ }+}++/**+ * Merges app-level tools with global tools+ * @param {import('@librechat/api').LCAvailableTools} appTools+ * @returns {Promise<void>}+ */+async function mergeAppTools(appTools) {+ try {+ const count = Object.keys(appTools).length;+ if (!count) {+ return;+ }+ const cachedTools = await getCachedTools({ includeGlobal: true });+ const mergedTools = { ...cachedTools, ...appTools };+ await setCachedTools(mergedTools, { isGlobal: true });+ const cache = getLogStores(CacheKeys.CONFIG_STORE);+ await cache.delete(CacheKeys.TOOLS);+ logger.debug(`Merged ${count} app-level tools`);+ } catch (error) {+ logger.error('Failed to merge app-level tools:', error);+ throw error;+ }+}++/**+ * Merges user-level tools with global tools+ * @param {object} params+ * @param {string} params.userId+ * @param {Record<string, FunctionTool>} params.cachedUserTools+ * @param {import('@librechat/api').LCAvailableTools} params.userTools+ * @returns {Promise<void>}+ */+async function mergeUserTools({ userId, cachedUserTools, userTools }) {+ try {+ if (!userId) {+ return;+ }+ const count = Object.keys(userTools).length;+ if (!count) {+ return;+ }+ const cachedTools = cachedUserTools ?? (await getCachedTools({ userId }));+ const mergedTools = { ...cachedTools, ...userTools };+ await setCachedTools(mergedTools, { userId });+ const cache = getLogStores(CacheKeys.CONFIG_STORE);+ await cache.delete(CacheKeys.TOOLS);+ logger.debug(`Merged ${count} user-level tools`);+ } catch (error) {+ logger.error('Failed to merge user-level tools:', error);+ throw error;+ }+}++/**+ * Clears all MCP tools for a specific server+ * @param {Object} params - Parameters for clearing MCP tools+ * @param {string} [params.userId] - User ID (if clearing user-specific tools)+ * @param {string} params.serverName - MCP server name+ * @returns {Promise<void>}+ */+async function clearMCPServerTools({ userId, serverName }) {+ try {+ const tools = await getCachedTools({ userId, includeGlobal: !userId });++ // Remove all tools for this server+ const mcpDelimiter = Constants.mcp_delimiter;+ let removedCount = 0;+ for (const key of Object.keys(tools)) {+ if (key.endsWith(`${mcpDelimiter}${serverName}`)) {+ delete tools[key];+ removedCount++;+ }+ }++ if (removedCount > 0) {+ await setCachedTools(tools, userId ? { userId } : { isGlobal: true });++ const cache = getLogStores(CacheKeys.CONFIG_STORE);+ await cache.delete(CacheKeys.TOOLS);++ logger.debug(+ `[MCP Cache] Removed ${removedCount} tools for ${serverName}${userId ? ` user ${userId}` : ' (global)'}`,+ );+ }+ } catch (error) {+ logger.error(`[MCP Cache] Failed to clear tools for ${serverName}:`, error);+ throw error;+ }+}++module.exports = {+ mergeAppTools,+ mergeUserTools,+ updateMCPUserTools,+ clearMCPServerTools,+};diff --git a/api/server/services/initializeMCPs.js b/api/server/services/initializeMCPs.jsindex 0ca402766b..6963733846 100644--- a/api/server/services/initializeMCPs.js+++ b/api/server/services/initializeMCPs.js@@ -1,8 +1,6 @@const { logger } = require('@librechat/data-schemas');-const { getCachedTools, setCachedTools } = require('./Config');-const { CacheKeys } = require('librechat-data-provider');const { createMCPManager } = require('~/config');-const { getLogStores } = require('~/cache');+const { mergeAppTools } = require('./Config');/*** Initialize MCP servers@@ -18,21 +16,12 @@ async function initializeMCPs(app) {try {delete app.locals.mcpConfig;- const cachedTools = await getCachedTools();+ const mcpTools = mcpManager.getAppToolFunctions() || {};+ await mergeAppTools(mcpTools);- if (!cachedTools) {- logger.warn('No available tools found in cache during MCP initialization');- return;- }-- const mcpTools = mcpManager.getAppToolFunctions() ?? {};- await setCachedTools({ ...cachedTools, ...mcpTools }, { isGlobal: true });-- const cache = getLogStores(CacheKeys.CONFIG_STORE);- await cache.delete(CacheKeys.TOOLS);- logger.debug('Cleared tools array cache after MCP initialization');-- logger.info('MCP servers initialized successfully');+ logger.info(+ `MCP servers initialized successfully. Added ${Object.keys(mcpTools).length} MCP tools.`,+ );} catch (error) {logger.error('Failed to initialize MCP servers:', error);}diff --git a/packages/api/src/mcp/MCPManager.ts b/packages/api/src/mcp/MCPManager.tsindex 41b4f1a0fb..b561e71fd9 100644--- a/packages/api/src/mcp/MCPManager.ts+++ b/packages/api/src/mcp/MCPManager.ts@@ -101,34 +101,36 @@ ${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. */- public async loadManifestTools({- serverToolsCallback,- getServerTools,- }: {- flowManager: FlowStateManager<MCPOAuthTokens | null>;- serverToolsCallback?: (serverName: string, tools: t.LCManifestTool[]) => Promise<void>;- getServerTools?: (serverName: string) => Promise<t.LCManifestTool[] | undefined>;- }): Promise<t.LCToolManifest> {+ private async loadManifestTools(+ connections?: Map<string, MCPConnection> | null,+ ): Promise<t.LCToolManifest> {const mcpTools: t.LCManifestTool[] = [];- const connections = await this.appConnections!.getAll();+ 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.`,);- if (typeof getServerTools !== 'function') {- logger.warn(- `[MCP][${serverName}] No \`getServerTools\` function provided, skipping tool loading.`,- );- continue;- }- const serverTools = await getServerTools(serverName);- if (serverTools && serverTools.length > 0) {- logger.info(`[MCP][${serverName}] Loaded tools from cache for manifest`);- mcpTools.push(...serverTools);- }continue;}@@ -157,9 +159,6 @@ Please follow these instructions when using tools from the respective MCP servermcpTools.push(manifestTool);serverTools.push(manifestTool);}- if (typeof serverToolsCallback === 'function') {- await serverToolsCallback(serverName, serverTools);- }} catch (error) {logger.error(`[MCP][${serverName}] Error fetching tools for manifest:`, error);}diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex bb333d736a..0be8ce3ffe 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -1242,10 +1242,6 @@ export enum CacheKeys {* Key for in-progress flow states.*/FLOWS = 'FLOWS',- /**- * Key for individual MCP Tool Manifests.- */- MCP_TOOLS = 'MCP_TOOLS',/*** Key for pending chat requests (concurrency check)*/