Use .actor/input_schema.json as input for MCP

Author: jirispilka

.dockerignore

@@ -5,6 +5,7 @@
 apify_storage
 crawlee_storage
 storage
+dist
 
 # installed files
 node_modules
@@ -14,3 +15,4 @@ node_modules
 
 # data
 data
+src/storage

src/mcp/server.ts

@@ -8,28 +8,19 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 
-import { defaults } from '../const.js';
+import inputSchema from '../../.actor/input_schema.json' assert { type: 'json' };
 import { handleModelContextProtocol } from '../search.js';
 import { Input } from '../types.js';
 
-const TOOL_SEARCH = 'search';
+const TOOL_SEARCH = inputSchema.title.toLowerCase().replace(/ /g, '-');
 
-const WebBrowserArgsSchema = {
-    type: 'object',
-    properties: {
-        query: {
-            type: 'string',
-            description: 'Google Search keywords or a URL of a specific web page',
-        },
-        maxResults: {
-            type: 'integer',
-            description: 'The maximum number of top organic Google Search results whose web pages will be extracted (default: 1)',
-            default: defaults.maxResults,
-            minimum: 1, // Ensures the number is positive
-        },
+const TOOLS = [
+    {
+        name: TOOL_SEARCH,
+        description: inputSchema.description,
+        inputSchema,
     },
-    required: ['query'],
-};
+];
 
 /**
  * Create an MCP server with a tool to call RAG Web Browser Actor
@@ -66,23 +57,15 @@ export class RagWebBrowserServer {
     private setupToolHandlers(): void {
         this.server.setRequestHandler(ListToolsRequestSchema, async () => {
             return {
-                tools: [
-                    {
-                        name: TOOL_SEARCH,
-                        description: 'Search phrase or a URL at Google and return crawled web pages as text or Markdown',
-                        inputSchema: WebBrowserArgsSchema,
-                    },
-                ],
+                tools: TOOLS,
             };
         });
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
             switch (name) {
                 case TOOL_SEARCH: {
                     const content = await handleModelContextProtocol(args as unknown as Input);
-                    return {
-                        content: [{ type: 'text', text: JSON.stringify(content) }],
-                    };
+                    return { content: content.map((message) => ({ type: 'text', text: JSON.stringify(message) })) };
                 }
                 default: {
                     throw new Error(`Unknown tool: ${name}`);

src/search.ts

@@ -6,7 +6,7 @@ import { addPlaywrightCrawlRequest, addSearchRequest, createAndStartCrawlers } f
 import { UserInputError } from './errors.js';
 import { processInput } from './input.js';
 import { createResponsePromise } from './responses.js';
-import { Input, PlaywrightScraperSettings } from './types.js';
+import { Input, Output, PlaywrightScraperSettings } from './types.js';
 import {
     addTimeMeasureEvent,
     checkAndRemoveExtraParams,
@@ -53,7 +53,7 @@ function prepareRequest(
  * Internal function that handles the common logic for search.
  * Returns a promise that resolves to the final results array of Output objects.
  */
-async function runSearchProcess(params: Partial<Input>): Promise<unknown> {
+async function runSearchProcess(params: Partial<Input>): Promise<Output[]> {
     // Process the query parameters the same way as normal inputs
     const {
         input,
@@ -114,14 +114,14 @@ export async function handleSearchRequest(request: IncomingMessage, response: Se
  * Handles the model context protocol scenario (non-HTTP scenario).
  * Uses the same runSearchProcess function but just returns the results as a promise.
  */
-export async function handleModelContextProtocol(params: Partial<Input>) {
+export async function handleModelContextProtocol(params: Partial<Input>): Promise<Output[]> {
     try {
         log.info(`Received parameters: ${JSON.stringify(params)}`);
         return await runSearchProcess(params);
     } catch (e) {
         const error = e as Error;
         log.error(`UserInputError occurred: ${error.message}`);
-        return JSON.stringify({ errorMessage: error.message });
+        return [{ text: error.message }] as Output[];
     }
 }