MCP Bridge by Appfactor

MCP Bridge is launched by Appfactor, positioned to make enterprise data usable by scalable AI agents and workflows, and to instantly turn existing APIs into "AI-ready" ones without incurring long-term technical debt. Its core goal is to connect any API to any AI agent.

Purpose and Background

Most legacy and existing APIs were not designed with "the consumer is a large language model" in mind: schemas lack semantic context, tool boundaries are unclear, and payloads easily consume the context window. MCP Bridge is used to expose, govern, and optimize LLMs, MCP, and API resources, reducing integration complexity through a single control point and avoiding the creation and maintenance of hundreds or thousands of separate MCP servers.

Main Capabilities

• Automatic generation of MCP tool definitions: supports REST, GraphQL, SOAP, and gRPC; can parse OpenAPI 3, GraphQL introspection, WSDL, and .proto files (including gRPC server reflection). Each operation becomes a complete MCP tool with typed input/output schemas, parameter mappings, behavioral annotations, and documentation, usable by Claude, GPT, Gemini, or any MCP-compatible client.
• Runtime execution: MCP Bridge validates inputs, maps parameters, handles authentication, and forwards requests to the backend; responses undergo post-processing to reduce token waste.
• Code Mode extension: for large APIs, replace the full tool catalog with 3 meta-tools, which can cut context window usage by about 98%; the LLM orchestrates calls through a secure Boa sandbox, with a 30-second timeout.
• Tool management and governance: can enable/disable, rename, edit descriptions, customize parameter mappings, and configure per-tool response handling.
• Response post-processing: supports per-tool declarative rules (unwrap, select, exclude, limit, sort, flatten, aggregate) or custom JavaScript in a sandbox.
• Enterprise authentication: supports Bearer, Basic, API Key, OAuth2, and AWS Cognito SRP; the Web UI supports OIDC and can integrate with Entra ID, Keycloak, Auth0, and Okta.
• Analytics dashboard: displays latency, throughput, by tool and by API metrics, token usage details, and error rates; the Enterprise edition supports O-Tel.
• Tool annotations: Hint information such as read-only, destructive, idempotent, and open-world can be automatically inferred from API semantics and edited per tool.
• Semantic tool search: Hybrid search, including full-text and trigram fuzzy matching, with optional vector similarity search available through pgvector and HNSW.
• Deployment and operational assurance: Docker containers can run on AWS ECS, Azure Container Apps, or any orchestrator, with zero external SaaS dependencies at runtime; provides per-API token bucket rate limiting, exponential backoff with jitter, configurable retry policies, and health checks.

How to Use

According to the material, the process has four steps:

1. Import the API schema: Provide the schema via URL, paste content, or upload a file; supports OpenAPI (JSON/YAML), GraphQL introspection, WSDL, and gRPC (server reflection or .proto files).
2. Automatically generate MCP tools: Each operation is a fully described MCP tool, with typed input/output schemas, parameter mappings, behavior annotations, and documentation.
3. Runtime execution: Validate input, map parameters, handle authentication, and forward to the backend; responses are post-processed to reduce token waste.
4. Extend with Code Mode: For large APIs, replace the full catalog with 3 meta-tools, reducing context window usage by about 98%.

The example commands and configurations in the material include:

# Pull and run MCP Bridge
$ docker run -d \
  --name mcp-bridge \
  -p 8080:8080 \
  -v ./bridge.yaml:/app/config.yaml \
  appfactor/mcp-bridge: latest

# Point any MCP client at the endpoint
$ curl https://localhost:8080/mcp/tools
→ 42 tools generated · ready

apis :
  - name : "payments"
    protocol : "rest"
    schema : "https://api.acme.io/openapi.yaml"
    auth :
      type : "oauth2"
      flow : "client_credentials"
    code_mode : true   # 98% less context
    observability :
      otel : true
      log_level : "info"

# Auto-generated tools, ready for any LLM
tools_generated : 42
protocols : [rest, graphql]
annotations :
  read_only : 28
  idempotent : 31
  destructive : 4
avg_tokens_per_tool : 487
code_mode_tokens : 960   # vs ~48,000 raw

Applicable Scenarios

• Platform engineering: No need to write or maintain an MCP adapter for each service; import schemas, configure authentication, and expose governed tools through a single control plane.
• Building agents: Agents that call enterprise APIs can have built-in authentication, rate limiting, response post-processing, and observability.
• Enterprise organizations: Adopt MCP as a standard, quickly and securely connect the existing API landscape to LLM clients without refactoring services.

Limitations and Availability

The material does not provide specific billing or pricing information, only stating that it is available on AWS and Azure Marketplace, with tiers ranging from evaluation to enterprise-grade deployment. It emphasizes self-hosting, no glue code, data not leaving your own network, and no external SaaS dependencies at runtime. Regarding the complete list of supported LLM providers, maximum scale, or performance benchmarks, the material does not yet provide this.