Skip to main content
Adapters are powerful components that automatically convert external APIs and services into MCP tools. Instead of writing custom tools manually, adapters generate them from specifications like OpenAPI, GraphQL schemas, or database schemas.

​
Why Use Adapters?

Zero Boilerplate

Generate hundreds of tools from a single specification without writing code for each endpoint.

Type Safety

Automatic schema validation using Zod ensures type-safe inputs and outputs.

Consistency

All tools follow the same patterns for authentication, error handling, and validation.

Maintainability

Update your spec and regenerate tools automatically — no manual updates needed.

​
Official Adapters

These adapters are maintained by the FrontMCP team and included in @frontmcp/adapters.

OpenAPI Adapter

Generate MCP tools from OpenAPI 3.x specifications. Perfect for REST APIs with comprehensive documentation.Features:
  • Multi-provider authentication support
  • Path, query, header, and body parameter handling
  • Request/response validation
  • Filter operations by path or operation ID
  • Custom headers and body mapping
Best for: REST APIs, microservices, third-party integrations
More official adapters are coming soon! GraphQL, gRPC, and database adapters are in development.

​
Community Adapters

Community adapters are created and maintained by the FrontMCP community. While not officially supported, they extend FrontMCP’s capabilities to new APIs and services.
Community adapters are not maintained by the FrontMCP team. Please review the code and security practices before using them in production.

​
How to Find Community Adapters

1

Search npm

Search for packages tagged with frontmcp-adapter or mcp-adapter:
npm search frontmcp-adapter
2

Check GitHub Topics

Browse repositories tagged with frontmcp-adapter on GitHub.
3

Join the Community

Visit the FrontMCP Discussions to discover and share adapters.
This section is for community-contributed adapters. If you’ve created an adapter, submit a PR to add it here!

Submit Your Adapter

Created an adapter? Share it with the community! Submit a PR to add your adapter to this page.

Adapter Template

Use the official adapter structure as a template for building your own adapters.

​
Creating Custom Adapters

You can create custom adapters to integrate any API or service with FrontMCP. Adapters are TypeScript classes that implement the adapter interface.

​
Basic Adapter Structure

import { BaseAdapter } from '@frontmcp/sdk';

export class MyCustomAdapter extends BaseAdapter {
  async fetch(ctx: ToolContext) {
    // Initialize your adapter
    // Generate tools from your API/service
    // Return array of MCP tools

    return [
      {
        name: 'myTool',
        description: 'Description of the tool',
        inputSchema: {
          type: 'object',
          properties: {
            param1: { type: 'string' },
          },
        },
        execute: async (input) => {
          // Execute the tool
          return { result: 'success' };
        },
      },
    ];
  }

  static init(options: MyAdapterOptions) {
    return new MyCustomAdapter(options);
  }
}

​
Adapter Best Practices

  • Never expose credentials in tool inputs
  • Use authInfo from context for authentication
  • Validate and sanitize all inputs
  • Document security risk levels
  • Implement proper error handling
  • Generate Zod schemas from specifications - Validate inputs at runtime - Provide TypeScript types for all options - Use strict type checking
  • Use lazy loading for specifications - Cache generated tools when possible - Implement connection pooling - Handle rate limiting gracefully
  • Provide clear documentation - Include working examples - Support common authentication patterns - Add helpful error messages - Write comprehensive tests
  • Follow the official adapter structure
  • Version your adapter properly
  • Document breaking changes
  • Provide migration guides
  • Keep dependencies up to date

​
Publishing Your Adapter

When publishing a community adapter:
  1. Package Name: Use the pattern @yourscope/frontmcp-adapter-name or frontmcp-adapter-name
  2. Keywords: Include frontmcp, frontmcp-adapter, mcp, adapter
  3. README: Include installation, usage, examples, and security considerations
  4. License: Use a permissive license (MIT, Apache 2.0, etc.)
  5. Tests: Include comprehensive test coverage
  6. TypeScript: Provide TypeScript types and declarations
package.json
{
  "name": "@yourscope/frontmcp-adapter-myapi",
  "version": "1.0.0",
  "description": "FrontMCP adapter for MyAPI",
  "keywords": ["frontmcp", "frontmcp-adapter", "mcp", "adapter", "myapi"],
  "peerDependencies": {
    "@frontmcp/sdk": "^0.3.0"
  }
}

​
Adapter Comparison

Choose the right adapter for your use case:
AdapterBest ForAuthenticationType SafetyComplexity
OpenAPIREST APIs with specsMulti-providerAuto-generatedLow
CustomAny API/serviceFully customizableManual schemasMedium-High

​
Next Steps

OpenAPI Adapter

Learn how to use the OpenAPI adapter

Browse Examples

See adapters in action with real examples

Join Community

Get help and share your adapters

​
Resources

SDK Documentation

Learn about the FrontMCP SDK and adapter interfaces

Source Code

View the official adapters source code

npm Package

Install the official adapters package

Contributing Guide

Contribute to FrontMCP adapters