Fastn

by fastnai

7 stars

229 downloads

Not rated

GitHub

About

Dynamically registers and executes tools across multiple services, enabling seamless integration and real-time operations through a flexible, API-driven platform with robust logging and error handling.

Details

Author: fastnai
Repository: fastn-ai/fastn-mcp
GitHub stars: 7
Downloads: 229
License: MIT License
Categories: Developer Tools, API, Automation, AI, Infrastructure, Communication
Tags: #integration

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below
Plugin Name Fastn

Command (node, npx, python, etc.) fastn-mcp
Arguments
- Argument 1 --stdio
Environment
- FASTN_API_KEY your-api-key
- FASTN_PROJECT_ID your-project-id
Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "/c",
                "fastn-mcp --stdio"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "/c",
                "fastn-mcp --stdio"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "/c",
                "fastn-mcp --stdio"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "/c",
                "fastn-mcp --stdio"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "/c",
                "fastn-mcp --stdio"
            ],
            "command": "cmd"
        }
    }
}

JSON

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

From the repository

Sign up or log in at ucl.dev, activate the services you want to use, then follow the instructions in the Integrate section to connect UCL to your agents. Alternatively, use UCL’s native sandbox or preview mode to test it immediately.

`find_tools`

Search for available connector tools by natural language prompt. Returns matching tools with IDs and input schemas.

`execute_tool`

Execute a connector tool by its ID with parameters. Returns the result directly.

`list_connectors`

Browse all 250+ available connectors in the registry, including ones not yet connected.

`list_skills`

List available skills in the project.

`list_projects`

List available projects for the authenticated user.

`list_flows`

List saved automations (flows) in the project.

`run_flow`

Execute a saved flow by its ID.

`delete_flow`

Remove a flow from the project.

`create_flow`

Create a flow from natural language. *(Under development)*

`update_flow`

Update an existing flow. *(Under development)*

`configure_custom_auth`

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "fastn": {
            "env": {
                "FASTN_API_KEY": "your-api-key",
                "FASTN_PROJECT_ID": "your-project-id"
            },
            "args": [
                "--stdio"
            ],
            "command": "fastn-mcp"
        }
    }
}

Linux

{
    "env": {
        "FASTN_API_KEY": "your-api-key",
        "FASTN_PROJECT_ID": "your-project-id"
    },
    "args": [
        "--stdio"
    ],
    "command": "fastn-mcp"
}

Macos

{
    "env": {
        "FASTN_API_KEY": "your-api-key",
        "FASTN_PROJECT_ID": "your-project-id"
    },
    "args": [
        "--stdio"
    ],
    "command": "fastn-mcp"
}

Windows

{
    "env": {
        "FASTN_API_KEY": "your-api-key",
        "FASTN_PROJECT_ID": "your-project-id"
    },
    "args": [
        "/c",
        "fastn-mcp --stdio"
    ],
    "command": "cmd"
}

Give your AI agents and apps secure, governed access to your customers' tools and systems through one multi-tenant MCP endpoint.

Part of Fastn, the embedded integration platform for SaaS products and AI agents. Fastn MCP Server is a production-readyModel Context Protocol (MCP)gateway that connects AI agents and apps to Slack, Jira, GitHub, Salesforce, HubSpot, Postgres, and 200+ more services, with fully managed auth, governed multi-tenant access, and sub-second execution.

Built on the Fastn SDK, this server exposes MCP tools that any compatible AI platform can use out of the box.

Create an account and connect your first connectors (Gmail, Slack, GitHub, etc.).

Hosted server (recommended), no installation needed:

Point any MCP client at this URL. Authentication is handled via MCP OAuth 2.1 automatically. See Client Configurationfor Claude Desktop and Cursor examples.

Self-hosted, install and run your own instance:

pip install fastn-mcp-server fastn-mcp --shttp --port 8000

Use the hosted server (mcp.live.fastn.ai) or your self-hosted instance. Each path exposes a different set of tools:

https://mcp.live.fastn.ai/shttp # All tools https://mcp.live.fastn.ai/shttp/tools # Fastn tools only https://mcp.live.fastn.ai/shttp/tools/{project_id} # Pre-set project https://mcp.live.fastn.ai/shttp/tools/{project_id}/{skill_id} # Pre-set project + skill

The MCP server supports three authentication methods. Get your credentials from app.fastn.ai.

Standard MCP OAuth flow with PKCE. The server bridges to Fastn's identity provider automatically. Just point your client at the URL, you'll be prompted to authenticate:

{ "mcpServers": { "tools": { "url": "https://mcp.live.fastn.ai/shttp" } } }

Pass a Fastn auth token or API key via theAuthorizationheader in your MCP client config:

{ "mcpServers": { "tools": { "url": "https://mcp.live.fastn.ai/shttp", "headers": { "Authorization": "Bearer <your-token-or-api-key>" } } } }

You can also passx-project-idto scope requests to a specific project:

{ "mcpServers": { "tools": { "url": "https://mcp.live.fastn.ai/shttp", "headers": { "Authorization": "Bearer <your-token-or-api-key>", "x-project-id": "<your-project-id>" } } } }

For local stdio transport, pass credentials as environment variables:

{ "mcpServers": { "tools": { "command": "fastn-mcp", "args": ["--stdio"], "env": { "FASTN_API_KEY": "your-api-key", "FASTN_PROJECT_ID": "your-project-id" } } } }

The server exposes these tools to AI agents:

Workflow:Browse connectors →list_connectors. Execute an action →find_tools→execute_tool. Iffind_toolsreturns nothing relevant →list_connectors(connector may need connecting).

AI Agent (Claude, Cursor, Lovable) │ ▼ MCP Protocol (stdio / SSE / Streamable HTTP) │ ▼ ┌─────────────────────────────┐ │ Fastn MCP Server │ │ ┌───────────────────────┐ │ │ │ Tool Discovery │ │ find_tools, list_connectors │ │ Tool Execution │ │ execute_tool │ │ Flow Management │ │ list/run/delete/create flows │ │ Auth & Config │ │ OAuth 2.1, custom JWT │ └───────────────────────┘ │ └─────────────────────────────┘ │ ▼ Fastn SDK → Fastn API │ ▼ 250+ Connectors (Slack, Jira, GitHub, Salesforce, Postgres, ...)

Connectorsprovide tools.Flowscompose tools.Agentsrun flows and tools with reasoning.

The JSON examples above work with any MCP client. Here are the config file locations:

For Cursor, use the/shttp/toolsendpoint to expose only Fastn tools (recommended for coding assistants):

{ "mcpServers": { "tools": { "url": "https://mcp.live.fastn.ai/shttp/tools" } } }

fastn-mcp --stdio fastn-mcp --stdio --mode tools # Fastn tools only fastn-mcp --stdio --mode tools --project ID # Fastn tools + pre-set project fastn-mcp --stdio --mode tools --project ID --skill ID # Fastn tools + pre-set project and skill

SSE + Streamable HTTP (remote), For web-based AI platforms:

Remote transports use MCP OAuth 2.1 by default. The server implements RFC 9728 Protected Resource Metadata:

fastn-mcp --sse --shttp --port 8000 # OAuth endpoints auto-configured at /.well-known/oauth-protected-resource

fastn-mcp --sse --shttp --port 8000 --server-url https://mcp.example.com

docker build -t fastn-mcp . docker run -p 8000:8000 fastn-mcp

Server configuration for self-hosted deployments:

FASTN_MCP_PORT=8000 FASTN_MCP_HOST=0.0.0.0 FASTN_MCP_SERVER_URL=https://your-public-url FASTN_MCP_TRANSPORT=both FASTN_MCP_NO_AUTH=false FASTN_MCP_VERBOSE=false

For local development and testing only, use ngrok to expose your local server:

# Terminal 1: Start the MCP server fastn-mcp --shttp --port 8000 --verbose # Terminal 2: Start ngrok tunnel ngrok http 8000

Then restart with the ngrok URL so OAuth metadata resolves:

fastn-mcp --shttp --port 8000 \ --server-url https://abc123.ngrok-free.dev \ --verbose

For production, deploy with Docker behind a reverse proxy with a real domain.

git clone https://github.com/fastn-ai/fastn-mcp.git cd fastn-mcp python -m venv .venv source .venv/bin/activate pip install -e ".[dev]"

fastn-mcp/ ├── fastn_mcp/ │ ├── __init__.py # Package metadata │ ├── __main__.py # CLI entry point │ ├── server.py # MCP server, tools, handlers, routing │ ├── auth.py # OAuth 2.1 provider (RFC 9728) │ └── tools/ # Tool utilities ├── tests/ │ ├── test_server.py # 185+ tests covering all tools and transports │ └── conftest.py # Test fixtures ├── Dockerfile # Production container ├── docker-compose.yml # Docker Compose for deployment ├── pyproject.toml # Python project configuration └── README.md

fastn-mcp [OPTIONS] Transport: --stdio Use stdio transport (Claude Desktop, Cursor) --sse Enable SSE transport --shttp Enable Streamable HTTP transport Server: --host HOST Bind address (default: 0.0.0.0) --port PORT Port number (default: 8000) --no-auth Disable OAuth (development only) --server-url URL Public URL for OAuth metadata Mode: --mode {agent,tools} Tool mode for stdio: "agent" (all tools) or "tools" (Fastn tools only) --project ID Pre-set project ID for stdio --skill ID Pre-set skill ID for stdio (requires --project) Debug: -v, --verbose Enable debug logging

Fastn provides 250+ pre-built connectors including:

Communication:Slack, Microsoft Teams, Discord, Gmail, Outlook, SendGrid, Twilio

Project Management:Jira, Linear, Asana, Trello, Monday.com, ClickUp, Notion

Development:GitHub, GitLab, Bitbucket, PagerDuty, Sentry, Datadog

CRM & Sales:Salesforce, HubSpot, Pipedrive, Zoho CRM

Databases:PostgreSQL, MySQL, MongoDB, Redis, Supabase, Firebase

Cloud:AWS, Google Cloud, Azure, Cloudflare

And 200+ more, browse the full catalog atfastn.ai/integrations

- Fastn Platform
- Fastn SDK
- MCP Specification
- Documentation

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

The MCP server for Bitrix24 provides AI assistants with structured access to the Bitrix24 API. It delivers up-to-date method descriptions, parameters, and valid values, allowing assistants to work with precise data instead of guesswork. This reduces code errors and accelerates Bitrix24 integration development.

One remote MCP server for 500+ production APIs — Stripe, HubSpot, Postgres, Gmail, and more. OAuth and API key auth, credential management, and a CLI.

Single tool to control all 100+ API integrations, and UI components

Agent-native developer Q&A API with MCP + A2A endpoints for citations, job pickup, and answer submission.

Self-hosted MCP gateway: convert REST/SOAP/GraphQL/SQL APIs into MCP tools with 29 pre-built adapters, OAuth2, RBAC and audit log.

A universal bridge to convert any web API into an MCP server, supporting multiple transport types.

Dynamically creates MCP servers from web API configurations, integrating any REST API, GraphQL endpoint, or web service into MCP-compatible tools.

Hosted MCP server and coordination layer for AI coding agents — live API contracts, database schema, frontend/backend mismatch detection, and shared handoff tickets for Claude Code, Cursor, Codex, and Lovable.

An MCP server that dynamically loads tools from an external JSON file configured via an environment variable.

A lightweight server exposing Axone's capabilities through the Model-Context Protocol.

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

find_tools

execute_tool

list_connectors

list_skills

list_projects

list_flows

run_flow

delete_flow

create_flow

update_flow

configure_custom_auth

Claude Desktop / Cursor

Linux

Macos

Windows

Install

More like this

@mendableai/firecrawl Mcp Server

Umut Naci

Playwright

Sentry

Github

Fetch

`find_tools`

`execute_tool`

`list_connectors`

`list_skills`

`list_projects`

`list_flows`

`run_flow`

`delete_flow`

`create_flow`

`update_flow`

`configure_custom_auth`