Skip to main content
Glama
seedfast-ai

Seedfast MCP Server

Official

seedfast_plan

Generate a seeding plan for a database and scope without writing data, storing it for later execution. Use it to preview which tables a seeding operation would affect before committing.

Instructions

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 Schema

TableJSON Schema
NameRequiredDescriptionDefault
dsnYesPostgreSQL connection string for the target database.
scopeYesPlain-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.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv2.6.4

TDQS

A4.4/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It discloses the critical non-destructive behavior ('WITHOUT writing any data'), the requirement of SEEDFAST_API_KEY, and the side effect of storing the plan in the MCP session. It also describes the return format (text block with plan ID, scope, table list, preview). The only minor gap is not detailing what happens to a previously stored plan with the same ID, but the disclosure is strong overall.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single dense paragraph that front-loads the core purpose and non-destructive behavior, then covers return format, use case, prerequisites, and next steps. It's efficient and every sentence earns its place. It could be slightly more structured (e.g., separate sentences for workflow), but it's not bloated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with 2 required params, no output schema, and no annotations, the description is remarkably complete. It covers what the tool does, what it returns, when to use it, prerequisites (API key), and the follow-up workflow. An agent has everything needed to select and invoke this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds a useful note about the scope parameter being 'interpreted server-side by the backend LLM — do not pre-parse or validate it,' which is valuable behavioral guidance beyond the schema. However, it doesn't add much about dsn beyond what the schema says. Baseline 3 is appropriate since the schema does the heavy lifting and the description adds a small but meaningful extra.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Generates a seeding plan'), the resource ('for the given database and scope'), and a key behavioral distinction: it does NOT write data. It also names the sibling tool it is not (seedfast_run) and explains the plan is stored for later reuse. This clearly differentiates it from siblings like seedfast_plan_create and seedfast_run.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use this tool: 'when the user wants to review what would be seeded before committing — e.g., to inspect which tables the scope covers.' It also provides a clear next-step workflow: call seedfast_plan_get or read the seedfast://plans/{planId} resource, then seedfast_run with planId. It even mentions requesting the `scope-examples` prompt for scope-writing guidance. This is exemplary usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.