@amplify-studio/open-mcp 0.8.0

package/dist/types.js

@@ -0,0 +1,79 @@
+export function isSearXNGWebSearchArgs(args) {
+    return (typeof args === "object" &&
+        args !== null &&
+        "query" in args &&
+        typeof args.query === "string");
+}
+export const WEB_SEARCH_TOOL = {
+    name: "searxng_web_search",
+    description: "Performs a web search using the SearXNG API, ideal for general queries, news, articles, and online content. " +
+        "Use this for broad information gathering, recent events, or when you need diverse web sources.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            query: {
+                type: "string",
+                description: "The search query. This is the main input for the web search",
+            },
+            pageno: {
+                type: "number",
+                description: "Search page number (starts at 1)",
+                default: 1,
+            },
+            time_range: {
+                type: "string",
+                description: "Time range of search (day, month, year)",
+                enum: ["day", "month", "year"],
+            },
+            language: {
+                type: "string",
+                description: "Language code for search results (e.g., 'en', 'fr', 'de'). Default is instance-dependent.",
+                default: "all",
+            },
+            safesearch: {
+                type: "string",
+                description: "Safe search filter level (0: None, 1: Moderate, 2: Strict)",
+                enum: ["0", "1", "2"],
+                default: "0",
+            },
+        },
+        required: ["query"],
+    },
+};
+export const READ_URL_TOOL = {
+    name: "web_url_read",
+    description: "Read the content from an URL. " +
+        "Use this for further information retrieving to understand the content of each URL.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            url: {
+                type: "string",
+                description: "URL",
+            },
+            startChar: {
+                type: "number",
+                description: "Starting character position for content extraction (default: 0)",
+                minimum: 0,
+            },
+            maxLength: {
+                type: "number",
+                description: "Maximum number of characters to return",
+                minimum: 1,
+            },
+            section: {
+                type: "string",
+                description: "Extract content under a specific heading (searches for heading text)",
+            },
+            paragraphRange: {
+                type: "string",
+                description: "Return specific paragraph ranges (e.g., '1-5', '3', '10-')",
+            },
+            readHeadings: {
+                type: "boolean",
+                description: "Return only a list of headings instead of full content",
+            },
+        },
+        required: ["url"],
+    },
+};

package/dist/url-reader.d.ts

@@ -0,0 +1,10 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+interface PaginationOptions {
+    startChar?: number;
+    maxLength?: number;
+    section?: string;
+    paragraphRange?: string;
+    readHeadings?: boolean;
+}
+export declare function fetchAndConvertToMarkdown(server: Server, url: string, timeoutMs?: number, paginationOptions?: PaginationOptions): Promise<string>;
+export {};

package/dist/url-reader.js

@@ -0,0 +1,212 @@
+import { createProxyAgent } from "./proxy.js";
+import { logMessage } from "./logging.js";
+import { urlCache } from "./cache.js";
+import { createURLFormatError, createNetworkError, createServerError, createContentError, createTimeoutError, createEmptyContentWarning, createUnexpectedError } from "./error-handler.js";
+function applyCharacterPagination(content, startChar = 0, maxLength) {
+    if (startChar >= content.length) {
+        return "";
+    }
+    const start = Math.max(0, startChar);
+    const end = maxLength ? Math.min(content.length, start + maxLength) : content.length;
+    return content.slice(start, end);
+}
+function extractSection(markdownContent, sectionHeading) {
+    const lines = markdownContent.split('\n');
+    const sectionRegex = new RegExp(`^#{1,6}\s*.*${sectionHeading}.*$`, 'i');
+    let startIndex = -1;
+    let currentLevel = 0;
+    // Find the section start
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (sectionRegex.test(line)) {
+            startIndex = i;
+            currentLevel = (line.match(/^#+/) || [''])[0].length;
+            break;
+        }
+    }
+    if (startIndex === -1) {
+        return "";
+    }
+    // Find the section end (next heading of same or higher level)
+    let endIndex = lines.length;
+    for (let i = startIndex + 1; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(/^#+/);
+        if (match && match[0].length <= currentLevel) {
+            endIndex = i;
+            break;
+        }
+    }
+    return lines.slice(startIndex, endIndex).join('\n');
+}
+function extractParagraphRange(markdownContent, range) {
+    const paragraphs = markdownContent.split('\n\n').filter(p => p.trim().length > 0);
+    // Parse range (e.g., "1-5", "3", "10-")
+    const rangeMatch = range.match(/^(\d+)(?:-(\d*))?$/);
+    if (!rangeMatch) {
+        return "";
+    }
+    const start = parseInt(rangeMatch[1]) - 1; // Convert to 0-based index
+    const endStr = rangeMatch[2];
+    if (start < 0 || start >= paragraphs.length) {
+        return "";
+    }
+    if (endStr === undefined) {
+        // Single paragraph (e.g., "3")
+        return paragraphs[start] || "";
+    }
+    else if (endStr === "") {
+        // Range to end (e.g., "10-")
+        return paragraphs.slice(start).join('\n\n');
+    }
+    else {
+        // Specific range (e.g., "1-5")
+        const end = parseInt(endStr);
+        return paragraphs.slice(start, end).join('\n\n');
+    }
+}
+function extractHeadings(markdownContent) {
+    const lines = markdownContent.split('\n');
+    const headings = lines.filter(line => /^#{1,6}\s/.test(line));
+    if (headings.length === 0) {
+        return "No headings found in the content.";
+    }
+    return headings.join('\n');
+}
+function applyPaginationOptions(markdownContent, options) {
+    let result = markdownContent;
+    // Apply heading extraction first if requested
+    if (options.readHeadings) {
+        return extractHeadings(result);
+    }
+    // Apply section extraction
+    if (options.section) {
+        result = extractSection(result, options.section);
+        if (result === "") {
+            return `Section "${options.section}" not found in the content.`;
+        }
+    }
+    // Apply paragraph range filtering
+    if (options.paragraphRange) {
+        result = extractParagraphRange(result, options.paragraphRange);
+        if (result === "") {
+            return `Paragraph range "${options.paragraphRange}" is invalid or out of bounds.`;
+        }
+    }
+    // Apply character-based pagination last
+    if (options.startChar !== undefined || options.maxLength !== undefined) {
+        result = applyCharacterPagination(result, options.startChar, options.maxLength);
+    }
+    return result;
+}
+export async function fetchAndConvertToMarkdown(server, url, timeoutMs = 10000, paginationOptions = {}) {
+    const startTime = Date.now();
+    logMessage(server, "info", `Fetching URL: ${url}`);
+    // Check cache first
+    const cachedEntry = urlCache.get(url);
+    if (cachedEntry) {
+        logMessage(server, "info", `Using cached content for URL: ${url}`);
+        const result = applyPaginationOptions(cachedEntry.markdownContent, paginationOptions);
+        const duration = Date.now() - startTime;
+        logMessage(server, "info", `Processed cached URL: ${url} (${result.length} chars in ${duration}ms)`);
+        return result;
+    }
+    // Validate URL format
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(url);
+    }
+    catch (error) {
+        logMessage(server, "error", `Invalid URL format: ${url}`);
+        throw createURLFormatError(url);
+    }
+    // Build gateway API URL
+    const gatewayUrl = process.env.GATEWAY_URL || "http://115.190.91.253:80";
+    const gatewayApiUrl = `${gatewayUrl}/api/read/${encodeURIComponent(url)}`;
+    // Create an AbortController instance
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        // Prepare request options with proxy support
+        const requestOptions = {
+            signal: controller.signal,
+        };
+        // Add proxy dispatcher if proxy is configured
+        // Node.js fetch uses 'dispatcher' option for proxy, not 'agent'
+        const proxyAgent = createProxyAgent(gatewayApiUrl);
+        if (proxyAgent) {
+            requestOptions.dispatcher = proxyAgent;
+        }
+        let response;
+        try {
+            // Fetch the URL via gateway API with the abort signal
+            response = await fetch(gatewayApiUrl, requestOptions);
+        }
+        catch (error) {
+            const context = {
+                url,
+                gatewayUrl,
+                proxyAgent: !!proxyAgent,
+                timeout: timeoutMs
+            };
+            throw createNetworkError(error, context);
+        }
+        if (!response.ok) {
+            let responseBody;
+            try {
+                responseBody = await response.text();
+            }
+            catch {
+                responseBody = '[Could not read response body]';
+            }
+            const context = { url, gatewayUrl };
+            throw createServerError(response.status, response.statusText, responseBody, context);
+        }
+        // Retrieve content from gateway API (JSON response)
+        let markdownContent;
+        try {
+            const jsonData = await response.json();
+            // Gateway API returns: { content: "...", title: "...", url: "...", wordCount: N }
+            if (!jsonData.content) {
+                throw createContentError("Gateway API returned empty content field.", url);
+            }
+            markdownContent = jsonData.content;
+        }
+        catch (error) {
+            if (error.name === 'MCPSearXNGError') {
+                throw error;
+            }
+            throw createContentError(`Failed to read gateway response: ${error.message || 'Unknown error'}`, url);
+        }
+        if (!markdownContent || markdownContent.trim().length === 0) {
+            logMessage(server, "warning", `Empty content from gateway: ${url}`);
+            return createEmptyContentWarning(url, 0, "");
+        }
+        // Cache the markdown content from gateway
+        urlCache.set(url, "", markdownContent);
+        // Apply pagination options
+        const result = applyPaginationOptions(markdownContent, paginationOptions);
+        const duration = Date.now() - startTime;
+        logMessage(server, "info", `Successfully fetched and converted URL: ${url} (${result.length} chars in ${duration}ms)`);
+        return result;
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            logMessage(server, "error", `Timeout fetching URL: ${url} (${timeoutMs}ms)`);
+            throw createTimeoutError(timeoutMs, url);
+        }
+        // Re-throw our enhanced errors
+        if (error.name === 'MCPSearXNGError') {
+            logMessage(server, "error", `Error fetching URL: ${url} - ${error.message}`);
+            throw error;
+        }
+        // Catch any unexpected errors
+        logMessage(server, "error", `Unexpected error fetching URL: ${url}`, error);
+        const context = { url };
+        throw createUnexpectedError(error, context);
+    }
+    finally {
+        // Clean up the timeout to prevent memory leaks
+        clearTimeout(timeoutId);
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+    "name": "@amplify-studio/open-mcp",
+    "version": "0.8.0",
+    "description": "Open MCP server for web search and URL reading via Gateway API",
+    "license": "MIT",
+    "author": "Amplify Studio (https://github.com/amplify-studio)",
+    "homepage": "https://github.com/amplify-studio/open-mcp",
+    "bugs": "https://github.com/amplify-studio/open-mcp/issues",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/amplify-studio/open-mcp"
+    },
+    "keywords": [
+        "mcp",
+        "modelcontextprotocol",
+        "searxng",
+        "search",
+        "web-search",
+        "claude",
+        "ai",
+        "pagination",
+        "smithery",
+        "url-reader"
+    ],
+    "type": "module",
+    "bin": {
+        "open-mcp": "dist/index.js"
+    },
+    "main": "dist/index.js",
+    "files": [
+        "dist"
+    ],
+    "engines": {
+        "node": ">=20"
+    },
+    "scripts": {
+        "build": "tsc && shx chmod +x dist/*.js",
+        "watch": "tsc --watch",
+        "test": "SEARXNG_URL=https://test-searx.example.com tsx __tests__/run-all.ts",
+        "test:coverage": "SEARXNG_URL=https://test-searx.example.com c8 --reporter=text tsx __tests__/run-all.ts",
+        "bootstrap": "npm install && npm run build",
+        "inspector": "DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector node dist/index.js",
+        "postversion": "TAG=$(node scripts/update-version.js | tail -1) && git add src/index.ts && git commit --amend --no-edit && git tag -f $TAG"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "1.17.4",
+        "@types/cors": "^2.8.19",
+        "@types/express": "^5.0.3",
+        "cors": "^2.8.5",
+        "express": "^5.1.0",
+        "node-html-markdown": "^1.3.0",
+        "undici": "^6.20.1"
+    },
+    "devDependencies": {
+        "mcp-evals": "^1.0.18",
+        "@types/node": "^22.17.2",
+        "@types/supertest": "^6.0.3",
+        "c8": "^10.1.3",
+        "shx": "^0.4.0",
+        "supertest": "^7.1.4",
+        "tsx": "^4.20.5",
+        "typescript": "^5.8.3"
+    }
+}