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 el sembrado inteligente de bases de datos en tu flujo de trabajo de IA, sin necesidad de cambiar de contexto.

Esta guía explica cómo conectar 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, es útil 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 sembrado 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 por separado. 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 solicita una versión exacta en lugar de seedfast@latest. Esto es importante porque tu configuración de MCP es un archivo desde el que todo tu equipo trabaja, y @latest se vuelve a resolver en cada inicio del servidor. Publicamos con suficiente frecuencia como para que dos personas en la misma rama en la misma semana puedan terminar con versiones diferentes, lo que convierte "funciona en mi máquina" en una pregunta que nadie puede responder solo con la configuración.

Fíjala y actualiza la fijación cuando lo decidas:

npm view seedfast version   # what's current

Para un experimento local desechable, @latest es suficiente. Cualquier cosa que se confirme, se comparta o se ejecute en CI debe 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 se encuentra 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

Añade el servidor Seedfast:

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

Claude Desktop no expande variables en este archivo, por lo que la clave debe 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 menor de lo que parece, pero el archivo 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.

Añade a .cursor/mcp.json o a la configuración global:

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@2.6.0", "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 se puede confirmar 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.

Añade a .continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "npx",
          "args": ["-y", "seedfast@2.6.0", "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:

Añade a tu .mcp.json:

{
  "mcpServers": {
    "seedfast": {
      "command": "npx",
      "args": ["-y", "seedfast@2.6.0", "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 ser confirmado para que todos en el equipo recojan los mismos servidores, hacer referencia a la variable es el punto clave: el archivo describe la configuración y tu shell proporciona la credencial.

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

Deberías ver una salida que confirme que el servidor MCP está ejecutándose y autenticado:

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

Configurar la Autenticación

Seedfast MCP utiliza autenticación basada en configuración a través de la sección env en tu configuración de MCP.

Obtén tu clave de API:

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

Apunta la configuración a la clave:

Exprésala 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 caso atípico 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 tiene.

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

Tu Primer Sembrado Impulsado por IA

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

Prueba la conexión a la base de datos:

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

Crea un plan de sembrado:

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

Esto genera un plan sin ejecutarlo, para que puedas revisar lo que se sembrará.

Ejecuta el sembrado:

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

Tu asistente ejecutará el sembrado e informará el progreso a medida que avanza.

Sesión de Ejemplo

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

AI:  Seeding started.

     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

Herramientas MCP Disponibles

Herramientas principales:

seedfast_doctor — Verifica la instalación de la CLI, el entorno y el estado de autenticación
seedfast_connections_test — Prueba la conectividad de la base de datos
seedfast_run — Ejecuta el sembrado de la base de datos
seedfast_run_status — Comprueba el progreso del sembrado
seedfast_run_cancel — Cancela la operación en ejecución

Herramientas de gestión de planes:

seedfast_plan — Crea un plan de sembrado analizando el esquema de la base de datos
seedfast_plans_list — Lista todos los planes de sembrado en la sesión actual
seedfast_plan_get — Obtiene un plan de sembrado por ID
seedfast_plan_create — Crea un plan de sembrado manualmente (sin CLI)
seedfast_plan_update — Actualiza un plan de sembrado existente
seedfast_plan_delete — Elimina un plan de sembrado

Recursos MCP: Más Allá de las Herramientas

Seedfast MCP expone no solo herramientas sino también recursos — endpoints de datos de solo lectura que los asistentes de IA pueden acceder para obtener contexto.

Recursos disponibles:

seedfast://plans/{planId} — Obtiene detalles específicos del plan
seedfast://runs/{runId}/summary — Obtiene el estado y los resultados de la ejecución
seedfast://runs/{runId}/log — Transmite eventos de ejecución como NDJSON

Escritura de Alcance: Patrones de Prompt MCP

El parámetro --scope es cómo comunicas la intención al motor de IA de Seedfast. Estos patrones de prompt MCP producen mejores resultados, más rápido.

Sé específico, no genérico

# Too broad - seeds entire database, slow
"Seed all tables"

# Better - targets relevant subsystem
"Seed user authentication tables: users, sessions, password_resets"

Sé explícito sobre los esquemas

"Sembrar todas las tablas" puede sembrar solo un esquema según el contexto. Usa "sembrar todas las tablas en todos los esquemas" cuando realmente quieras un sembrado completo de la base de datos.

Especifica las relaciones explícitamente

Cuando los datos relacionales importan para tus pruebas, indica las relaciones explícitamente:

# Implicit relationships - AI may or may not connect them
"Seed users and orders"

# Explicit relationships - guarantees connected data
"Seed users with related orders and line items"

Usa alcance negativo para exclusiones

# Exclude sensitive or irrelevant tables
"Seed all tables in public schema except audit_logs and system_configs"

Patrón de Planificar-Luego-Ejecutar

Para entornos similares a producción o conjuntos de datos grandes, siempre revisa antes de sembrar. Pide a tu asistente que planifique primero, observa lo que propone y luego aprueba.

Paso 1: Solicita un plan

"Crea un plan de sembrado para las tablas de productos, almacenes y stock_levels"

Tu asistente devuelve una vista previa de lo que se sembraría — qué tablas, recuentos estimados de filas, cómo se relacionan — sin escribir nada en la base de datos todavía:

Tables (3):
  - products
  - warehouses
  - stock_levels

Preview: Will seed 3 tables...

Paso 2: Revisa

Comprueba que el plan incluya las tablas que quieres y excluya cualquier cosa sensible — registros de auditoría, datos archivados, cualquier cosa que no quieras tocar.

Paso 3: Aprueba

"Se ve bien, ejecuta ese plan"

Tu asistente ejecuta exactamente el plan que acabas de revisar.

Expectativas de Rendimiento

Alcance estrecho = sembrado más rápido

Menos tablas significa una finalización más rápida. Tiempos de ejecución aproximados con el recuento de filas predeterminado (~5 filas por tabla), con números reales que dependen del recuento de filas y la complejidad del esquema:

Tabla única: 5-15 segundos
5-10 tablas relacionadas: 30-60 segundos
Esquema completo (50+ tablas): 2-5 minutos

Para la iteración de desarrollo, siembra solo lo que tu característica actual necesita.

Lectura de Resultados de Ejecución

Cuando el sembrado se completa, obtienes un resumen por tabla. Si algunas tablas fallan, la ejecución continúa con el resto, y el resumen te dice exactamente cuáles se completaron y cuáles no:

Summary:
  Success: false
  Total Tables: 10
  Succeeded: 8
  Failed: 2 (orders, payments)

Investiga las tablas fallidas individualmente y ajusta el alcance o corrige el problema subyacente del esquema antes de volver a ejecutar.

Antipatrones a Evitar

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

Seedfast escribe filas dondequiera que 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 en las inserciones por completo en lugar de limitarlas.

Vale la pena conocer el radio de explosión, ya que determina cuánta protección vale la pena. Una ejecución solo inserta. No elimina, trunca ni actualiza, por lo que el modo de fallo son filas no deseadas en una tabla en vivo en lugar de datos perdidos.

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 haya reiniciado por completo (no solo minimizado)
Revisa la consola de Herramientas de Desarrollo para ver errores

Problemas con Cursor IDE

Paquete npm no encontrado

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

npm cache clean --force
npx -y seedfast@2.6.0 --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.