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.

Editor setup

Kilo Code MCP Server

Fastest: npx -y zephex setup --kilo (browser sign-in, writes kilo.jsonc with local npx zephex). Legacy VS Code extension users may still get .kilocode/mcp.json. Manual HTTP streamable-http is optional below.

Official Kilo Code MCP documentation: Kilo Code MCP docs

MCP endpointhttps://zephex.dev/mcp
AuthenticationAuthorization: Bearer mcp_sk_...
Config file.kilocode/mcp.json (project) or VS Code: Kilo → MCP settings → Edit Global MCP (path varies by version)

Why Zephex

Without MCP, your agent guesses project layout and misses supply-chain risk. Zephex connects one hosted endpoint so every session gets the same ten tools — no per-machine npm installs, no version drift across the team.

Before you start

  • Kilo Code extension installed in VS Code (or compatible editor).
  • A Zephex API key from Dashboard → API Keys.
  • Network access to https://zephex.dev/mcp.
  • Workspace folder opened at your repo root — Kilo can use “this project” for tools when the folder is correct.

Get and paste your API key

HTTP and stdio setups both need a key from your Zephex dashboard. OAuth-only flows (ChatGPT, Claude.ai web) sign you in in the browser instead — skip this section for those.

  1. Sign in at zephex.dev → Dashboard → API Keys (or /dashboard/api-keys).
  2. Click Create API key, give it a name you will recognize (e.g. "Kilo — work laptop"), then create.
  3. Copy the key as soon as it appears — Zephex only shows the full secret once. It starts with mcp_sk_ or a newer mcp_prod_… format.
  4. Paste into your config: either only the key in an env field (ZEPHEX_API_KEY), or the full HTTP header value Authorization: Bearer YOUR_KEY — match what your editor’s form asks for.
  5. Do not wrap the key in extra quotes inside JSON unless the file already quotes other string values.
  6. Never commit API keys to git. Revoke and create a new key in the dashboard if one leaks.

Setup policy for Kilo Code

Matches the published CLI (mcp-proxy/src/commands/setup.ts). One command signs you in, writes the correct transport, and verifies 10 tools.

Recommended commandnpx -y zephex setup --kilo
Project-scopednpx -y zephex setup --kilo --project
Transportstdio (npx -y zephex + ZEPHEX_API_KEY)
Config parent keymcp

Global vs project config

  • Global setup is the default — run setup without --project so Zephex works in every folder you open.
  • Global setup also removes stale project-level Zephex entries that shadow your user config.
  • Add --project only when you intentionally want workspace-scoped config (e.g. .cursor/mcp.json in one repo).

After setup

  • setup --kilo writes kilo.jsonc stdio (type local + npx zephex) — recommended over manual HTTP.
  • Do not enable both streamable-http and stdio zephex entries.

Account teardown: logout vs disconnect · Connect MCP walkthrough

Find where setup wrote your config

Search docs for “where is my MCP file” — the answer is always: run list first, then open the path it prints.

  1. Primary (CLI): ~/.config/kilo/kilo.jsonc or ./kilo.jsonc — parent key mcp, type local.
  2. Legacy VS Code extension: .kilocode/mcp.json or globalStorage mcp_settings.json.
  3. npx -y zephex@latest list prints every path Zephex touched.

Documented paths: ~/.config/kilo/kilo.jsonc or project kilo.jsonc / .kilo/kilo.jsonc; legacy: .kilocode/mcp.json

One command

Kilo CLI kilo.jsonc uses type local + npx zephex + ZEPHEX_API_KEY (normal MCP file). Legacy VS Code extension uses mcpServers stdio.

Guided install (matches published CLI)

Runs the same code as mcp-proxy/src/commands/setup.ts — OAuth in browser, creates a CLI key, writes your editor config, verifies tools.

shell
npx -y zephex setup --kilo

Already have a key?

Skip browser OAuth — paste a key from zephex.dev/dashboard/keys. Must start with mcp_prod_, mcp_dev_, or mcp_sk_.

shell
npx -y zephex setup --kilo --api-key mcp_prod_your-key-here

Guided install (matches published CLI)

Runs the same code as mcp-proxy/src/commands/setup.ts — OAuth in browser, creates a CLI key, writes your editor config, verifies tools.

shell
npx -y zephex setup --kilo --project

What setup writes (Kilo CLI — kilo.jsonc)

type local + command array + ZEPHEX_API_KEY: Transport: stdio (see ~/.config/kilo/kilo.jsonc or project kilo.jsonc / .kilo/kilo.jsonc; legacy: .kilocode/mcp.json).

json
{  "mcp": {    "zephex": {      "type": "local",      "command": ["npx", "-y", "zephex"],      "environment": {        "ZEPHEX_API_KEY": "mcp_sk_your_key_here"      },      "enabled": true,      "timeout": 10000    }  }}

Legacy VS Code extension only

If globalStorage already exists, setup keeps mcpServers stdio: Transport: stdio (see ~/.config/kilo/kilo.jsonc or project kilo.jsonc / .kilo/kilo.jsonc; legacy: .kilocode/mcp.json).

json
{  "mcpServers": {    "zephex": {      "command": "npx",      "args": ["-y", "zephex"],      "env": {        "ZEPHEX_API_KEY": "mcp_sk_your_key_here"      }    }  }}

After CLI install, fully restart the app if tools do not appear. Manual JSON/TOML blocks below are equivalent — use them when CLI commands are unavailable.

Hosted HTTP vs npx stdio

  • Recommended: npx -y zephex setup --kilo — Kilo CLI kilo.jsonc uses type local + npx zephex + ZEPHEX_API_KEY (normal MCP file). Legacy VS Code extension uses mcpServers stdio.
  • Config path: ~/.config/kilo/kilo.jsonc or project kilo.jsonc / .kilo/kilo.jsonc; legacy: .kilocode/mcp.json
  • Manual stdio shape: command "npx", args ["-y","zephex"], env ZEPHEX_API_KEY (parent key: mcp).
  • Optional hosted HTTP (https://zephex.dev/mcp + Bearer) only if you do not need automatic workspace file access — pass github: URLs in prompts.
  • Never keep two zephex entries (stdio + HTTP) in the same config — pick one transport.
  • Cloud-only tools (check_package, project_memory, audit_headers, keep_thinking, Zephex_dev_info) work on both transports.
  • Repo tools (get_project_context, read_code, find_code, explain_architecture, check_test) need either stdio/npx setup or an explicit github:owner/repo or absolute path on HTTP.

Full comparison: HTTP vs stdio · npx zephex reference

How to connect Zephex

Recommended: npx -y zephex setup --kilo writes kilo.jsonc (type local + npx zephex). Manual HTTP in Kilo UI is optional — do not enable both.

  1. Recommended: npx -y zephex@latest setup --kilo (browser OAuth, writes kilo.jsonc with stdio).
  2. Run npx -y zephex@latest list — shows ~/.config/kilo/kilo.jsonc and any project kilo.jsonc paths.
  3. Legacy VS Code extension: may use .kilocode/mcp.json — setup can write stdio there if detected.
  4. Optional UI path: Kilo → MCP Servers → Streamable HTTP only if you skip CLI setup.
  5. VS Code Command Palette → Developer: Reload Window after file edits.
  6. Open Kilo agent mode. Confirm zephex enabled in MCP server list.
  7. Test: check_package, then get_project_context on this workspace.

Configuration

Replace mcp_sk_your_key_here with your key from Dashboard → API Keys. Copy the full key once at creation — paste into Authorization: Bearer … for HTTP configs, or into ZEPHEX_API_KEY for stdio/npx configs.

Kilo CLI — kilo.jsonc (what npx zephex setup --kilo writes)

Official Kilo CLI shape: mcp + type local + command array + environment.ZEPHEX_API_KEY.

json
{  "mcp": {    "zephex": {      "type": "local",      "command": ["npx", "-y", "zephex"],      "environment": {        "ZEPHEX_API_KEY": "mcp_sk_your_key_here"      },      "enabled": true,      "timeout": 10000    }  }}

Remote server connection (manual / UI)

Hosted MCP — no local Node process. Use "type": "streamable-http" and url https://zephex.dev/mcp. Matches Kilo’s HTTP / Streamable HTTP UI.

json
{  "mcpServers": {    "zephex": {      "type": "streamable-http",      "url": "https://zephex.dev/mcp",      "headers": {        "Authorization": "Bearer mcp_sk_your_key_here"      },      "disabled": false    }  }}

Local server connection (optional)

Same shape as `npx zephex setup --kilo`. Use only if you want the editor to spawn npx -y zephex — do not enable both HTTP and stdio zephex entries.

json
{  "mcpServers": {    "zephex": {      "command": "npx",      "args": ["-y", "zephex"],      "env": {        "ZEPHEX_API_KEY": "mcp_sk_your_key_here"      }    }  }}

Tip

If both global and project MCP files exist, know which one Kilo loads for this workspace — wrong file edits are the #1 silent failure.

Verify, repair, disconnect (CLI)

Run these in a terminal when the editor UI is unclear — catches stale npm, wrong transport, and project shadows.

shell
npx -y zephex@latest listnpx -y zephex@latest doctornpx -y zephex@latest repair# Fully quit the editor (Cmd+Q / Alt+F4), reopen, start a new agent session

Repair policy

  • npx -y zephex@latest repair pins stdio to zephex@latest, fixes OpenCode command-array shape, and adds PATH hints for GUI-launched apps.
  • repair migrates legacy HTTP → stdio for filesystem editors — not for Cursor, Claude Code global HTTP, or Crush.

Disconnect & skills

  • disconnect --<editor> removes Zephex from config files the CLI knows about and revokes the API key found in those files.
  • There is no disconnect --project flag — disconnect checks both global and project paths (project paths use your current terminal cwd).
  • Terminal-only sign-out: mcpcli logout (editors unchanged). Full teardown: mcpcli logout --all.
  • This editor: mcpcli disconnect --kilo
  • Fresh OAuth: mcpcli reconnect --kilo
  • Add agent guidance: mcpcli setup --kilo --with-skill or mcpcli skills --<editor>.
  • Remove skills from one editor: mcpcli reset --kilo (disconnect + skill files).
  • Remove all skill copies: mcpcli skills --remove.

Check that it works

After saving your config, confirm Zephex is connected before you rely on it in real work.

  1. Kilo MCP settings show zephex connected with tools listed.
  2. Agent mode: “Use check_package on express.”
  3. “Use get_project_context on this project” with the repo root open in VS Code.
  4. If empty, retry with github:owner/repo or absolute Mac/Windows path.

Common searches

Questions people ask when Kilo Code does not show Zephex tools — indexed for docs search.

Kilo Code MCP jsonc format

Parent key is mcp (not mcpServers). Setup writes type local with command array and environment.ZEPHEX_API_KEY.

Example ways to use the tools

You do not call tools yourself — ask your agent in plain language. Try these once Zephex is connected:

“Kilo agent mode: check_test for adding Stripe billing portal to our Next.js app.”

Scoped plan inside VS Code before Kilo edits routes and API handlers.

“get_project_context on this workspace — Kilo sees the VS Code root folder.”

Usually works when .kilocode/mcp.json sits at the repo root.

“read_code the middleware.ts edge handler only.”

Precise read for Vercel-style middleware files.

“check_package on @tanstack/react-query v5 migration target.”

Pre-install check before Kilo updates package.json.

“find_code all usages of useServerAction in app/.”

App router search without manual ripgrep in Kilo chat.

“audit_headers on our preview deployment URL from the last PR.”

Preview env security check from the IDE.

Which tools need your project path?

You do not pick tools from a menu — ask your agent in normal sentences. Half of the tools only need a package name or URL; the other half need to know which codebase you mean (your Mac/Windows project folder or a GitHub repo).

Need a repo or folder path

  • get_project_context — full stack snapshot for one repo
  • read_code — read functions/classes by symbol name
  • find_code — search definitions and usages
  • explain_architecture — Mermaid diagrams for the repo
  • check_test — minimal file list for a task you describe

Work without a local project

  • check_package — npm/PyPI/Cargo/Go registry safety (no repo path)
  • project_memory — Cross-session project memory: remember decisions, gotchas, goals, conventions across sessions via local SQLite (stdio only).
  • audit_headers — security grade for any HTTPS URL you own or may test
  • keep_thinking — structured debugging notes across steps
  • Zephex_dev_info — vetted patterns (auth, DB, deploy, etc.)

How to tell the agent where the code lives

  • GitHub (no clone required): say github:owner/repo — example: github:vercel/next.js
  • Local folder: give the absolute path to the project root (the folder that contains package.json, pyproject.toml, or go.mod).
  • If your editor already has the repo open, try “use get_project_context on this workspace” first; if the tool returns empty, repeat with the full path or github: URL in the same chat.
  • For read_code / find_code, name the symbol or search term in the same message as the path (e.g. “find_code AuthService in github:myorg/api”).

macOS and Windows paths

  • macOS example path: /Users/yourname/Developer/my-app
  • Windows example path: C:\Users\yourname\projects\my-app
  • Replace yourname with your Mac or Windows login — the agent cannot guess your home directory.
  • Cloud-only tools (check_package, audit_headers) never need your username or project folder.

When Zephex will not connect

These situations usually mean the setup cannot work until you fix the underlying issue:

  • No internet or a firewall blocks outbound HTTPS to zephex.dev (port 443).
  • API key never created, revoked, or pasted incorrectly (missing Bearer , extra quotes, or truncated copy).
  • Wrong MCP URL — must be exactly https://zephex.dev/mcp (not /docs, not /api, no wrong host).
  • Mixed stdio + HTTP — two zephex entries (npx and url) confuse many clients; keep one transport.
  • Corporate proxy strips Authorization headers or chunked transfer encoding.
  • Monthly request limit reached on the Free plan (555 requests/month) — tools stop until next cycle, share for bonus requests, or upgrade.
  • Editing the wrong config file — global vs project-level paths differ by editor and OS.
  • App not fully quit after save — MCP often loads only on a cold start (especially IDEs).
  • Tools connect but return “no project” — not a connection failure; add github:owner/repo or an absolute path (see tool usage section).
  • Node.js or npx not on PATH when the desktop app launches (common on macOS Dock launches).
  • Invalid JSON in the config file (comments, trailing commas, or wrong wrapper key).
  • ZEPHEX_API_KEY missing, still set to the placeholder, or pasted in the wrong field (stdio uses env, not Bearer headers).
  • You edited Claude Code’s config but opened Claude Desktop (different files).
  • App was not fully quit after saving the config — MCP only reloads on a cold start.
  • npx works in Terminal but not inside the app — use absolute paths to node/npx in the command block if needed.
  • First npx -y zephex run can take 30–60s — increase startup_timeout_sec where the editor supports it.
  • Still have an HTTP url block while testing stdio — remove the duplicate zephex server.
  • Both kilo.jsonc stdio and streamable-http UI server enabled — keep one zephex entry.
  • disabled: true or server toggled off in Kilo MCP panel.
  • Editing global kilo.jsonc while workspace uses ./kilo.jsonc (or the reverse).
  • Only using Chat mode when your Kilo build requires Agent mode for MCP tools.

If something goes wrong

Wrong transport / shape

CLI setup uses kilo.jsonc parent key mcp + type local. Run repair if doctor flags wrong shape.

401 Unauthorized

Header Authorization: Bearer mcp_sk_... in JSON or UI — no extra quotes around the key in the UI field.

Config saved but server missing

Reload VS Code window. Confirm file path is workspace/.kilocode/mcp.json.

Tools work for packages but not code

Open the correct workspace folder at repo root, or pass github: or absolute path in the prompt.

0 tools listed

Set disabled: false, enable server in Kilo MCP UI, start new agent session after reload.

Still stuck? Quickstart · MCP troubleshooting

Tools included with Zephex

Kilo streamable-http server exposes ten tools in agent mode inside VS Code:

  • get_project_context

    Reads your project structure, dependencies, scripts, env vars, and framework markers in one call. Replaces manually opening package.json, tsconfig, and multiple config files at the start of every session.

  • read_code

    AST-based code extraction: pass a symbol name and get the implementation without reading entire files. Supports symbol lookup, batched file reads, and structural outlines for large files.

  • find_code

    Ranked search across the repo for definitions, usages, and patterns. Faster than blind grep when the agent does not know where a symbol lives.

  • check_package

    Live registry lookup for npm, PyPI, Cargo, and Go modules. Surfaces typosquat risk, maintainer changes, and suspicious version jumps before you run install.

  • explain_architecture

    Generates Mermaid diagrams for auth flows, service boundaries, and module dependencies so the agent reasons about structure instead of guessing.

  • check_test

    Turns a task description into the smallest file set to read or edit, with risk ratings and caller impact notes.

  • audit_headers

    Grades a deployed URL for CSP, HSTS, TLS, cookies, and redirects. Returns fix snippets for common hosts (Vercel, Cloudflare, Nginx).

  • keep_thinking

    Structured multi-step debugging: tracks hypotheses and conclusions so long investigations do not loop.

  • Zephex_dev_info

    Expert patterns for authentication, databases, frontend frameworks, deployment, and mobile stacks when the agent needs vetted guidance.

  • project_memory

    Persists decisions, gotchas, and conventions per project in ~/.zephex/memory (SQLite FTS5). recall before unfamiliar areas; remember after discoveries. Local stdio only on npx zephex.

Related

  • CLI setup (--kilo) — paths by OS
  • VS Code MCP setup
  • Roo Code MCP setup
  • read_code reference
  • check_package reference
  • Quickstart — create your first API key
  • HTTP vs stdio — which to use
  • npx zephex setup commands
  • MCP troubleshooting
  • All supported editors
  • All 10 MCP tools
  • Install wizard
  • Pricing and limits