Solucortex Mcp

io.github.soluai-spaPublished by GitHub account soluai-spav1.1.2Updated Oct 24, 2026

Living technical memory for AI agents: recall approved project context, record what was learned.

VerifiedStreamable HTTPWeb executableKnowledge & MemoryDeveloper Tools

Overview

AI-generated overview

SoluCortex MCP gives an assistant a project's living technical memory: recall approved decisions, conventions and risks, and record what it learns.

What you can do
  • Recall ranked project context at the start of a task
  • Run ad-hoc semantic searches over stored memories
  • Record new memories when a task closes or a technical decision is made
  • Correct an existing memory, which returns it to pending for human re-approval
  • Flag a memory as outdated or incorrect for human review
  • List a project's memories for quick inspection or audit
When to use it
Useful when an assistant works repeatedly on the same codebase or project and should start each task with the team's approved decisions, conventions, risks and architecture, then write back what it learned. It fits teams that want agent-proposed memory with human approval in a panel.
Requirements
A SoluCortex account and a project API key with the scx_ prefix. Remote use needs the hosted Streamable HTTP endpoint with an Authorization bearer header and optional X-Solucortex-Project header; local use needs uv, Python 3.10 or later, or Docker, with SOLUCORTEX_API_KEY set and optional SOLUCORTEX_PROJECT_ID and SOLUCORTEX_URL. Network access to the SoluCortex API.
Before you install
The API key is a secret: keep it in the client config env block or a local .env and never commit it. The server writes to a shared project memory store, so recorded memories affect what other agents recall; edits go back to pending and only humans can delete. Recall and semantic search consume OpenAI embedding quota at 20 requests per minute. Do not store real secrets in memories; record location, type and severity instead.

Installation

In SourceWeft

  1. Open Solucortex Mcp in the dashboard and add it to a workspace.
  2. Connect Authorization token credentials. They are stored privately and never shown on public pages.
  3. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.soluai-spa%2Fsolucortex-mcp/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "solucortex": {
      "type": "http",
      "url": "https://mcp.solucortex.ai/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_TOKEN>"
      }
    }
  }
}

README

SoluCortex MCP

[PyPI] [CI] [Python] [License: MIT]

Official Model Context Protocol server for SoluCortex — living technical memory for AI agents.

Connect any MCP-compatible agent (Claude Code, Claude Desktop, Cursor, Codex, Cline, …) to your SoluCortex project so it can recall the decisions, conventions, risks and architecture that matter before it works, and remember what it learns when it's done.

Website: solucortex.ai · Setup guide: solucortex.ai/docs/mcp · Tools reference: solucortex.ai/docs/mcp-tools · PyPI: solucortex-mcp · MCP Registry: io.github.soluai-spa/solucortex-mcp

[SoluCortex MCP demo: recall approved context at task start, remember learnings at close]

Tools

ToolWhat it doesWhen to use
solucortex_recallBuilds living context for a task (ranked by semantic similarity + importance)At the start of a task, before touching code
solucortex_searchAd-hoc semantic search over the project's memoriesSpecific questions mid-task
solucortex_rememberRecords a memory (stored approved + traced as an authorized agent)At close, or on a relevant technical decision
solucortex_update_memoryCorrects an existing memory — the edit returns it to pending for human re-approval in the panelWhen a memory is right in spirit but wrong in detail
solucortex_flag_memoryFlags a memory as outdated/incorrect with a reason; a human resolves it in the panelWhen a memory should be reviewed, archived or deleted
solucortex_list_memoriesLists memories without semantic searchQuick inspection / audit

Governance by design: agents propose, humans govern. Agents can never change a memory's status, rewrite its metadata, or delete it — edits go back to pending and deletions only happen from the SoluCortex panel.

Requirements

  • A SoluCortex account and a project API key (prefix scx_) — get it from your SoluCortex dashboard.
  • One of: uv (recommended), Python ≥ 3.10, or Docker.

Configuration

stdio mode (default, local)

The server is configured entirely through environment variables:

VariableRequiredDescription
SOLUCORTEX_API_KEY✅Project API key (scx_…)
SOLUCORTEX_PROJECT_IDoptionalDefault project UUID; if omitted, the backend infers it from the API key
SOLUCORTEX_URLoptionalAPI base URL. Default https://solucortex.ai

HTTP mode (remote, multi-tenant)

Run with MCP_TRANSPORT=http (or --http) to serve Streamable HTTP on $PORT (default 8080) — the mode behind https://mcp.solucortex.ai. Credentials travel with each request and the environment is ignored:

HeaderRequiredDescription
Authorization: Bearer scx_…✅The caller's project API key (401 without it)
X-Solucortex-ProjectoptionalDefault project UUID; if omitted, the backend infers it from the API key

GET /health (and /healthz locally; Cloud Run's frontend intercepts /healthz) responds without auth. The MCP endpoint is /mcp, runs stateless, and shares nothing between requests/tenants.

Never commit your API key. Keep it in your MCP client config's env block or a local .env (see .env.example).

Install

Remote (recommended — nothing to install)

The hosted server at https://mcp.solucortex.ai/mcp speaks Streamable HTTP; your key travels with each request:

bash
claude mcp add --transport http solucortex https://mcp.solucortex.ai/mcp \  --header "Authorization: Bearer scx_xxx" \  --header "X-Solucortex-Project: your-project-uuid"

Or in any client with remote MCP support:

json
{  "mcpServers": {    "solucortex": {      "type": "http",      "url": "https://mcp.solucortex.ai/mcp",      "headers": {        "Authorization": "Bearer scx_xxx",        "X-Solucortex-Project": "your-project-uuid"      }    }  }}

Claude Code (local, stdio)

bash
claude mcp add solucortex \  -e SOLUCORTEX_API_KEY=scx_xxx \  -e SOLUCORTEX_PROJECT_ID=your-project-uuid \  -- uvx solucortex-mcp

Claude Desktop / Cursor / Cline (JSON config)

Add to the client's MCP config (claude_desktop_config.json, Cursor mcp.json, etc.):

json
{  "mcpServers": {    "solucortex": {      "command": "uvx",      "args": ["solucortex-mcp"],      "env": {        "SOLUCORTEX_API_KEY": "scx_xxx",        "SOLUCORTEX_PROJECT_ID": "your-project-uuid"      }    }  }}

From a local clone

bash
git clone https://github.com/soluai-spa/solucortex-mcpcd solucortex-mcpcp .env.example .env   # fill in your key./run.sh               # loads .env, then runs via uv# or, with SOLUCORTEX_* already exported: uv run solucortex-mcp

Docker

Prebuilt image on GHCR:

bash
docker run --rm -i \  -e SOLUCORTEX_API_KEY=scx_xxx \  ghcr.io/soluai-spa/solucortex-mcp:latest

Or build it yourself:

bash
docker build -t solucortex-mcp .docker run --rm -i \  -e SOLUCORTEX_API_KEY=scx_xxx \  -e SOLUCORTEX_PROJECT_ID=your-project-uuid \  solucortex-mcp

The server speaks MCP over stdio, so clients launch it as a subprocess (-i keeps stdin open).

Instructions for your agent (AGENTS.md)

Once connected, give your agent the methodology too: copy templates/AGENTS.md into the root of your repo (it works as AGENTS.md or CLAUDE.md). The MCP handshake already carries these instructions — the file lets you version them alongside your code, extend them with your own conventions, and optionally enable the commented Claude Code hook recipe for guaranteed recall.

Development

bash
uv syncuv run solucortex-mcp            # run (stdio)MCP_TRANSPORT=http uv run solucortex-mcp   # run (HTTP on :8080)uv run pytest                    # test suitenpx @modelcontextprotocol/inspector uv run solucortex-mcp   # interactive test

Notes

  • Memory type vocabulary: the canonical set is architecture, decision, risk, convention, bug_history, tech_debt, sensitive_module, learning, external_integration. Some backends accept an older set (technical_decision, historical_bug, current_state, task_closure). The server passes type through and surfaces HTTP 422 so you can retry with the other set.
  • Never store real secrets in a memory. Record location, type, severity and action taken instead.

License

MIT — see LICENSE.

Source: README.md at commit b97a3af

Tools

6

solucortex_recall

SoluCortex: recall task context

Build living context for a task (POST /context/build). Call this at the START of a task, before touching code: returns approved, active memories (decisions, conventions, risks, sensitive modules, architecture) ranked by semantic similarity + importance. Uses OpenAI embeddings (slower, 20 req/min).

Parametersqueryrequiredproject_id

solucortex_remember

SoluCortex: record a memory

Record a memory in SoluCortex (POST /memories). Call when closing a task or making a relevant technical decision. As an authorized agent (Bearer api_key), the memory is stored with status 'approved' and traced. Never store real secrets: if you find one, record location/type/severity and action taken, with a redacted reference.

Parameterstyperequiredtitlerequiredcontentrequiredimportanceproject_id

solucortex_update_memory

SoluCortex: update a memory (requires human re-approval)

Correct an existing memory (PATCH /memories/{id}). Agents propose, humans govern: the edit is applied but the memory returns to PENDING until a human re-approves it. ALWAYS tell the user the change awaits their approval in the SoluCortex panel. Status changes are not possible here.

Parameterstypetitlecontentmemory_idrequiredimportance

solucortex_flag_memory

SoluCortex: flag a memory for human review

Flag a memory as outdated/incorrect (POST /memories/{id}/flag). The memory is marked for human review in the SoluCortex panel; nothing is deleted or unpublished. ALWAYS tell the user a memory awaits their decision in the panel. Deletion is human-only by design.

Parametersreasonrequiredmemory_idrequiredsuggested_action

solucortex_list_memories

SoluCortex: list memories

List the project's memories without semantic search (GET /memories). Useful for quick inspection/audit or to confirm a just-created memory was stored. Does not consume OpenAI quota.

Parameterslimitproject_id

Version history

1
  1. v1.1.2LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts