@apify/actors-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,316 @@
+# Apify Model Context Protocol (MCP) Server
+
+Implementation of an MCP server for all [Apify Actors](https://apify.com/store).
+This server enables interaction with one or more Apify Actors that can be defined in the MCP Server configuration.
+
+The server can be used in two ways:
+- 🇦 **Apify MCP Server Actor**: runs an HTTP server with MCP protocol via Server-Sent Events.
+- ⾕ **Apify MCP Server Stdio**: provides support for the MCP protocol via standard input/output stdio.
+
+# 🎯 What does Apify MCP server do?
+
+The MCP Server Actor allows an AI assistant to use any [Apify Actor](https://apify.com/store) as a tool to perform a specific task.
+For example it can:
+- use [Facebook Posts Scraper](https://apify.com/apify/facebook-posts-scraper) to extract data from Facebook posts from multiple pages/profiles
+- use [Google Maps Email Extractor](https://apify.com/lukaskrivka/google-maps-with-contact-details) to extract Google Maps contact details
+- use [Google Search Results Scraper](https://apify.com/apify/google-search-scraper) to scrape Google Search Engine Results Pages (SERPs)
+- use [Instagram Scraper](https://apify.com/apify/instagram-scraper) to scrape Instagram posts, profiles, places, photos, and comments
+- use [RAG Web Browser](https://apify.com/apify/web-scraper) to search the web, scrape the top N URLs, and return their content
+
+To interact with the Apify MCP server, you can use MCP clients such as [Claude Desktop](https://claude.ai/download), [Superinference.ai](https://superinterface.ai/), or [LibreChat](https://www.librechat.ai/).
+Additionally, you can use simple example clients found in the [examples](https://github.com/apify/actor-mcp-server/tree/main/src/examples) directory.
+
+When you have Actors integrated with the MCP server, you can ask:
+- "Search web and summarize recent trends about AI Agents"
+- "Find top 10 best Italian restaurants in San Francisco"
+- "Find and analyze Instagram profile of The Rock"
+- "Provide a step-by-step guide on using the Model Context Protocol with source URLs."
+- "What Apify Actors I can use?"
+
+In the future, we plan to load Actors dynamically and provide Apify's dataset and key-value store as resources.
+See the [Roadmap](#-roadmap-january-2025) for more details.
+
+# 🔄 What is the Model Context Protocol?
+
+The Model Context Protocol (MCP) allows AI applications (and AI agents), such as Claude Desktop, to connect to external tools and data sources.
+MCP is an open protocol that enables secure, controlled interactions between AI applications, AI Agents, and local or remote resources.
+
+# 🧱 Components
+
+## Tools
+
+Any [Apify Actor](https://apify.com/store) can be used as a tool.
+By default, the server is pre-configured with the Actors specified below, but it can be overridden by providing Actor input.
+
+```text
+'apify/instagram-scraper'
+'apify/rag-web-browser'
+'lukaskrivka/google-maps-with-contact-details'
+```
+The MCP server loads the Actor input schema and creates MCP tools corresponding to the Actors.
+See this example of input schema for the [RAG Web Browser](https://apify.com/apify/rag-web-browser/input-schema).
+
+The tool name must always be the full Actor name, such as `apify/rag-web-browser`.
+The arguments for an MCP tool represent the input parameters of the Actor.
+For example, for the `apify/rag-web-browser` Actor, the arguments are:
+
+```json
+{
+  "query": "restaurants in San Francisco",
+  "maxResults": 3
+}
+```
+You don't need to specify the input parameters or which Actor to call, everything is managed by an LLM.
+When a tool is called, the arguments are automatically passed to the Actor by the LLM.
+You can refer to the specific Actor's documentation for a list of available arguments.
+
+## Prompt & Resources
+
+The server does not provide any resources and prompts.
+We plan to add Apify's dataset and key-value store as resources in the future.
+
+# ⚙️ Usage
+
+The Apify MCP Server can be used in two ways: **as an Apify Actor** running at Apify platform
+or as a **local server** running on your machine.
+
+## 🇦 MCP Server Actor
+
+### Standby web server
+
+The Actor runs in [**Standby mode**](https://docs.apify.com/platform/actors/running/standby) with an HTTP web server that receives and processes requests.
+
+Start server with default Actors. To use the Apify MCP Server with set of default Actors,
+send an HTTP GET request with your [Apify API token](https://console.apify.com/settings/integrations) to the following URL.
+```
+https://actors-mcp-server.apify.actor?token=<APIFY_TOKEN>
+```
+It is also possible to start the MCP server with a different set of Actors.
+To do this, create a [task](https://docs.apify.com/platform/actors/running/tasks) and specify the list of Actors you want to use.
+
+Then, run task in Standby mode with the selected Actors using your Apify API token.
+```shell
+https://actors-mcp-server-task.apify.actor?token=<APIFY_TOKEN>
+```
+
+You can find a list of all available Actors in the [Apify Store](https://apify.com/store).
+
+#### 💬 Interact with the MCP Server
+
+Once the server is running, you can interact with Server-Sent Events (SSE) to send messages to the server and receive responses.
+You can use MCP clients such as [Superinference.ai](https://superinterface.ai/) or [LibreChat](https://www.librechat.ai/).
+([Claude Desktop](https://claude.ai/download) does not support SSE transport yet)
+
+In the client settings you need to provide server configuration:
+```json
+{
+    "mcpServers": {
+        "apify": {
+            "type": "sse",
+            "url": "https://actors-mcp-server.apify.actor/sse",
+            "env": {
+                "APIFY_TOKEN": "your-apify-token"
+            }
+        }
+    }
+}
+```
+Alternatively, you can use simple python [client_see.py](https://github.com/apify/actor-mcp-server/tree/main/src/examples/client_sse.py) or test the server using `curl` </> commands.
+
+1. Initiate Server-Sent-Events (SSE) by sending a GET request to the following URL:
+    ```
+    curl https://actors-mcp-server.apify.actor/sse?token=<APIFY_TOKEN>
+    ```
+    The server will respond with a `sessionId`, which you can use to send messages to the server:
+    ```shell
+    event: endpoint
+    data: /message?sessionId=a1b
+    ```
+
+2. Send a message to the server by making a POST request with the `sessionId`:
+    ```shell
+    curl -X POST "https://actors-mcp-server.apify.actor?token=<APIFY_TOKEN>&session_id=a1b" -H "Content-Type: application/json" -d '{
+      "jsonrpc": "2.0",
+      "id": 1,
+      "method": "tools/call",
+      "params": {
+        "arguments": { "searchStringsArray": ["restaurants in San Francisco"], "maxCrawledPlacesPerSearch": 3 },
+        "name": "lukaskrivka/google-maps-with-contact-details"
+      }
+    }'
+    ```
+    The MCP server will start the Actor `lukaskrivka/google-maps-with-contact-details` with the provided arguments as input parameters.
+    For this POST request, the server will respond with:
+
+    ```text
+    Accepted
+    ```
+
+3. Receive the response. The server will invoke the specified Actor as a tool using the provided query parameters and stream the response back to the client via SSE.
+    The response will be returned as JSON text.
+
+    ```text
+    event: message
+    data: {"result":{"content":[{"type":"text","text":"{\"searchString\":\"restaurants in San Francisco\",\"rank\":1,\"title\":\"Gary Danko\",\"description\":\"Renowned chef Gary Danko's fixed-price menus of American cuisine ... \",\"price\":\"$100+\"...}}]}}
+    ```
+
+## ⾕ MCP Server at a local host
+
+### Prerequisites
+
+- MacOS or Windows
+- The latest version of Claude Desktop must be installed (or another MCP client)
+- [Node.js](https://nodejs.org/en) (v18 or higher)
+- [Apify API Token](https://docs.apify.com/platform/integrations/api#api-token) (`APIFY_TOKEN`)
+
+### Install
+
+Follow the steps below to set up and run the server on your local machine:
+First, clone the repository using the following command:
+
+```bash
+git clone git@github.com:apify/actor-mcp-server.git
+```
+Navigate to the project directory and install the required dependencies:
+
+```bash
+cd actor-mcp-server
+npm install
+```
+
+Before running the server, you need to build the project:
+
+```bash
+npm run build
+```
+
+#### Claude Desktop
+
+Configure Claude Desktop to recognize the MCP server.
+
+1. Open your Claude Desktop configuration and edit the following file:
+
+    - On macOS: `~/Library/Application\ Support/Claude/claude_desktop_config.json`
+    - On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
+
+    ```text
+    "mcpServers": {
+      "apify": {
+        "command": "npx",
+        "args": [
+          "/path/to/actor-mcp-server/dist/index.js"
+        ]
+        "env": {
+           "APIFY_TOKEN": "your-apify-token"
+        }
+      }
+    }
+    ```
+    Alternatively, you can use the following command to select one or more Apify Actors:
+    ```text
+    "mcpServers": {
+      "apify-mcp-server": {
+        "command": "npx",
+        "args": [
+          "/path/to/actor-mcp-server/dist/index.js",
+          "--actors",
+          "lukaskrivka/google-maps-with-contact-details,apify/instagram-scraper"
+        ]
+        "env": {
+           "APIFY_TOKEN": "your-apify-token"
+        }
+      }
+    }
+    ```
+
+2. Restart Claude Desktop
+
+    - Fully quit Claude Desktop (ensure it’s not just minimized or closed).
+    - Restart Claude Desktop.
+    - Look for the 🔌 icon to confirm that the Exa server is connected.
+
+3. Examples
+
+   You can ask Claude to perform web searches, such as:
+    ```text
+    Find and analyze recent research papers about LLMs.
+    Find top 10 best Italian restaurants in San Francisco.
+    Find and analyze instagram profile of the Rock.
+    ```
+
+#### Stdio clients
+
+Create environment file `.env` with the following content:
+```text
+APIFY_TOKEN=your-apify-token
+# ANTHROPIC_API_KEY is only required when you want to run examples/clientStdioChat.js
+ANTHROPIC_API_KEY=your-anthropic-api-token
+```
+In the `examples` directory, you can find two clients that interact with the server via
+standard input/output (stdio):
+1. [`clientStdio.ts`](https://github.com/apify/actor-mcp-server/tree/main/src/examples/clientStdio.ts)
+    This client script starts the MCP server with two specified Actors.
+    It then calls the `apify/rag-web-browser` tool with a query and prints the result.
+    It demonstrates how to connect to the MCP server, list available tools, and call a specific tool using stdio transport.
+    ```bash
+    node dist/examples/clientStdio.js
+    ```
+
+2. [`clientStdioChat.ts`](https://github.com/apify/actor-mcp-server/tree/main/src/examples/clientStdioChat.ts)
+    This client script also starts the MCP server but provides an interactive command-line chat interface.
+    It prompts the user to interact with the server, allowing for dynamic tool calls and responses.
+    This example is useful for testing and debugging interactions with the MCP server in conversational manner.
+
+    ```bash
+    node dist/examples/clientStdioChat.js
+    ```
+
+# 👷🏼 Development
+
+## Prerequisites
+
+- [Node.js](https://nodejs.org/en) (v18 or higher)
+- Python 3.6 or higher
+
+Create environment file `.env` with the following content:
+```text
+APIFY_TOKEN=your-apify-token
+# ANTHROPIC_API_KEY is only required when you want to run examples/clientStdioChat.js
+ANTHROPIC_API_KEY=your-anthropic-api-token
+```
+## Local client (SSE)
+
+To test the server with the SSE transport, you can use python script `examples/client_sse.py`:
+Currently, the node.js client does not support to establish a connection to remote server witch custom headers.
+You need to change URL to your local server URL in the script.
+
+```bash
+python src/examples/client_sse.py
+```
+
+## Debugging
+
+Since MCP servers operate over standard input/output (stdio), debugging can be challenging.
+For the best debugging experience, use the [MCP Inspector](https://github.com/modelcontextprotocol/inspector).
+
+Build the actor-mcp-server package:
+
+```bash
+npm run build
+```
+
+You can launch the MCP Inspector via [`npm`](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) with this command:
+
+```bash
+npx @modelcontextprotocol/inspector node /path/to/actor-mcp-server/dist/index.js --env APIFY_TOKEN=your-apify-token
+```
+
+Upon launching, the Inspector will display a URL that you can access in your browser to begin debugging.
+
+# 🚀 Roadmap (January 2025)
+
+- Document examples for [Superinference.ai](https://superinterface.ai/) and [LibreChat](https://www.librechat.ai/).
+- Provide tools to search for Actors and load them as needed.
+- Add Apify's dataset and key-value store as resources.
+- Add tools such as Actor logs and Actor runs for debugging.
+- Prune Actors input schema to reduce context size.

package/eslint.config.mjs

@@ -0,0 +1,16 @@
+import apify from '@apify/eslint-config';
+
+// eslint-disable-next-line import/no-default-export
+export default [
+    { ignores: ['**/dist'] }, // Ignores need to happen first
+    ...apify,
+    {
+        languageOptions: {
+            sourceType: 'module',
+
+            parserOptions: {
+                project: 'tsconfig.eslint.json',
+            },
+        },
+    },
+];

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@apify/actors-mcp-server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Model Context Protocol Server for Apify Actors",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "actors-mcp-server": "dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/apify/actors-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/apify/actors-mcp-server/issues"
+  },
+  "homepage": "https://apify.com/apify/actors-mcp-server",
+  "keywords": [
+    "apify",
+    "mcp",
+    "server",
+    "actors",
+    "model context protocol"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.1.1",
+    "ajv": "^8.17.1",
+    "apify": "^3.2.6",
+    "apify-client": "^2.11.1",
+    "express": "^4.21.2",
+    "minimist": "^1.2.8"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.33.1",
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "@apify/eslint-config": "^0.5.0-beta.2",
+    "@apify/tsconfig": "^0.1.0",
+    "@types/express": "^4.0.0",
+    "@types/minimist": "^1.2.5",
+    "dotenv": "^16.4.7",
+    "eslint": "^9.17.0",
+    "eventsource": "^3.0.2",
+    "tsx": "^4.6.2",
+    "typescript": "^5.3.3",
+    "typescript-eslint": "^8.18.2"
+  },
+  "scripts": {
+    "start": "npm run start:dev",
+    "start:prod": "node dist/main.js",
+    "start:dev": "tsx src/main.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "build": "tsc",
+    "test": "echo \"Error: oops, the actor has no tests yet, sad!\" && exit 1",
+    "watch": "tsc --watch"
+  },
+  "author": "Apify",
+  "license": "MIT"
+}

package/src/actorDefinition.ts

@@ -0,0 +1,87 @@
+import { Ajv } from 'ajv';
+import { ApifyClient } from 'apify-client';
+
+import { log } from './logger.js';
+import type { ActorDefinitionWithDesc, Tool } from './types';
+
+/**
+ * Get actor input schema by actor name.
+ * First, fetch the actor details to get the default build tag and buildId.
+ * Then, fetch the build details and return actorName, description, and input schema.
+ * @param {string} actorFullName - The full name of the actor.
+ * @returns {Promise<ActorDefinitionWithDesc | null>} - The actor definition with description or null if not found.
+ */
+async function fetchActorDefinition(actorFullName: string): Promise<ActorDefinitionWithDesc | null> {
+    if (!process.env.APIFY_TOKEN) {
+        log.error('APIFY_TOKEN is required but not set. Please set it as an environment variable');
+        return null;
+    }
+    const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
+    const actorClient = client.actor(actorFullName);
+
+    try {
+        // Fetch actor details
+        const actor = await actorClient.get();
+        if (!actor) {
+            log.error(`Failed to fetch input schema for actor: ${actorFullName}. Actor not found.`);
+            return null;
+        }
+
+        // fnesveda: The default build is not necessarily tagged, you can specify any build number as default build.
+        // There will be a new API endpoint to fetch a default build.
+        // For now, we'll use the tagged build, it will work for 90% of Actors. Later, we can update this.
+        const tag = actor.defaultRunOptions?.build || '';
+        const buildId = actor.taggedBuilds?.[tag]?.buildId || '';
+
+        if (!buildId) {
+            log.error(`Failed to fetch input schema for actor: ${actorFullName}. Build ID not found.`);
+            return null;
+        }
+        // Fetch build details and return the input schema
+        const buildDetails = await client.build(buildId).get();
+        if (buildDetails?.actorDefinition) {
+            const actorDefinitions = buildDetails?.actorDefinition as ActorDefinitionWithDesc;
+            actorDefinitions.description = actor.description || '';
+            actorDefinitions.name = actorFullName;
+            return actorDefinitions;
+        }
+        return null;
+    } catch (error) {
+        log.error(`Failed to fetch input schema for actor: ${actorFullName} with error ${error}.`);
+        return null;
+    }
+}
+
+/**
+ * Fetches actor input schemas by actor full names and creates MCP tools.
+ *
+ * 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.
+ */
+export async function getActorsAsTools(actors: string[]): Promise<Tool[]> {
+    // Fetch input schemas in parallel
+    const ajv = new Ajv({ coerceTypes: 'array', strict: false });
+    const results = await Promise.all(actors.map(fetchActorDefinition));
+    const tools = [];
+    for (const result of results) {
+        if (result) {
+            try {
+                tools.push({
+                    name: result.name.replace('/', '_'),
+                    actorName: result.name,
+                    description: result.description,
+                    inputSchema: result.input || {},
+                    ajvValidate: ajv.compile(result.input || {}),
+                });
+            } catch (validationError) {
+                log.error(`Failed to compile AJV schema for actor: ${result.name}. Error: ${validationError}`);
+            }
+        }
+    }
+    return tools;
+}

package/src/const.ts

@@ -0,0 +1,20 @@
+export const SERVER_NAME = 'apify-mcp-server';
+export const SERVER_VERSION = '0.1.0';
+
+export const defaults = {
+    actors: [
+        'apify/instagram-scraper',
+        'apify/rag-web-browser',
+        'lukaskrivka/google-maps-with-contact-details',
+    ],
+};
+
+export const ACTOR_OUTPUT_MAX_CHARS_PER_ITEM = 2_000;
+export const ACTOR_OUTPUT_TRUNCATED_MESSAGE = `Output was truncated because it will not fit into context.`
+    + ` There is no reason to call this tool again!`;
+
+export enum Routes {
+    ROOT = '/',
+    SSE = '/sse',
+    MESSAGE = '/message',
+}

package/src/examples/clientSse.ts

@@ -0,0 +1,100 @@
+/* eslint-disable no-console */
+/**
+ * Connect to the MCP server using SSE transport and call a tool.
+ * The Actors MCP Server will load default Actors.
+ *
+ * !!! This example needs to be fixed as it does not work !!!
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
+import dotenv from 'dotenv';
+import { EventSource } from 'eventsource';
+
+// Resolve dirname equivalent in ES module
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+
+dotenv.config({ path: path.resolve(dirname, '../../.env') });
+
+const SERVER_URL = 'https://actors-mcp-server/sse';
+// We need to change forward slash / to underscore _ in the tool name as Anthropic does not allow forward slashes in the tool name
+const SELECTED_TOOL = 'apify_rag-web-browser';
+
+if (!process.env.APIFY_TOKEN) {
+    console.error('APIFY_TOKEN is required but not set in the environment variables.');
+    process.exit(1);
+}
+
+if (typeof globalThis.EventSource === 'undefined') {
+    globalThis.EventSource = EventSource as unknown as typeof globalThis.EventSource;
+}
+
+async function main(): Promise<void> {
+    const transport = new SSEClientTransport(
+        new URL(SERVER_URL),
+        {
+            requestInit: {
+                headers: {
+                    authorization: `Bearer ${process.env.APIFY_TOKEN}`,
+                },
+            },
+            eventSourceInit: {
+                // The EventSource package augments EventSourceInit with a "fetch" parameter.
+                // You can use this to set additional headers on the outgoing request.
+                // Based on this example: https://github.com/modelcontextprotocol/typescript-sdk/issues/118
+                async fetch(input: Request | URL | string, init?: RequestInit) {
+                    const headers = new Headers(init?.headers || {});
+                    headers.set('authorization', `Bearer ${process.env.APIFY_TOKEN}`);
+                    return fetch(input, { ...init, headers });
+                },
+            // We have to cast to "any" to use it, since it's non-standard
+            } as any, // eslint-disable-line @typescript-eslint/no-explicit-any
+        },
+    );
+    const client = new Client(
+        { name: 'example-client', version: '1.0.0' },
+        { capabilities: {} },
+    );
+
+    try {
+        // Connect to the MCP server
+        await client.connect(transport);
+
+        // List available tools
+        const tools = await client.listTools();
+        console.log('Available tools:', tools);
+
+        if (tools.tools.length === 0) {
+            console.log('No tools available');
+            return;
+        }
+
+        const selectedTool = tools.tools.find((tool) => tool.name === SELECTED_TOOL);
+        if (!selectedTool) {
+            console.error(`The specified tool: ${selectedTool} is not available. Exiting.`);
+            return;
+        }
+
+        // Call a tool
+        console.log('Calling actor ...');
+        const result = await client.callTool(
+            { name: SELECTED_TOOL, arguments: { query: 'web browser for Anthropic' } },
+            CallToolResultSchema,
+        );
+        console.log('Tool result:', JSON.stringify(result, null, 2));
+    } catch (error: unknown) {
+        if (error instanceof Error) {
+            console.error('Error:', error.message);
+            console.error(error.stack);
+        } else {
+            console.error('An unknown error occurred:', error);
+        }
+    }
+}
+
+await main();

package/src/examples/clientStdio.ts

@@ -0,0 +1,85 @@
+/* eslint-disable no-console */
+/**
+ * Connect to the MCP server using stdio transport and call a tool.
+ * This script uses a selected tool without LLM involvement.
+ * You need to provide the path to the MCP server and `APIFY_TOKEN` in the `.env` file.
+ * You can choose actors to run in the server, for example: `apify/rag-web-browser`.
+ */
+
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+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';
+
+// Resolve dirname equivalent in ES module
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+
+dotenv.config({ path: path.resolve(dirname, '../../.env') });
+const SERVER_PATH = path.resolve(dirname, '../../dist/index.js');
+const NODE_PATH = execSync(process.platform === 'win32' ? 'where node' : 'which node').toString().trim();
+
+const TOOLS = 'apify/rag-web-browser,lukaskrivka/google-maps-with-contact-details';
+const SELECTED_TOOL = 'apify_rag-web-browser'; // We need to change / to _ in the tool name
+
+if (!process.env.APIFY_TOKEN) {
+    console.error('APIFY_TOKEN is required but not set in the environment variables.');
+    process.exit(1);
+}
+
+// Create server parameters for stdio connection
+const transport = new StdioClientTransport({
+    command: NODE_PATH,
+    args: [SERVER_PATH, '--actors', TOOLS],
+    env: { APIFY_TOKEN: process.env.APIFY_TOKEN || '' },
+});
+
+// Create a new client instance
+const client = new Client(
+    { name: 'example-client', version: '0.1.0' },
+    { capabilities: {} },
+);
+
+// Main function to run the example client
+async function run() {
+    try {
+        // Connect to the MCP server
+        await client.connect(transport);
+
+        // List available tools
+        const tools = await client.listTools();
+        console.log('Available tools:', tools);
+
+        if (tools.tools.length === 0) {
+            console.log('No tools available');
+            return;
+        }
+
+        // Example: Call the first available tool
+        const selectedTool = tools.tools.find((tool) => tool.name === SELECTED_TOOL);
+
+        if (!selectedTool) {
+            console.error(`The specified tool: ${selectedTool} is not available. Exiting.`);
+            return;
+        }
+
+        // Call a tool
+        console.log('Calling actor ...');
+        const result = await client.callTool(
+            { name: SELECTED_TOOL, arguments: { query: 'web browser for Anthropic' } },
+            CallToolResultSchema,
+        );
+        console.log('Tool result:', JSON.stringify(result));
+    } catch (error) {
+        console.error('Error:', error);
+    }
+}
+
+run().catch((error) => {
+    console.error('Unhandled error:', error);
+    process.exit(1);
+});