Skip to content

getreka/reka

BranchesTags

Repository files navigation

Reka

Memory that flows. Knowledge that stays.

Self-hosted RAG infrastructure for AI coding assistants.
Give Claude Code, Cursor, or Windsurf persistent memory across sessions.

Claude Code Plugin npm npm License Stars

Plugin · Quick Start · How It Works · Features · Website · Issues

The Problem

Your AI coding assistant forgets everything between sessions. Every new conversation starts from zero -- no memory of past decisions, no knowledge of your architecture, no recall of what was already tried and failed.

Reka fixes this. It gives your AI assistant persistent memory, semantic code search, and a knowledge graph of your codebase -- all running on your machine.

Claude Code Plugin

The fastest way to use Reka. Two commands inside Claude Code:

/plugin marketplace add getreka/reka-plugin
/plugin install reka@reka-plugins

The plugin gives you the full Reka experience without any manual MCP configuration:

What you get Details
9 commands /reka:code, /reka:investigate, /reka:review, /reka:arch, /reka:debate, /reka:start, /reka:end, /reka:onboard, /reka:memory-review
4 agents feature-builder, code-reviewer, rag-researcher, rag-ops -- internal subagents used by the workflows, all with persistent memory
2 hooks Auto session lifecycle: SessionStart (context + session id) and SessionEnd (memory consolidation)
MCP server @getreka/mcp auto-configured with your API key (stored in OS keychain)

Team auto-install

Add to your project's .claude/settings.json and every team member gets the plugin automatically:

{
  "extraKnownMarketplaces": {
    "reka-plugins": {
      "source": { "source": "github", "repo": "getreka/reka-plugin" }
    }
  },
  "enabledPlugins": {
    "reka@reka-plugins": true
  }
}

Plugin repo: getreka/reka-plugin -- full docs, commands reference, and architecture overview.

Quick Start

Option A: Claude Code Plugin (recommended)

/plugin marketplace add getreka/reka-plugin
/plugin install reka@reka-plugins

Sessions start automatically (SessionStart hook); /reka:start shows session status.

Option B: MCP Server + CLI

# 1. Start the infrastructure
git clone https://github.com/getreka/reka.git
cd reka/docker && docker compose up -d

# 2. Initialize your project (generates API key + .mcp.json)
npx @getreka/cli init --project my-app

That's it. Open your AI assistant -- it now has memory.

Try the demo (no install needed)

npx @getreka/cli init --demo --project my-app

This connects to a live Reka instance so you can try memory, search, and indexing before deploying your own. Demo data may be reset periodically.

What reka init does

  1. Creates an API key mapped to your project
  2. Writes .mcp.json with the correct MCP server config
  3. Your AI assistant auto-discovers the MCP server on next launch

The generated .mcp.json:

{
  "mcpServers": {
    "reka": {
      "command": "npx",
      "args": ["-y", "@getreka/mcp"],
      "env": {
        "REKA_API_KEY": "rk_myapp_a3f8b2..."
      }
    }
  }
}

One API key = one project. No extra headers or config needed. The key tells Reka which project you're working on.

How It Works

 Claude Code + Reka Plugin
        │
        │  9 commands · 4 agents · 2 hooks
        │
        ▼
 @getreka/mcp            ← npm package, auto-configured by plugin
        │
        │ HTTP + API Key
        ▼
 Reka API (:3100)        ← Express server
        │
    ┌───────┼───────┐
    ▼       ▼       ▼
 Qdrant   Ollama   Redis
 vectors LLM+embed cache

Each project gets isolated collections in Qdrant:

  • myapp_codebase -- indexed source code
  • myapp_agent_memory -- decisions, patterns, insights
  • myapp_graph -- import/dependency relationships
  • myapp_symbols -- function/class/type index

No cross-contamination between projects. One backend serves them all.

Features

Search

  • Hybrid search -- vector similarity + keyword matching
  • Code graph -- traverse imports, dependencies, blast radius
  • Symbol index -- instant lookup of functions, classes, types
  • Smart dispatch -- LLM routes your query to the best search strategy

Memory

  • Persistent memory -- decisions, patterns, ADRs survive across sessions
  • Memory governance -- quarantine, promotion, decay (not everything deserves permanence)
  • Consolidation -- duplicate memories merge and evolve over time
  • Spreading activation -- associative recall finds related memories

Indexing

  • Multi-language -- TypeScript, Python, Go, Rust, Java, C#, and more
  • Incremental -- hash-based change detection, only re-indexes what changed
  • Knowledge graph -- auto-extracts import/export relationships

Platform

  • Claude Code plugin -- 9 commands, 4 agents, 2 hooks, auto-configured MCP
  • MCP native -- works with Claude Code, Cursor, Windsurf out of the box
  • 41 tools, 0 hidden -- search, memory, indexing, agents, architecture, database
  • Dashboard -- Vue 3 web UI for memory review and analytics

LLM & Embedding

  • Fully local -- Ollama for both LLM and embeddings (default), zero API keys needed
  • Or hybrid -- local for fast tasks, Claude/GPT-4 for complex analysis
  • Your choice -- Ollama, OpenAI, or Anthropic for LLM; Ollama (default), OpenAI, or BGE-M3 for embeddings

Deployment

Self-Hosted -- free. The full platform with zero limitations, running entirely on your machine: cd docker && docker compose up -d.

A self-hosted Team license is planned, but only if there is real demand -- tell us if you want it.

Requirements

Component Minimum Recommended
Docker 24+ Latest
RAM 8 GB 16 GB
Node.js 22+ Latest LTS
Disk ~2 GB SSD recommended
GPU Not required NVIDIA for Ollama acceleration

For the Claude Code plugin only: Claude Code 1.0.33+, Node.js 22+. Docker required only for self-hosted backend.

Configuration

Key environment variables for rag-api/.env (values shown are what the Docker stack in docker/docker-compose.yml uses):

Variable Docker stack value Description
EMBEDDING_PROVIDER ollama ollama, openai, bge-m3-server
OLLAMA_EMBEDDING_MODEL qwen3-embedding:4b Embedding model
VECTOR_SIZE 2560 Embedding dimensions
LLM_PROVIDER ollama ollama, openai, anthropic
OLLAMA_MODEL qwen3.5:9b Model for LLM completions
QDRANT_URL http://localhost:6333 Vector database
REDIS_URL redis://localhost:6380 Cache (optional, recommended)
OPENAI_API_KEY -- Required if using OpenAI
ANTHROPIC_API_KEY -- Required if using Anthropic

Default config runs fully local -- no API keys needed.

MCP Tools

Reka exposes 41 tools to your AI assistant (none hidden). The most used:

Tool What it does
hybrid_search Semantic + keyword search over your code
find_symbol Fast lookup: functions, classes, types
search_graph Traverse imports, find dependencies
search_docs Search indexed documentation
context_briefing Multi-strategy lookup before making changes
remember Store a decision, insight, or pattern
recall Retrieve relevant memories
record_adr Record an architecture decision
index_codebase Index or re-index the project
start_session / end_session Session lifecycle with continuity
run_agent Launch an autonomous sub-agent

Dashboard

cd dashboard && npm install && npm run dev
# Open http://localhost:3000

Memory explorer, search playground, project analytics, indexing status, system health.

Comparison

Reka Cursor Memory Cody (Sourcegraph) Continue.dev Greptile
Self-hosted Fully Cloud only Partial Yes Cloud only
Claude Code plugin Yes No No No No
Memory governance Full lifecycle No No No No
Multi-project Isolated Per-workspace Yes Limited Yes
Code graph Yes No Yes No Yes
MCP native Yes No No Yes No
LLM choice Any Locked Locked Any Locked
Data privacy 100% local Cloud Partial Local Cloud
Cost Free $/seat $/seat Free $/repo

Project Structure

reka/
├── rag-api/          # Core API server (Express, TypeScript)
├── mcp-server/       # MCP server (@getreka/mcp)
├── cli/              # CLI tool (@getreka/cli)
├── dashboard/        # Web dashboard (Vue 3)
├── docker/           # Canonical compose stack + Grafana, Prometheus configs
├── docs/archive/     # Historical status snapshots
├── landing/design/   # Landing page design source (.pen)
└── docker-compose.yml  # Thin shim that includes docker/docker-compose.yml

Plugin: getreka/reka-plugin -- Claude Code plugin (separate repo)

Contributing

We welcome contributions. See CONTRIBUTING.md for setup and guidelines.

Good first issues are labeled good first issue.

License

Reka is source-available under the Business Source License 1.1.

  • Self-host freely -- no restrictions for internal use
  • Build integrations -- plugins, extensions, custom tools
  • Converts to Apache 2.0 after 3 years

The only restriction: you cannot offer Reka as a managed service competing with Reka Cloud.

Give your AI assistant the memory it deserves.

Install Plugin · Get started · getreka.dev · Report an issue

About

Memory infrastructure for AI coding assistants — Claude Code plugin, MCP server, semantic search, project memory, architecture decisions. Self-hosted.

getreka.dev

Topics

mcp self-hosted semantic-search rag vector-search architecture-decisions ai-coding claude-code project-memory claude-code-plugin

Resources

Readme

License

View license

Contributing

Contributing
Activity
Custom properties

Stars

1 star

Watchers

0 watching

Forks

1 fork
Report repository

Releases

8 tags

Packages

 
 
 

Contributors

Languages