Seedfast

Preenche um banco de dados PostgreSQL com dados de teste sintéticos gerados a partir do seu schema ativo, com cada chave estrangeira apontando para uma linha existente. Planeje, execute e inspecione execuções de seed a partir de um agente de IA.

Ver em seedfa.stExperimente este MCPPatrocinado

Documentação

Documentation

Guia de Configuração do MCP

O Model Context Protocol (MCP) permite que assistentes de IA interajam diretamente com ferramentas de desenvolvimento. O servidor MCP do Seedfast traz o seeding de banco de dados para esse fluxo de trabalho, para que você peça ao seu assistente em vez de alternar para um terminal.

Este guia mostra como conectar o Seedfast MCP ao Claude Desktop, Cursor IDE, VS Code ou Claude Code CLI.

Entendendo a Arquitetura do MCP

Antes de mergulhar na configuração, ajuda entender o que o MCP realmente faz:

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

O servidor MCP atua como uma ponte entre seu assistente de IA e o backend do Seedfast. Quando você pede ao Claude para "popular meu banco de dados com usuários de teste", o assistente invoca ferramentas MCP que executam as operações reais de seeding.

Pré-requisitos

Antes de começar, certifique-se de ter:

Uma conta Seedfast (plano gratuito em seedfa.st)
Banco de dados PostgreSQL acessível a partir da sua máquina
Node.js 18+ instalado (para o servidor MCP baseado em npx)
Um dos seguintes: Claude Desktop, Cursor IDE, VS Code com Continue.dev ou Claude Code CLI

Instalação

Nenhuma instalação separada é necessária. O servidor MCP está integrado ao CLI do Seedfast e roda via npx diretamente da sua configuração.

Fixe a versão

Cada exemplo abaixo pede uma versão exata em vez de seedfast@latest. Isso importa porque sua configuração MCP é um arquivo que todo o time executa, e @latest é re-resolvido a cada inicialização do servidor. Lançamos com frequência suficiente para que duas pessoas no mesmo branch na mesma semana possam acabar em builds diferentes, o que transforma "funciona na minha máquina" em uma pergunta que ninguém consegue responder apenas pela configuração.

Fixe a versão e atualize a fixação quando você escolher:

npm view seedfast version   # what's current

Para um experimento local descartável, @latest é suficiente. Qualquer coisa commitada, compartilhada ou executada em CI deve nomear uma versão. Uma ressalva que vale saber: o CLI fala com a API do Seedfast, então uma versão fixada que você não toca por muitos meses pode eventualmente ficar defasada em relação ao que a API espera. Trate a atualização como manutenção de rotina, e não como algo que você faz apenas quando uma execução quebra.

Mantenha a chave da API fora do arquivo

Quatro dos cinco clientes aqui podem ler a chave do seu ambiente em vez de armazená-la na configuração, que é o que você quer para qualquer arquivo que viva em um repositório. Cada um escreve isso de forma diferente, e as seções abaixo usam a sintaxe correta para cada um. O Claude Desktop é a exceção e precisa de um valor literal, embora sua configuração fique no diretório de suporte a aplicativos do seu sistema operacional, e não no seu projeto, então não é algo que você commitaria por acidente.

Exporte a chave uma vez no seu perfil de shell:

export SEEDFAST_API_KEY="sfk_live_your_actual_key_here"

Configurar o Claude Desktop

O Claude Desktop é o cliente oficial da Anthropic com suporte nativo a MCP.

Localize seu arquivo de configuração:

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

Adicione o servidor Seedfast:

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

O Claude Desktop não expande variáveis neste arquivo, então a chave precisa ser escrita por extenso. Como a configuração fica no diretório de suporte a aplicativos e não em um projeto, isso é um problema menor do que parece, mas o arquivo contém uma credencial utilizável em texto puro e merece o mesmo cuidado que qualquer outro dotfile que faça isso.

Reinicie o Claude Desktop para carregar a nova configuração.

Configurar o Cursor IDE

O Cursor executa servidores MCP em um ambiente isolado. A autenticação é configurada diretamente na seção env da configuração MCP.

Adicione em .cursor/mcp.json ou nas configurações globais:

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

O Cursor interpola ${env:NAME} em command, args, env, url e headers, então .cursor/mcp.json pode ser commitado como está e cada pessoa fornece sua própria chave por meio do ambiente.

Configurar o VS Code com Continue.dev

O Continue.dev fornece suporte a MCP para usuários do VS Code.

Adicione em .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 }}"
          }
        }
      }
    ]
  }
}

O Continue resolve ${{ secrets.NAME }} em args e env contra seu próprio armazenamento de segredos, então a chave nunca aparece em config.json.

Configurar o Claude Code CLI

Para fluxos de trabalho baseados em terminal com o Claude Code:

Adicione ao seu .mcp.json:

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

O Claude Code expande ${VAR} e ${VAR:-default} em command, args, env, url e headers. Como .mcp.json deve ser commitado para que todos no time usem os mesmos servidores, referenciar a variável é exatamente o objetivo: o arquivo descreve a configuração e seu shell fornece a credencial.

Habilidade do Claude Code

O servidor MCP entrega as ferramentas ao Claude. Uma habilidade entrega o procedimento. Sem uma, um agente descobre a ordem a partir das descrições das ferramentas em cada conversa nova, o que geralmente é próximo o suficiente e ocasionalmente não é, e o que escapa é a leitura do schema, ou a resposta de seedfast_run sendo relatada como um trabalho concluído quando ela apenas confirma que uma execução começou.

O Seedfast envia duas delas. A habilidade seedfast fixa a sequência, carrega as convenções de escrita de escopo medidas em exemplos de escopo, aponta para os prompts que o servidor MCP publica para os casos mais difíceis e detalha as regras sobre bancos de dados de produção e nomes de tabelas inventados. Quando as ferramentas estão ausentes, ou a chave é rejeitada, ou uma string de conexão não resolve, seedfast-setup é o que carrega, e ela percorre a correção sem nunca pedir que você cole a chave no chat. O Claude Code decide qual delas uma conversa precisa, então não há comando para lembrar e nenhum custo quando o assunto nunca surge.

Instalar com o plugin

O plugin do Seedfast agrupa a configuração do servidor MCP com ambas as habilidades, e o Claude Code pede sua chave de API durante a instalação, mantendo essa chave em seu próprio armazenamento em vez de um arquivo que você possa commitar.

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

Pule o marketplace e copie as pastas diretamente se uma versão fixada do Claude Code for anterior ao suporte a plugins, ou se o time apenas preferir arquivos que possa revisar em um diff.

Instalar copiando as pastas

O pacote npm carrega ambas as habilidades em skills/. Copiá-las para um projeto significa que todos que clonarem o repositório as receberão:

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/

Aponte os mesmos dois comandos para ~/.claude/skills e as habilidades seguirão você em todos os projetos da máquina. Com o Seedfast instalado como dependência do projeto em vez de globalmente, o caminho de origem é node_modules/seedfast/skills/..., e o Windows PowerShell quer Copy-Item -Recurse para o mesmo trabalho. Reinicie o Claude Code depois e execute /skills, que agora deve listar seedfast e seedfast-setup.

Se a versão que você fixou for anterior ao lançamento que adicionou essas pastas, nada está perdido. A habilidade de seeding é reproduzida abaixo na íntegra. Salve-a como .claude/skills/seedfast/SKILL.md, reinicie, e você terá o mesmo comportamento sem esperar por uma atualização.

---
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.

Então peça o que você quer em palavras comuns, nomeando o banco de dados e aproximadamente quantos dados você precisa. O agente verifica o ambiente, testa a conexão, lê o schema, redige a descrição, aguarda sua aprovação e só então começa a escrever linhas. Seeding com um agente de IA mostra como essa sessão se parece, da primeira chamada às consultas de contagem no final.

Verificar a Instalação

Após a configuração, verifique se o servidor MCP está acessível. No seu assistente de IA, pergunte:

Use seedfast_doctor to check the installation

Aqui está o que a verificação retorna. O caminho é específico da máquina em que foi executado, então aparece aqui como <where the binary was installed>, e a linha Platform será diferente em uma máquina Mac ou 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 Autenticação

O Seedfast MCP usa autenticação baseada em configuração por meio da seção env na sua configuração MCP.

Obtenha sua chave de API:

Faça login em seedfa.st
Abra Configurações e depois Chaves de API
Clique em Criar nova chave
Copie a chave (formato: sfk_live_xxxxx...)

Aponte a configuração para a chave:

Exporte-a no seu perfil de shell para que o valor viva em um único lugar:

export SEEDFAST_API_KEY="sfk_live_your_actual_key_here"

Depois referencie-a na seção env. Cada cliente tem sua própria sintaxe:

Cliente	Arquivo de configuração	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`	a chave literal, sem expansão

O Codex é o diferente na forma, não na intenção: em vez de substituir um valor, ele coloca o nome da variável na lista de permissões e encaminha o que seu shell já tem.

Em CI, defina SEEDFAST_API_KEY como um segredo de pipeline e a mesma configuração commitada continua funcionando sem edição local.

Seu Primeiro Seed com IA

Com tudo configurado, tente sua primeira operação de seeding.

Teste a conexão com o banco de dados:

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

Execute um seed:

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

Seu assistente executa o seed em segundo plano e relata o progresso conforme avança. Como escrever a descrição, e uma sessão real de ponta a ponta, está em seeding com um agente de IA.

Ferramentas MCP Disponíveis

Duas ferramentas precisam de SEEDFAST_API_KEY no ambiente do servidor, seedfast_plan e seedfast_run. As outras leem o estado da sessão local ou o banco de dados e funcionam sem isso.

Verificações:

seedfast_doctor relata o status e a versão do CLI, o caminho do binário, se a chave está definida, a plataforma e as versões do Go e do servidor MCP.
seedfast_connections_test abre uma conexão com o banco de dados no DSN fornecido e retorna sucesso ou falha, com as credenciais mascaradas.
seedfast_schema_info lê o schema e retorna tabelas, colunas, chaves primárias, chaves estrangeiras e contagens aproximadas de linhas como JSON.

Execuções:

seedfast_run inicia uma execução de seeding em segundo plano e retorna o ID da execução com seu status inicial imediatamente.
seedfast_run_status retorna o estado e o progresso de uma execução, e seu resumo quando ela termina.
seedfast_run_answer envia uma resposta a uma execução que está aguardando uma pergunta e retorna uma confirmação curta.
seedfast_run_cancel solicita o cancelamento de uma operação pendente ou em andamento. Linhas já escritas permanecem no banco de dados.

Planos:

seedfast_plan constrói um plano de seeding para um escopo sem escrever dados, armazena-o para a sessão e retorna o ID do plano com sua lista de tabelas.
seedfast_plans_list lista os planos armazenados na sessão atual.
seedfast_plan_get retorna um plano armazenado pelo seu ID.
seedfast_plan_create armazena um plano que você fornece diretamente, pulando a ida e volta do planejamento.
seedfast_plan_update altera as tabelas ou o escopo de um plano armazenado.
seedfast_plan_delete remove um plano armazenado.

Recursos MCP: Além das Ferramentas

O Seedfast MCP também expõe recursos, que são endpoints de dados somente leitura que um assistente de IA pode ler para contexto em vez de chamar uma ferramenta.

seedfast://plans/{planId} retorna os detalhes de um plano armazenado, como JSON.
seedfast://runs/{runId}/summary retorna o status e os resultados de uma execução, como JSON.
seedfast://runs/{runId}/log transmite os eventos de uma execução como NDJSON.
seedfast://runs/{runId}/pending_question retorna a pergunta que uma execução está aguardando enquanto seu estado é awaiting_input, como JSON.

Prompts MCP

seed-production-db orienta o assistente a verificar o ambiente, testar a conexão, planejar e executar um seed nessa ordem, e recebe um argumento obrigatório scope para o que semear, além de um dsn_description opcional nomeando o banco de dados de destino.
scope-examples retorna exemplos de strings de escopo para um argumento use_case fornecido, um de general, ci ou exploration.

Escrevendo a descrição

O argumento scope que você passa para seedfast_plan ou seedfast_run é texto simples, não uma linguagem de consulta. Dentro de um cliente MCP, seu assistente normalmente redige esse texto por conta própria, a partir do esquema que seedfast_schema_info retorna e de quaisquer documentos do projeto que estejam abertos, e então mostra a redação antes de qualquer execução. Semeadura com um agente de IA aborda os princípios por trás de uma boa descrição e percorre uma execução completa, e exemplos de escopo mostra quatro descrições de tamanhos crescentes executadas a partir do terminal.

Anti-Padrões a Evitar

Não Semeie em Produção Sem Intenção Explícita

O Seedfast grava linhas onde quer que sua string de conexão aponte, e não tem como distinguir um banco de produção de um de desenvolvimento. Não há lista de permissões de host, verificação de ambiente ou etapa de confirmação antes de uma execução. Qualquer proteção que você queira aqui, você constrói do seu lado. As duas que não custam nada são manter a string de conexão de produção fora de qualquer ambiente que o agente possa ler e condicionar o job de CI à sua própria branch ou condição de ambiente. Restringir privilégios de banco de dados vale a pena testar antes de confiar nisso, porque um papel com permissões reduzidas pode falhar nas inserções por completo, em vez de apenas limitá-las.

Conhecer o raio de impacto molda o quanto de proteção vale a pena construir. Uma execução apenas insere. Ela não remove, trunca ou atualiza nada, então um escopo ruim deixa linhas indesejadas em uma tabela ativa para você limpar.

Solução de Problemas

"npx: comando não encontrado"

O Node.js não está instalado ou não está no seu PATH. Instale o Node.js 18+ em nodejs.org.

Erro "Não autenticado" ou "SEEDFAST_API_KEY não configurada"

Verifique se sua chave de API está configurada no MCP:

Abra seu arquivo de configuração do MCP (veja as seções de configuração acima para a localização)
Verifique se a seção env contém SEEDFAST_API_KEY
Confirme se a chave começa com sfk_live_
Reinicie seu assistente de IA para recarregar a configuração

Você também pode verificar o status de autenticação perguntando:

Run seedfast_doctor to check the installation

A saída esperada deve mostrar: Auth: OK (SEEDFAST_API_KEY configured)

O Claude Desktop não vê o servidor

Verifique a sintaxe JSON no arquivo de configuração
Garanta que o Claude Desktop foi totalmente reiniciado (não apenas minimizado)
Verifique o console das Ferramentas de Desenvolvedor para erros

Problemas com o Cursor IDE

Pacote npm não encontrado

Se você vir erros sobre o pacote não encontrado, tente limpar o cache do npm:

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

Use a mesma versão que sua configuração fixa, para que um sucesso aqui diga algo sobre a compilação que você realmente executa.