@oevortex/ddg_search 1.1.2 → 1.1.3

package/Dockerfile

@@ -1,20 +1,26 @@
-# Use official Node.js LTS image
-FROM node:20-alpine
-
-# Set working directory
+# Build stage: install dependencies
+FROM node:22-slim AS build
 WORKDIR /app
 
-# Copy package.json and package-lock.json
-COPY package*.json ./
+# Copy package manifests and lockfile first for better caching
+COPY package.json package-lock.json ./
 
-# Install dependencies
-RUN npm install --production
+# Install production dependencies (use npm ci when lockfile exists)
+RUN if [ -f package-lock.json ]; then npm ci --production; else npm install --production; fi
 
-# Copy source code
+# Copy application source
 COPY . .
 
-# Expose port (if your app listens on a port, e.g. 3000)
+# Final minimal runtime image
+FROM node:22-slim AS runtime
+WORKDIR /app
+
+# Copy node_modules and built app from build stage
+COPY --from=build /app/node_modules ./node_modules
+COPY --from=build /app .
+
+# Expose port in case the MCP server needs it
 EXPOSE 3000
 
-# Default command (adjust if your entry point is different)
-CMD ["node", "src/index.js"]
+# Default command: use the CLI entry which starts the MCP server
+CMD ["node", "bin/cli.js"]

package/README.md

@@ -227,4 +227,4 @@ Apache License 2.0
 
 <div align="center">
   <sub>Made with ❤️ by <a href="https://youtube.com/@OEvortex">@OEvortex</a></sub>
-</div>
+</div>

package/bin/cli.js

@@ -19,29 +19,47 @@ async function startServer() {
       id: 'ddg-search-mcp',
       name: 'DuckDuckGo & Felo AI Search MCP',
       description: 'A Model Context Protocol server for web search using DuckDuckGo and Felo AI',
-      version: '1.1.1'
+      version: '1.1.2'
     }, {
       capabilities: {
-        tools: {}
+        tools: {
+          listChanged: true
+        }
       }
     });
 
+    // Global variable to track available tools
+    let availableTools = [
+      searchToolDefinition,
+      fetchUrlToolDefinition,
+      metadataToolDefinition,
+      feloToolDefinition
+    ];
+
     // Define available tools
     server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
-        tools: [
-          searchToolDefinition,
-          fetchUrlToolDefinition,
-          metadataToolDefinition,
-          feloToolDefinition
-        ]
+        tools: availableTools
       };
     });
 
+    // Function to notify clients when tools list changes
+    function notifyToolsChanged() {
+      server.notification({
+        method: 'notifications/tools/list_changed'
+      });
+    }
+
     // Handle tool execution
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
       try {
         const { name, arguments: args } = request.params;
+        
+        // Validate tool name
+        const validTools = ['web-search', 'fetch-url', 'url-metadata', 'felo-search'];
+        if (!validTools.includes(name)) {
+          throw new Error(`Unknown tool: ${name}`);
+        }
 
         // Route to the appropriate tool handler
         switch (name) {
@@ -61,13 +79,15 @@ async function startServer() {
             throw new Error(`Tool not found: ${name}`);
         }
       } catch (error) {
-        console.error(`Error handling ${request.params.name} request:`, error);
+        console.error(`Error handling ${request.params.name} tool call:`, error);
+        
+        // Return proper tool execution error format
         return {
           isError: true,
           content: [
             {
               type: 'text',
-              text: `Error: ${error.message}`
+              text: `Error executing tool '${request.params.name}': ${error.message}`
             }
           ]
         };

package/package.json

@@ -1 +1 @@
-{"name":"@oevortex/ddg_search","version":"1.1.2","description":"A Model Context Protocol server for web search using DuckDuckGo and Felo AI","main":"src/index.js","bin":{"ddg-search-mcp":"bin/cli.js","oevortex-ddg-search":"bin/cli.js"},"scripts":{"test":"echo \"Error: no test specified\" && exit 1","start":"node bin/cli.js","prepublishOnly":"npm run lint","lint":"echo \"No linting configured\""},"publishConfig":{"access":"public"},"keywords":["mcp","model-context-protocol","duckduckgo","felo","search","web-search","ai-search","claude","ai","llm"],"author":"OEvortex","license":"Apache-2.0","type":"module","dependencies":{"@modelcontextprotocol/sdk":"^1.9.0","axios":"^1.8.4","cheerio":"^1.0.0","jsdom":"^26.1.0","uuid":"^9.0.1"}}
+{"name":"@oevortex/ddg_search","version":"1.1.3","description":"A Model Context Protocol server for web search using DuckDuckGo and Felo AI","main":"src/index.js","module":"src/index.ts","exports":{".":{"import":"./src/index.js","default":"./src/index.js"}},"bin":{"ddg-search-mcp":"bin/cli.js","oevortex-ddg-search":"bin/cli.js"},"scripts":{"test":"echo \"Error: no test specified\" && exit 1","start":"node bin/cli.js","prepublishOnly":"npm run lint","lint":"echo \"No linting configured\"","build":"npx @smithery/cli build","dev":"npx @smithery/cli dev"},"publishConfig":{"access":"public"},"keywords":["mcp","model-context-protocol","duckduckgo","felo","search","web-search","ai-search","claude","ai","llm"],"author":"OEvortex","license":"Apache-2.0","type":"module","dependencies":{"@modelcontextprotocol/sdk":"^1.17.4","axios":"^1.8.4","cheerio":"^1.0.0","jsdom":"^26.1.0","smithery":"^0.5.2","uuid":"^9.0.1"},"devDependencies":{"@types/node":"^24.3.0","tsx":"^4.20.4","typescript":"^5.9.2"}}

package/smithery.yaml

@@ -0,0 +1,12 @@
+runtime: typescript
+
+build:
+  external:
+    - canvas
+    - utf-8-validate
+    - bufferutil
+  esbuild:
+    bundle: true
+    platform: node
+    format: cjs
+    target: node18

package/src/index.js

@@ -1,5 +1,4 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
 // Import tool definitions and handlers
@@ -8,75 +7,99 @@ import { fetchUrlToolDefinition, fetchUrlToolHandler } from './tools/fetchUrlToo
 import { metadataToolDefinition, metadataToolHandler } from './tools/metadataTool.js';
 import { feloToolDefinition, feloToolHandler } from './tools/feloTool.js';
 
-// Create the MCP server
-const server = new Server({
-  id: 'ddg-search-mcp',
-  name: 'DuckDuckGo & Felo AI Search MCP',
-  description: 'A Model Context Protocol server for web search using DuckDuckGo and Felo AI',
-  version: '1.1.1'
-}, {
-  capabilities: {
-    tools: {}
-  }
-});
+// Required: Export default createServer function for Smithery
+export default function createServer({ config } = {}) {
+  console.log('Creating MCP server with latest SDK...');
+  
+  // Global variable to track available tools
+  const availableTools = [
+    searchToolDefinition,
+    fetchUrlToolDefinition,
+    metadataToolDefinition,
+    feloToolDefinition
+  ];
+  
+  console.log('Available tools:', availableTools.map(t => t.name));
 
-// Define available tools
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      searchToolDefinition,
-      fetchUrlToolDefinition,
-      metadataToolDefinition,
-      feloToolDefinition
-    ]
-  };
-});
+  // Create the MCP server using the Server class
+  const server = new Server({
+    name: 'ddg-search-mcp',
+    version: '1.1.2'
+  }, {
+    capabilities: {
+      tools: {
+        listChanged: true
+      }
+    }
+  });
 
-// Handle tool execution
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    const { name, arguments: args } = request.params;
-      // Route to the appropriate tool handler
-    switch (name) {
-      case 'web-search':
-        return await searchToolHandler(args);
-      
-      case 'fetch-url':
-        return await fetchUrlToolHandler(args);
-      
-      case 'url-metadata':
-        return await metadataToolHandler(args);
+  // Define available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    console.log('Tools list requested, returning:', availableTools.length, 'tools');
+    return {
+      tools: availableTools
+    };
+  });
+
+  // Handle tool execution
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      const { name, arguments: args } = request.params;
+      console.log(`Tool call received: ${name} with args:`, args);
       
-      case 'felo-search':
-        return await feloToolHandler(args);
+      // Route to the appropriate tool handler
+      switch (name) {
+        case 'web-search':
+          return await searchToolHandler(args);
+        
+        case 'fetch-url':
+          return await fetchUrlToolHandler(args);
+        
+        case 'url-metadata':
+          return await metadataToolHandler(args);
+        
+        case 'felo-search':
+          return await feloToolHandler(args);
+        
+        default:
+          throw new Error(`Tool not found: ${name}`);
+      }
+    } catch (error) {
+      console.error(`Error handling ${request.params.name} tool call:`, error);
       
-      default:
-        throw new Error(`Tool not found: ${name}`);
+      // Return proper tool execution error format
+      return {
+        isError: true,
+        content: [
+          {
+            type: 'text',
+            text: `Error executing tool '${request.params.name}': ${error.message}`
+          }
+        ]
+      };
     }
-  } catch (error) {
-    console.error(`Error handling ${request.params.name} request:`, error);
-    return {
-      isError: true,
-      content: [
-        {
-          type: 'text',
-          text: `Error: ${error.message}`
-        }
-      ]
-    };
-  }
-});
+  });
 
-// Start the server with stdio transport
-async function main() {
-  try {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error('WebSearch MCP server started and listening on stdio');
-  } catch (error) {
-    console.error('Failed to start server:', error);
-    process.exit(1);
-  }
+  console.log('MCP server created successfully');
+  
+  // Return the server instance (required for Smithery)
+  return server;
 }
 
-main();
+// Legacy standalone server support (for CLI usage)
+if (import.meta.url === `file://${process.argv[1]}`) {
+  async function main() {
+    try {
+      const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+      const server = createServer();
+      const transport = new StdioServerTransport();
+      await server.connect(transport);
+      console.error('WebSearch MCP server started and listening on stdio');
+    } catch (error) {
+      console.error('Failed to start server:', error);
+      process.exit(1);
+    }
+  }
+
+  main();
+}

package/src/index.ts

@@ -0,0 +1,90 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+
+// Import tool definitions and handlers
+import { searchToolDefinition, searchToolHandler } from './tools/searchTool.js';
+import { fetchUrlToolDefinition, fetchUrlToolHandler } from './tools/fetchUrlTool.js';
+import { metadataToolDefinition, metadataToolHandler } from './tools/metadataTool.js';
+import { feloToolDefinition, feloToolHandler } from './tools/feloTool.js';
+
+// Required: Export default createServer function for Smithery
+export default function createServer({ config }: { config?: any } = {}) {
+  console.log('Creating MCP server with latest SDK...');
+  
+  // Global variable to track available tools
+  const availableTools = [
+    searchToolDefinition,
+    fetchUrlToolDefinition,
+    metadataToolDefinition,
+    feloToolDefinition
+  ];
+  
+  console.log('Available tools:', availableTools.map(t => t.name));
+
+  // Create the MCP server using the Server class
+  const server = new Server({
+    name: 'ddg-search-mcp',
+    version: '1.1.2'
+  }, {
+    capabilities: {
+      tools: {
+        listChanged: true
+      }
+    }
+  });
+
+  // Define available tools
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    console.log('Tools list requested, returning:', availableTools.length, 'tools');
+    return {
+      tools: availableTools
+    };
+  });
+
+  // Handle tool execution
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      const { name, arguments: args } = request.params;
+      console.log(`Tool call received: ${name} with args:`, args);
+      
+      // Route to the appropriate tool handler
+      switch (name) {
+        case 'web-search':
+          return await searchToolHandler(args);
+        
+        case 'fetch-url':
+          return await fetchUrlToolHandler(args);
+        
+        case 'url-metadata':
+          return await metadataToolHandler(args);
+        
+        case 'felo-search':
+          return await feloToolHandler(args);
+        
+        default:
+          throw new Error(`Tool not found: ${name}`);
+      }
+    } catch (error: any) {
+      console.error(`Error handling ${request.params.name} tool call:`, error);
+      
+      // Return proper tool execution error format
+      return {
+        isError: true,
+        content: [
+          {
+            type: 'text',
+            text: `Error executing tool '${request.params.name}': ${error.message}`
+          }
+        ]
+      };
+    }
+  });
+
+  console.log('MCP server created successfully');
+  
+  // Return the server instance (required for Smithery)
+  return server;
+}
+
+// Optional: No configuration schema needed for this server
+// export const configSchema = z.object({});

package/src/tools/feloTool.js

@@ -5,7 +5,8 @@ import { searchFelo } from '../utils/search_felo.js';
  */
 export const feloToolDefinition = {
   name: 'felo-search',
-  description: 'Advanced web search tool for technical intelligence. Retrieves up-to-date information from the web, including latest software releases, security advisories, migration guides, benchmarks, developer documentation, and community insights. Designed for function calling and automation, it provides structured, relevant results for engineering, DevOps, and research workflows. Supports both standard and streaming responses for real-time data consumption.',
+  title: 'Felo AI Advanced Search',
+  description: 'Advanced AI-powered web search for technical intelligence. Retrieves up-to-date information including software releases, security advisories, migration guides, benchmarks, developer documentation, and community insights. Supports both standard and streaming responses.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -22,9 +23,8 @@ export const feloToolDefinition = {
     required: ['query']
   },
   annotations: {
-    title: 'Felo AI Advanced Web Search',
-    readOnlyHint: 'Results are read-only and cannot be modified. Use for information retrieval only.',
-    openWorldHint: 'Searches the open web and technical sources for the most current and relevant data. Not limited to a fixed dataset.'
+    readOnlyHint: true,
+    openWorldHint: false
   }
 };
 

package/src/tools/fetchUrlTool.js

@@ -5,50 +5,46 @@ import { fetchUrlContent } from '../utils/search.js';
  */
 export const fetchUrlToolDefinition = {
   name: 'fetch-url',
-  description: 'Fetch the content of a URL and return it as text, with options to control extraction',
+  title: 'Fetch URL Content',
+  description: 'Fetch and extract the main content from any URL, with customizable extraction options for text, links, and images',
   inputSchema: {
     type: 'object',
     properties: {
       url: {
         type: 'string',
-        description: 'The URL to fetch'
+        description: 'The URL to fetch content from (must be a valid HTTP/HTTPS URL)'
       },
       maxLength: {
         type: 'integer',
-        description: 'Maximum length of content to return (default: 10000)',
+        description: 'Maximum length of content to return in characters (default: 10000)',
         default: 10000,
         minimum: 1000,
         maximum: 50000
       },
       extractMainContent: {
         type: 'boolean',
-        description: 'Whether to attempt to extract main content (default: true)',
+        description: 'Whether to attempt to extract main content only, filtering out navigation and ads (default: true)',
         default: true
       },
       includeLinks: {
         type: 'boolean',
-        description: 'Whether to include link text (default: true)',
+        description: 'Whether to include link text in the extracted content (default: true)',
         default: true
       },
       includeImages: {
         type: 'boolean',
-        description: 'Whether to include image alt text (default: true)',
+        description: 'Whether to include image alt text in the extracted content (default: true)',
         default: true
       },
       excludeTags: {
         type: 'array',
-        description: 'Tags to exclude from extraction (default: script, style, etc.)',
+        description: 'HTML tags to exclude from extraction (default: script, style, etc.)',
         items: {
           type: 'string'
         }
       }
     },
     required: ['url']
-  },
-  annotations: {
-    title: 'Fetch URL Content',
-    readOnlyHint: true,
-    openWorldHint: true
   }
 };
 

package/src/tools/metadataTool.js

@@ -5,21 +5,17 @@ import { extractUrlMetadata } from '../utils/search.js';
  */
 export const metadataToolDefinition = {
   name: 'url-metadata',
-  description: 'Extract metadata from a URL (title, description, etc.)',
+  title: 'URL Metadata Extractor',
+  description: 'Extract metadata from a URL including title, description, Open Graph data, and favicon information',
   inputSchema: {
     type: 'object',
     properties: {
       url: {
         type: 'string',
-        description: 'The URL to extract metadata from'
+        description: 'The URL to extract metadata from (must be a valid HTTP/HTTPS URL)'
       }
     },
     required: ['url']
-  },
-  annotations: {
-    title: 'URL Metadata',
-    readOnlyHint: true,
-    openWorldHint: true
   }
 };
 

package/src/tools/searchTool.js

@@ -5,34 +5,30 @@ import { searchDuckDuckGo } from '../utils/search.js';
  */
 export const searchToolDefinition = {
   name: 'web-search',
-  description: 'Search the web using DuckDuckGo and return results',
+  title: 'Web Search',
+  description: 'Search the web using DuckDuckGo and return comprehensive results with titles, URLs, and snippets',
   inputSchema: {
     type: 'object',
     properties: {
       query: {
         type: 'string',
-        description: 'The search query'
+        description: 'The search query to find relevant web pages'
       },
       page: {
         type: 'integer',
-        description: 'Page number (default: 1)',
+        description: 'Page number for pagination (default: 1)',
         default: 1,
         minimum: 1
       },
       numResults: {
         type: 'integer',
-        description: 'Number of results to return (default: 10)',
+        description: 'Number of results to return per page (default: 10, max: 20)',
         default: 10,
         minimum: 1,
         maximum: 20
       }
     },
     required: ['query']
-  },
-  annotations: {
-    title: 'Web Search',
-    readOnlyHint: true,
-    openWorldHint: true
   }
 };