@samanhappy/mcphub 0.9.16 → 0.10.1

package/dist/services/mcpService.js

@@ -4,7 +4,7 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { StreamableHTTPClientTransport, } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { loadSettings, expandEnvVars, replaceEnvVars, getNameSeparator } from '../config/index.js';
 import config from '../config/index.js';
 import { getGroup } from './sseService.js';
@@ -14,6 +14,8 @@ import { OpenAPIClient } from '../clients/openapi.js';
 import { RequestContextService } from './requestContextService.js';
 import { getDataService } from './services.js';
 import { getServerDao } from '../dao/index.js';
+import { initializeAllOAuthClients } from './oauthService.js';
+import { createOAuthProvider } from './mcpOAuthProvider.js';
 const servers = {};
 const serverDao = getServerDao();
 // Helper function to set up keep-alive ping for SSE connections
@@ -43,6 +45,9 @@ const setupKeepAlive = (serverInfo, serverConfig) => {
     console.log(`Keep-alive ping set up for server ${serverInfo.name} with interval ${interval / 1000} seconds`);
 };
 export const initUpstreamServers = async () => {
+    // Initialize OAuth clients for servers with dynamic registration
+    await initializeAllOAuthClients();
+    // Register all tools from upstream servers
     await registerAllTools(true);
 };
 export const getMcpServer = (sessionId, group) => {
@@ -128,28 +133,42 @@ export const cleanupAllServers = () => {
     });
 };
 // Helper function to create transport based on server configuration
-const createTransportFromConfig = (name, conf) => {
+export const createTransportFromConfig = async (name, conf) => {
     let transport;
     if (conf.type === 'streamable-http') {
         const options = {};
-        if (conf.headers && Object.keys(conf.headers).length > 0) {
+        const headers = conf.headers ? replaceEnvVars(conf.headers) : {};
+        if (Object.keys(headers).length > 0) {
             options.requestInit = {
-                headers: conf.headers,
+                headers,
             };
         }
+        // Create OAuth provider if configured - SDK will handle authentication automatically
+        const authProvider = await createOAuthProvider(name, conf);
+        if (authProvider) {
+            options.authProvider = authProvider;
+            console.log(`OAuth provider configured for server: ${name}`);
+        }
         transport = new StreamableHTTPClientTransport(new URL(conf.url || ''), options);
     }
     else if (conf.url) {
         // SSE transport
         const options = {};
-        if (conf.headers && Object.keys(conf.headers).length > 0) {
+        const headers = conf.headers ? replaceEnvVars(conf.headers) : {};
+        if (Object.keys(headers).length > 0) {
             options.eventSourceInit = {
-                headers: conf.headers,
+                headers,
             };
             options.requestInit = {
-                headers: conf.headers,
+                headers,
             };
         }
+        // Create OAuth provider if configured - SDK will handle authentication automatically
+        const authProvider = await createOAuthProvider(name, conf);
+        if (authProvider) {
+            options.authProvider = authProvider;
+            console.log(`OAuth provider configured for server: ${name}`);
+        }
         transport = new SSEClientTransport(new URL(conf.url), options);
     }
     else if (conf.command && conf.args) {
@@ -173,6 +192,7 @@ const createTransportFromConfig = (name, conf) => {
                 conf.command === 'node')) {
             env['npm_config_registry'] = settings.systemConfig.install.npmRegistry;
         }
+        // Expand environment variables in command
         transport = new StdioClientTransport({
             cwd: os.homedir(),
             command: conf.command,
@@ -222,7 +242,7 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
                         throw new Error(`Server configuration not found for: ${serverInfo.name}`);
                     }
                     // Recreate transport using helper function
-                    const newTransport = createTransportFromConfig(serverInfo.name, server);
+                    const newTransport = await createTransportFromConfig(serverInfo.name, server);
                     // Create new client
                     const client = new Client({
                         name: `mcp-client-${serverInfo.name}`,
@@ -282,194 +302,230 @@ const callToolWithReconnect = async (serverInfo, toolParams, options, maxRetries
 export const initializeClientsFromSettings = async (isInit, serverName) => {
     const allServers = await serverDao.findAll();
     const existingServerInfos = serverInfos;
-    serverInfos = [];
-    for (const conf of allServers) {
-        const { name } = conf;
-        // Skip disabled servers
-        if (conf.enabled === false) {
-            console.log(`Skipping disabled server: ${name}`);
-            serverInfos.push({
-                name,
-                owner: conf.owner,
-                status: 'disconnected',
-                error: null,
-                tools: [],
-                prompts: [],
-                createTime: Date.now(),
-                enabled: false,
-            });
-            continue;
-        }
-        // Check if server is already connected
-        const existingServer = existingServerInfos.find((s) => s.name === name && s.status === 'connected');
-        if (existingServer && (!serverName || serverName !== name)) {
-            serverInfos.push({
-                ...existingServer,
-                enabled: conf.enabled === undefined ? true : conf.enabled,
-            });
-            console.log(`Server '${name}' is already connected.`);
-            continue;
-        }
-        let transport;
-        let openApiClient;
-        if (conf.type === 'openapi') {
-            // Handle OpenAPI type servers
-            if (!conf.openapi?.url && !conf.openapi?.schema) {
-                console.warn(`Skipping OpenAPI server '${name}': missing OpenAPI specification URL or schema`);
-                serverInfos.push({
+    const nextServerInfos = [];
+    try {
+        for (const conf of allServers) {
+            const { name } = conf;
+            // Expand environment variables in all configuration values
+            const expandedConf = replaceEnvVars(conf);
+            // Skip disabled servers
+            if (expandedConf.enabled === false) {
+                console.log(`Skipping disabled server: ${name}`);
+                nextServerInfos.push({
                     name,
-                    owner: conf.owner,
+                    owner: expandedConf.owner,
                     status: 'disconnected',
-                    error: 'Missing OpenAPI specification URL or schema',
+                    error: null,
                     tools: [],
                     prompts: [],
                     createTime: Date.now(),
+                    enabled: false,
+                });
+                continue;
+            }
+            // Check if server is already connected
+            const existingServer = existingServerInfos.find((s) => s.name === name && s.status === 'connected');
+            if (existingServer && (!serverName || serverName !== name)) {
+                nextServerInfos.push({
+                    ...existingServer,
+                    enabled: expandedConf.enabled === undefined ? true : expandedConf.enabled,
                 });
+                console.log(`Server '${name}' is already connected.`);
                 continue;
             }
+            let transport;
+            let openApiClient;
+            if (expandedConf.type === 'openapi') {
+                // Handle OpenAPI type servers
+                if (!expandedConf.openapi?.url && !expandedConf.openapi?.schema) {
+                    console.warn(`Skipping OpenAPI server '${name}': missing OpenAPI specification URL or schema`);
+                    nextServerInfos.push({
+                        name,
+                        owner: expandedConf.owner,
+                        status: 'disconnected',
+                        error: 'Missing OpenAPI specification URL or schema',
+                        tools: [],
+                        prompts: [],
+                        createTime: Date.now(),
+                    });
+                    continue;
+                }
+                // Create server info first and keep reference to it
+                const serverInfo = {
+                    name,
+                    owner: expandedConf.owner,
+                    status: 'connecting',
+                    error: null,
+                    tools: [],
+                    prompts: [],
+                    createTime: Date.now(),
+                    enabled: expandedConf.enabled === undefined ? true : expandedConf.enabled,
+                    config: expandedConf, // Store reference to expanded config for OpenAPI passthrough headers
+                };
+                nextServerInfos.push(serverInfo);
+                try {
+                    // Create OpenAPI client instance
+                    openApiClient = new OpenAPIClient(expandedConf);
+                    console.log(`Initializing OpenAPI server: ${name}...`);
+                    // Perform async initialization
+                    await openApiClient.initialize();
+                    // Convert OpenAPI tools to MCP tool format
+                    const openApiTools = openApiClient.getTools();
+                    const mcpTools = openApiTools.map((tool) => ({
+                        name: `${name}${getNameSeparator()}${tool.name}`,
+                        description: tool.description,
+                        inputSchema: cleanInputSchema(tool.inputSchema),
+                    }));
+                    // Update server info with successful initialization
+                    serverInfo.status = 'connected';
+                    serverInfo.tools = mcpTools;
+                    serverInfo.openApiClient = openApiClient;
+                    console.log(`Successfully initialized OpenAPI server: ${name} with ${mcpTools.length} tools`);
+                    // Save tools as vector embeddings for search
+                    saveToolsAsVectorEmbeddings(name, mcpTools);
+                    continue;
+                }
+                catch (error) {
+                    console.error(`Failed to initialize OpenAPI server ${name}:`, error);
+                    // Update the already pushed server info with error status
+                    serverInfo.status = 'disconnected';
+                    serverInfo.error = `Failed to initialize OpenAPI server: ${error}`;
+                    continue;
+                }
+            }
+            else {
+                transport = await createTransportFromConfig(name, expandedConf);
+            }
+            const client = new Client({
+                name: `mcp-client-${name}`,
+                version: '1.0.0',
+            }, {
+                capabilities: {
+                    prompts: {},
+                    resources: {},
+                    tools: {},
+                },
+            });
+            const initRequestOptions = isInit
+                ? {
+                    timeout: Number(config.initTimeout) || 60000,
+                }
+                : undefined;
+            // Get request options from server configuration, with fallbacks
+            const serverRequestOptions = expandedConf.options || {};
+            const requestOptions = {
+                timeout: serverRequestOptions.timeout || 60000,
+                resetTimeoutOnProgress: serverRequestOptions.resetTimeoutOnProgress || false,
+                maxTotalTimeout: serverRequestOptions.maxTotalTimeout,
+            };
             // Create server info first and keep reference to it
             const serverInfo = {
                 name,
-                owner: conf.owner,
+                owner: expandedConf.owner,
                 status: 'connecting',
                 error: null,
                 tools: [],
                 prompts: [],
+                client,
+                transport,
+                options: requestOptions,
                 createTime: Date.now(),
-                enabled: conf.enabled === undefined ? true : conf.enabled,
-                config: conf, // Store reference to original config for OpenAPI passthrough headers
+                config: expandedConf, // Store reference to expanded config
             };
-            serverInfos.push(serverInfo);
-            try {
-                // Create OpenAPI client instance
-                openApiClient = new OpenAPIClient(conf);
-                console.log(`Initializing OpenAPI server: ${name}...`);
-                // Perform async initialization
-                await openApiClient.initialize();
-                // Convert OpenAPI tools to MCP tool format
-                const openApiTools = openApiClient.getTools();
-                const mcpTools = openApiTools.map((tool) => ({
-                    name: `${name}${getNameSeparator()}${tool.name}`,
-                    description: tool.description,
-                    inputSchema: cleanInputSchema(tool.inputSchema),
-                }));
-                // Update server info with successful initialization
-                serverInfo.status = 'connected';
-                serverInfo.tools = mcpTools;
-                serverInfo.openApiClient = openApiClient;
-                console.log(`Successfully initialized OpenAPI server: ${name} with ${mcpTools.length} tools`);
-                // Save tools as vector embeddings for search
-                saveToolsAsVectorEmbeddings(name, mcpTools);
-                continue;
-            }
-            catch (error) {
-                console.error(`Failed to initialize OpenAPI server ${name}:`, error);
-                // Update the already pushed server info with error status
-                serverInfo.status = 'disconnected';
-                serverInfo.error = `Failed to initialize OpenAPI server: ${error}`;
-                continue;
-            }
-        }
-        else {
-            transport = createTransportFromConfig(name, conf);
-        }
-        const client = new Client({
-            name: `mcp-client-${name}`,
-            version: '1.0.0',
-        }, {
-            capabilities: {
-                prompts: {},
-                resources: {},
-                tools: {},
-            },
-        });
-        const initRequestOptions = isInit
-            ? {
-                timeout: Number(config.initTimeout) || 60000,
-            }
-            : undefined;
-        // Get request options from server configuration, with fallbacks
-        const serverRequestOptions = conf.options || {};
-        const requestOptions = {
-            timeout: serverRequestOptions.timeout || 60000,
-            resetTimeoutOnProgress: serverRequestOptions.resetTimeoutOnProgress || false,
-            maxTotalTimeout: serverRequestOptions.maxTotalTimeout,
-        };
-        // Create server info first and keep reference to it
-        const serverInfo = {
-            name,
-            owner: conf.owner,
-            status: 'connecting',
-            error: null,
-            tools: [],
-            prompts: [],
-            client,
-            transport,
-            options: requestOptions,
-            createTime: Date.now(),
-            config: conf, // Store reference to original config
-        };
-        serverInfos.push(serverInfo);
-        client
-            .connect(transport, initRequestOptions || requestOptions)
-            .then(() => {
-            console.log(`Successfully connected client for server: ${name}`);
-            const capabilities = client.getServerCapabilities();
-            console.log(`Server capabilities: ${JSON.stringify(capabilities)}`);
-            let dataError = null;
-            if (capabilities?.tools) {
-                client
-                    .listTools({}, initRequestOptions || requestOptions)
-                    .then((tools) => {
-                    console.log(`Successfully listed ${tools.tools.length} tools for server: ${name}`);
-                    serverInfo.tools = tools.tools.map((tool) => ({
-                        name: `${name}${getNameSeparator()}${tool.name}`,
-                        description: tool.description || '',
-                        inputSchema: cleanInputSchema(tool.inputSchema || {}),
-                    }));
-                    // Save tools as vector embeddings for search
-                    saveToolsAsVectorEmbeddings(name, serverInfo.tools);
-                })
-                    .catch((error) => {
-                    console.error(`Failed to list tools for server ${name} by error: ${error} with stack: ${error.stack}`);
-                    dataError = error;
-                });
-            }
-            if (capabilities?.prompts) {
-                client
-                    .listPrompts({}, initRequestOptions || requestOptions)
-                    .then((prompts) => {
-                    console.log(`Successfully listed ${prompts.prompts.length} prompts for server: ${name}`);
-                    serverInfo.prompts = prompts.prompts.map((prompt) => ({
-                        name: `${name}${getNameSeparator()}${prompt.name}`,
-                        title: prompt.title,
-                        description: prompt.description,
-                        arguments: prompt.arguments,
-                    }));
-                })
-                    .catch((error) => {
-                    console.error(`Failed to list prompts for server ${name} by error: ${error} with stack: ${error.stack}`);
-                    dataError = error;
-                });
-            }
-            if (!dataError) {
-                serverInfo.status = 'connected';
+            const pendingAuth = expandedConf.oauth?.pendingAuthorization;
+            if (pendingAuth) {
+                serverInfo.status = 'oauth_required';
                 serverInfo.error = null;
-                // Set up keep-alive ping for SSE connections
-                setupKeepAlive(serverInfo, conf);
-            }
-            else {
-                serverInfo.status = 'disconnected';
-                serverInfo.error = `Failed to list data: ${dataError} `;
+                serverInfo.oauth = {
+                    authorizationUrl: pendingAuth.authorizationUrl,
+                    state: pendingAuth.state,
+                    codeVerifier: pendingAuth.codeVerifier,
+                };
             }
-        })
-            .catch((error) => {
-            console.error(`Failed to connect client for server ${name} by error: ${error} with stack: ${error.stack}`);
-            serverInfo.status = 'disconnected';
-            serverInfo.error = `Failed to connect: ${error.stack} `;
-        });
-        console.log(`Initialized client for server: ${name}`);
+            nextServerInfos.push(serverInfo);
+            client
+                .connect(transport, initRequestOptions || requestOptions)
+                .then(() => {
+                console.log(`Successfully connected client for server: ${name}`);
+                const capabilities = client.getServerCapabilities();
+                console.log(`Server capabilities: ${JSON.stringify(capabilities)}`);
+                let dataError = null;
+                if (capabilities?.tools) {
+                    client
+                        .listTools({}, initRequestOptions || requestOptions)
+                        .then((tools) => {
+                        console.log(`Successfully listed ${tools.tools.length} tools for server: ${name}`);
+                        serverInfo.tools = tools.tools.map((tool) => ({
+                            name: `${name}${getNameSeparator()}${tool.name}`,
+                            description: tool.description || '',
+                            inputSchema: cleanInputSchema(tool.inputSchema || {}),
+                        }));
+                        // Save tools as vector embeddings for search
+                        saveToolsAsVectorEmbeddings(name, serverInfo.tools);
+                    })
+                        .catch((error) => {
+                        console.error(`Failed to list tools for server ${name} by error: ${error} with stack: ${error.stack}`);
+                        dataError = error;
+                    });
+                }
+                if (capabilities?.prompts) {
+                    client
+                        .listPrompts({}, initRequestOptions || requestOptions)
+                        .then((prompts) => {
+                        console.log(`Successfully listed ${prompts.prompts.length} prompts for server: ${name}`);
+                        serverInfo.prompts = prompts.prompts.map((prompt) => ({
+                            name: `${name}${getNameSeparator()}${prompt.name}`,
+                            title: prompt.title,
+                            description: prompt.description,
+                            arguments: prompt.arguments,
+                        }));
+                    })
+                        .catch((error) => {
+                        console.error(`Failed to list prompts for server ${name} by error: ${error} with stack: ${error.stack}`);
+                        dataError = error;
+                    });
+                }
+                if (!dataError) {
+                    serverInfo.status = 'connected';
+                    serverInfo.error = null;
+                    // Set up keep-alive ping for SSE connections
+                    setupKeepAlive(serverInfo, expandedConf);
+                }
+                else {
+                    serverInfo.status = 'disconnected';
+                    serverInfo.error = `Failed to list data: ${dataError} `;
+                }
+            })
+                .catch(async (error) => {
+                // Check if this is an OAuth authorization error
+                const isOAuthError = error?.message?.includes('OAuth authorization required') ||
+                    error?.message?.includes('Authorization required');
+                if (isOAuthError) {
+                    // OAuth provider should have already set the status to 'oauth_required'
+                    // and stored the authorization URL in serverInfo.oauth
+                    console.log(`OAuth authorization required for server ${name}. Status should be set to 'oauth_required'.`);
+                    // Make sure status is set correctly
+                    if (serverInfo.status !== 'oauth_required') {
+                        serverInfo.status = 'oauth_required';
+                    }
+                    serverInfo.error = null;
+                }
+                else {
+                    console.error(`Failed to connect client for server ${name} by error: ${error} with stack: ${error.stack}`);
+                    // Other connection errors
+                    serverInfo.status = 'disconnected';
+                    serverInfo.error = `Failed to connect: ${error.stack} `;
+                }
+            });
+            console.log(`Initialized client for server: ${name}`);
+        }
+    }
+    catch (error) {
+        // Restore previous state if initialization fails to avoid exposing an empty server list
+        serverInfos = existingServerInfos;
+        throw error;
     }
+    serverInfos = nextServerInfos;
     return serverInfos;
 };
 // Register all MCP tools
@@ -483,7 +539,7 @@ export const getServersInfo = async () => {
     const filterServerInfos = dataService.filterData
         ? dataService.filterData(serverInfos)
         : serverInfos;
-    const infos = filterServerInfos.map(({ name, status, tools, prompts, createTime, error }) => {
+    const infos = filterServerInfos.map(({ name, status, tools, prompts, createTime, error, oauth }) => {
         const serverConfig = allServers.find((server) => server.name === name);
         const enabled = serverConfig ? serverConfig.enabled !== false : true;
         // Add enabled status and custom description to each tool
@@ -511,6 +567,13 @@ export const getServersInfo = async () => {
             prompts: promptsWithEnabled,
             createTime,
             enabled,
+            oauth: oauth
+                ? {
+                    authorizationUrl: oauth.authorizationUrl,
+                    state: oauth.state,
+                    // Don't expose codeVerifier to frontend for security
+                }
+                : undefined,
         };
     });
     infos.sort((a, b) => {
@@ -524,6 +587,45 @@ export const getServersInfo = async () => {
 export const getServerByName = (name) => {
     return serverInfos.find((serverInfo) => serverInfo.name === name);
 };
+// Get server by OAuth state parameter
+export const getServerByOAuthState = (state) => {
+    return serverInfos.find((serverInfo) => serverInfo.oauth?.state === state);
+};
+/**
+ * Reconnect a server after OAuth authorization or configuration change
+ * This will close the existing connection and reinitialize the server
+ */
+export const reconnectServer = async (serverName) => {
+    console.log(`Reconnecting server: ${serverName}`);
+    const serverInfo = getServerByName(serverName);
+    if (!serverInfo) {
+        throw new Error(`Server not found: ${serverName}`);
+    }
+    // Close existing connection if any
+    if (serverInfo.client) {
+        try {
+            serverInfo.client.close();
+        }
+        catch (error) {
+            console.warn(`Error closing client for server ${serverName}:`, error);
+        }
+    }
+    if (serverInfo.transport) {
+        try {
+            serverInfo.transport.close();
+        }
+        catch (error) {
+            console.warn(`Error closing transport for server ${serverName}:`, error);
+        }
+    }
+    if (serverInfo.keepAliveIntervalId) {
+        clearInterval(serverInfo.keepAliveIntervalId);
+        serverInfo.keepAliveIntervalId = undefined;
+    }
+    // Reinitialize the server
+    await initializeClientsFromSettings(false, serverName);
+    console.log(`Successfully reconnected server: ${serverName}`);
+};
 // Filter tools by server configuration
 const filterToolsByConfig = async (serverName, tools) => {
     const serverConfig = await serverDao.findById(serverName);
@@ -635,28 +737,39 @@ export const handleListToolsRequest = async (_, extra) => {
     const group = getGroup(sessionId);
     console.log(`Handling ListToolsRequest for group: ${group}`);
     // Special handling for $smart group to return special tools
-    if (group === '$smart') {
+    // Support both $smart and $smart/{group} patterns
+    if (group === '$smart' || group?.startsWith('$smart/')) {
+        // Extract target group if pattern is $smart/{group}
+        const targetGroup = group?.startsWith('$smart/') ? group.substring(7) : undefined;
+        // Get info about available servers, filtered by target group if specified
+        let availableServers = serverInfos.filter((server) => server.status === 'connected' && server.enabled !== false);
+        // If a target group is specified, filter servers to only those in the group
+        if (targetGroup) {
+            const serversInGroup = getServersInGroup(targetGroup);
+            if (serversInGroup && serversInGroup.length > 0) {
+                availableServers = availableServers.filter((server) => serversInGroup.includes(server.name));
+            }
+        }
+        // Create simple server information with only server names
+        const serversList = availableServers
+            .map((server) => {
+            return `${server.name}`;
+        })
+            .join(', ');
+        const scopeDescription = targetGroup
+            ? `servers in the "${targetGroup}" group`
+            : 'all available servers';
         return {
             tools: [
                 {
                     name: 'search_tools',
-                    description: (() => {
-                        // Get info about available servers
-                        const availableServers = serverInfos.filter((server) => server.status === 'connected' && server.enabled !== false);
-                        // Create simple server information with only server names
-                        const serversList = availableServers
-                            .map((server) => {
-                            return `${server.name}`;
-                        })
-                            .join(', ');
-                        return `STEP 1 of 2: Use this tool FIRST to discover and search for relevant tools across all available servers. This tool and call_tool work together as a two-step process: 1) search_tools to find what you need, 2) call_tool to execute it.
+                    description: `STEP 1 of 2: Use this tool FIRST to discover and search for relevant tools across ${scopeDescription}. This tool and call_tool work together as a two-step process: 1) search_tools to find what you need, 2) call_tool to execute it.
 
 For optimal results, use specific queries matching your exact needs. Call this tool multiple times with different queries for different parts of complex tasks. Example queries: "image generation tools", "code review tools", "data analysis", "translation capabilities", etc. Results are sorted by relevance using vector similarity.
 
 After finding relevant tools, you MUST use the call_tool to actually execute them. The search_tools only finds tools - it doesn't execute them.
 
-Available servers: ${serversList}`;
-                    })(),
+Available servers: ${serversList}`,
                     inputSchema: {
                         type: 'object',
                         properties: {
@@ -757,7 +870,24 @@ export const handleCallToolRequest = async (request, extra) => {
                 thresholdNum = 0.4;
             }
             console.log(`Using similarity threshold: ${thresholdNum} for query: "${query}"`);
-            const servers = undefined; // No server filtering
+            // Determine server filtering based on group
+            const sessionId = extra.sessionId || '';
+            const group = getGroup(sessionId);
+            let servers = undefined; // No server filtering by default
+            // If group is in format $smart/{group}, filter servers to that group
+            if (group?.startsWith('$smart/')) {
+                const targetGroup = group.substring(7);
+                const serversInGroup = getServersInGroup(targetGroup);
+                if (serversInGroup !== undefined && serversInGroup !== null) {
+                    servers = serversInGroup;
+                    if (servers.length > 0) {
+                        console.log(`Filtering search to servers in group "${targetGroup}": ${servers.join(', ')}`);
+                    }
+                    else {
+                        console.log(`Group "${targetGroup}" has no servers, search will return no results`);
+                    }
+                }
+            }
             const searchResults = await searchToolsByVector(query, limitNum, thresholdNum, servers);
             console.log(`Search results: ${JSON.stringify(searchResults)}`);
             // Find actual tool information from serverInfos by serverName and toolName