Skip to main content
Glama

ControlAPI-MCP

MCP server that exposes any OpenAPI/REST API as MCP tools with dynamic server switching and variable substitution.

🚀 One-Click Install

Click to install directly in your editor - no configuration needed!

Linux / macOS:

📥 Install in VS Code

📥 Install in VS Code Insiders

💡 After Installation: The AI assistant will guide you to connect to an API server. Simply provide the OpenAPI URL when asked, or use the set_server_config tool to connect to your API.

Related MCP server: Swagger to MCP

Quick Start (Auto-Download)

Zero installation - automatically downloads and runs the latest release:

  1. Download the auto-run script:

curl -O https://raw.githubusercontent.com/fellowabhi/ControlAPI-openapi-to-mcp/main/auto-run.sh
chmod +x auto-run.sh
  1. Use it in your MCP config:

{
  "servers": {
    "controlapi-mcp": {
      "type": "stdio",
      "command": "/path/to/auto-run.sh"
    }
  }
}

Note: You can optionally set OPENAPI_URL, BASE_URL, and SERVER_NICKNAME in env vars, or configure dynamically using the set_server_config tool.

Download from releases or build:

export OPENAPI_URL='http://your-api.com/openapi.json'
export BASE_URL='http://your-api.com'  # optional
./dist/controlapi-mcp

Setup (Development)

pip install -e .

Building Binary

./build.sh

Creates a standalone executable at dist/controlapi-mcp (16MB)

MCP Configuration

Using Binary

{
  "servers": {
    "controlapi-mcp": {
      "type": "stdio",
      "command": "/path/to/openapi-mcp-adapter/dist/controlapi-mcp",
      "env": {
        "OPENAPI_URL": "http://localhost:8000/openapi.json",
        "BASE_URL": "http://localhost:8000",
        "DEBUG_PORT": "45133"
      }
    }
  }
}

Using Python (Development)

{
  "servers": {
    "controlapi-mcp": {
      "type": "stdio",
      "command": "/path/to/project/.venv/bin/python",
      "args": ["-m", "src.main"],
      "cwd": "/path/to/project",
      "env": {
        "OPENAPI_URL": "http://localhost:8000/openapi.json",
        "REFRESH_INTERVAL": "300",
        "PYTHONPATH": "/path/to/project",
        "BASE_URL": "http://localhost:8000",
        "DEBUG_PORT": "45133"
      }
    }
  }
}

Optional: OPENAPI_URL, BASE_URL, SERVER_NICKNAME, DEBUG_PORT (default: 45133)

💡 No Configuration Needed: You can start with no environment variables and configure the server dynamically using the set_server_config tool. The AI assistant will guide you through the setup.

🔍 Debug UI: Access browser-based request/response monitor at http://localhost:45133 (or custom DEBUG_PORT). URL available in get_server_info response.

Features

Cross-Platform Support

  • Linux (x86_64) - Full support

  • macOS (Intel & Apple Silicon) - Full support

  • Windows - Use Python or WSL

Dynamic Server Switching

  • Connect to any OpenAPI server at runtime

  • Switch between multiple APIs (dev, staging, production)

  • Server context tracking with history

  • Automatic schema reloading

Available Tools

  • set_server_config - Connect to an OpenAPI server (use this first if not configured)

  • get_server_info - Check current server and connection status

  • get_server_history - View recent server switches

  • health_check - Test server connectivity

  • list_endpoints - List all API endpoints

  • search_schema - Search endpoints by keyword

  • execute_request - Make HTTP requests with variable substitution

  • set_variable - Store variable (e.g., auth token)

  • get_variables - View all stored variables

  • reload_schema - Reload current server's schema

Variable Substitution

Use {{variable_name}} in headers, body, or path:

{
  "headers": {
    "Authorization": "{{token}}"
  }
}

Example Workflow

  1. First time: set_server_config with openapi_url

  2. execute_request to /auth/login → get token

  3. set_variable key="token" value="Bearer xyz..."

  4. execute_request with Authorization: {{token}}

  5. Switch servers: set_server_config to test on different environment

Available Tools

12 tools
execute_requestA

Execute HTTP requests to API endpoints. Returns compact response by default (no headers, no server_context). Use include_headers/include_server_context for full details. Full unfiltered response is always cached — use replay_response to re-inspect without re-executing. PREFERRED: If you know or can predict the response structure, always pass a jsonpath param to extract only the needed fields — this saves tokens and avoids re-execution. e.g. jsonpath='$.data.access_token' to get a token, '$.results' for a list. Root $ = response body directly.

Inputs: path (required), method (required), path_params, query_params, +6 more.

get_endpoint_detailsA

Get detailed schema for a specific endpoint. Returns compact field:type summary by default. Use compact=false for raw OpenAPI schema. Use sections to request only specific parts.

Inputs: path (required), method (required), sections, compact.

get_server_historyA

View recent server switches with timestamps and last operations

Inputs: no named parameters.

get_server_infoA

Get current server configuration and status. Returns debug_ui_url — if the user asks to open the debug monitor, fetch this then open that URL in their browser.

Inputs: no named parameters.

get_variablesA

Get all stored variables

Inputs: no named parameters.

health_checkA

Test connectivity to current OpenAPI server

Inputs: no named parameters.

list_endpointsA

List API endpoints. Returns compact one-liners default (saves tokens). Use compact=false for full details. Supports pagination with limit/offset.

Inputs: method_filter, path_prefix, tag, limit, +2 more.

reload_schemaB

Reload OpenAPI schema to get latest endpoints

Inputs: no named parameters.

replay_responseA

Re-inspect a cached API response WITHOUT re-executing the request. Critical for POST/PUT/DELETE — avoids duplicate side effects. Supports JSONPath to drill into specific fields. Use index=-1 for latest (default), or negative index for older responses.

Inputs: index, jsonpath, include_headers, include_request, +1 more.

search_schemaA

Search endpoints by query (multiple words = OR match). Returns compact one-liners by default. Supports pagination with limit/offset.

Inputs: query (required), limit, offset, compact.

set_server_configA

Connect to an OpenAPI server. If no server is configured yet, use this tool first to set the OpenAPI URL. Switches between different API servers dynamically.

Inputs: openapi_url (required), base_url, nickname.

set_variableA

Store values (like auth tokens) for reuse in requests via {{varname}} syntax

Inputs: key (required), value (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 12 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: executing requests, getting endpoint details, managing history, etc. No two tools overlap significantly, and the descriptions clearly differentiate them.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern (e.g., execute_request, get_endpoint_details, list_endpoints), with no mixing of conventions or irregular naming.

    Tool Count5/5

    12 tools is well-scoped for a server that manages API connections, discovery, execution, caching, and variable storage. Each tool serves a necessary function without redundancy.

    Completeness4/5

    The tool set covers core workflows: connecting, discovering endpoints, executing requests, caching, and managing variables. Minor gaps exist (e.g., no tool to delete variables or disconnect from a server), but these do not severely hinder typical use.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Dynamically converts any REST service's OpenAPI specification into MCP tools, enabling interaction with REST endpoints through natural language. Supports Spring Boot services and includes auto-discovery for common API configurations.
      -
    • A
      license
      Not graded
      quality
      Not graded
      maintenance
      Automatically converts Swagger/OpenAPI specifications into dynamic MCP tools, enabling interaction with any REST API through natural language by loading specs from local files or URLs.
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that dynamically converts any OpenAPI or REST API into MCP tools, allowing for real-time server switching and schema reloading. It supports variable substitution for headers and bodies, enabling seamless authentication and interaction with multiple API environments.
      MIT