AI Agent Tools: MCP Debugger, Pipeline Builder & LLM Optimizer

ApifyForge includes four tools for developers building AI agent workflows with Apify actors: the MCP Connection Debugger, the Agent Pipeline Builder, the LLM Output Optimizer, and the Integration Template Generator. These tools help you connect actors to AI agents, chain actors together, reduce token costs, and integrate with automation platforms.

MCP Connection Debugger

The MCP Connection Debugger at apifyforge.com/tools/mcp-debugger tests whether your Model Context Protocol server is running correctly and responding to MCP requests.

What MCP servers are

MCP (Model Context Protocol) servers on Apify run as standby-mode actors that expose an HTTP endpoint — typically /mcp — for AI agents like Claude, GPT, and custom LLM applications to connect to. The server receives JSON-RPC requests from the agent, executes tools (which call other Apify actors), and returns structured results.

What the debugger checks

Enter your actor's standby URL and optionally your API token, then click Test. The debugger sends a standard MCP initialize handshake and reports:

- **Connection status** — can it reach your actor's standby URL at all? A failure here means the actor is not deployed, standby mode is not enabled, or the URL is wrong. - **Response format** — does the server respond with valid JSON-RPC? If not, the raw response body is shown so you can see what came back instead. - **Authentication** — does the request authenticate correctly? A 401 or 403 indicates a token issue. - **Latency** — how long the server takes to respond. Slow responses (over 5 seconds) cause timeouts in MCP clients.

Common issues and fixes

**502/503 errors** — the actor is not in standby mode. Check that usesStandbyMode: true is set in your .actor/actor.json file and that webServerMcpPath: "/mcp" is configured.

**404 Not Found** — wrong URL. The standby URL format is https://YOUR_ACTOR_NAME.apify.actor/mcp. Make sure the actor name matches exactly and the /mcp path suffix is included.

**SSE Response detected** — your server is using Server-Sent Events transport instead of the standard HTTP transport. Some MCP clients expect one or the other. The debugger identifies which transport your server uses.

**Timeout** — the server took more than 30 seconds to respond. This usually means the actor is starting up from a cold state. Standby actors have a warm-up period on first request.

Agent Pipeline Builder

The Agent Pipeline Builder at apifyforge.com/tools/pipeline-builder helps you design multi-actor data pipelines where one actor's output feeds into the next actor's input.

Why pipelines matter

Many data tasks require multiple actors working in sequence. A lead enrichment pipeline might:

1. Run a Google Maps scraper to find businesses in a location 2. Feed those business URLs into a website contact scraper to extract emails 3. Pass the emails through an email verification actor

Building this manually requires writing Actor.call() code, reading datasets between steps, transforming data formats, and handling errors. The Pipeline Builder automates the design and generates the orchestration code.

How to use it

1. **Add stages** — select actors from the dropdown to add pipeline stages in order 2. **Map fields** — for each stage, choose which output fields from the previous actor map to which input fields of the next actor. The builder shows the expected output schema of each actor so you can see what data flows between stages. 3. **Configure settings** — set memory allocation and timeout per stage 4. **Generate code** — click Generate to get a complete TypeScript actor that orchestrates the entire pipeline using Actor.call() and dataset forwarding

Cost estimation

The builder estimates total pipeline cost by summing PPE charges across all stages for your expected volume. A 3-stage pipeline processing 1,000 items might cost $0.02 at stage 1, $0.05 at stage 2, and $0.01 at stage 3 = $0.08 total per batch. This helps you price composite workflows before committing credits.

LLM Output Optimizer

The LLM Output Optimizer at apifyforge.com/tools/llm-optimizer analyzes your actor's output and recommends ways to reduce token consumption when feeding data to large language models.

The problem

When you pipe Apify actor output into an LLM for summarization, classification, or extraction, every field in every record costs tokens. A typical actor outputs 20+ fields per record, but your LLM prompt might only need 5. The rest is wasted tokens — higher AI API costs with no improvement in results. For large datasets, this waste compounds fast.

How it works

Paste a sample of your actor's JSON output into the tool. The optimizer scores every field across all records by:

- **Field name recognition** — common identifiers like id, name, url score higher because they are usually essential - **Data type** — primitives (strings, numbers) are cheap; nested objects and arrays are expensive - **Value length** — long text blobs like HTML bodies cost many tokens but rarely add LLM value - **Null/empty frequency** — fields that are often empty provide little value per token

What you get

The output shows three views side by side:

1. **Original data** with total token count 2. **Optimized data** with total token count (keeping only the highest-value fields) 3. **Percentage savings** — typically 40-70% for actors with verbose output schemas

The optimizer also suggests specific transformations: truncating long string fields to a character limit, flattening nested objects into dot-notation keys, and converting arrays to comma-separated strings.

Example

A Google Maps scraper might output 25 fields per business including htmlContent, rawHtml, scrapedAt, requestUrl, and #debug metadata. For an LLM that needs to classify businesses by type, you only need name, category, description, and address. The optimizer identifies this and cuts tokens by 70%.

Integration Template Generator

The Integration Template Generator at apifyforge.com/integrations creates ready-to-import workflow templates for n8n and Make.com (formerly Integromat).

What it generates

Select an actor and choose your automation platform. The generator creates a complete workflow with:

- **HTTP Request node** configured with the correct Apify API endpoint and authentication headers - **Polling loop** that checks run status at appropriate intervals (not too frequent, not too slow) - **Dataset retrieval** step that fetches results when the run completes - **Error handling** for common failures: timeout, actor crash, authentication errors

For n8n

The output is a workflow JSON file. Import it in n8n via Settings > Import Workflow. The template includes placeholder fields marked YOUR_API_TOKEN and YOUR_INPUT_HERE for you to fill in. The polling interval is pre-configured to check every 10 seconds for short-running actors and every 30 seconds for long-running ones.

For Make.com

The output is a scenario blueprint. Import it in the Make.com dashboard under Scenarios > Import Blueprint. Same placeholder approach — fill in your API token and actor input, and the workflow is ready to run.

Why not build from scratch?

Configuring Apify API calls manually in n8n or Make.com takes 30-60 minutes per workflow. The polling logic is especially tricky — check too often and you waste API calls, check too rarely and you add unnecessary delay. The templates handle all of this with tested, optimized configurations.

All four tools run entirely in your browser with no API calls and no costs.