Memory for each Actor is limited to 4GB.

Free users have an 8GB limit, 128MB needs to be allocated for running `Actors-MCP-Server`.

Author: jirispilka

README.md

@@ -19,7 +19,8 @@ For example it can:
 - 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/).
+
+To interact with the Apify MCP server, you can use MCP clients such as [Claude Desktop](https://claude.ai/download), [LibreChat](https://www.librechat.ai/), or other [MCP clients](https://glama.ai/mcp/clients).
 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:
@@ -29,6 +30,10 @@ When you have Actors integrated with the MCP server, you can ask:
 - "Provide a step-by-step guide on using the Model Context Protocol with source URLs."
 - "What Apify Actors I can use?"
 
+The following image shows how the Apify MCP server interacts with the Apify platform and AI clients:
+
+![Actors-MCP-server](https://raw.githubusercontent.com/apify/actors-mcp-server/refs/heads/master/docs/actors-mcp-server.png)
+
 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.
 
@@ -311,11 +316,14 @@ Upon launching, the Inspector will display a URL that you can access in your bro
 To limit the context size the properties in the `input schema` are pruned and description is truncated to 200 characters.
 Enum fields and titles are truncated to max 50 options.
 
+Memory for each Actor is limited to 4GB.
+Free users have an 8GB limit, 128MB needs to be allocated for running `Actors-MCP-Server`.
+
 If you need other features or have any feedback, please [submit an issue](https://console.apify.com/actors/3ox4R101TgZz67sLr/issues) in Apify Console to let us know.
 
 # 🚀 Roadmap (January 2025)
 
-- Document examples for [Superinference.ai](https://superinterface.ai/) and [LibreChat](https://www.librechat.ai/).
+- Document examples for [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.

src/actorDefinition.ts

@@ -1,9 +1,9 @@
 import { Ajv } from 'ajv';
 import { ApifyClient } from 'apify-client';
 
-import { MAX_DESCRIPTION_LENGTH, MAX_ENUM_LENGTH } from './const.js';
+import { MAX_DESCRIPTION_LENGTH, MAX_ENUM_LENGTH, MAX_MEMORY_MBYTES } from './const.js';
 import { log } from './logger.js';
-import type { ActorDefinitionWithDesc, Tool, SchemaProperties } from './types.js';
+import type { ActorDefinitionWithDesc, SchemaProperties, Tool } from './types.js';
 
 /**
  * Get actor input schema by actor name.
@@ -44,6 +44,7 @@ async function fetchActorDefinition(actorFullName: string): Promise<ActorDefinit
             const actorDefinitions = buildDetails?.actorDefinition as ActorDefinitionWithDesc;
             actorDefinitions.description = actor.description || '';
             actorDefinitions.name = actorFullName;
+            actorDefinitions.defaultRunOptions = actor.defaultRunOptions;
             return actorDefinitions;
         }
         return null;
@@ -108,12 +109,14 @@ export async function getActorsAsTools(actors: string[]): Promise<Tool[]> {
                 result.input.properties = shortenProperties(properties);
             }
             try {
+                const memoryMbytes = result.defaultRunOptions?.memoryMbytes || MAX_MEMORY_MBYTES;
                 tools.push({
                     name: result.name.replace('/', '_'),
                     actorName: result.name,
                     description: result.description,
                     inputSchema: result.input || {},
                     ajvValidate: ajv.compile(result.input || {}),
+                    memoryMbytes: memoryMbytes > MAX_MEMORY_MBYTES ? MAX_MEMORY_MBYTES : memoryMbytes,
                 });
             } catch (validationError) {
                 log.error(`Failed to compile AJV schema for actor: ${result.name}. Error: ${validationError}`);

src/const.ts

@@ -5,6 +5,8 @@ export const HEADER_READINESS_PROBE = 'x-apify-container-server-readiness-probe'
 
 export const MAX_ENUM_LENGTH = 50;
 export const MAX_DESCRIPTION_LENGTH = 200;
+// Limit memory to 4GB for Actors. Free users have 8 GB limit, but we need to reserve some memory for Actors-MCP-Server too
+export const MAX_MEMORY_MBYTES = 4096;
 
 export const USER_AGENT_ORIGIN = 'Origin/mcp-server';
 

src/examples/client_sse.py

@@ -43,8 +43,9 @@ async def run() -> None:
                 print("No tools available!")
                 return
 
+            print("\n\nCall tool")
             result = await session.call_tool("apify/rag-web-browser", { "query": "example.com", "maxResults": 3 })
-            print("Tools Call Result:")
+            print("Tools call result:")
 
             for content in result.content:
                 print(content)

src/main.ts

@@ -3,10 +3,11 @@ import { parse } from 'querystring';
 
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { Actor } from 'apify';
+import type { ActorCallOptions } from 'apify-client';
 import type { Request, Response } from 'express';
 import express from 'express';
 
-import { HEADER_READINESS_PROBE, Routes } from './const.js';
+import { HEADER_READINESS_PROBE, MAX_MEMORY_MBYTES, Routes } from './const.js';
 import { processInput } from './input.js';
 import { log } from './logger.js';
 import { ApifyMcpServer } from './server.js';
@@ -115,6 +116,7 @@ if (STANDBY_MODE) {
     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!);
+    const options = { memory: MAX_MEMORY_MBYTES } as ActorCallOptions;
+    await mcpServer.callActorGetDataset(input.debugActor!, input.debugActorInput!, options);
     await Actor.exit();
 }

src/server.ts

@@ -7,6 +7,7 @@ import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import type { ApifyClientOptions } from 'apify';
 import { Actor } from 'apify';
+import type { ActorCallOptions } from 'apify-client';
 import { ApifyClient } from 'apify-client';
 import type { AxiosRequestConfig } from 'axios';
 
@@ -65,11 +66,16 @@ export class ApifyMcpServer {
      * 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 {ActorCallOptions} callOptions - The options to pass to the actor.
      * @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[]> {
+    public async callActorGetDataset(
+        actorName: string,
+        input: unknown,
+        callOptions: ActorCallOptions | undefined = undefined,
+    ): Promise<object[]> {
         if (!process.env.APIFY_TOKEN) {
             throw new Error('APIFY_TOKEN is required but not set. Please set it as an environment variable');
         }
@@ -80,7 +86,7 @@ export class ApifyMcpServer {
             const client = new ApifyClient({ ...options, token: process.env.APIFY_TOKEN });
             const actorClient = client.actor(actorName);
 
-            const results = await actorClient.call(input);
+            const results = await actorClient.call(input, callOptions);
             const dataset = await client.dataset(results.defaultDatasetId).listItems();
             log.info(`Actor ${actorName} finished with ${dataset.items.length} items`);
 
@@ -149,7 +155,7 @@ export class ApifyMcpServer {
             }
 
             try {
-                const items = await this.callActorGetDataset(tool.actorName, args);
+                const items = await this.callActorGetDataset(tool.actorName, args, { memory: tool.memoryMbytes } as ActorCallOptions);
                 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

src/types.ts

@@ -1,5 +1,5 @@
 import type { ValidateFunction } from 'ajv';
-import type { ActorDefinition } from 'apify-client';
+import type { ActorDefaultRunOptions, ActorDefinition } from 'apify-client';
 
 export type Input = {
     actors: string[] | string;
@@ -9,6 +9,7 @@ export type Input = {
 
 export interface ActorDefinitionWithDesc extends ActorDefinition {
     description: string;
+    defaultRunOptions: ActorDefaultRunOptions
 }
 
 export interface Tool {
@@ -17,6 +18,7 @@ export interface Tool {
     description: string;
     inputSchema: object;
     ajvValidate: ValidateFunction;
+    memoryMbytes: number;
 }
 
 export interface SchemaProperties {