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
✨ feat: Add MCP Reinitialization to MCPPanel (#8418)
Dustin Healyfaaba30af180
diff --git a/api/app/clients/tools/util/handleTools.js b/api/app/clients/tools/util/handleTools.jsindex 3b06580c08..fc04d0c58a 100644--- a/api/app/clients/tools/util/handleTools.js+++ b/api/app/clients/tools/util/handleTools.js@@ -230,7 +230,7 @@ const loadTools = async ({/** @type {Record<string, string>} */const toolContextMap = {};- const appTools = (await getCachedTools({ includeGlobal: true })) ?? {};+ const cachedTools = (await getCachedTools({ userId: user, includeGlobal: true })) ?? {};for (const tool of tools) {if (tool === Tools.execute_code) {@@ -298,7 +298,7 @@ Current Date & Time: ${replaceSpecialVars({ text: '{{iso_datetime}}' })}});};continue;- } else if (tool && appTools[tool] && mcpToolPattern.test(tool)) {+ } else if (tool && cachedTools && mcpToolPattern.test(tool)) {requestedTools[tool] = async () =>createMCPTool({req: options.req,diff --git a/api/models/Agent.js b/api/models/Agent.jsindex dcb646f039..7cb32e6cb4 100644--- a/api/models/Agent.js+++ b/api/models/Agent.js@@ -61,7 +61,7 @@ const getAgent = async (searchParameter) => await Agent.findOne(searchParameter)const loadEphemeralAgent = async ({ req, agent_id, endpoint, model_parameters: _m }) => {const { model, ...model_parameters } = _m;/** @type {Record<string, FunctionTool>} */- const availableTools = await getCachedTools({ includeGlobal: true });+ const availableTools = await getCachedTools({ userId: req.user.id, includeGlobal: true });/** @type {TEphemeralAgent | null} */const ephemeralAgent = req.body.ephemeralAgent;const mcpServers = new Set(ephemeralAgent?.mcp);diff --git a/api/server/controllers/PluginController.js b/api/server/controllers/PluginController.jsindex a0af142938..1dbc7633ac 100644--- a/api/server/controllers/PluginController.js+++ b/api/server/controllers/PluginController.js@@ -138,15 +138,21 @@ function createGetServerTools() {*/const getAvailableTools = async (req, res) => {try {+ const userId = req.user?.id;+ const customConfig = await getCustomConfig();const cache = getLogStores(CacheKeys.CONFIG_STORE);const cachedToolsArray = await cache.get(CacheKeys.TOOLS);- if (cachedToolsArray) {- res.status(200).json(cachedToolsArray);+ const cachedUserTools = await getCachedTools({ userId });+ const userPlugins = convertMCPToolsToPlugins(cachedUserTools, customConfig);++ if (cachedToolsArray && userPlugins) {+ const dedupedTools = filterUniquePlugins([...userPlugins, ...cachedToolsArray]);+ res.status(200).json(dedupedTools);return;}+ // If not in cache, build from manifestlet pluginManifest = availableTools;- const customConfig = await getCustomConfig();if (customConfig?.mcpServers != null) {const mcpManager = getMCPManager();const flowsCache = getLogStores(CacheKeys.FLOWS);@@ -217,16 +223,69 @@ const getAvailableTools = async (req, res) => {toolsOutput.push(toolToAdd);}-const finalTools = filterUniquePlugins(toolsOutput);await cache.set(CacheKeys.TOOLS, finalTools);- res.status(200).json(finalTools);++ const dedupedTools = filterUniquePlugins([...userPlugins, ...finalTools]);++ res.status(200).json(dedupedTools);} catch (error) {logger.error('[getAvailableTools]', error);res.status(500).json({ message: error.message });}};+/**+ * Converts MCP function format tools to plugin format+ * @param {Object} functionTools - Object with function format tools+ * @param {Object} customConfig - Custom configuration for MCP servers+ * @returns {Array} Array of plugin objects+ */+function convertMCPToolsToPlugins(functionTools, customConfig) {+ const plugins = [];++ for (const [toolKey, toolData] of Object.entries(functionTools)) {+ if (!toolData.function || !toolKey.includes(Constants.mcp_delimiter)) {+ continue;+ }++ const functionData = toolData.function;+ const parts = toolKey.split(Constants.mcp_delimiter);+ const serverName = parts[parts.length - 1];++ const plugin = {+ name: parts[0], // Use the tool name without server suffix+ pluginKey: toolKey,+ description: functionData.description || '',+ authenticated: true,+ icon: undefined,+ };++ // Build authConfig for MCP tools+ const serverConfig = customConfig?.mcpServers?.[serverName];+ if (!serverConfig?.customUserVars) {+ plugin.authConfig = [];+ plugins.push(plugin);+ continue;+ }++ const customVarKeys = Object.keys(serverConfig.customUserVars);+ if (customVarKeys.length === 0) {+ plugin.authConfig = [];+ } else {+ plugin.authConfig = Object.entries(serverConfig.customUserVars).map(([key, value]) => ({+ authField: key,+ label: value.title || key,+ description: value.description || '',+ }));+ }++ plugins.push(plugin);+ }++ return plugins;+}+module.exports = {getAvailableTools,getAvailablePluginsController,diff --git a/api/server/index.js b/api/server/index.jsindex 2da1adfcde..a792c70a67 100644--- a/api/server/index.js+++ b/api/server/index.js@@ -16,7 +16,7 @@ const { connectDb, indexSync } = require('~/db');const validateImageRequest = require('./middleware/validateImageRequest');const { jwtLogin, ldapLogin, passportLogin } = require('~/strategies');const errorController = require('./controllers/ErrorController');-const initializeMCP = require('./services/initializeMCP');+const initializeMCPs = require('./services/initializeMCPs');const configureSocialLogins = require('./socialLogins');const AppService = require('./services/AppService');const staticCache = require('./utils/staticCache');@@ -146,7 +146,7 @@ const startServer = async () => {logger.info(`Server listening at http://${host == '0.0.0.0' ? 'localhost' : host}:${port}`);}- initializeMCP(app);+ initializeMCPs(app);});};diff --git a/api/server/routes/mcp.js b/api/server/routes/mcp.jsindex 3dfed4d240..b9084f982d 100644--- a/api/server/routes/mcp.js+++ b/api/server/routes/mcp.js@@ -1,9 +1,12 @@const { Router } = require('express');-const { MCPOAuthHandler } = require('@librechat/api');const { logger } = require('@librechat/data-schemas');-const { CacheKeys } = require('librechat-data-provider');+const { MCPOAuthHandler } = require('@librechat/api');+const { CacheKeys, Constants } = require('librechat-data-provider');+const { findToken, updateToken, createToken, deleteTokens } = require('~/models');+const { setCachedTools, getCachedTools, loadCustomConfig } = require('~/server/services/Config');+const { getUserPluginAuthValue } = require('~/server/services/PluginService');+const { getMCPManager, getFlowStateManager } = require('~/config');const { requireJwtAuth } = require('~/server/middleware');-const { getFlowStateManager } = require('~/config');const { getLogStores } = require('~/cache');const router = Router();@@ -202,4 +205,106 @@ router.get('/oauth/status/:flowId', async (req, res) => {}});+/**+ * Reinitialize MCP server+ * This endpoint allows reinitializing a specific MCP server+ */+router.post('/:serverName/reinitialize', requireJwtAuth, async (req, res) => {+ try {+ const { serverName } = req.params;+ const user = req.user;++ if (!user?.id) {+ return res.status(401).json({ error: 'User not authenticated' });+ }++ logger.info(`[MCP Reinitialize] Reinitializing server: ${serverName}`);++ const config = await loadCustomConfig();+ if (!config || !config.mcpServers || !config.mcpServers[serverName]) {+ return res.status(404).json({+ error: `MCP server '${serverName}' not found in configuration`,+ });+ }++ const flowsCache = getLogStores(CacheKeys.FLOWS);+ const flowManager = getFlowStateManager(flowsCache);+ const mcpManager = getMCPManager();++ await mcpManager.disconnectServer(serverName);+ logger.info(`[MCP Reinitialize] Disconnected existing server: ${serverName}`);++ const serverConfig = config.mcpServers[serverName];+ mcpManager.mcpConfigs[serverName] = serverConfig;+ let customUserVars = {};+ if (serverConfig.customUserVars && typeof serverConfig.customUserVars === 'object') {+ for (const varName of Object.keys(serverConfig.customUserVars)) {+ try {+ const value = await getUserPluginAuthValue(user.id, varName, false);+ if (value) {+ customUserVars[varName] = value;+ }+ } catch (err) {+ logger.error(`[MCP Reinitialize] Error fetching ${varName} for user ${user.id}:`, err);+ }+ }+ }++ let userConnection = null;+ try {+ userConnection = await mcpManager.getUserConnection({+ user,+ serverName,+ flowManager,+ customUserVars,+ tokenMethods: {+ findToken,+ updateToken,+ createToken,+ deleteTokens,+ },+ });+ } catch (err) {+ logger.error(`[MCP Reinitialize] Error initializing MCP server ${serverName} for user:`, err);+ return res.status(500).json({ error: 'Failed to reinitialize MCP server for user' });+ }++ const userTools = (await getCachedTools({ userId: user.id })) || {};++ // Remove any old tools from this server in the user's cache+ const mcpDelimiter = Constants.mcp_delimiter;+ for (const key of Object.keys(userTools)) {+ if (key.endsWith(`${mcpDelimiter}${serverName}`)) {+ delete userTools[key];+ }+ }++ // Add the new tools from this server+ 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,+ },+ };+ }++ // Save the updated user tool cache+ await setCachedTools(userTools, { userId: user.id });++ res.json({+ success: true,+ message: `MCP server '${serverName}' reinitialized successfully`,+ serverName,+ });+ } catch (error) {+ logger.error('[MCP Reinitialize] Unexpected error', error);+ res.status(500).json({ error: 'Internal server error' });+ }+});+module.exports = router;diff --git a/api/server/services/MCP.js b/api/server/services/MCP.jsindex c228242003..3f0a4d618e 100644--- a/api/server/services/MCP.js+++ b/api/server/services/MCP.js@@ -104,7 +104,7 @@ function createAbortHandler({ userId, serverName, toolName, flowManager }) {* @returns { Promise<typeof tool | { _call: (toolInput: Object | string) => unknown}> } An object with `_call` method to execute the tool input.*/async function createMCPTool({ req, res, toolKey, provider: _provider }) {- const availableTools = await getCachedTools({ includeGlobal: true });+ const availableTools = await getCachedTools({ userId: req.user?.id, includeGlobal: true });const toolDefinition = availableTools?.[toolKey]?.function;if (!toolDefinition) {logger.error(`Tool ${toolKey} not found in available tools`);diff --git a/api/server/services/ToolService.js b/api/server/services/ToolService.jsindex f1567a3783..e37202a888 100644--- a/api/server/services/ToolService.js+++ b/api/server/services/ToolService.js@@ -226,7 +226,7 @@ async function processRequiredActions(client, requiredActions) {`[required actions] user: ${client.req.user.id} | thread_id: ${requiredActions[0].thread_id} | run_id: ${requiredActions[0].run_id}`,requiredActions,);- const toolDefinitions = await getCachedTools({ includeGlobal: true });+ const toolDefinitions = await getCachedTools({ userId: client.req.user.id, includeGlobal: true });const seenToolkits = new Set();const tools = requiredActions.map((action) => {diff --git a/api/server/services/initializeMCP.js b/api/server/services/initializeMCPs.jssimilarity index 72%rename from api/server/services/initializeMCP.jsrename to api/server/services/initializeMCPs.jsindex 0ed82e6ea1..18edb2449d 100644--- a/api/server/services/initializeMCP.js+++ b/api/server/services/initializeMCPs.js@@ -9,20 +9,35 @@ const { getLogStores } = require('~/cache');* Initialize MCP servers* @param {import('express').Application} app - Express app instance*/-async function initializeMCP(app) {+async function initializeMCPs(app) {const mcpServers = app.locals.mcpConfig;if (!mcpServers) {return;}+ // Filter out servers with startup: false+ const filteredServers = {};+ for (const [name, config] of Object.entries(mcpServers)) {+ if (config.startup === false) {+ logger.info(`Skipping MCP server '${name}' due to startup: false`);+ continue;+ }+ filteredServers[name] = config;+ }++ if (Object.keys(filteredServers).length === 0) {+ logger.info('[MCP] No MCP servers to initialize (all skipped or none configured)');+ return;+ }+logger.info('Initializing MCP servers...');const mcpManager = getMCPManager();const flowsCache = getLogStores(CacheKeys.FLOWS);const flowManager = flowsCache ? getFlowStateManager(flowsCache) : null;try {- await mcpManager.initializeMCP({- mcpServers,+ await mcpManager.initializeMCPs({+ mcpServers: filteredServers,flowManager,tokenMethods: {findToken,@@ -47,10 +62,11 @@ async function initializeMCP(app) {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');} catch (error) {logger.error('Failed to initialize MCP servers:', error);}}-module.exports = initializeMCP;+module.exports = initializeMCPs;diff --git a/client/src/components/SidePanel/MCP/MCPPanel.tsx b/client/src/components/SidePanel/MCP/MCPPanel.tsxindex aa2bf72112..0a8ca856f6 100644--- a/client/src/components/SidePanel/MCP/MCPPanel.tsx+++ b/client/src/components/SidePanel/MCP/MCPPanel.tsx@@ -1,8 +1,11 @@-import React, { useState, useCallback, useMemo, useEffect } from 'react';-import { ChevronLeft } from 'lucide-react';import { Constants } from 'librechat-data-provider';+import { ChevronLeft, RefreshCw } from 'lucide-react';import { useForm, Controller } from 'react-hook-form';-import { useUpdateUserPluginsMutation } from 'librechat-data-provider/react-query';+import React, { useState, useCallback, useMemo, useEffect } from 'react';+import {+ useUpdateUserPluginsMutation,+ useReinitializeMCPServerMutation,+} from 'librechat-data-provider/react-query';import type { TUpdateUserPlugins } from 'librechat-data-provider';import { Button, Input, Label } from '~/components/ui';import { useGetStartupConfig } from '~/data-provider';@@ -24,6 +27,8 @@ export default function MCPPanel() {const [selectedServerNameForEditing, setSelectedServerNameForEditing] = useState<string | null>(null,);+ const [rotatingServers, setRotatingServers] = useState<Set<string>>(new Set());+ const reinitializeMCPMutation = useReinitializeMCPServerMutation();const mcpServerDefinitions = useMemo(() => {if (!startupConfig?.mcpServers) {@@ -89,6 +94,32 @@ export default function MCPPanel() {setSelectedServerNameForEditing(null);};+ const handleReinitializeServer = useCallback(+ async (serverName: string) => {+ setRotatingServers((prev) => new Set(prev).add(serverName));+ try {+ await reinitializeMCPMutation.mutateAsync(serverName);+ showToast({+ message: `MCP server '${serverName}' reinitialized successfully`,+ status: 'success',+ });+ } catch (error) {+ console.error('Error reinitializing MCP server:', error);+ showToast({+ message: 'Failed to reinitialize MCP server',+ status: 'error',+ });+ } finally {+ setRotatingServers((prev) => {+ const next = new Set(prev);+ next.delete(serverName);+ return next;+ });+ }+ },+ [showToast, reinitializeMCPMutation],+ );+if (startupConfigLoading) {return <MCPPanelSkeleton />;}@@ -144,14 +175,27 @@ export default function MCPPanel() {<div className="h-auto max-w-full overflow-x-hidden p-3"><div className="space-y-2">{mcpServerDefinitions.map((server) => (- <Button- key={server.serverName}- variant="outline"- className="w-full justify-start dark:hover:bg-gray-700"- onClick={() => handleServerClickToEdit(server.serverName)}- >- {server.serverName}- </Button>+ <div key={server.serverName} className="flex items-center gap-2">+ <Button+ variant="outline"+ className="flex-1 justify-start dark:hover:bg-gray-700"+ onClick={() => handleServerClickToEdit(server.serverName)}+ >+ {server.serverName}+ </Button>+ <Button+ variant="ghost"+ size="sm"+ onClick={() => handleReinitializeServer(server.serverName)}+ className="px-2 py-1"+ title="Reinitialize MCP server"+ disabled={reinitializeMCPMutation.isLoading}+ >+ <RefreshCw+ className={`h-4 w-4 ${rotatingServers.has(server.serverName) ? 'animate-spin' : ''}`}+ />+ </Button>+ </div>))}</div></div>diff --git a/packages/api/src/mcp/manager.ts b/packages/api/src/mcp/manager.tsindex b4a6a71a1f..a3bee8a18c 100644--- a/packages/api/src/mcp/manager.ts+++ b/packages/api/src/mcp/manager.ts@@ -39,7 +39,7 @@ export class MCPManager {}/** Stores configs and initializes app-level connections */- public async initializeMCP({+ public async initializeMCPs({mcpServers,flowManager,tokenMethods,@@ -60,173 +60,17 @@ export class MCPManager {const entries = Object.entries(mcpServers);const initializedServers = new Set();const connectionResults = await Promise.allSettled(- entries.map(async ([serverName, _config], i) => {- /** Process env for app-level connections */- const config = processMCPEnv(_config);-- /** Existing tokens for system-level connections */- let tokens: MCPOAuthTokens | null = null;- if (tokenMethods?.findToken) {- try {- /** Refresh function for app-level connections */- const refreshTokensFunction = async (- refreshToken: string,- metadata: {- userId: string;- serverName: string;- identifier: string;- clientInfo?: OAuthClientInformation;- },- ) => {- /** URL from config if available */- const serverUrl = (config as t.SSEOptions | t.StreamableHTTPOptions).url;- return await MCPOAuthHandler.refreshOAuthTokens(- refreshToken,- {- serverName: metadata.serverName,- serverUrl,- clientInfo: metadata.clientInfo,- },- config.oauth,- );- };-- /** Flow state to prevent concurrent token operations */- const tokenFlowId = `tokens:${CONSTANTS.SYSTEM_USER_ID}:${serverName}`;- tokens = await flowManager.createFlowWithHandler(- tokenFlowId,- 'mcp_get_tokens',- async () => {- return await MCPTokenStorage.getTokens({- userId: CONSTANTS.SYSTEM_USER_ID,- serverName,- findToken: tokenMethods.findToken,- refreshTokens: refreshTokensFunction,- createToken: tokenMethods.createToken,- updateToken: tokenMethods.updateToken,- });- },- );- } catch {- logger.debug(`[MCP][${serverName}] No existing tokens found`);- }- }-- if (tokens) {- logger.info(`[MCP][${serverName}] Loaded OAuth tokens`);- }-- const connection = new MCPConnection(serverName, config, undefined, tokens);-- /** Listen for OAuth requirements */- logger.info(`[MCP][${serverName}] Setting up OAuth event listener`);- connection.on('oauthRequired', async (data) => {- logger.debug(`[MCP][${serverName}] oauthRequired event received`);- const result = await this.handleOAuthRequired({- ...data,- flowManager,- });-- if (result?.tokens && tokenMethods?.createToken) {- try {- connection.setOAuthTokens(result.tokens);- await MCPTokenStorage.storeTokens({- userId: CONSTANTS.SYSTEM_USER_ID,- serverName,- tokens: result.tokens,- createToken: tokenMethods.createToken,- updateToken: tokenMethods.updateToken,- findToken: tokenMethods.findToken,- clientInfo: result.clientInfo,- });- logger.info(`[MCP][${serverName}] OAuth tokens saved to storage`);- } catch (error) {- logger.error(`[MCP][${serverName}] Failed to save OAuth tokens to storage`, error);- }- }-- // Only emit oauthHandled if we actually got tokens (OAuth succeeded)- if (result?.tokens) {- connection.emit('oauthHandled');- } else {- // OAuth failed, emit oauthFailed to properly reject the promise- logger.warn(`[MCP][${serverName}] OAuth failed, emitting oauthFailed event`);- connection.emit('oauthFailed', new Error('OAuth authentication failed'));- }- });-+ entries.map(async ([serverName, config], i) => {try {- const connectTimeout = config.initTimeout ?? 30000;- const connectionTimeout = new Promise<void>((_, reject) =>- setTimeout(- () => reject(new Error(`Connection timeout after ${connectTimeout}ms`)),- connectTimeout,- ),- );-- const connectionAttempt = this.initializeServer({- connection,- logPrefix: `[MCP][${serverName}]`,+ await this.initializeMCP({+ serverName,+ config,flowManager,- handleOAuth: false,+ tokenMethods,});- await Promise.race([connectionAttempt, connectionTimeout]);-- if (await connection.isConnected()) {- initializedServers.add(i);- this.connections.set(serverName, connection);-- /** Unified `serverInstructions` configuration */- const configInstructions = config.serverInstructions;-- if (configInstructions !== undefined) {- if (typeof configInstructions === 'string') {- this.serverInstructions.set(serverName, configInstructions);- logger.info(- `[MCP][${serverName}] Custom instructions stored for context inclusion: ${configInstructions}`,- );- } else if (configInstructions === true) {- /** Server-provided instructions */- const serverInstructions = connection.client.getInstructions();-- if (serverInstructions) {- this.serverInstructions.set(serverName, serverInstructions);- logger.info(- `[MCP][${serverName}] Server instructions stored for context inclusion: ${serverInstructions}`,- );- } else {- logger.info(- `[MCP][${serverName}] serverInstructions=true but no server instructions available`,- );- }- } else {- logger.info(- `[MCP][${serverName}] Instructions explicitly disabled (serverInstructions=false)`,- );- }- } else {- logger.info(- `[MCP][${serverName}] Instructions not included (serverInstructions not configured)`,- );- }-- const serverCapabilities = connection.client.getServerCapabilities();- logger.info(`[MCP][${serverName}] Capabilities: ${JSON.stringify(serverCapabilities)}`);-- if (serverCapabilities?.tools) {- const tools = await connection.client.listTools();- if (tools.tools.length) {- logger.info(- `[MCP][${serverName}] Available tools: ${tools.tools- .map((tool) => tool.name)- .join(', ')}`,- );- }- }- }+ initializedServers.add(i);} catch (error) {logger.error(`[MCP][${serverName}] Initialization failed`, error);- throw error;}}),);@@ -260,6 +104,176 @@ export class MCPManager {}}+ /** Initializes a single MCP server connection (app-level) */+ public async initializeMCP({+ serverName,+ config,+ flowManager,+ tokenMethods,+ }: {+ serverName: string;+ config: t.MCPOptions;+ flowManager: FlowStateManager<MCPOAuthTokens | null>;+ tokenMethods?: TokenMethods;+ }): Promise<void> {+ const processedConfig = processMCPEnv(config);+ let tokens: MCPOAuthTokens | null = null;+ if (tokenMethods?.findToken) {+ try {+ /** Refresh function for app-level connections */+ const refreshTokensFunction = async (+ refreshToken: string,+ metadata: {+ userId: string;+ serverName: string;+ identifier: string;+ clientInfo?: OAuthClientInformation;+ },+ ) => {+ const serverUrl = (processedConfig as t.SSEOptions | t.StreamableHTTPOptions).url;+ return await MCPOAuthHandler.refreshOAuthTokens(+ refreshToken,+ {+ serverName: metadata.serverName,+ serverUrl,+ clientInfo: metadata.clientInfo,+ },+ processedConfig.oauth,+ );+ };++ /** Flow state to prevent concurrent token operations */+ const tokenFlowId = `tokens:${CONSTANTS.SYSTEM_USER_ID}:${serverName}`;+ tokens = await flowManager.createFlowWithHandler(+ tokenFlowId,+ 'mcp_get_tokens',+ async () => {+ return await MCPTokenStorage.getTokens({+ userId: CONSTANTS.SYSTEM_USER_ID,+ serverName,+ findToken: tokenMethods.findToken,+ refreshTokens: refreshTokensFunction,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ });+ },+ );+ } catch {+ logger.debug(`[MCP][${serverName}] No existing tokens found`);+ }+ }+ if (tokens) {+ logger.info(`[MCP][${serverName}] Loaded OAuth tokens`);+ }+ const connection = new MCPConnection(serverName, processedConfig, undefined, tokens);+ logger.info(`[MCP][${serverName}] Setting up OAuth event listener`);+ connection.on('oauthRequired', async (data) => {+ logger.debug(`[MCP][${serverName}] oauthRequired event received`);+ const result = await this.handleOAuthRequired({+ ...data,+ flowManager,+ });+ if (result?.tokens && tokenMethods?.createToken) {+ try {+ connection.setOAuthTokens(result.tokens);+ await MCPTokenStorage.storeTokens({+ userId: CONSTANTS.SYSTEM_USER_ID,+ serverName,+ tokens: result.tokens,+ createToken: tokenMethods.createToken,+ updateToken: tokenMethods.updateToken,+ findToken: tokenMethods.findToken,+ clientInfo: result.clientInfo,+ });+ logger.info(`[MCP][${serverName}] OAuth tokens saved to storage`);+ } catch (error) {+ logger.error(`[MCP][${serverName}] Failed to save OAuth tokens to storage`, error);+ }+ }++ // Only emit oauthHandled if we actually got tokens (OAuth succeeded)+ if (result?.tokens) {+ connection.emit('oauthHandled');+ } else {+ // OAuth failed, emit oauthFailed to properly reject the promise+ logger.warn(`[MCP][${serverName}] OAuth failed, emitting oauthFailed event`);+ connection.emit('oauthFailed', new Error('OAuth authentication failed'));+ }+ });+ try {+ const connectTimeout = processedConfig.initTimeout ?? 30000;+ const connectionTimeout = new Promise<void>((_, reject) =>+ setTimeout(+ () => reject(new Error(`Connection timeout after ${connectTimeout}ms`)),+ connectTimeout,+ ),+ );+ const connectionAttempt = this.initializeServer({+ connection,+ logPrefix: `[MCP][${serverName}]`,+ flowManager,+ handleOAuth: false,+ });+ await Promise.race([connectionAttempt, connectionTimeout]);+ if (await connection.isConnected()) {+ this.connections.set(serverName, connection);++ /** Unified `serverInstructions` configuration */+ const configInstructions = processedConfig.serverInstructions;+ if (configInstructions !== undefined) {+ if (typeof configInstructions === 'string') {+ this.serverInstructions.set(serverName, configInstructions);+ logger.info(+ `[MCP][${serverName}] Custom instructions stored for context inclusion: ${configInstructions}`,+ );+ } else if (configInstructions === true) {+ /** Server-provided instructions */+ const serverInstructions = connection.client.getInstructions();++ if (serverInstructions) {+ this.serverInstructions.set(serverName, serverInstructions);+ logger.info(+ `[MCP][${serverName}] Server instructions stored for context inclusion: ${serverInstructions}`,+ );+ } else {+ logger.info(+ `[MCP][${serverName}] serverInstructions=true but no server instructions available`,+ );+ }+ } else {+ logger.info(+ `[MCP][${serverName}] Instructions explicitly disabled (serverInstructions=false)`,+ );+ }+ } else {+ logger.info(+ `[MCP][${serverName}] Instructions not included (serverInstructions not configured)`,+ );+ }++ const serverCapabilities = connection.client.getServerCapabilities();+ logger.info(`[MCP][${serverName}] Capabilities: ${JSON.stringify(serverCapabilities)}`);++ if (serverCapabilities?.tools) {+ const tools = await connection.client.listTools();+ if (tools.tools.length) {+ logger.info(+ `[MCP][${serverName}] Available tools: ${tools.tools+ .map((tool) => tool.name)+ .join(', ')}`,+ );+ }+ }+ logger.info(`[MCP][${serverName}] ✓ Initialized`);+ } else {+ logger.info(`[MCP][${serverName}] ✗ Failed`);+ }+ } catch (error) {+ logger.error(`[MCP][${serverName}] Initialization failed`, error);+ throw error;+ }+ }+/** Generic server initialization logic */private async initializeServer({connection,diff --git a/packages/api/src/mcp/mcp.spec.ts b/packages/api/src/mcp/mcp.spec.tsindex a9f5b7db1d..f97d4b6bdd 100644--- a/packages/api/src/mcp/mcp.spec.ts+++ b/packages/api/src/mcp/mcp.spec.ts@@ -708,5 +708,53 @@ describe('Environment Variable Extraction (MCP)', () => {SYSTEM_PATH: process.env.PATH, // Actual value of PATH from the test environment});});++ it('should process GitHub MCP server configuration with PAT_TOKEN placeholder', () => {+ const user = createTestUser({ id: 'github-user-123', email: '[email protected]' });+ const customUserVars = {+ PAT_TOKEN: 'ghp_1234567890abcdef1234567890abcdef12345678', // GitHub Personal Access Token+ };++ // Simulate the GitHub MCP server configuration from librechat.yaml+ const obj: MCPOptions = {+ type: 'streamable-http',+ url: 'https://api.githubcopilot.com/mcp/',+ headers: {+ Authorization: '{{PAT_TOKEN}}',+ 'Content-Type': 'application/json',+ 'User-Agent': 'LibreChat-MCP-Client',+ },+ };++ const result = processMCPEnv(obj, user, customUserVars);++ expect('headers' in result && result.headers).toEqual({+ Authorization: 'ghp_1234567890abcdef1234567890abcdef12345678',+ 'Content-Type': 'application/json',+ 'User-Agent': 'LibreChat-MCP-Client',+ });+ expect('url' in result && result.url).toBe('https://api.githubcopilot.com/mcp/');+ expect(result.type).toBe('streamable-http');+ });++ it('should handle GitHub MCP server configuration without PAT_TOKEN (placeholder remains)', () => {+ const user = createTestUser({ id: 'github-user-123' });+ // No customUserVars provided - PAT_TOKEN should remain as placeholder+ const obj: MCPOptions = {+ type: 'streamable-http',+ url: 'https://api.githubcopilot.com/mcp/',+ headers: {+ Authorization: '{{PAT_TOKEN}}',+ 'Content-Type': 'application/json',+ },+ };++ const result = processMCPEnv(obj, user);++ expect('headers' in result && result.headers).toEqual({+ Authorization: '{{PAT_TOKEN}}', // Should remain unchanged since no customUserVars provided+ 'Content-Type': 'application/json',+ });+ });});});diff --git a/packages/data-provider/src/api-endpoints.ts b/packages/data-provider/src/api-endpoints.tsindex adb0e634a1..3930132ce0 100644--- a/packages/data-provider/src/api-endpoints.ts+++ b/packages/data-provider/src/api-endpoints.ts@@ -132,6 +132,8 @@ export const resendVerificationEmail = () => '/api/user/verify/resend';export const plugins = () => '/api/plugins';+export const mcpReinitialize = (serverName: string) => `/api/mcp/${serverName}/reinitialize`;+export const config = () => '/api/config';export const prompts = () => '/api/prompts';diff --git a/packages/data-provider/src/data-service.ts b/packages/data-provider/src/data-service.tsindex dde248e2ad..d9e8ff7d12 100644--- a/packages/data-provider/src/data-service.ts+++ b/packages/data-provider/src/data-service.ts@@ -141,6 +141,10 @@ export const updateUserPlugins = (payload: t.TUpdateUserPlugins) => {return request.post(endpoints.userPlugins(), payload);};+export const reinitializeMCPServer = (serverName: string) => {+ return request.post(endpoints.mcpReinitialize(serverName));+};+/* Config */export const getStartupConfig = (): Promise<diff --git a/packages/data-provider/src/react-query/react-query-service.ts b/packages/data-provider/src/react-query/react-query-service.tsindex 7e3fe549a8..ca7d4374fe 100644--- a/packages/data-provider/src/react-query/react-query-service.ts+++ b/packages/data-provider/src/react-query/react-query-service.ts@@ -316,6 +316,20 @@ export const useUpdateUserPluginsMutation = (});};+export const useReinitializeMCPServerMutation = (): UseMutationResult<+ { success: boolean; message: string; serverName: string },+ unknown,+ string,+ unknown+> => {+ const queryClient = useQueryClient();+ return useMutation((serverName: string) => dataService.reinitializeMCPServer(serverName), {+ onSuccess: () => {+ queryClient.refetchQueries([QueryKeys.tools]);+ },+ });+};+export const useGetCustomConfigSpeechQuery = (config?: UseQueryOptions<t.TCustomConfigSpeechResponse>,): QueryObserverResult<t.TCustomConfigSpeechResponse> => {