# Seedfast (npm · seedfast)

Generates relationally valid test data in a PostgreSQL database from its live schema.

- Trust score: 64/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-07

## Components

- npm · `seedfast`: 64/100 (this document), [markdown](https://verifymcp.io/servers/st-seedfa-seedfast/seedfast.md), [page](https://verifymcp.io/servers/st-seedfa-seedfast/seedfast)

## Channel facts

- Registry: `npm`
- Package: `seedfast`
- Version: `2.5.1`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-07.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 0 of 5 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 19/100
  - Repository check failed: no source repository is declared.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 2 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 77/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2534 tokens (~194/item across 13 items; 13 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### Claude

```bash
claude mcp add st-seedfa-seedfast -- npx -y seedfast
```

### Codex

```bash
codex mcp add st-seedfa-seedfast -- npx -y seedfast
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "st-seedfa-seedfast": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "seedfast"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add st-seedfa-seedfast --command npx --arg -y --arg seedfast
```

### Hermes

```yaml
mcp_servers:
  st-seedfa-seedfast:
    command: "npx"
    args: ["-y", "seedfast"]
```

### Other

```json
{
  "mcpServers": {
    "st-seedfa-seedfast": {
      "command": "npx",
      "args": [
        "-y",
        "seedfast"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-05 (score 64, +30)

- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Schema quality: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Schema quality: excellent
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 100

### 2026-08-04 (score 34)

First indexed and scored.

## MCP tools (13)

### `seedfast_connections_test` (~158 tokens)

Probes a PostgreSQL database for reachability by opening a connection pool and issuing a ping with a 10-second timeout. Returns a short text line stating success or failure for the supplied DSN (credentials are masked in the output). Use this before seedfast_plan or seedfast_run to catch bad DSNs, firewall issues, or wrong credentials without incurring a planning or seeding round-trip. Does not require SEEDFAST_API_KEY. Next: on success, call seedfast_plan to preview a seeding plan or seedfast_run to execute one.

Input parameters:

- `dsn` (string, required): PostgreSQL connection string (e.g., postgres://user:pass@host:5432/db). Credentials are masked in log/response output.

### `seedfast_doctor` (~124 tokens)

Diagnoses whether the Seedfast CLI environment is healthy and ready to run seedings. Returns a multi-line text summary: CLI status and version, binary path, whether SEEDFAST_API_KEY is configured, platform (GOOS/GOARCH), Go runtime version, and MCP server version. Call this FIRST before any other seedfast_* tool — it surfaces misconfigurations (missing CLI, missing API key) early and in plain language. Next: if status is OK, call seedfast_connections_test to verify database reachability before seedfast_plan or seedfast_run.

### `seedfast_plan` (~218 tokens)

Generates a seeding plan for the given database and scope WITHOUT writing any data, then stores the plan in the current MCP session for later reuse. Returns a text block containing the generated plan ID, the scope echoed back, a table list with count, and an optional human-readable preview. Use this when the user wants to review what would be seeded before committing — e.g., to inspect which tables the scope covers. Requires SEEDFAST_API_KEY configured in MCP env. For scope-writing guidance, request the `scope-examples` prompt. Next: call seedfast_plan_get or read the seedfast://plans/{planId} resource to inspect the plan, then seedfast_run with planId to execute it.

Input parameters:

- `dsn` (string, required): PostgreSQL connection string for the target database.
- `scope` (string, required): Plain-text description of what to seed (e.g., 'seed only the sales schema', 'populate users and orders'). Interpreted server-side by the backend LLM — do not pre-parse or validate it.

### `seedfast_plan_create` (~211 tokens)

Stores a manually-crafted seeding plan in the current MCP session without calling the backend planner. Returns a text block with the new plan ID, scope, and table list. Use this when the caller already knows exactly which tables to seed (e.g., derived from a user prompt or a previous run) and wants to skip the planner round-trip, or to construct a plan for seedfast_run with planId. At least one entry in `tables` is required. Does not require SEEDFAST_API_KEY. Next: call seedfast_run with planId to execute, or seedfast_plan_update to refine the plan.

Input parameters:

- `preview` (string): Optional human-readable summary shown by seedfast_plan_get and seedfast_plans_list.
- `scope` (string, required): Plain-text scope description (e.g., 'seed only sales schema'). Stored verbatim alongside the plan.
- `tables` (null|array, required): Non-empty list of table names to seed (e.g., ['users', 'orders']).

### `seedfast_plan_delete` (~124 tokens)

Permanently removes a stored plan from the current MCP session. Returns a short text line confirming deletion; returns an error when the ID is unknown or the delete fails. This is a destructive action — the plan cannot be recovered through this tool. It does NOT cancel or affect any seeding run that was previously started from the plan. Use only when the user explicitly wants to discard a plan. Does not require SEEDFAST_API_KEY. Next: call seedfast_plans_list to confirm the plan is gone.

Input parameters:

- `planId` (string, required): Plan ID to delete.

### `seedfast_plan_get` (~150 tokens)

Retrieves a single stored seeding plan by ID. Returns a text block with the plan ID, scope, full table list, optional human-readable preview, and created/updated timestamps; returns an error when the ID is unknown. Use this to inspect a plan's table set before executing it, or to show the user what a plan contains. Does not require SEEDFAST_API_KEY (reads local session state). Next: call seedfast_run with planId to execute, seedfast_plan_update to modify, or seedfast_plan_delete to remove it.

Input parameters:

- `planId` (string, required): Plan ID (as shown by seedfast_plans_list or returned by seedfast_plan / seedfast_plan_create).

### `seedfast_plan_update` (~234 tokens)

Modifies an existing stored plan in place. Returns a text block confirming the update with the plan ID, scope, table list, and new updated-at timestamp; returns an error when the ID is unknown. Only non-empty/non-zero fields in the request overwrite the stored plan — omitted fields are preserved (there is no way to clear preview or scope to empty via this tool). Use this to adjust a plan's tables or scope before executing with seedfast_run. Does not require SEEDFAST_API_KEY. Next: call seedfast_plan_get to verify, or seedfast_run with planId to execute.

Input parameters:

- `planId` (string, required): Plan ID to update.
- `preview` (string): Replacement preview text. When non-empty, overwrites the stored preview; empty string is treated as 'leave unchanged'.
- `scope` (string): Replacement scope description. When non-empty, overwrites the stored scope; empty string is treated as 'leave unchanged'.
- `tables` (null|array): Replacement list of tables. When provided and non-empty, overwrites the stored tables; when omitted, existing tables are preserved.

### `seedfast_plans_list` (~161 tokens)

Lists seeding plans stored in the current MCP session (in-memory; plans do not persist across MCP server restarts). Returns a text block with up to `limit` plans, each showing ID, scope, table count with names, and created/updated timestamps; returns 'No plans found' when the session has none. Use this to discover plan IDs before calling seedfast_plan_get, seedfast_plan_update, seedfast_plan_delete, or seedfast_run with planId. Does not require SEEDFAST_API_KEY. Next: pick an ID and call seedfast_plan_get for full details, or seedfast_run to execute.

Input parameters:

- `limit` (integer): Maximum number of plans to return. Defaults to 50 when omitted or non-positive.

### `seedfast_run` (~327 tokens)

Kicks off an asynchronous seeding run against the target database. Returns immediately with a text block containing the new runId, initial status (pending), the plan ID if supplied, and the effective scope; the seeding itself runs in the background — poll seedfast_run_status or subscribe to the seedfast://runs/{runId}/summary and seedfast://runs/{runId}/log resources for progress. If planId is provided, the scope is auto-generated from that plan's tables and the scope argument is ignored; otherwise scope is required. If idempotencyKey matches a prior run, that existing run is returned instead of starting a new one. Use this once the user has approved a plan (or wants direct execution). Requires SEEDFAST_API_KEY configured in MCP env. For production-safe workflows, request the `seed-production-db` prompt first. Next: seedfast_run_status to poll, or seedfast_run_cancel to abort.

Input parameters:

- `dsn` (string, required): PostgreSQL connection string for the target database.
- `idempotencyKey` (string): Caller-chosen key for safe retries. If a prior run was started with the same key, that run is returned and no new run is created.
- `planId` (string): ID of a plan previously produced by seedfast_plan or seedfast_plan_create. When set, the run seeds exactly those tables and the scope argument is overridden.
- `scope` (string): Plain-text scope description. Required unless planId is provided; ignored when planId is set (scope is derived from the plan's tables).

### `seedfast_run_answer` (~246 tokens)

Answers a pending question for a run that is in state 'awaiting_input'. The CLI forwards backend questions (scope validation issues, replans) to this MCP server via subprocess stdio and blocks for up to 5 minutes on a reply. Call this tool with the runId, the questionId from seedfast_run_status (or the seedfast://runs/{runId}/pending_question resource), and an answer object. Set answer.human_answer=true to approve the current plan/scope as-is; set human_answer=false and supply answer.raw with a textual refinement (e.g., 'seed only the org schema') when the plan should be adjusted. Returns a short text confirmation. On success the run transitions back to 'running'; poll seedfast_run_status to observe progress. Does not require SEEDFAST_API_KEY.

Input parameters:

- `answer` (object, required): Answer payload: set human_answer=true to approve, otherwise provide refined scope in raw.
- `questionId` (string, required): Question ID from the pending_question resource or from seedfast_run_status output.
- `runId` (string, required): Run ID returned by seedfast_run (the run must be in state 'awaiting_input').

### `seedfast_run_cancel` (~132 tokens)

Requests cancellation of a pending or running seeding operation. Returns a text line confirming cancellation, or — if the run is already completed/failed/cancelled — a message that it is not cancellable (no error). This is a destructive action against the run: partial inserts already written to the database are NOT rolled back. Use only when the user explicitly asks to stop a run or when a runaway operation must be aborted. Does not require SEEDFAST_API_KEY. Next: call seedfast_run_status to confirm the final state.

Input parameters:

- `runId` (string, required): Run ID returned by seedfast_run.

### `seedfast_run_status` (~173 tokens)

Reports the current state and progress of a seeding run by ID. Returns a text block containing: run ID, state (pending/running/completed/failed/cancelled), scope, started/completed timestamps, progress (completed vs total tables with percent, total rows, failed count, currently-seeding table), any error message, and — once finished — a summary block with success flag, totals, and elapsed milliseconds. Use this to poll an async seedfast_run; it is safe to call repeatedly. Does not require SEEDFAST_API_KEY (reads local in-memory state). Next: if state is still running, poll again; if failed, inspect the error and failed-tables map; if completed, the run is done.

Input parameters:

- `runId` (string, required): Run ID returned by seedfast_run.

### `seedfast_schema_info` (~276 tokens)

Introspects a PostgreSQL database schema — lists tables, columns, primary keys, foreign keys, and approximate row counts. Returns a JSON object with a tables array; each entry has name (schema-qualified), columns (name, data_type, nullable, default), primary_key, foreign_keys (columns, references_table, references_columns), and approximate_row_count. Row counts come from pg_class.reltuples and are APPROXIMATE — they may be stale between ANALYZEs and may be -1 on never-analyzed tables. Implementation invokes `seedfast schema --json` as a subprocess with a 30s timeout. Call this before writing a scope description — it helps you understand table relationships and size so you can craft a precise scope; especially useful for large databases where you want to target specific tables. Does not require SEEDFAST_API_KEY. The `dsn` argument is optional — when omitted, the server falls back to SEEDFAST_DSN or DATABASE_URL from its environment. Next: use the schema info to write a scope string, then call seedfast_plan with that scope. For scope-writing guidance, also request the `scope-examples` prompt.

Input parameters:

- `dsn` (string): PostgreSQL connection string. When omitted, the MCP server falls back to SEEDFAST_DSN, then DATABASE_URL.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/st-seedfa-seedfast/seedfast#diagnostics

## Score history

- 2026-08-07: 64
- 2026-08-06: 64
- 2026-08-05: 64
- 2026-08-04: 34

## Links

- npm package: https://www.npmjs.com/package/seedfast
- Socket report: https://socket.dev/npm/package/seedfast
- Website: https://seedfa.st/
- Changelog RSS feed: https://verifymcp.io/servers/st-seedfa-seedfast/seedfast.xml
- Changelog JSON feed: https://verifymcp.io/servers/st-seedfa-seedfast/seedfast.json
- HTML version of this page: https://verifymcp.io/servers/st-seedfa-seedfast/seedfast