Skip to main content
FlowMCP Hero Light

​
What is FlowMCP?

FlowMCP transforms REST APIs into standardized MCP servers for AI applications. Define APIs as schemas, launch one server, and AI tools like Claude Desktop can access all your data sources through a unified interface.

🚀 Quick Start

Get up and running with FlowMCP quickly

​
Core Features

  • Universal API Adaptation: Transform any REST API into MCP tools automatically
  • Schema-Driven Development: Declarative schemas handle validation, parameters, and errors
  • Extensive Production APIs: Battle-tested with GitHub, Stripe, OpenWeather, and more
  • Flexible Deployment: stdio servers for AI apps, HTTP servers for web services

​
Why FlowMCP?

Traditional MCP: Write separate servers for each API with custom authentication, validation, and error handling. Time: weeks per API. With FlowMCP: Define schemas, launch one server, access all APIs. Time: hours total.

​
Real-World Impact

Consider a typical AI development scenario where you need access to:
  • GitHub for code repository data
  • OpenWeather for environmental context
  • CoinGecko for financial market data
  • News APIs for current events
  • Social media APIs for trend analysis
Traditional Approach: Implement 5+ separate MCP servers, each requiring protocol knowledge, error handling, and ongoing maintenance. Estimated development time: 2-4 weeks. FlowMCP Approach: Create 5 schema files (10-20 lines each), launch one MCP server. Development time: hours total. The framework handles all the MCP protocol complexity, parameter validation, authentication management, and error handling automatically. This allows developers to focus on building AI applications rather than maintaining API infrastructure.

​
Live Example: Multi-Provider MCP Server

See how FlowMCP consolidates multiple data sources into a single MCP server: 
import { FlowMCP } from './src/index.mjs'
import { Server } from '@modelcontextprotocol/sdk/server/index.js'

// Basic schema definition
const githubSchema = {
  namespace: 'github',
  flowMCP: '1.2.2',
  root: 'https://api.github.com',
  requiredServerParams: ['GITHUB_TOKEN'],
  headers: {
    'Authorization': 'token {{GITHUB_TOKEN}}',
    'Accept': 'application/vnd.github.v3+json'
  },
  routes: {
    getUser: {
      requestMethod: 'GET',
      description: 'Get GitHub user information',
      route: '/users/{{USER_PARAM}}',
      parameters: [
        { position: { key: "username", value: "{{USER_PARAM}}", location: "insert" }, z: { primitive: "string()", options: ["min(1)", "max(39)"] } }
      ],
      tests: [],
      modifiers: []
    }
  }
}

// Validate schema structure
const validation = FlowMCP.validateSchema({ schema: githubSchema })
if (!validation.status) {
    console.error('Schema validation failed:', validation.messages)
    process.exit(1)
}

// Execute API request
const userParams = { username: 'octocat' }
const serverParams = { GITHUB_TOKEN: process.env.GITHUB_TOKEN }
const result = await FlowMCP.fetch({ 
    schema: githubSchema, 
    userParams, 
    serverParams, 
    routeName: 'getUser' 
})

if (result.status) {
    console.log('GitHub user:', result.dataAsString)
} else {
    console.error('API request failed:', result.messages)
}
Result: Instead of Claude Desktop needing separate integrations for GitHub, OpenWeather, and CoinGecko, it connects to one FlowMCP server and automatically gains access to all three APIs through standardized MCP tools.
Ready to dive in? Check out our Quick Start Guide or explore the extensive schema library.

​
FlowMCP Ecosystem

The FlowMCP ecosystem consists of several interconnected components that work together to provide comprehensive MCP server capabilities: FlowMCP Core is the foundational framework that handles schema validation, HTTP requests, parameter substitution, and response processing. It provides the essential FlowMCP.fetch() method for direct API calls and the filtering system for managing large schema collections. FlowMCP Schemas represents a curated library of extensive production-ready API schemas covering major services like GitHub, OpenWeather, Stripe, CoinGecko, and many others. Each schema is professionally crafted and tested, allowing you to quickly integrate popular APIs without writing custom configurations. FlowMCP Servers provides the MCP server implementations - LocalServer for stdio-based AI integrations (perfect for Claude Desktop), and RemoteServer for HTTP-based web applications. Both servers support the documented activateServerTools() method for converting schema arrays into MCP tool collections. Community Server offers a GitHub-integrated MCP server that demonstrates advanced FlowMCP patterns and provides ready-to-use functionality for development teams. It showcases how to build sophisticated MCP servers using FlowMCP as the foundation. X402 Core extends FlowMCP with ERC20-based payment capabilities for paid APIs, enabling blockchain-powered API access management. This component addresses the growing need for monetized API access in decentralized applications. The Visual Schema Browser provides an interactive web interface for exploring available schemas, understanding their structure, and testing their functionality before integration. This tool significantly reduces the learning curve for new FlowMCP users.
⌘I