M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
B

Butterbase

Community
AI-native, open-source backend-as-a-service with Postgres, auth, storage, functions, AI gateway, and MCP server.
How to install ↓ Compare GitHub source repository ↗
Category
Cloud Storage #10 of 15
Stars
★ 3.7k Very popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Node.js 22+ · Docker · Hosted (no local runtime)
Credentials
API key / credential required
License
Apache-2.0
Last commit
55FMRS · C

Butterbase is a feature-rich open-source BaaS with strong MCP server integration, suitable for developers building AI applications. Its strength lies in its all-in-one backend service, but the open-source version is still young, posing stability risks, and some advanced features are only available to managed users.

Strongest · Maintenance 15/20 Weakest · Reliability 7/20

Reliability
7/20
Security and permissions
11/20
Maintenance
15/20
Documentation
13/20
Setup experience
9/20
Why each score
Reliability 7/20
Evidence: the server manifest is well-formed, declaring the npm package @butterbase/mcp, a stdio transport, the required BUTTERBASE_API_KEY environment variable, and a streamable-http remote; the README describes a self-host stack with a health check (/health/ready) and a curl smoke-test path. Deductions: only the README and manifest (both untrusted evidence) were reviewed — no actual MCP server source, CI workflows, or committed tests were provided; the tool list, error handling, and edge-case behavior cannot be verified; both stdio and /mcp HTTP paths depend on control-api or the managed service, and with three Postgres planes, Docker, and a Deno runtime, failures are hard to diagnose from static material. Under the static calibration, reliability cannot exceed 12 without verifiable execution evidence, so 7 is awarded.
Security and permissions 11/20
Evidence: BUTTERBASE_API_KEY is marked required and secret in the manifest; the Authorization header is likewise marked required and secret; the project advertises row-level security, audit logs, and a SECURITY.md contact channel; no real tokens or secrets appear in install examples. Deductions: least-privilege scoping for the broad tool surface (auth, storage, functions, deploys, RAG) cannot be verified from source; confirmation flows for destructive/remote-command operations (deletes, deploys, function execution) are unverifiable; the local dev profile (AUTH_ENABLED=false) disables auth entirely, a risk if left enabled by self-hosters; data-flow disclosure for the managed remote is limited to the manifest. No red-line conditions were triggered, keeping the score above 4, but permission and confirmation evidence is incomplete, so 11 is awarded.
Maintenance 15/20
Evidence: Apache-2.0 license, a clear copyright owner (NetGPT Inc.), SECURITY.md with a dedicated security contact ([email protected]), CHANGELOG with a recent release (v0.2.0, 2026-05-25), ROADMAP, CONTRIBUTING.md; repository is not archived and has few open issues (5); the feature set evolves by version (v0.2.0 added KV store across SDK/REST/CLI/MCP). Deductions: commit frequency and issue-response times are not verifiable from the supplied material; the README itself describes the OSS distribution as young; stars were treated strictly as a discovery signal and not scored. Governance, licensing, and an update path are clear, but sustained activity lacks verifiable evidence, so 15 is awarded.
Documentation 13/20
Evidence: the README is comprehensive — feature overview, 6-step self-host quickstart, local endpoint table, architecture diagram, repo layout table, docs directory, SETUP.md, runbooks, Examples, and troubleshooting hints (first-run build time, migrations not applied automatically, fresh volumes need seeding); the manifest documents the env var format (bb_sk_...), the remote URL, and the required header. Deductions: no per-tool parameter documentation or MCP tool list is visible; no limits/cost disclosure for the managed endpoint; MCP-specific troubleshooting is only referenced via SETUP.md, whose content was not part of the reviewed material, leaving reviewable evidence incomplete. 13 is awarded.
Setup experience 9/20
Evidence: two connection paths are described — the managed path (stdio via npx @butterbase/mcp, or streamable-http at https://api.butterbase.ai/mcp) requires only BUTTERBASE_API_KEY; the self-host path has a step-by-step quickstart (clone with submodules, npm ci, docker compose, health check, migrations, seed, smoke test) and states Node 22+ and Docker requirements. Deductions: self-hosting involves many manual steps and documented footguns (a plain clone silently skips the plugin submodule, schema migrations are not automatic, fresh volumes require manual seeding, and auth is disabled in the dev profile); no mainstream MCP client configuration example is provided; the material contains no CI/test evidence, so per static calibration setup cannot exceed 15; overall complexity is high and fragile, giving 9.

Static review · not runListed 2026-08-07

Read the FMRS scoring method →

Fit and risk

What it can accessRuns commands or codeUses the networkChanges third-party account dataConnects to a database

Best for

  • Developers building AI-native applications
  • Teams needing a self-hosted BaaS
  • Projects wanting to expose backend capabilities to AI agents

Not for

  • Non-technical users requiring fully managed services
  • Enterprises with high demands for stability and production support
  • Scenarios with simple backend needs that only require a single feature

Required permissions

  • Requires a Butterbase API key (bb_sk_...) for API access
  • If self-hosting, requires Docker and Node.js 22+
  • May need to configure infrastructure such as Postgres, Redis, S3/R2

Risks and side effects

  • The open-source version is young (v0.2.0) and may have unnoticed bugs
  • Some features (e.g., multi-region orchestration, billing) are only in the managed private repo; self-hosted version is limited
  • The AI gateway lacks upstream router adapters, requiring custom implementations

Setup

Before you start

Runtime：Node.js 22+ · Docker · Hosted (no local runtime)

BUTTERBASE_API_KEY requiredsecret Butterbase API key (format bb_sk_...), required for auth on both stdio and remote endpoints; create one at https://butterbase.ai.
  1. Clone the repository (with submodules): git clone --recurse-submodules https://github.com/butterbase-ai/butterbase.git
  2. Install dependencies: npm ci
  3. Copy environment config: cp .env.example .env
  4. Start the stack: docker compose -f docker-compose.local.yml up -d
  5. Run database migrations: set environment variables as required and execute npm run migrate:all
  6. Seed the local dev user: npm run seed:dev

(The MCP server is available via the npm package @butterbase/mcp or the HTTP endpoint https://api.butterbase.ai/mcp)

claude_desktop_config.json 
{
  "mcpServers": {
    "butterbase": {
      "command": "npx",
      "args": [
        "-y",
        "@butterbase/mcp"
      ],
      "env": {
        "BUTTERBASE_API_KEY": "bb_sk_..."
      }
    }
  }
}

Shown for Claude Desktop. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "butterbase": {
      "command": "npx",
      "args": [
        "-y",
        "@butterbase/mcp"
      ],
      "env": {
        "BUTTERBASE_API_KEY": "bb_sk_..."
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add butterbase -e BUTTERBASE_API_KEY=bb_sk_... -- npx -y @butterbase/mcp

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Add the server to your client config with BUTTERBASE_API_KEY set; the tool list should show Butterbase MCP tools for managing schemas, auth, functions, storage, RAG, and deploys.

Troubleshooting

  1. Check that the API key is set correctly
  2. Confirm the service is running (control API health check)
  3. Inspect Docker logs and Postgres connections
  4. Ensure database migrations have been executed correctly

Things to try

Once connected, you can ask your AI assistant things like:

  • Create a todos table with RLS policies in my Butterbase backend
  • List my app's storage buckets and generate a presigned URL for a file
  • Deploy a TypeScript function to Butterbase and run a test invocation
  • Run a semantic search in my RAG collection and synthesize an answer

Use cases

Building AI-driven applications with rapid backend setup
Providing backend management interfaces for AI agents
Quickly developing, testing, and deploying backend features

Supported clients

Claude Desktop

Listed from the project's documentation, not tested by this site.

Overview

Butterbase is an open-source, AI-native backend-as-a-service platform that provides a comprehensive set of backend capabilities: Postgres data plane (with row-level security), serverless functions, LLM gateway, realtime subscriptions, key-value store, file storage, RAG, durable per-key actors, and a built-in Model Context Protocol (MCP) server, enabling AI agents to operate your backend with tools instead of glue code. It supports both self-hosting and managed offerings.

Similar servers

Compare with other MCP servers

Source revision 830ed6053ab0 Data synced 2026-10-12 Read the FMRS scoring method