firecrawl-mcp 1.7.1 → 1.8.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 vrknetha
+Copyright (c) 2025 vrknetha
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -2,7 +2,9 @@
 
 A Model Context Protocol (MCP) server implementation that integrates with [Firecrawl](https://github.com/mendableai/firecrawl) for web scraping capabilities.
 
-Big thanks to [@vrknetha](https://github.com/vrknetha), [@cawstudios](https://caw.tech) for the initial implementation!
+> Big thanks to [@vrknetha](https://github.com/vrknetha), [@cawstudios](https://caw.tech) for the initial implementation!
+>
+> You can also play around with [our MCP Server on MCP.so's playground](https://mcp.so/playground?server=firecrawl-mcp-server) or on [Klavis AI](https://www.klavis.ai/mcp-servers). Thanks to MCP.so and Klavis AI for hosting and [@gstarwd](https://github.com/gstarwd) and [@xiangkaiz](https://github.com/xiangkaiz) for integrating our server.
 
 ## Features
 
@@ -11,10 +13,10 @@ Big thanks to [@vrknetha](https://github.com/vrknetha), [@cawstudios](https://ca
 - URL discovery and crawling
 - Web search with content extraction
 - Automatic retries with exponential backoff
-- - Efficient batch processing with built-in rate limiting
+  - Efficient batch processing with built-in rate limiting
 - Credit usage monitoring for cloud API
 - Comprehensive logging system
-- Support for cloud and self-hosted FireCrawl instances
+- Support for cloud and self-hosted Firecrawl instances
 - Mobile/Desktop viewport support
 - Smart content filtering with tag inclusion/exclusion
 
@@ -36,22 +38,44 @@ npm install -g firecrawl-mcp
 
 Configuring Cursor 🖥️
 Note: Requires Cursor version 0.45.6+
+For the most up-to-date configuration instructions, please refer to the official Cursor documentation on configuring MCP servers:
+[Cursor MCP Server Configuration Guide](https://docs.cursor.com/context/model-context-protocol#configuring-mcp-servers)
 
-To configure FireCrawl MCP in Cursor:
+To configure Firecrawl MCP in Cursor **v0.45.6**
 
 1. Open Cursor Settings
-2. Go to Features > MCP Servers 
+2. Go to Features > MCP Servers
 3. Click "+ Add New MCP Server"
 4. Enter the following:
    - Name: "firecrawl-mcp" (or your preferred name)
    - Type: "command"
    - Command: `env FIRECRAWL_API_KEY=your-api-key npx -y firecrawl-mcp`
 
+To configure Firecrawl MCP in Cursor **v0.48.6**
+
+1. Open Cursor Settings
+2. Go to Features > MCP Servers
+3. Click "+ Add new global MCP server"
+4. Enter the following code:
+   ```json
+   {
+     "mcpServers": {
+       "firecrawl-mcp": {
+         "command": "npx",
+         "args": ["-y", "firecrawl-mcp"],
+         "env": {
+           "FIRECRAWL_API_KEY": "YOUR-API-KEY"
+         }
+       }
+     }
+   }
+   ```
+
 > If you are using Windows and are running into issues, try `cmd /c "set FIRECRAWL_API_KEY=your-api-key && npx -y firecrawl-mcp"`
 
-Replace `your-api-key` with your FireCrawl API key.
+Replace `your-api-key` with your Firecrawl API key. If you don't have one yet, you can create an account and get it from https://www.firecrawl.dev/app/api-keys
 
-After adding, refresh the MCP server list to see the new tools. The Composer Agent will automatically use FireCrawl MCP when appropriate, but you can explicitly request it by describing your web scraping needs. Access the Composer via Command+L (Mac), select "Agent" next to the submit button, and enter your query.
+After adding, refresh the MCP server list to see the new tools. The Composer Agent will automatically use Firecrawl MCP when appropriate, but you can explicitly request it by describing your web scraping needs. Access the Composer via Command+L (Mac), select "Agent" next to the submit button, and enter your query.
 
 ### Running on Windsurf
 
@@ -64,17 +88,16 @@ Add this to your `./codeium/windsurf/model_config.json`:
       "command": "npx",
       "args": ["-y", "firecrawl-mcp"],
       "env": {
-        "FIRECRAWL_API_KEY": "YOUR_API_KEY_HERE"
+        "FIRECRAWL_API_KEY": "YOUR_API_KEY"
       }
     }
   }
 }
 ```
 
-
 ### Installing via Smithery (Legacy)
 
-To install FireCrawl for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@mendableai/mcp-server-firecrawl):
+To install Firecrawl for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@mendableai/mcp-server-firecrawl):
 
 ```bash
 npx -y @smithery/cli install @mendableai/mcp-server-firecrawl --client claude
@@ -86,7 +109,7 @@ npx -y @smithery/cli install @mendableai/mcp-server-firecrawl --client claude
 
 #### Required for Cloud API
 
-- `FIRECRAWL_API_KEY`: Your FireCrawl API key
+- `FIRECRAWL_API_KEY`: Your Firecrawl API key
   - Required when using cloud API (default)
   - Optional when using self-hosted instance with `FIRECRAWL_API_URL`
 - `FIRECRAWL_API_URL` (Optional): Custom API endpoint for self-hosted instances
@@ -206,7 +229,7 @@ These configurations control:
 
 ### Rate Limiting and Batch Processing
 
-The server utilizes FireCrawl's built-in rate limiting and batch processing capabilities:
+The server utilizes Firecrawl's built-in rate limiting and batch processing capabilities:
 
 - Automatic rate limit handling with exponential backoff
 - Efficient parallel processing for batch operations
@@ -372,7 +395,60 @@ Example response:
 - `enableWebSearch`: Enable web search for additional context
 - `includeSubdomains`: Include subdomains in extraction
 
-When using a self-hosted instance, the extraction will use your configured LLM. For cloud API, it uses FireCrawl's managed LLM service.
+When using a self-hosted instance, the extraction will use your configured LLM. For cloud API, it uses Firecrawl's managed LLM service.
+
+### 7. Deep Research Tool (firecrawl_deep_research)
+
+Conduct deep web research on a query using intelligent crawling, search, and LLM analysis.
+
+```json
+{
+  "name": "firecrawl_deep_research",
+  "arguments": {
+    "query": "how does carbon capture technology work?",
+    "maxDepth": 3,
+    "timeLimit": 120,
+    "maxUrls": 50
+  }
+}
+```
+
+Arguments:
+
+- query (string, required): The research question or topic to explore.
+- maxDepth (number, optional): Maximum recursive depth for crawling/search (default: 3).
+- timeLimit (number, optional): Time limit in seconds for the research session (default: 120).
+- maxUrls (number, optional): Maximum number of URLs to analyze (default: 50).
+
+Returns:
+
+- Final analysis generated by an LLM based on research. (data.finalAnalysis)
+- May also include structured activities and sources used in the research process.
+
+### 8. Generate LLMs.txt Tool (firecrawl_generate_llmstxt)
+
+Generate a standardized llms.txt (and optionally llms-full.txt) file for a given domain. This file defines how large language models should interact with the site.
+
+```json
+{
+  "name": "firecrawl_generate_llmstxt",
+  "arguments": {
+    "url": "https://example.com",
+    "maxUrls": 20,
+    "showFullText": true
+  }
+}
+```
+
+Arguments:
+
+- url (string, required): The base URL of the website to analyze.
+- maxUrls (number, optional): Max number of URLs to include (default: 10).
+- showFullText (boolean, optional): Whether to include llms-full.txt contents in the response.
+
+Returns:
+
+- Generated llms.txt file contents and optionally the llms-full.txt (data.llmstxt and/or data.llmsfulltxt)
 
 ## Logging System
 
@@ -387,7 +463,7 @@ The server includes comprehensive logging:
 Example log messages:
 
 ```
-[INFO] FireCrawl MCP Server initialized successfully
+[INFO] Firecrawl MCP Server initialized successfully
 [INFO] Starting scrape for URL: https://example.com
 [INFO] Batch operation queued with ID: batch_1
 [WARNING] Credit usage has reached warning threshold

package/dist/index.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import FirecrawlApp from '@mendable/firecrawl-js';
-import PQueue from 'p-queue';
+import express from 'express';
 import dotenv from 'dotenv';
 dotenv.config();
 // Tool definitions
@@ -33,6 +34,7 @@ const SCRAPE_TOOL = {
                         'extract',
                     ],
                 },
+                default: ['markdown'],
                 description: "Content formats to extract (default: ['markdown'])",
             },
             onlyMainContent: {
@@ -303,69 +305,6 @@ const CRAWL_TOOL = {
         required: ['url'],
     },
 };
-const BATCH_SCRAPE_TOOL = {
-    name: 'firecrawl_batch_scrape',
-    description: 'Scrape multiple URLs in batch mode. Returns a job ID that can be used to check status.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            urls: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'List of URLs to scrape',
-            },
-            options: {
-                type: 'object',
-                properties: {
-                    formats: {
-                        type: 'array',
-                        items: {
-                            type: 'string',
-                            enum: [
-                                'markdown',
-                                'html',
-                                'rawHtml',
-                                'screenshot',
-                                'links',
-                                'screenshot@fullPage',
-                                'extract',
-                            ],
-                        },
-                    },
-                    onlyMainContent: {
-                        type: 'boolean',
-                    },
-                    includeTags: {
-                        type: 'array',
-                        items: { type: 'string' },
-                    },
-                    excludeTags: {
-                        type: 'array',
-                        items: { type: 'string' },
-                    },
-                    waitFor: {
-                        type: 'number',
-                    },
-                },
-            },
-        },
-        required: ['urls'],
-    },
-};
-const CHECK_BATCH_STATUS_TOOL = {
-    name: 'firecrawl_check_batch_status',
-    description: 'Check the status of a batch scraping job.',
-    inputSchema: {
-        type: 'object',
-        properties: {
-            id: {
-                type: 'string',
-                description: 'Batch job ID to check',
-            },
-        },
-        required: ['id'],
-    },
-};
 const CHECK_CRAWL_STATUS_TOOL = {
     name: 'firecrawl_check_crawl_status',
     description: 'Check the status of a crawl job.',
@@ -559,13 +498,6 @@ function isCrawlOptions(args) {
         'url' in args &&
         typeof args.url === 'string');
 }
-function isBatchScrapeOptions(args) {
-    return (typeof args === 'object' &&
-        args !== null &&
-        'urls' in args &&
-        Array.isArray(args.urls) &&
-        args.urls.every((url) => typeof url === 'string'));
-}
 function isStatusCheckOptions(args) {
     return (typeof args === 'object' &&
         args !== null &&
@@ -605,15 +537,13 @@ const server = new Server({
 const FIRECRAWL_API_URL = process.env.FIRECRAWL_API_URL;
 const FIRECRAWL_API_KEY = process.env.FIRECRAWL_API_KEY;
 // Check if API key is required (only for cloud service)
-if (!FIRECRAWL_API_URL && !FIRECRAWL_API_KEY) {
+if (process.env.CLOUD_SERVICE !== 'true' &&
+    !FIRECRAWL_API_URL &&
+    !FIRECRAWL_API_KEY) {
     console.error('Error: FIRECRAWL_API_KEY environment variable is required when using the cloud service');
     process.exit(1);
 }
-// Initialize FireCrawl client with optional API URL
-const client = new FirecrawlApp({
-    apiKey: FIRECRAWL_API_KEY || '',
-    ...(FIRECRAWL_API_URL ? { apiUrl: FIRECRAWL_API_URL } : {}),
-});
+// Initialize Firecrawl client with optional API URL
 // Configuration for retries and monitoring
 const CONFIG = {
     retry: {
@@ -627,10 +557,6 @@ const CONFIG = {
         criticalThreshold: Number(process.env.FIRECRAWL_CREDIT_CRITICAL_THRESHOLD) || 100,
     },
 };
-const creditUsage = {
-    total: 0,
-    lastCheck: Date.now(),
-};
 // Add utility function for delay
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -664,58 +590,12 @@ async function withRetry(operation, context, attempt = 1) {
         throw error;
     }
 }
-// Add credit monitoring
-async function updateCreditUsage(creditsUsed) {
-    creditUsage.total += creditsUsed;
-    // Log credit usage
-    safeLog('info', `Credit usage: ${creditUsage.total} credits used total`);
-    // Check thresholds
-    if (creditUsage.total >= CONFIG.credit.criticalThreshold) {
-        safeLog('error', `CRITICAL: Credit usage has reached ${creditUsage.total}`);
-    }
-    else if (creditUsage.total >= CONFIG.credit.warningThreshold) {
-        safeLog('warning', `WARNING: Credit usage has reached ${creditUsage.total}`);
-    }
-}
-// Initialize queue system
-const batchQueue = new PQueue({ concurrency: 1 });
-const batchOperations = new Map();
-let operationCounter = 0;
-async function processBatchOperation(operation) {
-    try {
-        operation.status = 'processing';
-        let totalCreditsUsed = 0;
-        // Use library's built-in batch processing
-        const response = await withRetry(async () => client.asyncBatchScrapeUrls(operation.urls, operation.options), `batch ${operation.id} processing`);
-        if (!response.success) {
-            throw new Error(response.error || 'Batch operation failed');
-        }
-        // Track credits if using cloud API
-        if (!FIRECRAWL_API_URL && hasCredits(response)) {
-            totalCreditsUsed += response.creditsUsed;
-            await updateCreditUsage(response.creditsUsed);
-        }
-        operation.status = 'completed';
-        operation.result = response;
-        // Log final credit usage for the batch
-        if (!FIRECRAWL_API_URL) {
-            safeLog('info', `Batch ${operation.id} completed. Total credits used: ${totalCreditsUsed}`);
-        }
-    }
-    catch (error) {
-        operation.status = 'failed';
-        operation.error = error instanceof Error ? error.message : String(error);
-        safeLog('error', `Batch ${operation.id} failed: ${operation.error}`);
-    }
-}
 // Tool handlers
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
         SCRAPE_TOOL,
         MAP_TOOL,
         CRAWL_TOOL,
-        BATCH_SCRAPE_TOOL,
-        CHECK_BATCH_STATUS_TOOL,
         CHECK_CRAWL_STATUS_TOOL,
         SEARCH_TOOL,
         EXTRACT_TOOL,
@@ -727,6 +607,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const startTime = Date.now();
     try {
         const { name, arguments: args } = request.params;
+        const apiKey = process.env.CLOUD_SERVICE
+            ? request.params._meta?.apiKey
+            : FIRECRAWL_API_KEY;
+        if (process.env.CLOUD_SERVICE && !apiKey) {
+            throw new Error('No API key provided');
+        }
+        const client = new FirecrawlApp({
+            apiKey,
+            ...(FIRECRAWL_API_URL ? { apiUrl: FIRECRAWL_API_URL } : {}),
+        });
         // Log incoming request with timestamp
         safeLog('info', `[${new Date().toISOString()}] Received request for tool: ${name}`);
         if (!args) {
@@ -741,7 +631,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 try {
                     const scrapeStartTime = Date.now();
                     safeLog('info', `Starting scrape for URL: ${url} with options: ${JSON.stringify(options)}`);
-                    const response = await client.scrapeUrl(url, options);
+                    const response = await client.scrapeUrl(url, {
+                        ...options,
+                        // @ts-expect-error Extended API options including origin
+                        origin: 'mcp-server',
+                    });
                     // Log performance metrics
                     safeLog('info', `Scrape completed in ${Date.now() - scrapeStartTime}ms`);
                     if ('success' in response && !response.success) {
@@ -798,12 +692,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     throw new Error('Invalid arguments for firecrawl_map');
                 }
                 const { url, ...options } = args;
-                const response = await client.mapUrl(url, options);
+                const response = await client.mapUrl(url, {
+                    ...options,
+                    // @ts-expect-error Extended API options including origin
+                    origin: 'mcp-server',
+                });
                 if ('error' in response) {
                     throw new Error(response.error);
                 }
                 if (!response.links) {
-                    throw new Error('No links received from FireCrawl API');
+                    throw new Error('No links received from Firecrawl API');
                 }
                 return {
                     content: [
@@ -812,87 +710,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: false,
                 };
             }
-            case 'firecrawl_batch_scrape': {
-                if (!isBatchScrapeOptions(args)) {
-                    throw new Error('Invalid arguments for firecrawl_batch_scrape');
-                }
-                try {
-                    const operationId = `batch_${++operationCounter}`;
-                    const operation = {
-                        id: operationId,
-                        urls: args.urls,
-                        options: args.options,
-                        status: 'pending',
-                        progress: {
-                            completed: 0,
-                            total: args.urls.length,
-                        },
-                    };
-                    batchOperations.set(operationId, operation);
-                    // Queue the operation
-                    batchQueue.add(() => processBatchOperation(operation));
-                    safeLog('info', `Queued batch operation ${operationId} with ${args.urls.length} URLs`);
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: trimResponseText(`Batch operation queued with ID: ${operationId}. Use firecrawl_check_batch_status to check progress.`),
-                            },
-                        ],
-                        isError: false,
-                    };
-                }
-                catch (error) {
-                    const errorMessage = error instanceof Error
-                        ? error.message
-                        : `Batch operation failed: ${JSON.stringify(error)}`;
-                    return {
-                        content: [{ type: 'text', text: trimResponseText(errorMessage) }],
-                        isError: true,
-                    };
-                }
-            }
-            case 'firecrawl_check_batch_status': {
-                if (!isStatusCheckOptions(args)) {
-                    throw new Error('Invalid arguments for firecrawl_check_batch_status');
-                }
-                const operation = batchOperations.get(args.id);
-                if (!operation) {
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: trimResponseText(`No batch operation found with ID: ${args.id}`),
-                            },
-                        ],
-                        isError: true,
-                    };
-                }
-                const status = `Batch Status:
-Status: ${operation.status}
-Progress: ${operation.progress.completed}/${operation.progress.total}
-${operation.error ? `Error: ${operation.error}` : ''}
-${operation.result
-                    ? `Results: ${JSON.stringify(operation.result, null, 2)}`
-                    : ''}`;
-                return {
-                    content: [{ type: 'text', text: trimResponseText(status) }],
-                    isError: false,
-                };
-            }
             case 'firecrawl_crawl': {
                 if (!isCrawlOptions(args)) {
                     throw new Error('Invalid arguments for firecrawl_crawl');
                 }
                 const { url, ...options } = args;
-                const response = await withRetry(async () => client.asyncCrawlUrl(url, options), 'crawl operation');
+                const response = await withRetry(async () => 
+                // @ts-expect-error Extended API options including origin
+                client.asyncCrawlUrl(url, { ...options, origin: 'mcp-server' }), 'crawl operation');
                 if (!response.success) {
                     throw new Error(response.error);
                 }
-                // Monitor credits for cloud API
-                if (!FIRECRAWL_API_URL && hasCredits(response)) {
-                    await updateCreditUsage(response.creditsUsed);
-                }
                 return {
                     content: [
                         {
@@ -927,14 +755,10 @@ ${response.data.length > 0 ? '\nResults:\n' + formatResults(response.data) : ''}
                     throw new Error('Invalid arguments for firecrawl_search');
                 }
                 try {
-                    const response = await withRetry(async () => client.search(args.query, args), 'search operation');
+                    const response = await withRetry(async () => client.search(args.query, { ...args, origin: 'mcp-server' }), 'search operation');
                     if (!response.success) {
                         throw new Error(`Search failed: ${response.error || 'Unknown error'}`);
                     }
-                    // Monitor credits for cloud API
-                    if (!FIRECRAWL_API_URL && hasCredits(response)) {
-                        await updateCreditUsage(response.creditsUsed);
-                    }
                     // Format the results
                     const results = response.data
                         .map((result) => `URL: ${result.url}
@@ -982,10 +806,6 @@ ${result.markdown ? `\nContent:\n${result.markdown}` : ''}`)
                         throw new Error(extractResponse.error || 'Extraction failed');
                     }
                     const response = extractResponse;
-                    // Monitor credits for cloud API
-                    if (!FIRECRAWL_API_URL && hasCredits(response)) {
-                        await updateCreditUsage(response.creditsUsed || 0);
-                    }
                     // Log performance metrics
                     safeLog('info', `Extraction completed in ${Date.now() - extractStartTime}ms`);
                     // Add warning to response if present
@@ -1036,6 +856,8 @@ ${result.markdown ? `\nContent:\n${result.markdown}` : ''}`)
                         maxDepth: args.maxDepth,
                         timeLimit: args.timeLimit,
                         maxUrls: args.maxUrls,
+                        // @ts-expect-error Extended API options including origin
+                        origin: 'mcp-server',
                     }, 
                     // Activity callback
                     (activity) => {
@@ -1083,7 +905,9 @@ ${result.markdown ? `\nContent:\n${result.markdown}` : ''}`)
                     const generateStartTime = Date.now();
                     safeLog('info', `Starting LLMs.txt generation for URL: ${url}`);
                     // Start the generation process
-                    const response = await withRetry(async () => client.generateLLMsText(url, params), 'LLMs.txt generation');
+                    const response = await withRetry(async () => 
+                    // @ts-expect-error Extended API options including origin
+                    client.generateLLMsText(url, { ...params, origin: 'mcp-server' }), 'LLMs.txt generation');
                     if (!response.success) {
                         throw new Error(response.error || 'LLMs.txt generation failed');
                     }
@@ -1154,19 +978,15 @@ ${doc.metadata?.title ? `Title: ${doc.metadata.title}` : ''}`;
     })
         .join('\n\n');
 }
-// Add type guard for credit usage
-function hasCredits(response) {
-    return 'creditsUsed' in response && typeof response.creditsUsed === 'number';
-}
 // Utility function to trim trailing whitespace from text responses
 // This prevents Claude API errors with "final assistant content cannot end with trailing whitespace"
 function trimResponseText(text) {
     return text.trim();
 }
 // Server startup
-async function runServer() {
+async function runLocalServer() {
     try {
-        console.error('Initializing FireCrawl MCP Server...');
+        console.error('Initializing Firecrawl MCP Server...');
         const transport = new StdioServerTransport();
         // Detect if we're using stdio transport
         isStdioTransport = transport instanceof StdioServerTransport;
@@ -1175,16 +995,96 @@ async function runServer() {
         }
         await server.connect(transport);
         // Now that we're connected, we can send logging messages
-        safeLog('info', 'FireCrawl MCP Server initialized successfully');
+        safeLog('info', 'Firecrawl MCP Server initialized successfully');
         safeLog('info', `Configuration: API URL: ${FIRECRAWL_API_URL || 'default'}`);
-        console.error('FireCrawl MCP Server running on stdio');
+        console.error('Firecrawl MCP Server running on stdio');
     }
     catch (error) {
         console.error('Fatal error running server:', error);
         process.exit(1);
     }
 }
-runServer().catch((error) => {
-    console.error('Fatal error running server:', error);
-    process.exit(1);
-});
+async function runSSELocalServer() {
+    let transport = null;
+    const app = express();
+    app.get('/sse', async (req, res) => {
+        transport = new SSEServerTransport(`/messages`, res);
+        res.on('close', () => {
+            transport = null;
+        });
+        await server.connect(transport);
+    });
+    // Endpoint for the client to POST messages
+    // Remove express.json() middleware - let the transport handle the body
+    app.post('/messages', (req, res) => {
+        if (transport) {
+            transport.handlePostMessage(req, res);
+        }
+    });
+}
+async function runSSECloudServer() {
+    const transports = {};
+    const app = express();
+    app.get('/:apiKey/sse', async (req, res) => {
+        const apiKey = req.params.apiKey;
+        const transport = new SSEServerTransport(`/${apiKey}/messages`, res);
+        //todo: validate api key, close if invalid
+        const compositeKey = `${apiKey}-${transport.sessionId}`;
+        transports[compositeKey] = transport;
+        res.on('close', () => {
+            delete transports[compositeKey];
+        });
+        await server.connect(transport);
+    });
+    // Endpoint for the client to POST messages
+    // Remove express.json() middleware - let the transport handle the body
+    app.post('/:apiKey/messages', express.json(), async (req, res) => {
+        const apiKey = req.params.apiKey;
+        const body = req.body;
+        const enrichedBody = {
+            ...body,
+        };
+        if (enrichedBody && enrichedBody.params && !enrichedBody.params._meta) {
+            enrichedBody.params._meta = { apiKey };
+        }
+        else if (enrichedBody &&
+            enrichedBody.params &&
+            enrichedBody.params._meta) {
+            enrichedBody.params._meta.apiKey = apiKey;
+        }
+        console.log('enrichedBody', enrichedBody);
+        const sessionId = req.query.sessionId;
+        const compositeKey = `${apiKey}-${sessionId}`;
+        const transport = transports[compositeKey];
+        if (transport) {
+            await transport.handlePostMessage(req, res, enrichedBody);
+        }
+        else {
+            res.status(400).send('No transport found for sessionId');
+        }
+    });
+    const PORT = 3000;
+    app.listen(PORT, () => {
+        console.log(`MCP SSE Server listening on http://localhost:${PORT}`);
+        console.log(`SSE endpoint: http://localhost:${PORT}/sse`);
+        console.log(`Message endpoint: http://localhost:${PORT}/messages`);
+    });
+}
+if (process.env.CLOUD_SERVICE === 'true') {
+    runSSECloudServer().catch((error) => {
+        console.error('Fatal error running server:', error);
+        process.exit(1);
+    });
+}
+else if (process.env.SSE_LOCAL === 'true') {
+    runSSELocalServer().catch((error) => {
+        console.error('Fatal error running server:', error);
+        process.exit(1);
+    });
+}
+else {
+    runLocalServer().catch((error) => {
+        console.error('Fatal error running server:', error);
+        process.exit(1);
+    });
+}