REKHA (रेखा)

The High-Performance System-1 Control Plane for Production RAG

Cut LLM token bills by 50%+, block prompt injections in 35ms, and eliminate hallucinations with a single Python decorator. Zero external API calls, zero migration friction, 100% free and open-source.

🌐 Interactive Landing Page • 🏗️ Technical Architecture • 📊 Benchmark Report • 🥊 Competitor Teardown

---

⚡ The Core USP (Unique Selling Proposition)

"Rekha is the first zero-latency, 100% open-source System-1 control plane that wraps around any existing RAG pipeline in 1 line of code—cutting token bills by 50%, blocking prompt injections in 35ms, and preventing hallucinations with zero external API keys."

Why Developers Choose Rekha:

1. Zero Migration Friction (The 1-Line Decorator): You don't re-index your vector database, you don't change your embeddings, and you don't rewrite your prompts. Just add @gateway.protect.
2. Sub-35ms Non-Autoregressive Determinism: Rekha doesn't use a slow generative LLM to police another LLM. It uses a mathematical non-autoregressive encoder (Choice, Score, Noul) that responds in 35ms and physically cannot be hijacked by prompt injections.
3. 100% Air-Gapped & Free: Zero cloud telemetry, zero API keys, zero dollars spent. Your proprietary company data never leaves your local CPU or GPU.

---

🏗️ Architecture: The 5-Layer Sandwich Control Plane

                    ┌────────────────────────────────────────────────────────┐
                    │                      REKHA GATEWAY                     │
User Query ────────►│                                                        │
                    │  [ INBOUND STAGE ]                                     │
                    │  1. Guard Gate          (Injection, PII, Policy)       │
                    │  2. Cache Gate          (Canonical Intent Mapping)     │
                    │  3. Query Router        (Direct / Tool / Vector Index) │
                    │                                                        │
                    │  [ RETRIEVAL STAGE ]                                   │
                    │  4. Context Optimizer   (Micro-slice, Parallel Score,  │
                    │                          Budget Packer)                │
                    └───────────────────────────┬────────────────────────────┘
                                                │
                                                ▼
                                    ┌───────────────────────┐
                                    │     EXISTING RAG      │
                                    │  (100% Untouched)     │
                                    │  Vector DB  │   LLM   │
                                    └───────────┬───────────┘
                                                │
                    ┌───────────────────────────┴────────────────────────────┐
                    │  [ OUTBOUND STAGE ]                                    │
                    │  5. Verification Gate   (Negative Constraints,         │
                    │                          Entity Anchor, Grounding)     │
                    │                                                        │
                    │  Decision:  [ SUPPORTED ]   ──► Stream to User         │
                    │             [ BLOCK/RETRY ] ──► Fallback / Regenerate  │
                    └────────────────────────────────────────────────────────┘

---

⏱️ Live Response Times (Empirically Measured on Local CPU/GPU)

Layer	Component Name	Function / Decision	Response Time	vs. LLM-Prompt Guardrails
Layer 1	Inbound Guard Gate	Evaluates prompt injections, jailbreaks, PII & toxicity	~37 ms	~80x faster than calling GPT-4o (2,500ms)
Layer 2	Inbound Cache Gate	Canonical Intent Clustering + local memory LRU	~35 ms	~90x faster than a full Vector DB + LLM call
Layer 3	Query Router	Categorizes BYPASS, TOOL, or VECTOR partition	~38 ms	~75x faster than LLM tool routers
Layer 4	Context Optimizer	Micro-slicing + parallel batch scoring + knapsack packing	~69 ms	Slices 50%+ noise in memory
Layer 5	Outbound Verifier	Entity anchor audit ($ / dates) + negative constraint check	~72 ms	Replaces 3-second LLM-as-a-judge evals

The Net Latency Paradox: Rekha adds ~180ms of total control overhead on full RAG, but because it prunes 50%+ of input tokens, the downstream LLM streams its first token 800ms faster. Net result: The user gets their answer ~620ms FASTER.

---

📦 Installation & Zero-Config Setup

Installing Rekha takes one command. Rekha runs 100% locally and offline—it does not require any API keys, tokens, or external network connections:

pip install rekha

How Model Weights Work:

• Automatic Download: On your very first invocation of gateway = RekhaGateway(), the lightweight non-autoregressive decision model weights (~700MB) are automatically downloaded from Hugging Face into your standard local cache (~/.cache/huggingface/hub/models--convaiinnovations--laya).
• Zero External Calls Thereafter: Once downloaded, Rekha runs completely air-gapped on your local CPU or GPU.
• Air-Gapped / Docker Deployments: To bake the weights directly into an offline container image without runtime internet access:

  RUN pip install rekha
  RUN python -c "import laya; from laya import Laya; Laya()"
  ENV REKHA_AIRGAPPED=true
  

---

🚀 Quickstart: What Changes in Your Code? (Literally 2 Lines)

Before (Regular RAG)

import openai

def my_rag_pipeline(user_query: str):
    chunks = my_vector_db.similarity_search(user_query, k=5)
    context = "\n\n".join([c.page_content for c in chunks])
    
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"Answer based on:\n{context}"},
            {"role": "user", "content": user_query}
        ]
    )
    return response.choices[0].message.content

After (Rekha-Protected RAG)

import openai
from rekha import RekhaGateway       # <--- 1. Import Rekha

gateway = RekhaGateway()             # <--- 2. Initialize locally (0 API keys)

@gateway.protect                     # <--- 3. Add this one decorator
def my_rag_pipeline(user_query: str):
    chunks = my_vector_db.similarity_search(user_query, k=5)
    context = "\n\n".join([c.page_content for c in chunks])
    
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"Answer based on:\n{context}"},
            {"role": "user", "content": user_query}
        ]
    )
    return response.choices[0].message.content, context

---

🥊 What Makes Rekha Different From Competitors?

A. vs. DIRECT COMPETITORS (The Point Solutions)

Competitor Category	Key Players	How They Work	Why Rekha is Radically Better
Prompt Compressors	Microsoft LLMLingua	Token-level perplexity dropping via small causal models.	LLMLingua destroys syntax: Deletes closing brackets }, corrupts tables/JSON, and drops words like "not". 👉 Rekha preserves syntax: Micro-slicer protects Markdown tables, code blocks, and natural reading order.
AI Guardrails	Nvidia NeMo / Guardrails AI	Uses Colang rules or calls secondary LLMs to check safety.	Too slow & expensive: Calling a second LLM adds 2–4 seconds of latency and doubles API bills. 👉 Rekha blocks injections in 35ms locally for $0.00 without generative lag.
Document Rerankers	Cohere Rerank / BGE	Reorders retrieved chunks by relevance score.	Does not compress or verify: If a top chunk has 1,000 tokens with only 1 useful sentence, you still pay for all 1,000 tokens. 👉 Rekha prunes the noise inside the chunks and audits output facts before delivery.
Evaluation / Grounding	Ragas / TruLens	Calls GPT-4o ("LLM-as-a-judge") to grade answers against context.	Unusable on live user traffic: Taking 3 seconds to verify an answer kills live chat UX. 👉 Rekha verifies negative constraints & numbers in ~70ms before streaming.
Semantic Caches	Redis LangCache / GPTCache	Cosine distance thresholds over 1536d vector embeddings.	Threshold Drift: Small distance differences cause "How do I cancel?" to falsely match "How do I upgrade?". 👉 Rekha uses discrete Canonical Intent Clustering, yielding 99%+ deterministic confidence matches.

B. vs. INDIRECT COMPETITORS (Infrastructure We Supercharge)

• Vector Databases (Pinecone, Chroma, Qdrant): We are not a database. Vector DBs find documents; Rekha cleans the retrieved documents, stops injection attacks, and verifies output claims.
• Orchestrators (LangChain, LlamaIndex): LangChain is the plumbing; Rekha is the Security & Quality Guard that plugs into LangChain via a single decorator or callback.
• AI Gateways (Portkey, Helicone, LiteLLM): Gateways are network proxy routers for load-balancing and key rotation. Rekha provides in-memory deep semantic boundary intelligence.

---

🧪 Real-World Benchmark on a 361-Page PDF Book

Source: "The End of Molasses Classes" by Ron Clark (Founder of the Ron Clark Academy)

python demo/test_pdf_book.py

Scenario & Target Content	Query Tested	Traditional RAG (No Rekha)	Rekha-Augmented RAG	Token Savings	Rekha Grounding & Security
1. Text Philosophy & Grading (Pages 33–36)	"Why does Ron Clark give grades of 14, 20, 42 and what is 'Not every child deserves a cookie'?"	1,148 tokens dumped into prompt. No guard.	527 tokens. Micro-slices conversational filler, retains exact quotes.	54% PRUNED	5/5 Grounding Score (STREAM_TO_USER)
2. Structured Schedule / Rule (Pages 198–201)	"What are the timing hours for Rule 39 regarding parent Open House day?"	923 tokens. Susceptible to hallucinated hours.	433 tokens. Preserves exact 8:00 AM–4:00 PM full-day schedule.	53% PRUNED	5/5 Grounding Score (STREAM_TO_USER)
3. Image / Photo Context (Pages 116–118)	"Describe the photo on page 117: why was Ron Clark in a limousine with students?"	897 tokens. Narrative clutter.	438 tokens. Preserves visual anchor and reading reward context.	51% PRUNED	5/5 Grounding Score (STREAM_TO_USER)
4. Canonical FAQ Cache Bypass (Pages 12–14)	"What does the phrase 'Molasses Classes' mean and why is the book called that?"	1,082 tokens. Paid full LLM API bill.	Served directly from Inbound Cache Gate in 35ms.	100% SAVED ($0.00)	Verified Canonical Answer

---

📂 Repository Structure

D:\Mine Labs\Rekha/
├── rekha/                     # Core Python Package (Apache-2.0)
│   ├── __init__.py            # Package entrypoint & public exports
│   ├── gateway.py             # RekhaGateway orchestrator & @protect decorator
│   ├── guard.py               # Layer 1: Inbound Guard Gate (Injection, PII, Toxicity)
│   ├── cache.py               # Layer 2: Inbound Cache Gate (Canonical Clustering)
│   ├── router.py              # Layer 3: Query Router (Bypass / Tool / Vector)
│   ├── optimizer.py           # Layer 4: Context Optimizer (Micro-slice & budget pack)
│   ├── verifier.py            # Layer 5: Outbound Grounding & Verification Gate
│   └── types.py               # Pydantic v2 data models & decision contracts
│
├── demo/                      # Working Reference Application & Benchmarks
│   ├── sample_docs/           # Sample PDF & Markdown policies
│   ├── rag_engine.py          # Working retrieval engine
│   ├── app.py                 # Live 4-scenario comparison benchmark
│   └── test_pdf_book.py       # Live PDF multi-modal & text benchmark
│
├── tests/                     # 25-Stage Automated Enterprise Test Suite (pytest)
├── Architecture.md            # In-depth technical specification
├── Plan.md                    # Fully open-source strategy & competitor teardown
├── BENCHMARK_REPORT.md        # Comprehensive Senior Architect evaluation report
├── pyproject.toml             # Build & packaging metadata (Apache-2.0)
└── README.md                  # Project documentation

---

📜 License

Apache-2.0 License. Free for personal, commercial, and enterprise production deployments with zero restrictions.