MCP Setup Guide

By the Seedfast team · Updated March 22, 2026

The Model Context Protocol (MCP) enables AI assistants to interact directly with developer tools. Seedfast's MCP server brings intelligent database seeding into your AI workflow — no context switching required.

This guide walks through connecting Seedfast MCP to Claude Desktop, Cursor IDE, VS Code, or Claude Code CLI.

Understanding MCP Architecture

Before diving into configuration, it helps to understand what MCP actually does:

┌──────────────────────┐       ┌──────────────────────┐       ┌──────────────────────┐
│   AI Assistant       │ ◄───► │   Seedfast MCP       │ ◄───► │   Your Database      │
│   (Claude/Cursor)    │       │   Server             │       │   (PostgreSQL)       │
│                      │       │                      │       │                      │
│   Natural language   │       │   JSON-RPC protocol  │       │   SQL execution      │
│   commands           │       │   Tool orchestration  │       │   Data generation    │
└──────────────────────┘       └──────────────────────┘       └──────────────────────┘

The MCP server acts as a bridge between your AI assistant and Seedfast's backend. When you ask Claude to "seed my database with test users," the assistant invokes MCP tools that execute the actual seeding operations.

Prerequisites

Before starting, ensure you have:

A Seedfast account (free tier available at dashboard.seedfa.st)
PostgreSQL database accessible from your machine
Node.js 18+ installed (for npx-based MCP server)
One of: Claude Desktop, Cursor IDE, VS Code with Continue.dev, or Claude Code CLI

Installation

No separate installation required. The MCP server is built into the Seedfast CLI and runs via npx directly from your configuration.

Configure Claude Desktop

Claude Desktop is the official Anthropic client with native MCP support.

Locate your config file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

Add the Seedfast server:

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@latest", "mcp"],
      "env": {
        "SEEDFAST_API_KEY": "sfk_live_your_api_key_here"
      }
    }
  }
}

Restart Claude Desktop to load the new configuration.

Configure Cursor IDE

Cursor runs MCP servers in a sandboxed environment. Authentication is configured directly in the MCP config's env section.

Add to .cursor/mcp.json or global settings:

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@latest", "mcp"],
      "env": {
        "SEEDFAST_API_KEY": "sfk_live_your_api_key_here"
      }
    }
  }
}

Configure VS Code with Continue.dev

Continue.dev provides MCP support for VS Code users.

Add to .continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "seedfast@latest", "mcp"],
          "env": {
            "SEEDFAST_API_KEY": "sfk_live_your_api_key_here"
          }
        }
      }
    ]
  }
}

Configure Claude Code CLI

For terminal-based workflows with Claude Code:

Add to your .mcp.json:

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@latest", "mcp"],
      "env": {
        "SEEDFAST_API_KEY": "sfk_live_your_api_key_here"
      }
    }
  }
}

Verify Installation

After configuration, verify the MCP server is accessible. In your AI assistant, ask:

Use seedfast_doctor to check the installation

You should see output confirming the MCP server is running and authenticated:

CLI Status: OK
Version: 1.26.0
Auth: OK (SEEDFAST_API_KEY configured)
Platform: darwin/arm64
MCP Server Version: 1.0.0

Configure Authentication

Seedfast MCP uses config-based authentication via the env section in your MCP configuration.

Get Your API Key:

Log in to dashboard.seedfa.st
Navigate to Settings → API Keys
Click Create New Key
Copy the key (format: sfk_live_xxxxx...)

Add API Key to MCP Config:

Add your API key to the env section of your MCP configuration (as shown in the configuration examples above):

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@latest", "mcp"],
      "env": {
        "SEEDFAST_API_KEY": "sfk_live_your_actual_key_here"
      }
    }
  }
}

Your First AI-Powered Seed

With everything configured, try your first seeding operation.

Test Database Connection:

Test the database connection to postgresql://myuser:mypass@localhost:5432/mydb

Create a Seeding Plan:

Create a seeding plan for my HR schema for just employees, departments, and salaries tables

This generates a plan without executing it, so you can review what will be seeded.

Execute Seeding:

Seed my database at postgresql://myuser:mypass@localhost:5432/mydb — seed all tables in all schemas

The assistant will call seedfast_run, return a Run ID, and poll seedfast_run_status to show progress.

Example Session

You: Seed postgresql://postgres:postgres@localhost:5432/mydb
    with all tables in all schemas

AI:  Seeding started. Run ID: run_e1e4867ee678466a

     Progress: 5/22 tables (23%), 25 rows...
     Progress: 12/22 tables (55%), 62 rows...
     Progress: 22/22 tables (100%), 117 rows

     Seeding complete!
     - Tables seeded: 22/22 (100%)
     - Total rows: 117
     - Status: Success

Available MCP Tools

Core Tools:

seedfast_doctor — Verify CLI installation, environment, and auth status
seedfast_connections_test — Test database connectivity
seedfast_run — Execute database seeding
seedfast_run_status — Check seeding progress
seedfast_run_cancel — Cancel running operation

Plan Management Tools:

seedfast_plan — Create seeding plan by analyzing database schema
seedfast_plans_list — List all seeding plans in current session
seedfast_plan_get — Get a seeding plan by ID
seedfast_plan_create — Create a seeding plan manually (without CLI)
seedfast_plan_update — Update an existing seeding plan
seedfast_plan_delete — Delete a seeding plan

Troubleshooting

"npx: command not found"

Node.js isn't installed or not in your PATH. Install Node.js 18+ from nodejs.org.

"Not authenticated" or "SEEDFAST_API_KEY not configured" error

Verify your API key is configured in MCP config:

Open your MCP config file (see configuration sections above for location)
Check that the env section contains SEEDFAST_API_KEY
Verify the key starts with sfk_live_
Restart your AI assistant to reload the config

You can also verify auth status by asking:

Run seedfast_doctor to check the installation

Expected output should show: Auth: OK (SEEDFAST_API_KEY configured)

Claude Desktop doesn't see the server

Verify JSON syntax in config file
Ensure Claude Desktop was fully restarted (not just minimized)
Check Developer Tools console for errors

Cursor IDE issues

Verify JSON syntax in .cursor/mcp.json
Restart Cursor completely
Check that SEEDFAST_API_KEY is in the env section

npm package not found

If you see errors about the package not being found, try clearing npm cache:

npm cache clean --force
npx -y seedfast@latest --version

Scope Best Practices

The scope parameter tells Seedfast what to seed:

seed all tables in all schemas — Seeds every table in the database
seed only the sales schema — Seeds tables in specific schema
seed users, orders, and products tables — Seeds specific tables
seed HR department tables only — Seeds tables related to a domain

💡 Tip: Be explicit about schemas. "Seed all tables" might only seed one schema based on context. Use "seed all tables in all schemas" for full database seeding.

What's Next?

With MCP configured, explore these workflows:

Schema-specific seeding: "Seed only the hr schema with employee data"
Plan management: Create, review, and execute plans using seedfast_plan_* tools
Progress monitoring: Poll seedfast_run_status to track seeding progress