GZOO Cortex

If global install fails withEACCES, use a user prefix instead:

mkdir -p ~/.local npm config set prefix ~/.local echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc source ~/.bashrc npm install -g @gzoo/cortex

git clone https://github.com/gzoonet/cortex.git cd cortex npm install && npm run build && npm link

Verify:cortex --version(current release:0.8.1)

cortex init cortex doctor # verify config, providers, and DB

- LLM provider— Anthropic, Google Gemini, DeepSeek, Groq, OpenRouter, or Ollama (local)
- API key— saved securely to~/.cortex/.env
- Routing mode— cloud-first, hybrid, local-first, or local-only
- Watch directories— which directories Cortex should monitor
- Budget limit— monthly LLM spend cap

cortex initwrites global config to~/.cortex/cortex.config.json. API keys go in~/.cortex/.env.

cortex projects add my-app ~/projects/app cortex projects add api ~/projects/api cortex projects list # verify

Backfill existing files first— the watcher only picks up new changes:

cortex ingest "~/projects/app/src//.ts" # one-shot backfill cortex serve # dashboard + API + file watcher (recommended)

cortex query "what caching strategies am I using?" cortex query "what decisions have I made about authentication?" cortex find "PostgreSQL" --expand 2 cortex contradictions

cortex serve # open http://localhost:3710

cortex config exclude add docs # exclude a directory cortex config exclude add ".log" # exclude by pattern cortex config exclude list # see all excludes cortex config exclude remove docs # remove an exclude

Cortex runs a pipeline on every file change:
- Parse— file content is chunked by a language-aware parser (tree-sitter for code, remark for markdown)
- Extract— LLM identifies entities (decisions, components, patterns, etc.)
- Relate— LLM infers relationships between new and existing entities
- Detect— contradictions and duplicates are flagged automatically
- Store— entities, relationships, and vectors go into SQLite + LanceDB
- Query— natural language queries search the graph and synthesize answers

Cortex isprovider-agnostic. It supports:

- Anthropic Claude(Sonnet, Haiku) — via native Anthropic API
- Google Gemini— via OpenAI-compatible API
- DeepSeek(Reasoner, Chat) — strong reasoning, very affordable
- Groq— fast inference with free tier
- Any OpenAI-compatible API— OpenRouter, local proxies, etc.
- Ollama(Mistral, Llama, etc.) — fully local, no cloud required

Incloud-firstmode, all tasks route to your cloud provider. Ollama is not required and is only used if budget fallback is enabled. Hybrid mode routes high-volume tasks (entity extraction, ranking) to Ollama and reasoning-heavy tasks (relationship inference, queries) to your cloud provider.

Cortex blends keyword (full-text) search withvector similarity, so queries match by meaning rather than exact words. Embeddings areoptional and off by default— enable them with a cloud embeddings provider (no local GPU or Ollama required):

cortex config set llm.embeddings.enabled true cortex config set llm.embeddings.baseUrl https://api.openai.com/v1 cortex config set llm.embeddings.model text-embedding-3-small cortex config set llm.embeddings.apiKeySource env:OPENAI_API_KEY cortex config set llm.embeddings.dimensions 1536 # then add the key to ~/.cortex/.env: echo 'OPENAI_API_KEY=sk-...' >> ~/.cortex/.env

The embeddings provider isindependent of your chat provider— run chat on DeepSeek (or Anthropic, Groq, …) and embeddings on OpenAI. Any OpenAI-compatible embeddings endpoint works.

New files are embedded automatically as they're ingested. To build the index for a graph youalreadyingested, run a one-time reindex:

cortex reindex # all projects cortex reindex my-app # a single project

- Dashboard Home— graph stats, recent activity, entity type breakdown
- Knowledge Graph— interactive D3-force graph with clustering, click to explore
- Live Feed— real-time file change and entity extraction events via WebSocket (fromcortex serveonly)
- Query Explorer— natural language queries with streaming responses
- Contradiction Resolver— review and resolve conflicting decisions

location /api/ { auth_basic "Cortex"; auth_basic_user_file /etc/nginx/.htpasswd; proxy_pass http://127.0.0.1:3710; proxy_set_header Authorization "Bearer $CORTEX_TOKEN"; } location /ws { auth_basic "Cortex"; auth_basic_user_file /etc/nginx/.htpasswd; proxy_pass http://127.0.0.1:3710; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "upgrade"; } location / { auth_basic off; proxy_pass http://127.0.0.1:3710; }

claude mcp add cortex --scope user -- npx @gzoo/cortex mcp

- @cortex/core— types, EventBus, config loader, error classes
- @cortex/ingest— file parsers (tree-sitter + remark), chunker, watcher, pipeline
- @cortex/graph— SQLite store, LanceDB vectors, query engine
- @cortex/llm— Anthropic/Gemini/OpenAI-compatible/Ollama providers, router, prompts, cache
- @cortex/cli— Commander.js CLI
- @cortex/mcp— Model Context Protocol server (stdio transport, 12 tools)
- @cortex/server— Express REST API + WebSocket relay
- @cortex/web— React + Vite + D3 web dashboard

- Files classified asrestrictedarenever**sent to cloud LLMs
- Sensitive files (.env, .pem, .key) are auto-detected and blocked
- API key secrets are scanned and redacted before any cloud transmission
- All data stored locally in~/.cortex/— nothing phones home

Cortex started as an internal tool to maintain context across multiple client projects. We open-sourced it because every developer who works on more than one thing loses context, and we think this approach — automatic file watching + knowledge graph + natural language queries — is the right way to solve it.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

A server for CodeFuse-CGM, a graph-integrated large language model designed for repository-level software engineering tasks.

Developer context continuity system that builds a temporal knowledge graph of your codebase — modules, symbols, decisions, and open problems — and serves it to AI coding agents via 12 MCP tools, so every agent session starts knowing your architecture without manual context pasting.

Knowledge graph for token-efficient code reviews with Tree-sitter parsing, dual-mode embedding (ONNX + LiteLLM), and blast-radius analysis via MCP tools.

MCP server that ingests project docs once and lets Claude search by meaning instead of reading everything — saving tokens on large codebases

Easily provide codebase context to Large Language Models (LLMs).

An MCP server that indexes local code into a graph database to provide context to AI assistants.

Code Rag with Graph - local only installation

A blazingly fast codebase graphRAG implementation in 100% Rust

Graph-powered code intelligence MCP server with semantic search, knowledge graph, and dependency analysis for Claude Code, Cursor, and Copilot.