Start Standby server with Actors provided at input

Author: jirispilka

.actor/input_schema.json

@@ -3,6 +3,22 @@
     "type": "object",
     "schemaVersion": 1,
     "properties": {
+        "actors": {
+            "title": "Actors names to be exposed for an AI application (AI agent)",
+            "type": "array",
+            "description": "Specify the names of actors that will be exposed to an AI application (AI agent) and communicate with Apify Actors via the MCP protocol",
+            "editor": "stringList",
+            "prefill": [
+                "apidojo/tweet-scraper",
+                "apify/facebook-posts-scraper",
+                "apify/google-search-scraper",
+                "apify/instagram-scraper",
+                "apify/rag-web-browser",
+                "clockworks/free-tiktok-scraper",
+                "lukaskrivka/google-maps-with-contact-details",
+                "voyager/booking-scraper"
+            ]
+        },
         "debugActor": {
             "title": "Debug actor",
             "type": "string",

src/actorDefinition.ts

@@ -56,6 +56,8 @@ async function fetchActorDefinition(actorFullName: string): Promise<ActorDefinit
  * This function retrieves the input schemas for the specified actors and compiles them into MCP tools.
  * It uses the AJV library to validate the input schemas.
  *
+ * Tool name can't contain /, so it is replaced with _
+ *
  * @param {string[]} actors - An array of actor full names.
  * @returns {Promise<Tool[]>} - A promise that resolves to an array of MCP tools.
  */
@@ -69,6 +71,7 @@ export async function getActorsAsTools(actors: string[]): Promise<Tool[]> {
             try {
                 tools.push({
                     name: result.name.replace('/', '_'),
+                    actorName: result.name,
                     description: result.description,
                     inputSchema: result.input || {},
                     ajvValidate: ajv.compile(result.input || {}),

src/examples/clientStdioChat.ts

@@ -19,15 +19,20 @@
 
 import { execSync } from 'child_process';
 import * as readline from 'readline';
+import { fileURLToPath } from "url";
 
 import { Anthropic } from '@anthropic-ai/sdk';
 import type { Message, ToolUseBlock, MessageParam } from '@anthropic-ai/sdk/resources/messages';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
 import dotenv from 'dotenv';
+import path from "path";
 
-dotenv.config({ path: '../../.env' });
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+
+dotenv.config({ path: path.resolve(dirname, '../../.env') });
 
 const REQUEST_TIMEOUT = 120_000; // 2 minutes
 const MAX_TOKENS = 2048; // Maximum tokens for Claude response
@@ -36,7 +41,7 @@ const MAX_TOKENS = 2048; // Maximum tokens for Claude response
 // const CLAUDE_MODEL = 'claude-3-5-haiku-20241022'; // a fastest model
 const CLAUDE_MODEL = 'claude-3-haiku-20240307'; // a fastest and most compact model for near-instant responsiveness
 const DEBUG = true;
-const DEBUG_SERVER_PATH = '../../dist/index.js';
+const DEBUG_SERVER_PATH = path.resolve(dirname, '../../dist/index.js');
 
 const NODE_PATH = execSync('which node').toString().trim();
 

src/input.ts

@@ -1,3 +1,4 @@
+import { defaults } from './const.js';
 import type { Input } from './types.js';
 
 /**
@@ -6,7 +7,7 @@ import type { Input } from './types.js';
  * @returns input
  */
 export async function processInput(originalInput: Partial<Input>): Promise<Input> {
-    const input = originalInput as Input;
+    const input = { ...defaults, ...originalInput } as Input;
 
     // actors can be a string or an array of strings
     if (input.actors && typeof input.actors === 'string') {

src/main.ts

@@ -36,7 +36,9 @@ async function processParamsAndUpdateTools(url: string) {
     delete params.token;
     log.debug(`Received input parameters: ${JSON.stringify(params)}`);
     const input = await processInput(params as Input);
-    await (input.actors ? mcpServer.addToolsFromActors(input.actors as string[]) : mcpServer.addToolsFromDefaultActors());
+    if (input.actors) {
+        await mcpServer.addToolsFromActors(input.actors as string[]);
+    }
 }
 
 app.get(Routes.ROOT, async (req: Request, res: Response) => {
@@ -81,16 +83,20 @@ app.use((req: Request, res: Response) => {
     res.status(404).json({ message: `There is nothing at route ${req.method} ${req.originalUrl}. ${HELP_MESSAGE}` }).end();
 });
 
+const input = await processInput((await Actor.getInput<Partial<Input>>()) ?? ({} as Input));
+log.info(`Loaded input: ${JSON.stringify(input)} `);
+
 if (STANDBY_MODE) {
     log.info('Actor is running in the STANDBY mode.');
+    if (input.actors && input.actors.length > 0) {
+        await mcpServer.addToolsFromActors(input.actors as string[]);
+    }
 
     app.listen(PORT, () => {
         log.info(`The Actor web server is listening for user requests at ${HOST}.`);
     });
 } else {
     log.info('Actor is not designed to run in the NORMAL model (use this mode only for debugging purposes)');
-    const input = await processInput((await Actor.getInput<Partial<Input>>()) ?? ({} as Input));
-    log.info(`Loaded input: ${JSON.stringify(input)} `);
 
     if (input && !input.debugActor && !input.debugActorInput) {
         await Actor.fail('If you need to debug a specific actor, please provide the debugActor and debugActorInput fields in the input.');

src/server.ts

@@ -52,23 +52,22 @@ export class ApifyMcpServer {
         if (!process.env.APIFY_API_TOKEN) {
             throw new Error('APIFY_API_TOKEN is required but not set. Please set it as an environment variable');
         }
-        const name = actorName.replace('_', '/');
         try {
-            log.info(`Calling actor ${name} with input: ${JSON.stringify(input)}`);
+            log.info(`Calling actor ${actorName} with input: ${JSON.stringify(input)}`);
             const client = new ApifyClient({ token: process.env.APIFY_API_TOKEN });
-            const actorClient = client.actor(name);
+            const actorClient = client.actor(actorName);
 
             const results = await actorClient.call(input);
             const dataset = await client.dataset(results.defaultDatasetId).listItems();
-            log.info(`Actor ${name} finished with ${dataset.items.length} items`);
+            log.info(`Actor ${actorName} finished with ${dataset.items.length} items`);
 
             if (process.env.APIFY_IS_AT_HOME) {
                 await Actor.pushData(dataset.items);
                 log.info(`Pushed ${dataset.items.length} items to the dataset`);
             }
             return dataset.items;
         } catch (error) {
-            log.error(`Error calling actor: ${error}. Actor: ${name}, input: ${JSON.stringify(input)}`);
+            log.error(`Error calling actor: ${error}. Actor: ${actorName}, input: ${JSON.stringify(input)}`);
             throw new Error(`Error calling actor: ${error}`);
         }
     }
@@ -112,18 +111,18 @@ export class ApifyMcpServer {
         this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const { name, arguments: args } = request.params;
 
-            const tool = this.tools.get(name);
+            // Anthropic can't handle '/' in tool names. The replace is only necessary when calling the tool from stdio clients.
+            const tool = this.tools.get(name) || this.tools.get(name.replace('/', '_'));
             if (!tool) {
                 throw new Error(`Unknown tool: ${name}`);
             }
-
-            log.info(`Validate arguments for tool: ${name} with arguments: ${JSON.stringify(args)}`);
+            log.info(`Validate arguments for tool: ${tool.name} with arguments: ${JSON.stringify(args)}`);
             if (!tool.ajvValidate(args)) {
-                throw new Error(`Invalid arguments for tool ${name}: args: ${JSON.stringify(args)} error: ${JSON.stringify(tool?.ajvValidate.errors)}`);
+                throw new Error(`Invalid arguments for tool ${tool.name}: args: ${JSON.stringify(args)} error: ${JSON.stringify(tool?.ajvValidate.errors)}`);
             }
 
             try {
-                const items = await this.callActorGetDataset(name, args);
+                const items = await this.callActorGetDataset(tool.actorName, args);
                 return { content: items.map((item) => ({ type: 'text', text: JSON.stringify(item) })) };
             } catch (error) {
                 log.error(`Error calling tool: ${error}`);

src/types.ts

@@ -13,6 +13,7 @@ export interface ActorDefinitionWithDesc extends ActorDefinition {
 
 export interface Tool {
     name: string;
+    actorName: string;
     description: string;
     inputSchema: object;
     ajvValidate: ValidateFunction;