Seedfast

Fills a PostgreSQL database with relationally valid synthetic test data generated from its live schema, so an agent can seed a development or CI environment without production data. Plan a seed, run it and follow it to completion from the client. Runs as npx -y seedfast mcp and is published in the official MCP registry as st.seedfa/seedfast.

GitHubTry this MCPSponsored

Documentation

Seedfast MCP Server

Seedfast fills a PostgreSQL database with realistic, relationally valid test data generated from its live schema, so a team that cannot put production data into development still gets an environment that behaves like production.

This repository is the public integration surface for its MCP server. You will find the client configuration, the tool reference and a smoke test here. The engine and the CLI themselves are closed-source and ship through npm and Homebrew.

Published in the official MCP registry as st.seedfa/seedfast.

Install

Nothing separate to install. The MCP server is built into the Seedfast CLI and runs straight from npx:

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

That block goes into claude_desktop_config.json for Claude Desktop, .cursor/mcp.json for Cursor, or the equivalent file for VS Code and Claude Code. Client-by-client paths are in the MCP setup guide.

Prefer a local binary? Install the CLI and point command at seedfast with args: ["mcp"] instead:

brew install seedfast-ai/tap/seedfast   # macOS, Linux
npm install -g seedfast                 # any platform with Node.js

Configuration

Variable	Required	What it does
`SEEDFAST_API_KEY`	yes	API key created in the Seedfast dashboard
`SEEDFAST_MCP_RUNS_DB`	no	Path to a SQLite file. Without it, runs and plans live in memory and disappear when the server exits

Tools

Thirteen tools cover the whole loop of planning a seed, running it and inspecting what happened.

Tool	What it does
`seedfast_doctor`	Checks CLI health and whether authentication is configured
`seedfast_connections_test`	Tests a database connection before anything is written
`seedfast_schema_info`	Reads the live schema of the target database
`seedfast_plan`	Builds a seeding plan from a scope description
`seedfast_run`	Executes a seeding run
`seedfast_run_status`	Polls a run in progress
`seedfast_run_cancel`	Aborts a run
`seedfast_run_answer`	Answers a question the run raised while it was waiting for input
`seedfast_plans_list`	Lists saved plans
`seedfast_plan_get`	Reads one saved plan
`seedfast_plan_create`	Saves a new plan
`seedfast_plan_update`	Edits a saved plan
`seedfast_plan_delete`	Removes a saved plan

Resources

URI	Media type	Contents
`seedfast://runs/{runId}/summary`	`application/json`	Summary of a seeding run
`seedfast://runs/{runId}/log`	`application/x-ndjson`	Event log of a seeding run
`seedfast://runs/{runId}/pending_question`	`application/json`	The question a run is waiting on, while it is in `awaiting_input`
`seedfast://plans/{planId}`	`application/json`	Details of a saved plan

Prompts

Two prompts ship with the server: seed-production-db, which takes a scope and a description of the target database, and scope-examples, which turns a use case into example scopes.

Verify

The smoke test starts the published package over stdio, completes an MCP handshake and lists the tools. It needs no API key, since it never reaches the backend:

node scripts/smoke-test.mjs

Expected output ends with the protocol version the server negotiated and the number of tools it advertises.

Databases

Seedfast works with PostgreSQL today. Going PostgreSQL-first was deliberate, since its constraint and relationship system is the richest one out there and that is exactly where generating believable data gets hard. Support for MySQL, Oracle and SQLite is in development.

License

MIT for the contents of this repository. The Seedfast CLI is distributed under the same license; its engine runs as a hosted service.