@apify/actors-mcp-server 0.1.0 → 0.1.1-beta.0

package/src/main.ts

@@ -1,106 +0,0 @@
-import type { ParsedUrlQuery } from 'querystring';
-import { parse } from 'querystring';
-
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import { Actor } from 'apify';
-import type { Request, Response } from 'express';
-import express from 'express';
-
-import { Routes } from './const.js';
-import { processInput } from './input.js';
-import { log } from './logger.js';
-import { ApifyMcpServer } from './server.js';
-import type { Input } from './types.js';
-
-await Actor.init();
-
-const STANDBY_MODE = Actor.getEnv().metaOrigin === 'STANDBY';
-const HOST = Actor.isAtHome() ? process.env.ACTOR_STANDBY_URL : 'http://localhost';
-const PORT = Actor.isAtHome() ? process.env.ACTOR_STANDBY_PORT : 3001;
-
-const app = express();
-
-const mcpServer = new ApifyMcpServer();
-let transport: SSEServerTransport;
-
-const HELP_MESSAGE = `Connect to the server with GET request to ${HOST}/sse?token=YOUR-APIFY-TOKEN`
-    + ` and then send POST requests to ${HOST}/message?token=YOUR-APIFY-TOKEN.`;
-
-/**
- * Process input parameters and update tools
- * If URL contains query parameter actors, add tools from actors, otherwise add tools from default actors
- * @param url
- */
-async function processParamsAndUpdateTools(url: string) {
-    const params = parse(url.split('?')[1] || '') as ParsedUrlQuery;
-    delete params.token;
-    log.debug(`Received input parameters: ${JSON.stringify(params)}`);
-    const input = await processInput(params as Input);
-    if (input.actors) {
-        await mcpServer.addToolsFromActors(input.actors as string[]);
-    } else {
-        log.debug(`Server is running in STANDBY mode with the following Actors (tools): ${mcpServer.getToolNames()}.
-        To use different Actors, provide them in query parameter "actors" or include them in the Actor Task input.`);
-    }
-}
-
-app.get(Routes.ROOT, async (req: Request, res: Response) => {
-    try {
-        log.info(`Received GET message at: ${req.url}`);
-        await processParamsAndUpdateTools(req.url);
-        res.status(200).json({ message: `Actor is using Model Context Protocol. ${HELP_MESSAGE}` }).end();
-    } catch (error) {
-        log.error(`Error in GET ${Routes.ROOT} ${error}`);
-        res.status(500).json({ message: 'Internal Server Error' }).end();
-    }
-});
-
-app.head(Routes.ROOT, (_req: Request, res: Response) => {
-    res.status(200).end();
-});
-
-app.get(Routes.SSE, async (req: Request, res: Response) => {
-    try {
-        log.info(`Received GET message at: ${req.url}`);
-        await processParamsAndUpdateTools(req.url);
-        transport = new SSEServerTransport(Routes.MESSAGE, res);
-        await mcpServer.connect(transport);
-    } catch (error) {
-        log.error(`Error in GET ${Routes.SSE}: ${error}`);
-        res.status(500).json({ message: 'Internal Server Error' }).end();
-    }
-});
-
-app.post(Routes.MESSAGE, async (req: Request, res: Response) => {
-    try {
-        log.info(`Received POST message at: ${req.url}`);
-        await transport.handlePostMessage(req, res);
-    } catch (error) {
-        log.error(`Error in POST ${Routes.MESSAGE}: ${error}`);
-        res.status(500).json({ message: 'Internal Server Error' }).end();
-    }
-});
-
-// Catch-all for undefined routes
-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.');
-    await mcpServer.addToolsFromDefaultActors();
-    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)');
-
-    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.');
-    }
-    await mcpServer.callActorGetDataset(input.debugActor!, input.debugActorInput!);
-    await Actor.exit();
-}

package/src/server.ts

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-/**
- * Model Context Protocol (MCP) server for Apify Actors
- */
-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 { Actor } from 'apify';
-import { ApifyClient } from 'apify-client';
-
-import { getActorsAsTools } from './actorDefinition.js';
-import {
-    ACTOR_OUTPUT_MAX_CHARS_PER_ITEM,
-    ACTOR_OUTPUT_TRUNCATED_MESSAGE,
-    defaults,
-    SERVER_NAME,
-    SERVER_VERSION,
-} from './const.js';
-import { log } from './logger.js';
-import type { Tool } from './types';
-
-/**
- * Create Apify MCP server
- */
-export class ApifyMcpServer {
-    private server: Server;
-    private tools: Map<string, Tool>;
-
-    constructor() {
-        this.server = new Server(
-            {
-                name: SERVER_NAME,
-                version: SERVER_VERSION,
-            },
-            {
-                capabilities: {
-                    tools: {},
-                },
-            },
-        );
-        this.tools = new Map();
-        this.setupErrorHandling();
-        this.setupToolHandlers();
-    }
-
-    /**
-     * Calls an Apify actor and retrieves the dataset items.
-     *
-     * It requires the `APIFY_TOKEN` environment variable to be set.
-     * If the `APIFY_IS_AT_HOME` the dataset items are pushed to the Apify dataset.
-     *
-     * @param {string} actorName - The name of the actor to call.
-     * @param {unknown} input - The input to pass to the actor.
-     * @returns {Promise<object[]>} - A promise that resolves to an array of dataset items.
-     * @throws {Error} - Throws an error if the `APIFY_TOKEN` is not set
-     */
-    public async callActorGetDataset(actorName: string, input: unknown): Promise<object[]> {
-        if (!process.env.APIFY_TOKEN) {
-            throw new Error('APIFY_TOKEN is required but not set. Please set it as an environment variable');
-        }
-        try {
-            log.info(`Calling actor ${actorName} with input: ${JSON.stringify(input)}`);
-            const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
-            const actorClient = client.actor(actorName);
-
-            const results = await actorClient.call(input);
-            const dataset = await client.dataset(results.defaultDatasetId).listItems();
-            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: ${actorName}, input: ${JSON.stringify(input)}`);
-            throw new Error(`Error calling actor: ${error}`);
-        }
-    }
-
-    public async addToolsFromActors(actors: string[]) {
-        const tools = await getActorsAsTools(actors);
-        this.updateTools(tools);
-    }
-
-    public async addToolsFromDefaultActors() {
-        await this.addToolsFromActors(defaults.actors);
-    }
-
-    public updateTools(tools: Tool[]): void {
-        for (const tool of tools) {
-            this.tools.set(tool.name, tool);
-            log.info(`Added/Updated tool: ${tool.name}`);
-        }
-    }
-
-    public getToolNames(): string[] {
-        return Array.from(this.tools.keys());
-    }
-
-    private setupErrorHandling(): void {
-        this.server.onerror = (error) => {
-            console.error('[MCP Error]', error); // eslint-disable-line no-console
-        };
-        process.on('SIGINT', async () => {
-            await this.server.close();
-            process.exit(0);
-        });
-    }
-
-    private setupToolHandlers(): void {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-            return { tools: Array.from(this.tools.values()) };
-        });
-
-        /**
-         * Handles the request to call a tool.
-         * @param {object} request - The request object containing tool name and arguments.
-         * @throws {Error} - Throws an error if the tool is unknown or arguments are invalid.
-         */
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-
-            // 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: ${tool.name} with arguments: ${JSON.stringify(args)}`);
-            if (!tool.ajvValidate(args)) {
-                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(tool.actorName, args);
-                const content = items.map((item) => {
-                    const text = JSON.stringify(item).slice(0, ACTOR_OUTPUT_MAX_CHARS_PER_ITEM);
-                    return text.length === ACTOR_OUTPUT_MAX_CHARS_PER_ITEM
-                        ? { type: 'text', text: `${text} ... ${ACTOR_OUTPUT_TRUNCATED_MESSAGE}` }
-                        : { type: 'text', text };
-                });
-                return { content };
-            } catch (error) {
-                log.error(`Error calling tool: ${error}`);
-                throw new Error(`Error calling tool: ${error}`);
-            }
-        });
-    }
-
-    async connect(transport: Transport): Promise<void> {
-        await this.server.connect(transport);
-    }
-}

package/src/types.ts

@@ -1,20 +0,0 @@
-import type { ValidateFunction } from 'ajv';
-import type { ActorDefinition } from 'apify-client';
-
-export type Input = {
-    actors: string[] | string;
-    debugActor?: string;
-    debugActorInput?: unknown;
-};
-
-export interface ActorDefinitionWithDesc extends ActorDefinition {
-    description: string;
-}
-
-export interface Tool {
-    name: string;
-    actorName: string;
-    description: string;
-    inputSchema: object;
-    ajvValidate: ValidateFunction;
-}

package/tsconfig.eslint.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "include": ["./src/**/*"]
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "extends": "@apify/tsconfig",
-  "compilerOptions": {
-    "module": "ESNext",
-    "target": "ESNext",
-    "outDir": "dist",
-    "moduleResolution": "node",
-    "noUnusedLocals": false,
-    "lib": ["ES2022"],
-    "skipLibCheck": true,
-    "typeRoots": ["./types", "./node_modules/@types"],
-    "strict": true
-  },
-  "include": ["./src/**/*"],
-  "exclude": ["node_modules"]
-}