Skip to content
Back to search

cortex_suite

Local MCP servers that give coding agents a reliable project memory. quartz-ctx serves live code structure in 10 languages, cross-language calls included; cortex keeps learned patterns and traps, pushes them into the agent's context at edits and failing builds, and measures outcomes and token cost from real sessions. No network, no API keys.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/artistsyn--cortex-suite/badge.svg)](/listings/artistsyn--cortex-suite)

HTML

<a href="/listings/artistsyn--cortex-suite"><img src="/api/listings/artistsyn--cortex-suite/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

.\scripts\setup.ps1 -Workspace C:\code\my-project      # Windows
./scripts/setup.sh ~/code/my-project                    # macOS / Linux

Needs [Rust](https://rustup.rs) and a C toolchain (for the tree-sitter grammars — MSVC Build Tools on Windows, Xcode CLI tools on macOS, `build-essential` on Linux). Then edit `.cortex/index-sources.json`, run one `index` command, restart your editor.

Setup installs a launcher into `.cortex/` for both platforms — `cortex.sh` and `cortex.ps1`, same commands on each:

./.cortex/cortex.sh reindex      # full rebuild of every configured source (first run)
./.cortex/cortex.sh refresh      # re-index only what changed (the servers do this themselves)
./.cortex/cortex.sh check-mcp    # confirm both MCP configs agree and use relative paths
./.cortex/cortex.sh deploy       # rebuild without stopping the running server

Don't want to list crates by hand? `quartz-ctx serve --discover .` finds every crate under a directory — workspace members and standalone crates alike.

**→ Read [SETUP_HANDOFF.md](SETUP_HANDOFF.md) before you start.** It documents the pitfalls that cost us real debugging time — stale binaries, cache replay, config drift between editors, and the PowerShell 5.1 traps.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 155 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Cortex Suite
  2. Gives your AI coding assistant a memory and a map of your code.
  3. - **Remembers** what worked and what broke, so mistakes aren't repeated.
  4. - **Looks up your real code** instead of guessing names and types.
  5. - **Stays current**: change a file and it already knows.
  6. Works with Claude Code, VS Code Copilot and Codex, in 10 languages. Everything
  7. stays on your computer.
  8. ## Install
  9. ### Easiest: let your AI install it
  10. Don't have an AI coding assistant yet?
  11. [Install Claude Code](https://docs.claude.com/en/docs/claude-code/setup).
  12. Then copy the prompt for your assistant and paste it in. It installs Cortex
  13. Suite for **all** your projects.
  14. <details>
  15. <summary><b>Claude Code</b></summary>
  16. ```text
  17. Install Cortex Suite for all of my projects.
  18. 1. If `cargo` isn't installed, install Rust from https://rustup.rs first.
  19. 2. Clone https://github.com/Artistsyn/cortex_suite into ~/cortex_suite
  20. (if it's already there, run `git pull` in it instead).
  21. 3. From inside ~/cortex_suite, run ./scripts/install-global.sh
  22. If I have more than one Claude Code account (look in my shell profile for
  23. aliases that set CLAUDE_CONFIG_DIR), add `--claude-config <folder>` for each
  24. folder that isn't already a ~/.claude-* folder.
  25. 4. Show me the cortex and quartz-ctx lines from `claude mcp list`, then tell me
  26. to restart Claude Code.
  27. ```
  28. </details>
  29. <details>
  30. <summary><b>GitHub Copilot (VS Code, agent mode)</b></summary>
  31. ```text
  32. Install Cortex Suite so you can use it in all of my projects. Run each step in
  33. the terminal and check it worked before moving on.
  34. 1. Check the tools it needs: `git --version`, `cargo --version`, and a C
  35. compiler (on a Mac: `xcode-select -p`; on Linux: `cc --version`).
  36. - If cargo is missing, install Rust from https://rustup.rs, then open a new
  37. terminal so cargo is on the PATH.
  38. - If the C compiler is missing: on a Mac run `xcode-select --install`; on
  39. Linux install build-essential.
  40. 2. Clone https://github.com/Artistsyn/cortex_suite into ~/cortex_suite
  41. (if it's already there, run `git pull` in it instead).
  42. 3. From inside ~/cortex_suite, run ./scripts/install-global.sh
  43. It builds two MCP servers (cortex and quartz-ctx) and adds them to my VS Code
  44. user MCP config (mcp.json in VS Code's User folder), so they work in every
  45. workspace. The build takes a few minutes.
  46. 4. Open that user mcp.json (Command Palette: "MCP: Open User Configuration")
  47. and confirm it has "cortex" and "quartz-ctx" entries.
  48. 5. Tell me to reload the window, then run "MCP: List Servers" and start both,
  49. and to turn their tools on in the agent's tool picker.
  50. 6. If this workspace is a git repo, also run
  51. ~/cortex_suite/cortex/target/debug/cortex hooks-init --vscode
  52. so cortex can warn you about known mistakes as you work.
  53. I'm on Windows? The install script needs macOS or Linux. Instead, run
  54. .\scripts\setup.ps1 -Workspace <project folder> from ~/cortex_suite for each
  55. project.
  56. ```
  57. </details>
  58. <details>
  59. <summary><b>ChatGPT</b></summary>
  60. ```text
  61. I want to install Cortex Suite (https://github.com/Artistsyn/cortex_suite).
  62. It's a pair of local MCP servers, "cortex" (memory) and "quartz-ctx" (code
  63. map), that give AI coding assistants like Claude Code, VS Code Copilot and the
  64. Codex CLI a memory and a map of my code. You can't run commands on my computer,
  65. so walk me through it: give me ONE step at a time, tell me exactly what to type
  66. and what I should see, and wait for me to paste the result before the next step.
  67. If something fails, help me fix it before moving on.
  68. First ask me which operating system I use (macOS, Linux or Windows) and which
  69. assistants I use (Claude Code, VS Code Copilot, Codex CLI).
  70. The steps, for macOS and Linux:
  71. 1. Open a terminal.
  72. 2. Check git: `git --version`. If it's missing: on a Mac, `xcode-select
  73. --install`; on Linux, install git with the package manager.
  74. 3. Check a C compiler: on a Mac `xcode-select -p` (if it errors, run
  75. `xcode-select --install` and wait for it to finish); on Linux
  76. `cc --version` (if missing, `sudo apt install build-essential` or the
  77. distro's equivalent).
  78. 4. Check Rust: `cargo --version`. If it's missing, run
  79. `curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh`, accept the
  80. defaults, then close the terminal and open a new one, and check again.
  81. 5. Download it: `git clone https://github.com/Artistsyn/cortex_suite ~/cortex_suite`
  82. (if the folder already exists: `cd ~/cortex_suite && git pull`).
  83. 6. Install it for every project: `cd ~/cortex_suite && ./scripts/install-global.sh`
  84. The build takes a few minutes. It then registers both servers with every
  85. assistant it finds: each Claude Code account, VS Code's user MCP config, and
  86. ~/.codex/config.toml. Its output says which ones it set up. If I use more
  87. than one Claude Code account through CLAUDE_CONFIG_DIR, add
  88. `--claude-config <that folder>` for each.
  89. 7. Check it worked, for each assistant I use:
  90. - Claude Code: `claude mcp list` should show cortex and quartz-ctx as
  91. Connected. Then restart Claude Code.
  92. - VS Code Copilot: reload the window, run "MCP: List Servers" from the
  93. Command Palette, start both, and turn their tools on in agent mode.
  94. - Codex CLI: start a new codex session; the servers load from config.toml.
  95. For Windows, the install script doesn't run. Instead, after steps 2-5 (Git for
  96. Windows, Visual Studio Build Tools with the C++ workload, Rust from
  97. https://rustup.rs, and the clone), run in PowerShell from the cortex_suite
  98. folder, once per project:
  99. `.\scripts\setup.ps1 -Workspace C:\path\to\project`
  100. Common problems: "cargo: command not found" means the terminal needs
  101. reopening after installing Rust. A build error about "cc" or "linker" means the
  102. C compiler from step 3 is missing. A warning about mcp.json means VS Code's
  103. config has comments in it; then add the two servers by hand, with commands
  104. ~/.cortex-suite/bin/cortex-mcp and ~/.cortex-suite/bin/quartz-ctx-mcp.
  105. ```
  106. </details>
  107. ### Or by hand
  108. You need [Rust](https://rustup.rs).
  109. ```bash
  110. git clone https://github.com/Artistsyn/cortex_suite ~/cortex_suite
  111. ~/cortex_suite/scripts/install-global.sh
  112. ```
  113. Then restart your editor. Or, to set up just one project:
  114. `~/cortex_suite/scripts/setup.sh ~/code/my-project`
  115. (on Windows: `.\scripts\setup.ps1 -Workspace C:\code\my-project`).
  116. ## Is it working?
  117. In any project you've worked in:
  118. ```bash
  119. ~/cortex_suite/cortex/target/debug/cortex scoreboard
  120. ```
  121. ## Update
  122. `git pull` in `cortex_suite`, then run the install again.
  123. ---
  124. Details: [TECHNICAL.md](TECHNICAL.md) · Help: [SETUP_HANDOFF.md](SETUP_HANDOFF.md)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.