Seedfast

Rellena una base de datos PostgreSQL con datos de prueba sintéticos generados a partir de su esquema en vivo, con cada clave foránea apuntando a una fila que existe. Planifica, ejecuta e inspecciona ejecuciones de seed desde un agente de IA.

Ver en seedfa.stPrueba este MCPPatrocinado

Documentación

Documentation

Guía de Configuración de MCP

El Protocolo de Contexto de Modelo (MCP) permite que los asistentes de IA interactúen directamente con las herramientas de desarrollo. El servidor MCP de Seedfast integra la siembra de bases de datos en ese flujo de trabajo, para que le pidas a tu asistente en lugar de cambiar a una terminal.

Esta guía te lleva paso a paso por la conexión de Seedfast MCP a Claude Desktop, Cursor IDE, VS Code o Claude Code CLI.

Comprendiendo la Arquitectura de MCP

Antes de entrar en la configuración, ayuda entender qué hace realmente MCP:

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

El servidor MCP actúa como un puente entre tu asistente de IA y el backend de Seedfast. Cuando le pides a Claude que "siembre mi base de datos con usuarios de prueba", el asistente invoca las herramientas MCP que ejecutan las operaciones de siembra reales.

Requisitos Previos

Antes de comenzar, asegúrate de tener:

Una cuenta de Seedfast (plan gratuito en seedfa.st)
Una base de datos PostgreSQL accesible desde tu máquina
Node.js 18+ instalado (para el servidor MCP basado en npx)
Uno de: Claude Desktop, Cursor IDE, VS Code con Continue.dev, o Claude Code CLI

Instalación

No se requiere instalación separada. El servidor MCP está integrado en la CLI de Seedfast y se ejecuta mediante npx directamente desde tu configuración.

Fija la versión

Cada ejemplo a continuación pide una versión exacta en lugar de seedfast@latest. Eso importa porque tu configuración de MCP es un archivo desde el que corre todo tu equipo, y @latest se vuelve a resolver en cada inicio del servidor. Publicamos con suficiente frecuencia que dos personas en la misma rama en la misma semana pueden terminar en compilaciones diferentes, lo que convierte "funciona en mi máquina" en una pregunta que nadie puede responder solo desde la configuración.

Fíjala, y actualiza la fijación cuando elijas hacerlo:

npm view seedfast version   # what's current

Para un experimento local desechable, @latest está bien. Cualquier cosa confirmada, compartida o ejecutada en CI debería nombrar una versión. Una advertencia que vale la pena conocer: la CLI se comunica con la API de Seedfast, por lo que una fijación que dejes intacta durante muchos meses puede eventualmente quedarse atrás de lo que la API espera. Trata actualizarla como mantenimiento rutinario en lugar de algo que haces solo cuando una ejecución falla.

Mantén la clave de API fuera del archivo

Cuatro de los cinco clientes aquí pueden leer la clave desde tu entorno en lugar de almacenarla en la configuración, que es lo que quieres para cualquier archivo que viva en un repositorio. Cada uno lo escribe de manera diferente, y las secciones a continuación usan la sintaxis correcta para cada uno. Claude Desktop es la excepción y necesita un valor literal, aunque su configuración reside en el directorio de soporte de aplicaciones de tu sistema operativo en lugar de tu proyecto, por lo que no es algo que puedas confirmar por accidente.

Exporta la clave una vez en tu perfil de shell:

export SEEDFAST_API_KEY="sfk_live_your_actual_key_here"

Configurar Claude Desktop

Claude Desktop es el cliente oficial de Anthropic con soporte nativo de MCP.

Localiza tu archivo de configuración:

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

Agrega el servidor Seedfast:

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

Claude Desktop no expande variables en este archivo, por lo que la clave tiene que escribirse completa. Debido a que la configuración vive en tu directorio de soporte de aplicaciones y no en un proyecto, eso es un problema más pequeño de lo que parece, pero el archivo sí contiene una credencial utilizable en texto plano y merece el mismo cuidado que cualquier otro archivo de puntos que lo haga.

Reinicia Claude Desktop para cargar la nueva configuración.

Configurar Cursor IDE

Cursor ejecuta servidores MCP en un entorno de espacio aislado. La autenticación se configura directamente en la sección env de la configuración de MCP.

Agrega a .cursor/mcp.json o configuración global:

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

Cursor interpola ${env:NAME} en command, args, env, url y headers, por lo que .cursor/mcp.json puede confirmarse tal como está y cada persona proporciona su propia clave a través del entorno.

Configurar VS Code con Continue.dev

Continue.dev proporciona soporte de MCP para usuarios de VS Code.

Agrega a .continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "seedfast@2.6.3", "mcp"],
          "env": {
            "SEEDFAST_API_KEY": "${{ secrets.SEEDFAST_API_KEY }}"
          }
        }
      }
    ]
  }
}

Continue resuelve ${{ secrets.NAME }} en args y env contra su propio almacén de secretos, por lo que la clave nunca aparece en config.json.

Configurar Claude Code CLI

Para flujos de trabajo basados en terminal con Claude Code:

Agrega a tu .mcp.json:

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

Claude Code expande ${VAR} y ${VAR:-default} en command, args, env, url y headers. Dado que .mcp.json está destinado a confirmarse para que todos en el equipo recojan los mismos servidores, hacer referencia a la variable es el punto central: el archivo describe la configuración y tu shell proporciona la credencial.

Habilidad de Claude Code

El servidor MCP le entrega a Claude las herramientas. Una habilidad le entrega el procedimiento. Sin una, un agente deduce el orden a partir de las descripciones de herramientas en cada conversación nueva, lo que suele ser suficientemente cercano y ocasionalmente no, y lo que se pierde es la lectura del esquema, o la respuesta de seedfast_run que se reporta como un trabajo terminado cuando solo reconoce que una ejecución ha comenzado.

Seedfast incluye dos de ellas. La habilidad seedfast fija la secuencia, lleva las convenciones de redacción de alcance medidas en ejemplos de alcance, apunta a los avisos que el servidor MCP publica para los casos más difíciles, y explica las reglas sobre bases de datos de producción y nombres de tablas inventados. Cuando las herramientas faltan en su lugar, o la clave es rechazada, o una cadena de conexión no se resuelve, seedfast-setup es lo que se carga, y recorre la solución sin pedirte nunca que pegues la clave en el chat. Claude Code decide cuál necesita una conversación, por lo que no hay comando que recordar y no hay costo cuando el tema nunca surge.

Instalar con el plugin

El plugin de Seedfast agrupa la configuración del servidor MCP con ambas habilidades, y Claude Code te pide tu clave de API durante la instalación, luego guarda esa clave en su propio almacenamiento en lugar de un archivo que podrías confirmar.

/plugin marketplace add seedfast-ai/claude-plugins
/plugin install seedfast@seedfast

Omite el mercado y copia las carpetas directamente si una compilación fijada de Claude Code es anterior al soporte de plugins, o si el equipo simplemente prefiere archivos que pueda revisar en un diff.

Instalar copiando las carpetas

El paquete npm lleva ambas habilidades bajo skills/. Copiarlas en un proyecto significa que todos los que clonen el repositorio las recogen:

mkdir -p .claude/skills
cp -R "$(npm root -g)/seedfast/skills/seedfast" .claude/skills/
cp -R "$(npm root -g)/seedfast/skills/seedfast-setup" .claude/skills/

Apunta los mismos dos comandos a ~/.claude/skills en su lugar y las habilidades te siguen a través de cada proyecto en la máquina. Con Seedfast instalado como dependencia del proyecto en lugar de globalmente, la ruta de origen es node_modules/seedfast/skills/..., y Windows PowerShell quiere Copy-Item -Recurse para el mismo trabajo. Reinicia Claude Code después y ejecuta /skills, que ahora debería listar seedfast y seedfast-setup.

Si la versión que fijaste es anterior a la versión que agregó estas carpetas, no se pierde nada. La habilidad de siembra se reproduce a continuación en su totalidad. Guárdala como .claude/skills/seedfast/SKILL.md, reinicia, y tienes el mismo comportamiento sin esperar una actualización.

---
name: seedfast
description: Fill a PostgreSQL database with realistic, relationally valid test data using Seedfast over MCP. Use when the user wants to seed, populate or fill a database, needs test, demo or staging data, has empty tables to work against, wants a dev database that behaves like production, or says "seed the database", "seed my database", "populate my postgres with test data", "fill the staging database", "generate test data for these tables", "my dev database is empty", "I need demo data", "fixtures", "synthetic data" or "seedfast". Covers the environment check, the connection test, reading the schema, writing the plain-language scope, previewing a plan, starting a run, polling it to completion, answering a question the run raises, and counting what landed.
---

# Seeding a database with Seedfast

Seedfast reads a live PostgreSQL schema and generates data that satisfies it: foreign keys resolve, constraints hold, and values look like the domain rather than \`test_user_1\`. The work happens on Seedfast's backend, and the MCP tools here drive it.

## The loop

\`\`\`
doctor -> connections_test -> schema_info -> plan -> [user approves] -> run -> run_status (poll) -> count
\`\`\`

Skipping straight to \`seedfast_run\` is allowed, but only when the user has clearly said "just seed it" and the target is obviously disposable.

### 1. Check the environment

Call \`seedfast_doctor\` first, once per session. It reports CLI status and version, whether the API key is configured, and the platform. If it reports a missing API key, stop and route the user to the \`seedfast-setup\` skill instead of retrying.

If the \`seedfast_*\` tools are not visible at all, the MCP server is not registered with the client. That is also \`seedfast-setup\`, and no amount of retrying makes the tools appear.

### 2. Verify the connection before anything else

\`seedfast_connections_test\` with the DSN. It opens a pool and pings with a 10-second timeout, and masks credentials in its output. This catches a wrong password or a closed firewall port in one second instead of surfacing it as a confusing planner failure a minute later.

DSN format:

\`\`\`
postgres://user:password@host:5432/dbname
postgres://user:password@host:5432/dbname?sslmode=require
\`\`\`

Never print a DSN back to the user with the password intact. When you need to refer to a database, name it (\`the staging DB\`), don't echo the string.

### 3. Read the schema before writing a scope

\`seedfast_schema_info\` returns tables, columns, primary keys, foreign keys, and approximate row counts. Use it to ground the scope in tables that actually exist.

Row counts come from \`pg_class.reltuples\`. They are approximate, can be stale between \`ANALYZE\` runs, and are \`-1\` on never-analyzed tables. Treat them as a size hint, never as a fact to report.

The \`dsn\` argument is optional here. With it omitted, the server falls back to \`SEEDFAST_DSN\` or \`DATABASE_URL\` in its own environment.

### 4. Plan, then let the user look

\`seedfast_plan\` generates a plan without writing a single row, and stores it in the session. It returns a plan ID, the scope echoed back, and the table list.

Show the user the table list and the scope before running. This is the whole point of the plan step: it is the last cheap moment to catch "that scope also touches \`billing_invoices\`".

\`seedfast_plan\` requires an API key.

### 5. Run it

\`seedfast_run\` returns immediately with a \`runId\`, and the seeding proceeds in the background.

- Pass \`planId\` to execute an approved plan. The scope is derived from the plan's tables and the \`scope\` argument is ignored.
- Without \`planId\`, \`scope\` is required.
- Always pass an \`idempotencyKey\`. A retry carrying the same key returns the existing run instead of seeding twice, which is the difference between a dropped connection costing you nothing and costing the user a doubled \`orders\` table.

### 6. Poll to completion

\`seedfast_run_status\` is safe to call repeatedly. It reports state (\`pending\`, \`running\`, \`awaiting_input\`, \`completed\`, \`failed\`, \`cancelled\`), progress as completed vs total tables, row totals, the table currently being seeded, and a summary once finished.

Poll at a human pace, a few seconds between calls rather than a tight loop. Report progress to the user as it moves rather than going silent for two minutes.

### 7. Answer questions the run raises

A run can move to \`awaiting_input\` when the backend needs a decision about scope or a replan. \`seedfast_run_status\` surfaces the \`questionId\`, and the full text is at \`seedfast://runs/{runId}/pending_question\`.

Reply with \`seedfast_run_answer\`:

- \`answer.human_answer = true\` approves the current plan or scope as-is.
- \`answer.human_answer = false\` plus \`answer.raw\` with a textual refinement (\`"seed only the org schema"\`) adjusts it.

**Bring the question to the user.** Do not auto-approve on their behalf, because the backend asks precisely when the right call is not obvious. The CLI blocks for up to 5 minutes waiting for the reply, so answer promptly once the user decides.

### 8. Count what landed

Run \`SELECT count(*)\` against the tables the scope named and put those numbers beside the ones the scope asked for. A \`completed\` status says the run finished. Only the counts say it filled the database the user had in mind.

## Writing scopes

Scopes are plain English, interpreted by the backend. Do not pre-parse them into a DSL.

\`\`\`
seed the users and posts tables with 1000 rows each
HR schema only
everything except the audit and billing tables
enough orders across 50 customers to exercise the reporting dashboard
\`\`\`

Two things make a scope good: naming real tables from \`seedfast_schema_info\`, and saying how much. "Some test data" produces a plan nobody can review.

For more patterns, request the server's \`scope-examples\` prompt (\`general\`, \`ci\`, or \`exploration\`). For a production-shaped target, request the \`seed-production-db\` prompt before starting.

Worked descriptions of four different sizes, with the row counts each one produced on the same schema, are at https://seedfa.st/docs/scope-examples. Keep the final wording in the repository next to the migrations, since the same text feeds \`seedfast seed --scope\` at a terminal and a CI step behind an API key.

## Safety

**Seedfast writes rows to a real database.** Before the first \`seedfast_run\` of a session, confirm the target is a development, staging, or test database. If the DSN host looks production-shaped (\`prod\`, \`live\`, a customer domain, an RDS writer endpoint), stop and ask outright.

**Cancellation does not roll back.** \`seedfast_run_cancel\` stops the run, but rows already inserted stay inserted. A cancelled run leaves a partially seeded database that someone has to clean up. Say so when you cancel.

**\`seedfast_plan_delete\` is irreversible** and does not touch runs started from that plan.

## Guardrails

**Never invent a table name.** Every table a scope names comes from \`seedfast_schema_info\`. A guessed name produces nothing and reports nothing about having produced nothing.

**Never read success out of the \`seedfast_run\` response.** That call returns before the first insert, carrying a run ID and \`pending\`. Only \`seedfast_run_status\` reporting \`completed\` describes a result.

**Never start a second run to fix a slow one.** Poll it, or cancel it and then start a single run with a corrected scope. Two runs against the same tables leave a mess that has to be cleaned up by hand.

**Counted rows are the only real evidence.** Status text describes what the backend thinks it did. The counts from step 8 are what you report to the user.

## Plans

Plans live in the MCP session, in memory, unless the user configured a run-history file. They do not survive an MCP server restart. Do not promise a user that a plan will be there tomorrow.

| Tool                   | Use                                                                                                                                                       |
| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| \`seedfast_plans_list\`  | Find plan IDs (accepts \`limit\`)                                                                                                                           |
| \`seedfast_plan_get\`    | Full table list and preview for one plan                                                                                                                  |
| \`seedfast_plan_create\` | Store a hand-built plan, skipping the planner round-trip. Needs \`scope\` and at least one entry in \`tables\`                                                |
| \`seedfast_plan_update\` | Change \`tables\`, \`scope\`, or \`preview\`. Only non-empty fields overwrite, omitted fields are preserved, and there is no way to clear a field back to empty |
| \`seedfast_plan_delete\` | Discard a plan. Irreversible                                                                                                                              |

\`seedfast_plan_create\` is the fast path when the tables are already known from a previous run, since it needs no API key and no backend call.

## Resources

Read these directly when the status text is not enough:

| URI                                        | Contents                                              |
| ------------------------------------------ | ----------------------------------------------------- |
| \`seedfast://runs/{runId}/summary\`          | Run summary as JSON                                   |
| \`seedfast://runs/{runId}/log\`              | Event log, NDJSON, the place to look when a run fails |
| \`seedfast://runs/{runId}/pending_question\` | The question an \`awaiting_input\` run is blocked on    |
| \`seedfast://plans/{planId}\`                | Full plan as JSON                                     |

## When a run fails

1. \`seedfast_run_status\` for the error message and the failed-tables map.
2. \`seedfast://runs/{runId}/log\` for the events leading up to it.
3. Read the failure before re-running. A constraint the generator could not satisfy will fail again identically, so the scope or the schema is what needs to change.

## Which tools need the API key

Only \`seedfast_plan\` and \`seedfast_run\` reach the Seedfast backend. Everything else works without a key: \`doctor\`, \`connections_test\`, \`schema_info\`, all plan management, run status, cancel, and answer. A missing key is not a reason to abandon schema exploration.

## Scale

PostgreSQL only today. MySQL, Oracle, and SQLite are in development. If the user points this at a MySQL database, say that plainly rather than trying the DSN.

## Reference

- [MCP setup guide](https://seedfa.st/docs/mcp-setup-guide) has the config block each client expects, the API key, and the troubleshooting cases.
- [Seeding with an AI agent](https://seedfa.st/docs/ai-agent-seeding) walks one complete session, with the calls, the description, and the SQL that counted the rows afterwards.

Luego pide lo que quieras en palabras ordinarias, nombrando la base de datos y aproximadamente cuántos datos necesitas. El agente verifica el entorno, prueba la conexión, lee el esquema, redacta la descripción, espera tu aprobación y solo entonces comienza a escribir filas. Siembra con un agente de IA muestra cómo se ve esa sesión desde la primera llamada hasta las consultas de conteo al final.

Verificar la Instalación

Después de la configuración, verifica que el servidor MCP sea accesible. En tu asistente de IA, pregunta:

Use seedfast_doctor to check the installation

Esto es lo que devuelve la verificación. La ruta es específica de la máquina en la que se ejecutó, por lo que aparece aquí como <where the binary was installed>, y la línea Platform diferirá en una máquina Mac o Linux:

CLI Status: OK
Version: seedfast 2.6.3
backend 2.0.0
Path: <where the binary was installed>
Auth: OK (SEEDFAST_API_KEY configured)
Platform: windows/amd64
Go Version: go1.25.1
MCP Server Version: 1.0.0

Configurar la Autenticación

Seedfast MCP usa autenticación basada en configuración mediante la sección env en tu configuración de MCP.

Obtén tu clave de API:

Inicia sesión en seedfa.st
Abre Configuración, luego Claves de API
Haz clic en Crear nueva clave
Copia la clave (formato: sfk_live_xxxxx...)

Apunta la configuración a la clave:

Expórtala en tu perfil de shell para que el valor viva en un solo lugar:

export SEEDFAST_API_KEY="sfk_live_your_actual_key_here"

Luego haz referencia a ella desde la sección env. Cada cliente tiene su propia sintaxis:

Cliente	Archivo de configuración	Valor a usar
Claude Code	`.mcp.json`	`${SEEDFAST_API_KEY}`
Cursor	`.cursor/mcp.json`	`${env:SEEDFAST_API_KEY}`
Continue.dev	`.continue/config.json`	`${{ secrets.SEEDFAST_API_KEY }}`
Codex CLI	`config.toml`	`env_vars = ["SEEDFAST_API_KEY"]`
Claude Desktop	`claude_desktop_config.json`	la clave literal, sin expansión

Codex es el diferente en forma más que en intención: en lugar de sustituir un valor, incluye en la lista blanca el nombre de la variable y reenvía lo que tu shell ya tenga.

En CI, establece SEEDFAST_API_KEY como un secreto de pipeline y la misma configuración confirmada sigue funcionando sin una edición local.

Tu Primera Siembra Impulsada por IA

Con todo configurado, prueba tu primera operación de siembra.

Prueba la conexión a la base de datos:

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

Ejecuta una siembra:

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

Tu asistente ejecuta la siembra en segundo plano e informa el progreso a medida que avanza. Cómo escribir la descripción, y una sesión real de principio a fin, está en siembra con un agente de IA.

Herramientas MCP Disponibles

Dos herramientas necesitan SEEDFAST_API_KEY en el entorno del servidor, seedfast_plan y seedfast_run. Las demás leen el estado de la sesión local o la base de datos y funcionan sin ello.

Verificaciones:

seedfast_doctor informa el estado y la versión de la CLI, la ruta del binario, si la clave está establecida, la plataforma, y las versiones de Go y del servidor MCP.
seedfast_connections_test abre una conexión a la base de datos en el DSN dado y devuelve éxito o fracaso, con las credenciales enmascaradas.
seedfast_schema_info lee el esquema y devuelve tablas, columnas, claves primarias, claves foráneas y recuentos aproximados de filas como JSON.

Ejecuciones:

seedfast_run inicia una ejecución de siembra en segundo plano y devuelve el ID de ejecución con su estado inicial de inmediato.
seedfast_run_status devuelve el estado y el progreso de una ejecución, y su resumen una vez que ha terminado.
seedfast_run_answer envía una respuesta a una ejecución que está esperando una pregunta y devuelve una confirmación breve.
seedfast_run_cancel solicita la cancelación de una operación pendiente o en curso. Las filas ya escritas permanecen en la base de datos.

Planes:

seedfast_plan construye un plan de siembra para un alcance sin escribir datos, lo almacena para la sesión y devuelve el ID del plan con su lista de tablas.
seedfast_plans_list lista los planes almacenados en la sesión actual.
seedfast_plan_get devuelve un plan almacenado por su ID.
seedfast_plan_create almacena un plan que proporcionas directamente, omitiendo el viaje de ida y vuelta de planificación.
seedfast_plan_update cambia las tablas o el alcance en un plan almacenado.
seedfast_plan_delete elimina un plan almacenado.

Recursos MCP: Más Allá de las Herramientas

Seedfast MCP también expone recursos, que son endpoints de datos de solo lectura que un asistente de IA puede leer para obtener contexto en lugar de llamar a una herramienta.

seedfast://plans/{planId} devuelve los detalles de un plan almacenado, como JSON.
seedfast://runs/{runId}/summary devuelve el estado y los resultados de una ejecución, como JSON.
seedfast://runs/{runId}/log transmite los eventos de una ejecución como NDJSON.
seedfast://runs/{runId}/pending_question devuelve la pregunta que una ejecución está esperando mientras su estado es awaiting_input, como JSON.

Avisos MCP

seed-production-db guía al asistente a través de verificar el entorno, probar la conexión, planificar y ejecutar una siembra en ese orden, y toma un argumento scope requerido para qué sembrar más un dsn_description opcional que nombra la base de datos objetivo.
scope-examples devuelve cadenas de alcance de ejemplo para un argumento use_case dado, uno de general, ci o exploration.

Escribiendo la descripción

El argumento scope que pasas a seedfast_plan o seedfast_run es texto plano, no un lenguaje de consulta. Dentro de un cliente MCP, tu asistente normalmente redacta ese texto por sí mismo, a partir del esquema que devuelve seedfast_schema_info y de los documentos del proyecto que tenga abiertos, y luego te muestra el texto antes de que se ejecute cualquier cosa. Sembrado con un agente de IA cubre los principios detrás de una buena descripción y recorre una ejecución completa, y ejemplos de alcance muestra cuatro descripciones de tamaño creciente ejecutadas desde la terminal.

Anti-Patrones a Evitar

No sembrar en producción sin intención explícita

Seedfast escribe filas donde apunte tu cadena de conexión, y no tiene forma de distinguir una base de datos de producción de una de desarrollo. No hay lista blanca de hosts, ni verificación de entorno, ni paso de confirmación antes de una ejecución. Cualquier protección que quieras aquí, la construyes de tu lado. Las dos que no cuestan nada son mantener la cadena de conexión de producción fuera de cualquier entorno que el agente pueda leer, y condicionar el trabajo de CI a tu propia rama o condición de entorno. Reducir los privilegios de la base de datos vale la pena probarlo antes de confiar en ello, porque un rol con permisos reducidos puede fallar las inserciones por completo en lugar de limitarlas.

Conocer el radio de impacto determina cuánta protección vale la pena construir. Una ejecución solo inserta. No elimina, trunca ni actualiza nada, así que un alcance incorrecto deja filas no deseadas en una tabla en vivo para que las limpies.

Solución de Problemas

"npx: command not found"

Node.js no está instalado o no está en tu PATH. Instala Node.js 18+ desde nodejs.org.

Error "Not authenticated" o "SEEDFAST_API_KEY not configured"

Verifica que tu clave de API esté configurada en la configuración de MCP:

Abre tu archivo de configuración de MCP (consulta las secciones de configuración anteriores para la ubicación)
Comprueba que la sección env contenga SEEDFAST_API_KEY
Verifica que la clave comience con sfk_live_
Reinicia tu asistente de IA para recargar la configuración

También puedes verificar el estado de autenticación preguntando:

Run seedfast_doctor to check the installation

La salida esperada debería mostrar: Auth: OK (SEEDFAST_API_KEY configured)

Claude Desktop no ve el servidor

Verifica la sintaxis JSON en el archivo de configuración
Asegúrate de que Claude Desktop se reinició por completo (no solo se minimizó)
Revisa la consola de Developer Tools para ver errores

Problemas con Cursor IDE

Paquete npm no encontrado

Si ves errores sobre que no se encuentra el paquete, intenta limpiar la caché de npm:

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

Usa la misma versión que fija tu configuración, para que un éxito aquí te diga algo sobre la compilación que realmente ejecutas.