AgentPilot — API AI-Readiness & MCP Server Generator

Evaluate public OpenAPI/Swagger schemas for AI compatibility and automatically generate deployable Model Context Protocol (MCP) server code packages with zero setup.

⚙️ How It Works

AgentPilot audits and generates MCP wrapper code using a structured 4-step pipeline:

1. Schema Ingestion: The Actor loads the target OpenAPI specification from a provided URL (openapiUrl) or raw schema text input (openapiSpec).
2. AI-Readiness Audit: It parses the spec and scores each endpoint on its suitability for LLM use. The audit checks for required parameters, parameter types, authentication schemes, and descriptive text fields.
3. MCP Server Generation: Based on the selected target language (targetLanguage — TypeScript or Python), AgentPilot generates a fully hydrated MCP Server codebase with tool mappings matching your API paths.
4. Code Delivery: The generated code files are saved to the default Key-Value Store, and download links are returned inside the structured dataset output.

🚀 Features

• Automated AI Compatibility Audit: Scores API schemas (0-100) based on documentation quality, parameter definition completeness, and authentication setup.
• Node/TypeScript & Python Generators: Instantly outputs complete stdio-based MCP server code structures compatible with Cursor, Windsurf, and Claude Desktop.
• Built-in Parameter Mapping: Auto-serializes queries, headers, and body payloads, reducing integration friction.
• Zero Configuration: Ready to zip, deploy to Vercel/Render, or run locally out of the box.

📝 Input Parameters

• openapiUrl (String): An HTTP link to your public OpenAPI specification JSON/YAML file (e.g. https://api.example.com/openapi.json).
• openapiSpec (String): Paste the raw JSON or YAML schema directly.
• targetLanguage (Select): Choose between "typescript" or "python" for the generated server code.

📦 Output Format

The Actor writes a structured audit result to the default dataset and saves the generated MCP code files in the default Key-Value Store.

Dataset Output Example

{
  "openapiUrl": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json",
  "actorName": "AgentPilot — API AI-Readiness & MCP Server Generator",
  "status": "success",
  "score": 85,
  "overallWarnings": [
    "Uses complex authorization. Verify API key injection."
  ],
  "endpointsCount": 3,
  "endpoints": [
    {
      "path": "/pets",
      "method": "GET",
      "summary": "List all pets",
      "description": "Returns a list of pets.",
      "score": 100,
      "warnings": []
    }
  ],
  "fileUrls": {
    "package.json": "https://api.apify.com/v2/key-value-stores/.../records/packagejson",
    "tsconfig.json": "https://api.apify.com/v2/key-value-stores/.../records/tsconfigjson",
    "src/index.ts": "https://api.apify.com/v2/key-value-stores/.../records/src_indexts",
    "README.md": "https://api.apify.com/v2/key-value-stores/.../records/READMEmd"
  }
}

🛠 How to Integrate

You can trigger AgentPilot programmatically using the official Apify client libraries:

JavaScript/TypeScript Client

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

const input = {
    "openapiUrl": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json",
    "targetLanguage": "typescript"
};

const run = await client.actor("orbitai/agent-pilot-mcp-generator").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python Client

from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "openapiUrl": "https://raw.githubusercontent.com/OAI/OpenAPI-Specification/main/examples/v3.0/petstore.json",
    "targetLanguage": "typescript"
}

run = client.actor("orbitai/agent-pilot-mcp-generator").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

⚖️ Legal & Compliance

This tool analyzes publicly available or user-provided OpenAPI specifications to generate boilerplate code. Users are responsible for configuring their own API credentials and ensuring their generated servers comply with target API Terms of Service.