zephex
CLIGet StartedPricingMCP ToolsCommunityGuidesDocs
←BackSign in
CLIGet StartedPricingMCP ToolsCommunityGuidesDocs
Get started freeSign in
DocsAPIToolsEditorsChangelogHelp

GET STARTED

WelcomeQuickstartSetup videoMCP Q&A (learn)BlogWhat is MCP?Who is Zephex for?Plans & PricingZ-GASAB benchmarkBenchmark chart (live)Changelog

INSTALLATION

Web Terminal tools (plain English)Terminal tools (complete)Connect MCPVS Code Marketplace extensionCLI (no AI agent)CLI init (first run)CLI account & logoutNPX (Recommended)Test Pulse (check test)Test Pulse commandsProject MemorySupply Pulse (supply)Supply Pulse commandsTerminal CLI referenceSlash commands (37 palette)Web Terminal (dashboard)Command CompassCLI commandsCLI in DockerCLI: All editors (one command)CLI: Crush, Hermes, ChatGPT, KiloOAuth & HTTP setupInstall overviewHTTP APISetup WalkthroughHTTP vs stdio

API & KEYS

API Key ManagementKey Naming & FormatAuthenticationKey Dashboard

CONFIGURATION

Universal RequirementsSupported EditorsHow It WorksArchitectureCLAUDE.md TemplateAGENTS.md Template

EDITORS28 guides

Supported EditorsVS CodeVS Code extension (Marketplace)Claude CodeCursorWindsurfJetBrains

PLATFORM

macOSWindowsLinux

TOOLS10 tools

Capabilities OverviewTools OverviewTool FilteringTool Workflowsget_project_contextread_codefind_codecheck_packageexplain_architectureZephex_dev_infocheck_testaudit_headerskeep_thinkingproject_memory

GUIDES

Best PracticesToken EfficiencyUse CasesZephex vs Local MCPZephex vs Context7Zephex vs GitHub MCPZephex vs SmitheryMCP EcosystemMarkdown Access

SUPPORT

Help CenterMCP troubleshootingTeam rolloutFAQConnection IssuesRate LimitsDowntime & ErrorsBillingTier GuidePro & Max guideUsage LimitsUsage Analytics

LEGAL

System StatusTerms (summary)Privacy (summary)Data UseSecurityAuthenticationSecurityData HandlingPrivacy PolicyTerms of Service

Quick Links

API Reference

Complete API documentation

Troubleshooting

Common issues and solutions

Community

Join our Discord community

Plugins

Editor and CLI integrations

Pricing

Free, Pro, and Max plans

Enter
Zephex_devzephex-devzephexzephexhello@zephex.dev
© 2026 Zephex. All systems operational.

Tools

Tool Workflows

Individual tools are useful. Sequences are how pros work. Each recipe below has agent tool names and mcpcli copy-paste — Mode 1 and Mode 2 share the same hosted tools.

Zephex tool pipeline intent to hosted tools to answer card or JSON

Chain tools: orient → search → read → verify. Terminal prints answer cards; agents get JSON.

START-HERE COMMANDS (TERMINAL)
CommandPurpose
overviewProduct story + stack bars
get-contextStructured project brief
find-codeSearch symbols / strings
summarizePlain-English file read
check-testRun tests + failures
safePackage safety before install
architectureHow modules wire
check urlLive URL security audit
rememberSave a project fact
connectWire an editor MCP
DEEP RECIPES — AGENT + MCPCLI

Every recipe lists the MCP tool, what to ask an agent, the terminal command, and what you should see.

~4–6 successful tool calls

Onboard a new clone in 10 minutes

Scenario: You just cloned a repo and need the product story, stack, and where auth lives.

#ToolAgentTerminalYou get
1overview / get_project_contextget_project_context (topic identity then run)mcpcli overviewAnswer card: what it is, stack tags, how to run
2get_project_contextget_project_context topic=authmcpcli get-context --topic authAuth provider + env names (no secret values)
3explain_architectureexplain_architecture focus=authmcpcli architecture --focus authWiring map: entry → middleware → session
4find_codefind_code intent=symbol query="auth"mcpcli find-code "auth"Ranked paths to open next

Why this order: Overview orients; topic zooms; architecture shows flow; find lands on symbols.

shell
cd my-appmcpcli overviewmcpcli get-context --topic authmcpcli architecture --focus authmcpcli find-code "auth"

1–3 package calls (no project required)

Before you npm install anything

Scenario: A tutorial or AI suggested a package you have never used.

#ToolAgentTerminalYou get
1check_packagecheck_package task=checkmcpcli safe expressExists? CVEs? postinstall risk? typosquat?
2check_packagecheck_package task=security version=…mcpcli check-package axios --task securityAdvisories for a specific version
3check_packagecheck_package task=upgrade from_version=…mcpcli check-package next --task upgrade --from-version 14.2.0Breaking changes + migration hints

Why this order: Registry intel does not need your source tree. Catch hallucinations before they hit package.json.

shell
mcpcli safe lodashmcpcli check-package next --task upgrade --from-version 14.2.0mcpcli deps   # when already in a project

~5–7 calls

Debug 401 on protected routes

Scenario: Signed-in users still get 401 after a middleware change.

#ToolAgentTerminalYou get
1get_project_contexttopic=authmcpcli get-context --topic authAuth stack snapshot
2explain_architecturefocus=authmcpcli architecture --focus authRequest path diagram
3find_codesymbol validateSession / auth middlewaremcpcli find-code "validateSession"Definitions + usages
4read_codemode=symbol target=validateSessionmcpcli symbol validateSessionAST body of the suspect function
5keep_thinkingmulti-turn session with lastActionsmcpcli think "middleware order vs cookie refresh"One-shot checkpoint (full sessions = editor)

Why this order: Orient → map → locate → read → reason. Prevents random file thrashing.

shell
mcpcli get-context --topic authmcpcli architecture --focus authmcpcli find-code "validateSession"mcpcli symbol validateSessionmcpcli think "is middleware running before cookie refresh?"

suite run + 1–2 URL scans

Before you ship / after deploy

Scenario: Staging is up — confirm tests and live security surface.

#ToolAgentTerminalYou get
1check_testcheck_test task=run then failuresmcpcli check-testPass/fail clusters, fix_first
2audit_headersaudit_headers url=…mcpcli check url https://staging.example.comGrade A–F, headers, TLS, secrets surface
3supply (Pulse)— (terminal product)mcpcli supply https://staging.example.comSecrets / CVEs / live bundle intel

Why this order: Tests catch logic; live URL tools catch config that never shows in source alone.

shell
mcpcli check-testmcpcli check url https://staging.example.commcpcli supply https://staging.example.com

1 remember + later free-ish recalls

Capture tribal knowledge across sessions

Scenario: You learned something scanning cannot: webhook idempotency lives in Redis, not the DB.

#ToolAgentTerminalYou get
1project_memoryaction=remembermcpcli remember "webhooks dedupe by event.id in Redis 24h"Stored fact with id
2project_memoryaction=recall query=webhookmcpcli recall webhookPast decisions when you need them

Why this order: Memory is explicit tribal knowledge. get_project_context is the repo scanner — different job.

shell
mcpcli remember "Stripe webhooks dedupe event.id in Redis 24h TTL"mcpcli recall stripe webhookmcpcli memory list

1–2 finds + reads

Safe rename across the repo

Scenario: Rename OldService → NewService without missing a call site.

#ToolAgentTerminalYou get
1find_codeintent=everywhere whole_wordmcpcli rename "OldService"Every file:line before you edit
2read_codebatch files from hitsmcpcli summarize src/services/old.tsConfirm you have the right symbol

Why this order: everywhere/rename is rename-safe. Don't half-grep.

shell
mcpcli rename "OldService"mcpcli find-code "OldService" --exhaustive
WORKFLOW PATTERNS
PatternTool sequenceWhen to use
Overview → Arch → Findoverview / get_project_context → explain_architecture → find_codeNew repo onboarding
Test → Fix → Retestcheck_test → read_code → check_testBug fixes, small features
Context → Architecture → Testget_project_context → explain_architecture → check_testLarge features
Find → Read → Thinkfind_code → read_code → keep_thinkingDebugging, root cause analysis
Audit URL → Supply → Fixaudit_headers (check url) → supply → find_codePost-deploy security
Safe → Upgrade → Depscheck_package → task upgrade → depsDependency work
Remember → later Recallproject_memory remember → recallTribal knowledge across sessions
REAL WORKFLOW EXAMPLES

Debug auth — 401 on protected routes

Goal: Trace why signed-in users get 401 on API routes after a middleware change.
Cost: ~6 requests

  1. 1
    get_project_context

    topic auth — summarize auth method, session storage, and middleware entry points

    → Auth stack snapshot: Next.js middleware, JWT in cookie, Supabase client

  2. 2
    explain_architecture

    focus auth — trace request from middleware to session validation

    → Sequence diagram: middleware → validateSession → API handler

  3. 3
    find_code

    intent symbol, query "validateSession"

    → Definition in src/lib/auth.ts:42 plus 8 usages

  4. 4
    read_code

    mode symbol, target "validateSession"

    → Full function body — missing null check on expired token

  5. 5
    keep_thinking

    Hypothesis: middleware runs before cookie refresh. Rule out CORS, then check refresh timing.

    → Structured reasoning — next file: src/middleware.ts

  6. 6
    read_code

    mode outline, files ["src/middleware.ts"]

    → TOC shows refreshToken call missing before validateSession

Why this order: Context orients the stack, architecture shows the flow, find_code locates the symbol, read_code confirms the bug, keep_thinking prevents circular guesses.

Check package — before adding a dependency

Goal: Decide whether to install a new npm package and what version to pin.
Cost: ~4 requests

  1. 1
    check_package

    package "zod", task check

    → Registry status, maintainer count, postinstall risk — clean

  2. 2
    check_package

    package "zod", task security

    → No active CVEs affecting latest stable

  3. 3
    find_code

    query "zod" OR "z.object" — intent concept

    → Existing zod usage in 3 files — partial adoption already

  4. 4
    Zephex_dev_info

    search "Zod schema validation API routes" then get by slug

    → Checklist: validate at boundary, infer types, avoid duplicate parsers

Why this order: check_package covers supply-chain and CVE signals before you write import statements. find_code surfaces existing patterns so you extend instead of duplicate.

Scope refactor — rename a shared utility

Goal: Rename handleReadCode across the codebase with minimal blast radius.
Cost: ~5 requests

  1. 1
    find_code

    intent everywhere, query "handleReadCode", whole_word true

    → 14 file:line hits with files_summary — every occurrence before rename

  2. 2
    explain_architecture

    concern "read-code" or seed_files from find_code hits — map callers and tests

    → concern_cluster: definition, 3 callers, 2 test files — medium blast radius

  3. 3
    read_code

    mode symbol, target "handleReadCode"

    → Definition + signature to confirm rename scope

  4. 4
    read_code

    mode file, files ["src/__tests__/read-code.test.ts"]

    → Test expectations that must update with the rename

  5. 5
    project_memory

    action remember, title "Rename convention", content "Always update tests when renaming exported handlers"

    → Saved to local SQLite — recall before the next refactor in this repo

  6. 6
    check_test

    task run after rename — verify tests still pass

    → Structured pass/fail with fix_first if anything broke

Why this order: find_code everywhere maps every occurrence. explain_architecture shows blast radius. read_code confirms edits. check_test verifies after the rename — not before scoping.

Bug investigation — 500 on API endpoint

Goal: Find and fix a bug you can describe but have not located yet.
Cost: ~5 requests

  1. 1
    find_code

    intent concept, query "users" also_try ["getUserHandler","/api/users"]

    → Route handler and middleware hits ranked by relevance

  2. 2
    read_code

    mode symbol, target "getUserHandler"

    → Full function body with the bug

  3. 3
    find_code

    query "getUserHandler", intent everywhere

    → All call sites that might be affected

  4. 4
    keep_thinking

    Handler does not check for null user — list fix options and test impact

    → Structured reasoning, hypothesis tracking

  5. 5
    read_code

    mode file, files ["src/tests/users.test.ts"]

    → Existing tests to understand expected behavior

Why this order: find_code locates the handler and call sites. read_code extracts the exact function. keep_thinking structures the fix before you patch.

Security audit — deployed URL + source

Goal: Audit a deployed URL and its source code for security issues.
Cost: ~5 requests

  1. 1
    audit_headers

    url "https://your-app.com"

    → Header grades, missing CSP, HSTS status

  2. 2
    find_code

    query "cors" OR "Access-Control", intent concept

    → Where CORS is configured in source

  3. 3
    read_code

    mode symbol, target "corsMiddleware"

    → Full CORS config to review

  4. 4
    check_package

    package "helmet", task security

    → Version status, CVEs, supply-chain signals

  5. 5
    Zephex_dev_info

    search "CSP best practices Next.js production" then get by slug

    → key_principles, code_snippets, checklist

Why this order: audit_headers checks what the server actually returns. find_code and read_code connect live headers to source config. Zephex_dev_info provides fix guidance.

Codebase onboarding — first contribution

Goal: Understand a new codebase well enough to make your first change.
Cost: ~5 requests

  1. 1
    get_project_context

    full project brief — stack, scripts, entry points, dependencies

    → Framework, package manager, env vars, monorepo layout

  2. 2
    explain_architecture

    focus full, mode overview

    → Service diagram, data flow, external dependencies

  3. 3
    explain_architecture

    focus auth, mode deep

    → Auth flow sequence, session handling, middleware chain

  4. 4
    read_code

    mode outline, files ["src/app/layout.tsx"]

    → Structural TOC of the main layout

  5. 5
    check_test

    add a new API endpoint for /api/teams

    → Files to create/modify, existing patterns to follow

Why this order: get_project_context gives the 30-second overview. explain_architecture produces visual maps. check_test tells you exactly where to start editing.

REQUEST BUDGET PER WORKFLOW
WorkflowTypical requestsSessions/mo (Free)Sessions/mo (Pro)
Debug auth5-742-60500-700
Check package3-560-100700-1,166
Scope refactor4-650-75583-875
Bug fix (simple)3-560-100700-1,166
Security audit5-837-60437-700
Codebase onboarding5-742-60500-700
WHICH TOOL FOR WHICH QUESTION
Your questionBest toolWhy
What is this project?get_project_contextReturns stack, commands, deps in one call
How does X work?explain_architectureProduces diagrams and traces data flow
Where is X defined?find_codeBM25-ranked search across all files
Show me the code for Xread_codeAST-based extraction of specific symbols
What files do I need to change?check_testReturns minimal file set with roles
Is this package safe?check_packageRegistry lookup, CVE check, supply-chain signals
How do I upgrade X?check_package (task=upgrade)Breaking changes, migration steps, CVE details
Did the agent remember last session's decisions?project_memoryRemember and recall project decisions, gotchas, and conventions across sessions via local SQLite
Is this URL secure?audit_headers → mcpcli check urlLive header audit — terminal and editor
What did we decide last time?project_memory → remember/recallNot package upgrade (loop-guard is check-package)
How should I approach this?keep_thinking → think (one-shot CLI)Multi-turn sessions are editor-only
Best practice for X?Zephex_dev_info → docs / askExpert knowledge base with code examples
Live secrets on my site?supplySupply Pulse terminal product
NEXT STEPS
Go deeper

Tool Reference · Use Cases · Terminal Mode 2 · How it works · Usage Limits