Skip to content

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

🔬 refactor: Prevent Automatic MCP Server UI Deselection (#10588)

Danny Avila9f2fc25bde6d
diff --git a/api/server/experimental.js b/api/server/experimental.js
new file mode 100644
index 0000000000..f61b52a9c4
--- /dev/null
+++ b/api/server/experimental.js
@@ -0,0 +1,416 @@
+require('dotenv').config();
+const fs = require('fs');
+const path = require('path');
+require('module-alias')({ base: path.resolve(__dirname, '..') });
+const cluster = require('cluster');
+const Redis = require('ioredis');
+const cors = require('cors');
+const axios = require('axios');
+const express = require('express');
+const passport = require('passport');
+const compression = require('compression');
+const cookieParser = require('cookie-parser');
+const { logger } = require('@librechat/data-schemas');
+const mongoSanitize = require('express-mongo-sanitize');
+const {
+ isEnabled,
+ ErrorController,
+ performStartupChecks,
+ initializeFileStorage,
+} = require('@librechat/api');
+const { connectDb, indexSync } = require('~/db');
+const initializeOAuthReconnectManager = require('./services/initializeOAuthReconnectManager');
+const createValidateImageRequest = require('./middleware/validateImageRequest');
+const { jwtLogin, ldapLogin, passportLogin } = require('~/strategies');
+const { updateInterfacePermissions } = require('~/models/interface');
+const { checkMigrations } = require('./services/start/migration');
+const initializeMCPs = require('./services/initializeMCPs');
+const configureSocialLogins = require('./socialLogins');
+const { getAppConfig } = require('./services/Config');
+const staticCache = require('./utils/staticCache');
+const noIndex = require('./middleware/noIndex');
+const { seedDatabase } = require('~/models');
+const routes = require('./routes');
+
+const { PORT, HOST, ALLOW_SOCIAL_LOGIN, DISABLE_COMPRESSION, TRUST_PROXY } = process.env ?? {};
+
+/** Allow PORT=0 to be used for automatic free port assignment */
+const port = isNaN(Number(PORT)) ? 3080 : Number(PORT);
+const host = HOST || 'localhost';
+const trusted_proxy = Number(TRUST_PROXY) || 1;
+
+/** Number of worker processes to spawn (simulating multiple pods) */
+const workers = Number(process.env.CLUSTER_WORKERS) || 4;
+
+/** Helper to wrap log messages for better visibility */
+const wrapLogMessage = (msg) => {
+ return `\n${'='.repeat(50)}\n${msg}\n${'='.repeat(50)}`;
+};
+
+/**
+ * Flushes the Redis cache on startup
+ * This ensures a clean state for testing multi-pod MCP connection issues
+ */
+const flushRedisCache = async () => {
+ /** Skip cache flush if Redis is not enabled */
+ if (!isEnabled(process.env.USE_REDIS)) {
+ logger.info('Redis is not enabled, skipping cache flush');
+ return;
+ }
+
+ const redisConfig = {
+ host: process.env.REDIS_HOST || 'localhost',
+ port: process.env.REDIS_PORT || 6379,
+ };
+
+ if (process.env.REDIS_PASSWORD) {
+ redisConfig.password = process.env.REDIS_PASSWORD;
+ }
+
+ /** Handle Redis Cluster configuration */
+ if (isEnabled(process.env.USE_REDIS_CLUSTER) || process.env.REDIS_URI?.includes(',')) {
+ logger.info('Detected Redis Cluster configuration');
+ const uris = process.env.REDIS_URI?.split(',').map((uri) => {
+ const url = new URL(uri.trim());
+ return {
+ host: url.hostname,
+ port: parseInt(url.port || '6379', 10),
+ };
+ });
+ const redis = new Redis.Cluster(uris, {
+ redisOptions: {
+ password: process.env.REDIS_PASSWORD,
+ },
+ });
+
+ try {
+ logger.info('Attempting to connect to Redis Cluster...');
+ await redis.ping();
+ logger.info('Connected to Redis Cluster. Executing flushall...');
+ const result = await Promise.race([
+ redis.flushall(),
+ new Promise((_, reject) => setTimeout(() => reject(new Error('Flush timeout')), 10000)),
+ ]);
+ logger.info('Redis Cluster cache flushed successfully', { result });
+ } catch (err) {
+ logger.error('Error while flushing Redis Cluster cache:', err);
+ throw err;
+ } finally {
+ redis.disconnect();
+ }
+ return;
+ }
+
+ /** Handle single Redis instance */
+ const redis = new Redis(redisConfig);
+
+ try {
+ logger.info('Attempting to connect to Redis...');
+ await redis.ping();
+ logger.info('Connected to Redis. Executing flushall...');
+ const result = await Promise.race([
+ redis.flushall(),
+ new Promise((_, reject) => setTimeout(() => reject(new Error('Flush timeout')), 5000)),
+ ]);
+ logger.info('Redis cache flushed successfully', { result });
+ } catch (err) {
+ logger.error('Error while flushing Redis cache:', err);
+ throw err;
+ } finally {
+ redis.disconnect();
+ }
+};
+
+/**
+ * Master process
+ * Manages worker processes and handles graceful shutdowns
+ */
+if (cluster.isMaster) {
+ logger.info(wrapLogMessage(`Master ${process.pid} is starting...`));
+ logger.info(`Spawning ${workers} workers to simulate multi-pod environment`);
+
+ let activeWorkers = 0;
+ const startTime = Date.now();
+
+ /** Flush Redis cache before starting workers */
+ flushRedisCache()
+ .then(() => {
+ logger.info('Cache flushed, forking workers...');
+ for (let i = 0; i < workers; i++) {
+ cluster.fork();
+ }
+ })
+ .catch((err) => {
+ logger.error('Unable to flush Redis cache, not forking workers:', err);
+ process.exit(1);
+ });
+
+ /** Track worker lifecycle */
+ cluster.on('online', (worker) => {
+ activeWorkers++;
+ const uptime = ((Date.now() - startTime) / 1000).toFixed(2);
+ logger.info(
+ `Worker ${worker.process.pid} is online (${activeWorkers}/${workers}) after ${uptime}s`,
+ );
+
+ /** Notify the last worker to perform one-time initialization tasks */
+ if (activeWorkers === workers) {
+ const allWorkers = Object.values(cluster.workers);
+ const lastWorker = allWorkers[allWorkers.length - 1];
+ if (lastWorker) {
+ logger.info(wrapLogMessage(`All ${workers} workers are online`));
+ lastWorker.send({ type: 'last-worker' });
+ }
+ }
+ });
+
+ cluster.on('exit', (worker, code, signal) => {
+ activeWorkers--;
+ logger.error(
+ `Worker ${worker.process.pid} died (${activeWorkers}/${workers}). Code: ${code}, Signal: ${signal}`,
+ );
+ logger.info('Starting a new worker to replace it...');
+ cluster.fork();
+ });
+
+ /** Graceful shutdown on SIGTERM/SIGINT */
+ const shutdown = () => {
+ logger.info('Master received shutdown signal, terminating workers...');
+ for (const id in cluster.workers) {
+ cluster.workers[id].kill();
+ }
+ setTimeout(() => {
+ logger.info('Forcing shutdown after timeout');
+ process.exit(0);
+ }, 10000);
+ };
+
+ process.on('SIGTERM', shutdown);
+ process.on('SIGINT', shutdown);
+} else {
+ /**
+ * Worker process
+ * Each worker runs a full Express server instance
+ */
+ const app = express();
+
+ const startServer = async () => {
+ logger.info(`Worker ${process.pid} initializing...`);
+
+ if (typeof Bun !== 'undefined') {
+ axios.defaults.headers.common['Accept-Encoding'] = 'gzip';
+ }
+
+ /** Connect to MongoDB */
+ await connectDb();
+ logger.info(`Worker ${process.pid}: Connected to MongoDB`);
+
+ /** Background index sync (non-blocking) */
+ indexSync().catch((err) => {
+ logger.error(`[Worker ${process.pid}][indexSync] Background sync failed:`, err);
+ });
+
+ app.disable('x-powered-by');
+ app.set('trust proxy', trusted_proxy);
+
+ /** Seed database (idempotent) */
+ await seedDatabase();
+
+ /** Initialize app configuration */
+ const appConfig = await getAppConfig();
+ initializeFileStorage(appConfig);
+ await performStartupChecks(appConfig);
+ await updateInterfacePermissions(appConfig);
+
+ /** Load index.html for SPA serving */
+ const indexPath = path.join(appConfig.paths.dist, 'index.html');
+ let indexHTML = fs.readFileSync(indexPath, 'utf8');
+
+ /** Support serving in subdirectory if DOMAIN_CLIENT is set */
+ if (process.env.DOMAIN_CLIENT) {
+ const clientUrl = new URL(process.env.DOMAIN_CLIENT);
+ const baseHref = clientUrl.pathname.endsWith('/')
+ ? clientUrl.pathname
+ : `${clientUrl.pathname}/`;
+ if (baseHref !== '/') {
+ logger.info(`Setting base href to ${baseHref}`);
+ indexHTML = indexHTML.replace(/base href="\/"/, `base href="${baseHref}"`);
+ }
+ }
+
+ /** Health check endpoint */
+ app.get('/health', (_req, res) => res.status(200).send('OK'));
+
+ /** Middleware */
+ app.use(noIndex);
+ app.use(express.json({ limit: '3mb' }));
+ app.use(express.urlencoded({ extended: true, limit: '3mb' }));
+ app.use(mongoSanitize());
+ app.use(cors());
+ app.use(cookieParser());
+
+ if (!isEnabled(DISABLE_COMPRESSION)) {
+ app.use(compression());
+ } else {
+ logger.warn('Response compression has been disabled via DISABLE_COMPRESSION.');
+ }
+
+ app.use(staticCache(appConfig.paths.dist));
+ app.use(staticCache(appConfig.paths.fonts));
+ app.use(staticCache(appConfig.paths.assets));
+
+ if (!ALLOW_SOCIAL_LOGIN) {
+ logger.warn('Social logins are disabled. Set ALLOW_SOCIAL_LOGIN=true to enable them.');
+ }
+
+ /** OAUTH */
+ app.use(passport.initialize());
+ passport.use(jwtLogin());
+ passport.use(passportLogin());
+
+ /** LDAP Auth */
+ if (process.env.LDAP_URL && process.env.LDAP_USER_SEARCH_BASE) {
+ passport.use(ldapLogin);
+ }
+
+ if (isEnabled(ALLOW_SOCIAL_LOGIN)) {
+ await configureSocialLogins(app);
+ }
+
+ /** Routes */
+ app.use('/oauth', routes.oauth);
+ app.use('/api/auth', routes.auth);
+ app.use('/api/actions', routes.actions);
+ app.use('/api/keys', routes.keys);
+ app.use('/api/user', routes.user);
+ app.use('/api/search', routes.search);
+ app.use('/api/edit', routes.edit);
+ app.use('/api/messages', routes.messages);
+ app.use('/api/convos', routes.convos);
+ app.use('/api/presets', routes.presets);
+ app.use('/api/prompts', routes.prompts);
+ app.use('/api/categories', routes.categories);
+ app.use('/api/tokenizer', routes.tokenizer);
+ app.use('/api/endpoints', routes.endpoints);
+ app.use('/api/balance', routes.balance);
+ app.use('/api/models', routes.models);
+ app.use('/api/plugins', routes.plugins);
+ app.use('/api/config', routes.config);
+ app.use('/api/assistants', routes.assistants);
+ app.use('/api/files', await routes.files.initialize());
+ app.use('/images/', createValidateImageRequest(appConfig.secureImageLinks), routes.staticRoute);
+ app.use('/api/share', routes.share);
+ app.use('/api/roles', routes.roles);
+ app.use('/api/agents', routes.agents);
+ app.use('/api/banner', routes.banner);
+ app.use('/api/memories', routes.memories);
+ app.use('/api/permissions', routes.accessPermissions);
+ app.use('/api/tags', routes.tags);
+ app.use('/api/mcp', routes.mcp);
+
+ /** Error handler */
+ app.use(ErrorController);
+
+ /** SPA fallback - serve index.html for all unmatched routes */
+ app.use((req, res) => {
+ res.set({
+ 'Cache-Control': process.env.INDEX_CACHE_CONTROL || 'no-cache, no-store, must-revalidate',
+ Pragma: process.env.INDEX_PRAGMA || 'no-cache',
+ Expires: process.env.INDEX_EXPIRES || '0',
+ });
+
+ const lang = req.cookies.lang || req.headers['accept-language']?.split(',')[0] || 'en-US';
+ const saneLang = lang.replace(/"/g, '&quot;');
+ let updatedIndexHtml = indexHTML.replace(/lang="en-US"/g, `lang="${saneLang}"`);
+
+ res.type('html');
+ res.send(updatedIndexHtml);
+ });
+
+ /** Start listening on shared port (cluster will distribute connections) */
+ app.listen(port, host, async () => {
+ logger.info(
+ `Worker ${process.pid} started: Server listening at http://${
+ host == '0.0.0.0' ? 'localhost' : host
+ }:${port}`,
+ );
+
+ /** Initialize MCP servers and OAuth reconnection for this worker */
+ await initializeMCPs();
+ await initializeOAuthReconnectManager();
+ await checkMigrations();
+ });
+
+ /** Handle inter-process messages from master */
+ process.on('message', async (msg) => {
+ if (msg.type === 'last-worker') {
+ logger.info(
+ wrapLogMessage(
+ `Worker ${process.pid} is the last worker and can perform special initialization tasks`,
+ ),
+ );
+ /** Add any one-time initialization tasks here */
+ /** For example: scheduled jobs, cleanup tasks, etc. */
+ }
+ });
+ };
+
+ startServer().catch((err) => {
+ logger.error(`Failed to start worker ${process.pid}:`, err);
+ process.exit(1);
+ });
+
+ /** Export app for testing purposes (only available in worker processes) */
+ module.exports = app;
+}
+
+/**
+ * Uncaught exception handler
+ * Filters out known non-critical errors
+ */
+let messageCount = 0;
+process.on('uncaughtException', (err) => {
+ if (!err.message.includes('fetch failed')) {
+ logger.error('There was an uncaught error:', err);
+ }
+
+ if (err.message && err.message?.toLowerCase()?.includes('abort')) {
+ logger.warn('There was an uncatchable abort error.');
+ return;
+ }
+
+ if (err.message.includes('GoogleGenerativeAI')) {
+ logger.warn(
+ '\n\n`GoogleGenerativeAI` errors cannot be caught due to an upstream issue, see: https://github.com/google-gemini/generative-ai-js/issues/303',
+ );
+ return;
+ }
+
+ if (err.message.includes('fetch failed')) {
+ if (messageCount === 0) {
+ logger.warn('Meilisearch error, search will be disabled');
+ messageCount++;
+ }
+ return;
+ }
+
+ if (err.message.includes('OpenAIError') || err.message.includes('ChatCompletionMessage')) {
+ logger.error(
+ '\n\nAn Uncaught `OpenAIError` error may be due to your reverse-proxy setup or stream configuration, or a bug in the `openai` node package.',
+ );
+ return;
+ }
+
+ if (err.stack && err.stack.includes('@librechat/agents')) {
+ logger.error(
+ '\n\nAn error occurred in the agents system. The error has been logged and the app will continue running.',
+ {
+ message: err.message,
+ stack: err.stack,
+ },
+ );
+ return;
+ }
+
+ process.exit(1);
+});
diff --git a/client/src/hooks/MCP/useMCPServerManager.ts b/client/src/hooks/MCP/useMCPServerManager.ts
index 101904d29b..4d819b0ae6 100644
--- a/client/src/hooks/MCP/useMCPServerManager.ts
+++ b/client/src/hooks/MCP/useMCPServerManager.ts
@@ -84,32 +84,6 @@ export function useMCPServerManager({ conversationId }: { conversationId?: strin
enabled: !!startupConfig?.mcpServers && Object.keys(startupConfig.mcpServers).length > 0,
});
- /** Filter disconnected servers when values change, but only after initial load
- This prevents clearing selections on page refresh when servers haven't connected yet
- */
- const hasInitialLoadCompleted = useRef(false);
-
- useEffect(() => {
- if (!connectionStatus || Object.keys(connectionStatus).length === 0) {
- return;
- }
-
- if (!hasInitialLoadCompleted.current) {
- hasInitialLoadCompleted.current = true;
- return;
- }
-
- if (!mcpValues?.length) return;
-
- const connectedSelected = mcpValues.filter(
- (serverName) => connectionStatus[serverName]?.connectionState === 'connected',
- );
-
- if (connectedSelected.length !== mcpValues.length) {
- setMCPValues(connectedSelected);
- }
- }, [connectionStatus, mcpValues, setMCPValues]);
-
const updateServerState = useCallback((serverName: string, updates: Partial<ServerState>) => {
setServerStates((prev) => {
const newStates = { ...prev };
diff --git a/package.json b/package.json
index 1d9cf25a75..9362ef75ac 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,7 @@
"delete-banner": "node config/delete-banner.js",
"backend": "cross-env NODE_ENV=production node api/server/index.js",
"backend:dev": "cross-env NODE_ENV=development npx nodemon api/server/index.js",
+ "backend:experimental": "cross-env NODE_ENV=production node api/server/experimental.js",
"backend:stop": "node config/stop-backend.js",
"build:data-provider": "cd packages/data-provider && npm run build",
"build:api": "cd packages/api && npm run build",