Kelp
Kelp's MCP server lets an AI assistant run read-only, offline security scans and introspect Kelp's detection engine mid-conversation.
Scan a filesystem path or repo root for hardcoded secrets, Supabase edge-function JWT issues, and more.
Scan a single code snippet before showing or committing it.
List Kelp detection rules, optionally filtered by class (secret, auth, rls, edge-fn, misc).
Explain a specific finding using its rule ID, path, and preview, with reasoning and remediation.
Explain any rule by ID to understand its title, class, severity, and fix pattern.
Scans Supabase backends for security issues such as permissive RLS policies, hardcoded service_role JWTs, edge functions with verify_jwt disabled, and insecure auth/CORS configurations.
Kelp
Security scanner for vibe-coded apps. Finds the doors AI code generators leave open — hardcoded secrets, permissive RLS, unauthenticated edge functions — and gates them out of your pull requests.
Live app · Docs · CLI · MCP server · GitHub Action · Architecture
What it does
Kelp scans an app's backend surface the way an attacker would: Supabase (RLS policies, storage ACLs, edge functions) and Firebase (Firestore and Storage security rules), plus the Next.js route layer in front of them and the whole source tree. Every finding is evidence-gated: a reviewer re-runs the reproduction before it lands in your report, so what you see is what an attacker would actually get.
Four surfaces, one detection engine:
Surface | For | How you use it |
CLI | Local scans, CI shells, scripts |
|
MCP server | Claude Code, Claude Desktop, Cursor, any MCP client |
|
GitHub Action | Pull-request gating |
|
Hosted app kelp.build | Continuous scanning, dashboard, PR fixes | Connect a repo, sign in with GitHub |
Zero configuration in the common case. The Action reads the workflow's
GITHUB_TOKEN, the hosted app installs a GitHub App, the CLI walks the
filesystem, the MCP server speaks stdio JSON-RPC to the LLM client.
Related MCP server: supabase-security-mcp
Quickstart — CLI
npx @kelp-security/cli scan ./my-appkelp v0.14.0 · scanning ./my-app · 214 files walked
CRITICAL src/lib/db.ts:14 VITE_SERVICE_ROLE — Supabase service_role JWT
CRITICAL firestore.rules:9 /posts is public (allow read, write: if true)
HIGH src/api/orders.ts hardcoded Stripe secret (sk_live_…)
HIGH app/api/orders/route.ts POST handler has no auth check
MEDIUM supabase/config.toml verify_jwt=false on get-order
5 findings · 8s · report at ./kelp-report.jsonAdd --json for machine-readable output, --severity high to filter, or see
docs/CLI.md for the full reference.
Quickstart, MCP server
Kelp implements the Model Context Protocol so an LLM client (Claude Code, Claude Desktop, Cursor, or any MCP-compatible client) can call Kelp mid-conversation, while it is writing code, instead of scanning after the fact. Same static engine as the CLI, exposed as MCP tools, resources, and slash commands over stdio. Runs locally, offline. No file content ever leaves the machine.
Add to your client's MCP config (~/.claude.json, Claude Desktop config, or the
Cursor MCP settings):
{
"mcpServers": {
"kelp": {
"command": "npx",
"args": ["-y", "@kelp-security/cli", "mcp"]
}
}
}Restart the client, then ask the assistant to scan the repo, or use the
/kelp:review-repo slash command.
MCP tools: scan_path, scan_snippet, list_rules, explain_finding,
explain_rule. Resources: kelp://rules, kelp://rules/{ruleId}.
Prompts (slash commands): /kelp:review-repo, /kelp:harden-file.
Full guide, with per-client install snippets, in docs/MCP.md.
Quickstart — GitHub Action
Add .github/workflows/kelp-check.yml:
name: kelp/check
on:
pull_request:
branches: [main]
permissions:
contents: read
pull-requests: read
jobs:
check:
runs-on: ubuntu-latest
steps:
- uses: kelp-security/kelp-action@v1Kelp will run on every PR, comment the verdict on the PR, and fail the check when new critical or high findings are introduced against the base branch. See the action docs for inputs and required-status-check setup.
What Kelp checks today
Everything above the BOLA row is static, offline, and free: no API key, no live target, no setup. Run it in CI on every PR.
Class | How | Output |
Secrets in source | Provider patterns (AWS/GCP/Stripe/Supabase/GitHub/OpenAI/Anthropic/…) + entropy fallback | Masked preview + line + severity |
Client-exposed secrets | Backend keys named with a public prefix ( | Var name + line + severity |
Supabase RLS | Parses | Rule id + affected table |
Supabase Storage | Public buckets, and | Rule id + bucket or policy |
Firebase rules | Reads | Rule id + rule path + line |
Next.js routes + actions | Heuristic over | File + line + severity |
Open redirects | A redirect sink fed by a user-controlled URL ( | File + line + severity |
CORS misconfiguration | Reflected | File + line + severity |
Edge functions |
| Function name + reproduction |
CORS + auth flows | Reads config + auth callbacks for permissive defaults | Config diff |
BOLA (opt-in, hosted only) | Active test with two user-provided test accounts | Human-review only, never auto-fix |
An optional agent pass (--agent, needs ANTHROPIC_API_KEY) layers an
autonomous auditor on top of the static set. See docs/CLI.md.
New detections land in packages/core/src/scanners/.
Kelp reads two backends today, Supabase and Firebase, behind a BackendAdapter
seam. See docs/ADAPTERS.md for the adapter model and what
comes next (Convex, PocketBase, and the north-star issue).
Architecture
Monorepo (npm workspaces). Three surfaces share one engine:
apps/
├─ web/ Next.js, hosted app at kelp.build
├─ cli/ kelp binary, standalone Node CLI + MCP server
├─ worker/ scan pipeline + integrations (GitHub, Supabase, queue)
└─ test-target/ deliberately-vulnerable fixtures for verification
packages/
├─ core/ detection engine (pure, no I/O)
└─ db/ SQL migrationsThe core is intentionally I/O-free: it takes SourceFile[] and returns
Finding[]. The CLI shells file-reads to it; the worker adds the GitHub App
plumbing; the web app adds auth, storage, and the reviewer loop.
Full breakdown: docs/ARCHITECTURE.md.
Evidence-gating
Kelp's most important invariant: the model never decides a finding is real. Every agent-produced lead requires a reproduction (probe + expected observable, or a source citation). The executor re-runs it and records the finding only if the observable holds. Autonomy in reasoning, zero fabrication.
Read the full principle at docs/EVIDENCE-GATING.md.
Contributing
PRs, bug reports, and new detection classes are welcome — see CONTRIBUTING.md for the dev setup and the review checklist. Security vulnerabilities go through SECURITY.md, not the public issue tracker.
Good first contributions:
A new secret provider pattern in
packages/core/src/scanners/secrets.ts.A new edge-function heuristic in
packages/core/src/agent/edge-functions.ts.Docs improvements — the tutorials in
docs/are always in flight.
License
MIT — see LICENSE.
Acknowledgements
Kelp exists because vibe-code tools ship a lot of the same footguns, and the people using them shouldn't need a security team to catch them. Built by @Mic52M — solo, in the open.
Available Tools
5 toolsexplain_findingExplain a specific finding and how to fix itARead-only
Given a ruleId (and optionally the finding's path + preview), returns the reasoning ('why this matters') and a concrete remediation you can turn into a code change or an instruction to the user.
Inputs: ruleId (required), path, preview.
explain_ruleExplain a rule by idARead-only
Given a ruleId, returns the rule's title, class, severity, why-it-matters, and remediation pattern. Use before or after a scan to understand a rule without an active finding.
Inputs: ruleId (required).
list_rulesList Kelp detection rulesARead-only
Returns the catalog of rules Kelp can fire on. Use this to introspect coverage before scanning, or to answer 'does Kelp check X?' without running a scan.
Inputs: class.
scan_pathScan a repository or directoryARead-only
Runs Kelp's static engine over a filesystem path. Detects hardcoded secrets (Stripe, AWS, GitHub, OpenAI, Anthropic, Supabase service_role, private keys, and more), Supabase edge functions that skip JWT verification, and recons Supabase edge-fn deployables. Fast, offline, deterministic. Returns findings sorted by severity.
Inputs: path (required).
scan_snippetScan a single code snippetARead-only
Runs the static engine on one in-memory string as if it were a file. Use this after generating code, before showing it to the user or committing it. Cheaper than scan_path when only a diff is at stake.
Inputs: path (required), content (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 5 tools
Each tool has a distinct core purpose: scanning paths vs snippets, listing rules, and explaining rules vs findings. The pairings scan_path/scan_snippet and explain_rule/explain_finding have some surface similarity, but descriptions clarify their boundaries.
All tool names follow a consistent verb_noun pattern in snake_case: scan_path, scan_snippet, list_rules, explain_rule, explain_finding. The naming is predictable and makes the toolset easy to navigate.
Five tools is well-scoped for a security scanning server: two scan entry points, one rule catalog query, and two explanation helpers. Each tool serves a clear, non-redundant role in the workflow.
The toolset covers the full lifecycle expected of a static analysis scanner: discover rules, scan a path or snippet, retrieve rule details, and explain findings with remediation. There are no obvious missing operations for the stated domain.
Maintenance
Related MCP Connectors
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
Security scanner for MCP servers. Detect vulnerabilities, prompt injection, and tool poisoning.
Audit your MCP servers for poisoned tools and leaked secrets, and check AI-generated code for flaws.
Security checks for Next.js + Supabase apps: code scan, read-only live DB check, fix confirmation.
Related MCP Servers
- AlicenseBqualityBmaintenanceSecurity MCP server with 300+ rules for AI-generated code. Scans Next.js, Supabase, Clerk, Stripe, Prisma, Hono, GraphQL and 20+ modules. Zero config, runs locally.391,244 npm6Apache 2.0
- AlicenseAqualityDmaintenanceMCP server that lets AI coding agents (Claude Code, Cursor, Cline) audit Supabase projects for security misconfigurations AND apply the fixes — without leaving the agent. Tools: audit_project, list_findings, preview_fix (BEGIN/ROLLBACK safety), apply_fix (with confirmation), apply_all_fixes (transactional bulk). Closes the audit-fix loop entirely in the agent — other Supabase scanners only report.56 npm1MIT
- AlicenseNot gradedqualityFmaintenancePredeploy security scanner for AI-generated code. 80+ vulnerability patterns across secrets, auth, injection, config, Supabase, and logging. Runs locally, code never leaves your machine. Optional x402 witnessed attestation.96 npmApache 2.0
- AlicenseAqualityBmaintenanceLocal-first, zero-egress security scanner for AI-generated / "vibe-coded" JS/TS. Bundles Opengrep, Gitleaks & Trivy behind one CWE-keyed schema and adds AI-code-specific checks (client-side secret exposure, Supabase RLS, prompt-injection & LLM-output XSS sinks). No account, no telemetry.10358 npm51Apache 2.0