diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
index 94cb0ca..c052bbb 100644
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -1,6 +1,6 @@
 ---
 name: Feature Request
-about: Propose a new feature, metric, or memory backend
+about: Propose a new feature, LLM memory backend, evaluation metric, or benchmark scenario for MemoryLens
 title: "[FEAT] "
 labels: enhancement
 assignees: ''
@@ -8,24 +8,36 @@ assignees: ''
 
 ## What problem does this solve?
 
-<!-- Describe the gap. What can't you do with MemoryLens right now? -->
+<!-- Describe the gap in LLM memory evaluation. What can't MemoryLens measure right now?
+     Examples:
+     - "There's no way to benchmark memory across sessions (persistent memory)"
+     - "Chunked RAG doesn't model importance-weighted eviction"
+     - "The EdTech scenario is missing — I want to benchmark student/teacher memory decay"
+-->
 
 ## Proposed solution
 
-<!-- How would you implement this? New backend? New metric? Dashboard change? -->
+<!-- How would you implement this? New memory backend? New metric? New benchmark scenario? Dashboard change? -->
 
 ## Which layer does this touch?
 
-- [ ] `simulator/` — conversation generation or fact injection
-- [ ] `memory/` — new or improved memory backend
-- [ ] `evaluation/` — new metric or benchmark change
-- [ ] `dashboard.py` — visualisation
+- [ ] `simulator/` — conversation generation, fact injection, or new domain scenario
+- [ ] `memory/` — new or improved memory backend (LLM memory architecture)
+- [ ] `evaluation/` — new metric or multi-seed benchmark change
+- [ ] `utils/providers.py` — new LLM provider
+- [ ] `dashboard.py` — visualisation (Streamlit + Plotly)
 - [ ] `main.py` / CLI
-- [ ] Documentation
+- [ ] Documentation / research paper
+
+## Expected impact on recall or efficiency
+
+<!-- If this is a new memory backend, what recall@T behavior do you expect?
+     If this is a new metric, what does it capture that Recall@T doesn't?
+-->
 
 ## Alternatives considered
 
-<!-- Have you tried working around this? What else could solve the problem? -->
+<!-- Have you tried working around this? Which existing backends or metrics come closest? -->
 
 ## Are you willing to implement this?
 
@@ -35,4 +47,4 @@ assignees: ''
 
 ## Additional context
 
-<!-- Links, papers, related work, mockups, etc. -->
+<!-- Links to papers (MemGPT, A-MEM, RAGAS, etc.), related LLM memory work, mockups, etc. -->
diff --git a/.github/ISSUE_TEMPLATE/new_backend.md b/.github/ISSUE_TEMPLATE/new_backend.md
index 9a5e362..2ac77a4 100644
--- a/.github/ISSUE_TEMPLATE/new_backend.md
+++ b/.github/ISSUE_TEMPLATE/new_backend.md
@@ -1,6 +1,6 @@
 ---
 name: New Memory Backend
-about: Propose or claim a new memory backend implementation
+about: Propose or claim a new LLM memory architecture implementation for the MemoryLens benchmark
 title: "[BACKEND] "
 labels: enhancement, new-backend
 assignees: ''
@@ -8,34 +8,52 @@ assignees: ''
 
 ## Backend name
 
-<!-- e.g. SummaryMemory, EntityMemory, RedisMemory -->
+<!-- e.g. EntityMemory, GraphMemory, QdrantMemory, RedisMemory, SlidingWindowMemory -->
 
-## What strategy does it use?
+## Memory strategy
 
-<!-- Describe in 2-3 sentences how this backend stores and retrieves messages -->
+<!-- Describe in 2-3 sentences how this backend stores and retrieves messages.
+     Examples:
+     - "Extract named entities into a key-value store; retrieve by entity name matching"
+     - "Use Qdrant vector DB with HNSW index; evict chunks older than N days"
+     - "Knowledge graph: entities as nodes, relationships as edges; multi-hop retrieval"
+-->
 
-## Why is it interesting to benchmark?
+## Research hypothesis
 
-<!-- What hypothesis does this backend test? What trade-off does it make? -->
+<!-- What does this backend test? What trade-off does it make?
+     The MemoryLens benchmark exists to measure LLM memory decay — what specific decay 
+     behavior do you expect this backend to show vs Naive / RAG / Cascading?
+-->
+
+## Expected Recall@T curve
+
+<!-- e.g. "Should match Cascading at T=50 but outperform at T=100 due to structured storage" -->
 
 ## Implementation sketch
 
 ```python
 class YourMemory(BaseMemory):
-    name = "your_backend"
+    name = "your_backend"   # used in --backends flag
 
-    def add_message(self, role, content, turn): ...
-    def get_context(self, query, current_turn): ...
-    def reset(self): ...
+    def add_message(self, role: str, content: str, turn: int) -> None: ...
+    def get_context(self, query: str, current_turn: int) -> List[Dict]: ...
+    def reset(self) -> None: ...
 ```
 
 ## Dependencies required
 
-<!-- Any new pip packages? Keep them minimal. -->
+<!-- Any new pip packages? Keep them optional (add to pyproject.toml extras). -->
+
+## Related work
+
+<!-- Papers, existing implementations, or LLM memory systems this is based on:
+     e.g. MemGPT (Packer 2023), A-MEM (Xu 2024), LangChain EntityMemory
+-->
 
 ## Are you claiming this to implement?
 
 - [ ] Yes — I'll open a PR within 2 weeks
 - [ ] No — leaving it open for the community
 
-<!-- See CONTRIBUTING.md for the full backend implementation guide -->
+<!-- See docs/adding-a-new-backend.md for the full implementation guide -->
diff --git a/CITATION.cff b/CITATION.cff
new file mode 100644
index 0000000..d5dcbc0
--- /dev/null
+++ b/CITATION.cff
@@ -0,0 +1,50 @@
+cff-version: 1.2.0
+message: "If you use MemoryLens in your research, please cite it as below."
+type: software
+title: "MemoryLens: A Temporal Decay Benchmark for LLM Memory Architectures"
+abstract: >
+  MemoryLens is an open-source evaluation framework for measuring LLM memory decay
+  — how AI memory systems forget personal facts across long conversations. It implements
+  five memory architectures (Naive, Ideal RAG, Chunked RAG, Cascading Temporal, SummaryMemory),
+  five evaluation metrics (Recall@T, Precision@K, Temporal Drift, Memory Noise Ratio,
+  Cascade Efficiency), Ebbinghaus-grounded temporal decay with ablation, multi-seed
+  statistical validation across five diverse personas, and a dual evaluation pipeline
+  (content-based + LLM answer+judge) supporting five provider backends.
+authors:
+  - family-names: Srivastava
+    given-names: Neal
+    alias: Neal006
+    orcid: ""
+repository-code: "https://github.com/Neal006/memorylens"
+url: "https://github.com/Neal006/memorylens"
+license: MIT
+version: 0.3.0
+date-released: "2026-05-22"
+keywords:
+  - LLM memory
+  - memory decay
+  - LLM evaluation
+  - RAG evaluation
+  - temporal decay
+  - Ebbinghaus forgetting curve
+  - conversational AI
+  - memory benchmark
+  - long-term memory
+  - retrieval-augmented generation
+  - cascading memory
+  - LLM benchmark
+references:
+  - type: article
+    title: "RAGAS: Automated Evaluation of Retrieval Augmented Generation"
+    authors:
+      - family-names: Es
+        given-names: Shahul
+    year: 2023
+    url: "https://arxiv.org/abs/2309.15217"
+  - type: article
+    title: "MemGPT: Towards LLMs as Operating Systems"
+    authors:
+      - family-names: Packer
+        given-names: Charles
+    year: 2023
+    url: "https://arxiv.org/abs/2310.08560"
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index f6de797..3530ba9 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,6 +1,6 @@
 # Contributing to MemoryLens
 
-First off — thank you for taking the time to contribute. MemoryLens is an open research tool and every contribution, from a typo fix to a new memory backend, matters.
+Thank you for contributing to the **open-source benchmark for LLM memory decay**. Every contribution — a bug report, a new memory backend, a documentation fix — makes the benchmark better for the entire AI/ML community.
 
 ---
 
@@ -8,9 +8,9 @@ First off — thank you for taking the time to contribute. MemoryLens is an open
 
 - [Quick orientation](#quick-orientation)
 - [Development setup](#development-setup)
-- [Project structure explained](#project-structure-explained)
 - [How to add a new memory backend](#how-to-add-a-new-memory-backend)
 - [How to add a new metric](#how-to-add-a-new-metric)
+- [How to add a new persona / scenario](#how-to-add-a-new-persona--scenario)
 - [Running tests](#running-tests)
 - [Submitting a PR](#submitting-a-pr)
 - [Good first issues](#good-first-issues)
@@ -20,16 +20,20 @@ First off — thank you for taking the time to contribute. MemoryLens is an open
 
 ## Quick orientation
 
-MemoryLens has three moving parts:
+MemoryLens benchmarks **LLM memory decay** — how AI memory systems forget personal facts over long conversations. It has three layers:
 
 ```
 Simulator  →  Memory Backend  →  Evaluator  →  Dashboard
-(generate     (store + retrieve   (measure       (visualise
- fake conv.)   context)            decay)         results)
+(generate     (store + retrieve   (5 metrics,    (visualise
+ conversation  context)           dual mode)     results)
 ```
 
 Each layer is independently extensible. You can add a backend without touching the evaluator, and add a metric without touching the dashboard.
 
+**Current backends:** `naive` · `rag` · `rag_chunked` · `cascading` · `summary`  
+**Current metrics:** Recall@T · Precision@K · Temporal Drift · Memory Noise Ratio · Cascade Efficiency  
+**LLM eval providers:** Groq · OpenAI · Anthropic · OpenRouter · Ollama
+
 ---
 
 ## Development setup
@@ -48,56 +52,21 @@ source .venv/bin/activate        # Linux/macOS
 pip install -r requirements.txt
 
 # 4. Verify everything works (no API key needed)
-python quick_demo.py
-
-# 5. Run the test suite
 python tests/test_pipeline.py
-```
-
-Set `TRANSFORMERS_NO_TF=1` and `USE_TF=0` in your environment if you have TensorFlow installed — this prevents a protobuf conflict.
-
----
-
-## Project structure explained
 
+# 5. Optional: run multi-seed benchmark
+python main.py --seeds 5
 ```
-memorylens/
-│
-├── simulator/               # Synthetic conversation engine
-│   ├── facts.py             # Fact definitions + BENCHMARK_FACTS list
-│   └── conversation.py      # Generates turn-by-turn conversation events
-│
-├── memory/                  # Memory backend implementations
-│   ├── base.py              # Abstract base class — every backend implements this
-│   ├── naive.py             # Naive: full history, truncate oldest on overflow
-│   ├── rag.py               # RAG: embed all messages, retrieve top-K by cosine sim
-│   └── cascading.py         # Cascading Temporal: hot/warm/cold three-tier memory
-│
-├── evaluation/              # Metrics and orchestration
-│   ├── metrics.py           # Content-based metric functions (no LLM needed)
-│   ├── benchmark.py         # Benchmark runner — wires simulator + memory + metrics
-│   ├── llm_judge.py         # Optional: Groq-powered answer quality judge
-│   └── logger.py            # Experiment logger → JSON + CSV
-│
-├── utils/
-│   ├── embeddings.py        # sentence-transformers wrapper (cached model load)
-│   └── llm.py               # Groq API wrapper with retry logic
-│
-├── tests/
-│   ├── test_imports.py      # CI smoke test: all imports resolve
-│   └── test_pipeline.py     # 8 integration tests (no API key needed)
-│
-├── dashboard.py             # Streamlit visualisation layer
-├── main.py                  # CLI entry point
-├── quick_demo.py            # Zero-API-key demo script
-└── demo_results.json        # Pre-computed results for instant dashboard demo
-```
+
+Set `TRANSFORMERS_NO_TF=1` and `USE_TF=0` if you have TensorFlow installed.
 
 ---
 
 ## How to add a new memory backend
 
-This is the most impactful type of contribution. The interface is simple — 4 methods.
+The most impactful contribution type. Full guide with a worked EntityMemory example: [docs/adding-a-new-backend.md](docs/adding-a-new-backend.md)
+
+**Quick version — 4 steps:**
 
 **Step 1 — Create `memory/your_backend.py`:**
 
@@ -106,88 +75,116 @@ from typing import List, Dict
 from .base import BaseMemory
 
 class YourMemory(BaseMemory):
-    name = "your_backend"   # used in CLI --backends flag
+    name = "your_backend"   # used in --backends flag
 
     def __init__(self):
-        # initialise your data structures
-        pass
+        pass  # initialise your data structures
 
     def add_message(self, role: str, content: str, turn: int) -> None:
-        # store a new message
-        pass
+        pass  # store the message
 
     def get_context(self, query: str, current_turn: int) -> List[Dict]:
-        # return a list of {"role": ..., "content": ...} dicts
-        # these are what get measured by the evaluator
+        # return [{"role": "user", "content": "..."}, ...]
+        # this list is what the evaluator measures
         pass
 
     def reset(self) -> None:
-        # clear all stored state
-        pass
+        pass  # clear all state
 ```
 
 **Step 2 — Register in `evaluation/benchmark.py`:**
 
 ```python
-def _make_memory(name: str) -> BaseMemory:
-    if name == "naive":      return NaiveMemory(...)
-    if name == "rag":        return RAGMemory()
-    if name == "cascading":  return CascadingTemporalMemory()
-    if name == "your_backend": return YourMemory()   # add this line
+from memory.your_backend import YourMemory
+
+def _make_memory(name: str, decay: str = "ebbinghaus") -> BaseMemory:
+    if name == "your_backend":
+        return YourMemory()
+    # ... existing cases ...
 ```
 
-**Step 3 — Add a test in `tests/test_pipeline.py`:**
+Add `"your_backend"` to `VALID_BACKENDS`.
+
+**Step 3 — Add one test in `tests/test_pipeline.py`:**
 
 ```python
 def test_your_backend_recall_early():
+    from memory.your_backend import YourMemory
     mem = YourMemory()
     _populate(mem, BENCHMARK_FACTS, 15)
     active = [f for f in BENCHMARK_FACTS if f.injected_at < 15]
     results = [recall_at_t(mem, f, 14) for f in active]
     rate = sum(r["recalled"] for r in results) / len(results)
-    assert rate >= 0.75
+    assert rate >= 0.5  # adjust threshold to your backend's expected performance
     print(f"PASS: your_backend recall early ({rate:.0%})")
 ```
 
-**Step 4 — Run the full benchmark against your backend:**
+**Step 4 — Run the full benchmark:**
 
 ```bash
-python main.py --backends your_backend naive rag --output my_results.json
+python main.py --backends your_backend naive rag cascading --output my_results.json
 ```
 
-That's it. Open a PR with the three files changed.
+Open a PR with the three files changed. A maintainer will review within 48 hours.
 
 ---
 
 ## How to add a new metric
 
-All metrics live in `evaluation/metrics.py`. Each metric is a plain function — no classes, no magic.
+All metrics live in `evaluation/metrics.py`. Each is a plain function — no classes.
 
 ```python
 def your_metric(memory: BaseMemory, facts: List[Fact], current_turn: int) -> float:
     """
     Your Metric — one sentence description.
-    Returns a float in [0, 1] (or unbounded if it's a ratio).
+    Returns float in [0, 1] (or unbounded if it's a ratio like Cascade Efficiency).
+    Must work without any API key — use content-based checks only.
     """
-    # implement here
     return score
 ```
 
-Then wire it into the benchmark runner in `evaluation/benchmark.py` at the checkpoint evaluation block, and add a chart for it in `dashboard.py`.
+Wire it into the `CheckpointResult` dataclass in `evaluation/benchmark.py` and add a chart in `dashboard.py`.
+
+---
+
+## How to add a new persona / scenario
+
+MemoryLens ships with 5 personas for multi-seed validation (`simulator/personas.py`). Adding more personas or domain scenarios (medical, customer support, education) strengthens the benchmark.
+
+**Add a persona:**
+
+```python
+# simulator/personas.py — add to PERSONA_POOL
+[
+    Fact("name",       "Yuki Tanaka",     injected_at=0),
+    Fact("city",       "Tokyo",           injected_at=1, updated_at=40, updated_value="Osaka"),
+    Fact("occupation", "nurse",           injected_at=2),
+    # ... 8 facts total, matching the keys in BENCHMARK_FACTS ...
+]
+```
+
+**Add a domain scenario** (e.g., medical): create `simulator/medical_facts.py` with a `MEDICAL_FACTS` list and a matching `generate_medical_conversation()` function. Then run:
+
+```bash
+python main.py --backends naive rag cascading   # with your scenario wired in
+```
 
 ---
 
 ## Running tests
 
 ```bash
-# All tests (no API key needed)
+# All 24 integration tests (no API key needed)
 python tests/test_pipeline.py
 
-# Import smoke test only
+# Import smoke test
 python tests/test_imports.py
 
-# Full demo with real numbers
-python quick_demo.py
+# Quick demo with real benchmark numbers
+python main.py
+
+# Multi-seed with confidence intervals
+python main.py --seeds 5
 ```
 
 CI runs both test files on Python 3.10 and 3.11 on every push.
@@ -198,45 +195,46 @@ CI runs both test files on Python 3.10 and 3.11 on every push.
 
 1. **Fork** the repo and create a branch: `git checkout -b feat/your-feature`
 2. Make your changes with tests
-3. Run `python tests/test_pipeline.py` — all 8 tests must pass
+3. Run `python tests/test_pipeline.py` — all 24 tests must pass
 4. Open a PR against `main` — fill in the PR template
 5. A maintainer will review within 48 hours
 
 **PR checklist:**
-- [ ] Tests pass locally
-- [ ] New feature has at least one test
+- [ ] All 24 tests pass locally
+- [ ] New backend/metric has at least one test
 - [ ] `CHANGELOG.md` updated under `## [Unreleased]`
-- [ ] Docstring added to new functions
+- [ ] `VALID_BACKENDS` updated in `evaluation/benchmark.py` if adding a backend
 
 ---
 
 ## Good first issues
 
-If you're new to the project, these are well-scoped starting points:
+Open, well-scoped tasks — each has clear acceptance criteria:
 
-| Issue | Difficulty | Skills needed |
-|-------|-----------|---------------|
-| Add `SummaryMemory` backend — rolling LLM summary every K turns | Medium | Python, LLM APIs |
-| Multi-seed benchmark — run N seeds, report mean ± std | Easy | Python, numpy |
-| Update-aware Cascading — patch Cold tier on fact updates | Medium | Python, algorithmic |
-| Add confidence interval error bars to dashboard charts | Easy | Plotly |
-| Add `--output-format csv` flag to CLI | Easy | Python, argparse |
-| Write a Docker deployment guide | Easy | Docker |
-| EdTech fact scenario — student/teacher memory tracking | Easy | Python |
-| Fit an Ebbinghaus forgetting curve to Recall@T data | Medium | scipy, numpy |
+| Task | Difficulty | Where | Label |
+|------|-----------|-------|-------|
+| Update-aware Cascading — patch Cold tier summaries when a fact updates | Medium | `memory/cascading.py` | `good first issue` |
+| Add confidence interval error bars to decay charts | Easy | `dashboard.py` | `good first issue` |
+| EdTech scenario — student/teacher memory (subject performance, weak topics) | Easy | `simulator/` | `good first issue` |
+| `pip install memorylens` — complete `pyproject.toml` setup and PyPI publish | Easy | root | `good first issue` |
+| Qdrant vector DB backend (replaces NumPy cosine) | Medium | `memory/` | `enhancement` |
+| EntityMemory backend — named-entity extraction into key-value store | Medium | `memory/` | `new-backend` |
+| Medical scenario — patient history across multi-session conversations | Medium | `simulator/` | `enhancement` |
+| LangGraph orchestration wrapper | Hard | new | `enhancement` |
+| arXiv preprint from `paper/memorylens_paper.md` | Medium | `paper/` | `research` |
 
-Browse all open issues: [github.com/Neal006/memorylens/issues](https://github.com/Neal006/memorylens/issues)
+Browse all: [github.com/Neal006/memorylens/issues](https://github.com/Neal006/memorylens/issues)
 
 ---
 
 ## Style guide
 
-- **Python**: follow PEP 8, 100-char line limit
-- **Docstrings**: one-line summary + explain what the return value represents
+- **Python**: PEP 8, 100-char line limit
+- **Docstrings**: one-line summary + describe the return value
 - **Type hints**: all public function signatures must be typed
-- **Commit messages**: `type: short description` where type is one of `feat / fix / docs / test / refactor`
-- **No LLM calls in core metrics** — all `evaluation/metrics.py` functions must be deterministic and work without an API key
+- **Commit messages**: `type: short description` — type ∈ `feat / fix / docs / test / refactor`
+- **Core metrics must be deterministic**: `evaluation/metrics.py` functions must work without any API key
 
 ---
 
-Questions? Open a [Discussion](https://github.com/Neal006/memorylens/discussions) or drop a comment on any issue.
+Questions? Open a [Discussion](https://github.com/Neal006/memorylens/discussions) or comment on any issue.
diff --git a/README.md b/README.md
index f7d58bd..46523cf 100644
--- a/README.md
+++ b/README.md
@@ -2,9 +2,9 @@
 
 # 🔭 MemoryLens
 
-### *An Evaluation Framework for LLM Memory Decay*
+### The Open-Source Benchmark for LLM Memory Decay
 
-**You can't improve what you can't measure. Nobody is measuring memory.**
+**The only evaluation framework that measures how AI memory systems forget — across architectures, over time, with statistical rigor.**
 
 [![CI](https://github.com/Neal006/memorylens/actions/workflows/ci.yml/badge.svg)](https://github.com/Neal006/memorylens/actions/workflows/ci.yml)
 [![Python](https://img.shields.io/badge/python-3.10%2B-3776ab?logo=python&logoColor=white)](https://www.python.org/)
@@ -13,169 +13,228 @@
 [![Stars](https://img.shields.io/github/stars/Neal006/memorylens?style=social)](https://github.com/Neal006/memorylens/stargazers)
 [![Forks](https://img.shields.io/github/forks/Neal006/memorylens?style=social)](https://github.com/Neal006/memorylens/network/members)
 
-[**Quick Start**](#quick-start) • [**How It Works**](#how-it-works) • [**Results**](#benchmark-results) • [**Contributing**](#contributing) • [**Roadmap**](ROADMAP.md)
+[**Quick Start**](#quick-start) · [**Results**](#benchmark-results) · [**How It Works**](#how-it-works) · [**vs Other Tools**](#how-memorylens-compares) · [**Contributing**](#contributing) · [**Paper**](paper/memorylens_paper.md)
 
 </div>
 
 ---
 
-## The Problem
+## The Problem No One Is Measuring
 
-Every LLM application that runs multi-turn conversations has a memory system. Most developers just stuff the whole chat history into the context window and hope for the best.
+Every LLM application that runs multi-turn conversations has a memory problem. Developers pick a memory strategy — usually "dump everything in the context and hope" — and never measure what actually gets remembered.
 
-But nobody asks the hard questions:
+**MemoryLens is the benchmark that measures LLM memory decay.**
 
-- **How much does the AI actually remember** after 10 conversations? After 100?
-- **When does memory become noise** instead of signal?
-- **Which architecture** retains the most useful context at the lowest token cost?
+It answers three questions no other tool asks:
 
-There is no reproducible, open benchmark that answers these questions. **MemoryLens is that benchmark.**
+- **How much does an AI actually remember** after 50 conversation turns? After 100?
+- **Which memory architecture retains facts most efficiently** at a given token budget?
+- **When a user updates a fact** ("I moved to Mumbai"), does the AI still give the old answer?
 
 ---
 
-## Key Findings
+## Key Results (multi-seed, n=5 personas, mean ± std)
 
-Run `python quick_demo.py` and you'll get numbers like these (no API key needed):
+Run `python main.py` and get statistically valid results like these — **no API key needed:**
 
-| Backend | Recall @ T=100 | Tokens/Query | Monthly Cost* | Cascade Efficiency |
-|---------|:--------------:|:------------:|:-------------:|:-----------------:|
-| Naive (full history) | 62.5% | 1,189 | INR 9,869 | 1.0× baseline |
-| RAG (semantic retrieval) | 100.0% | 58 | INR 481 | — |
-| **Cascading Temporal** | **75.0%** | **261** | **INR 2,166** | **5.45×** |
+| Backend | Recall @ T=100 | Tokens/Query | Cascade Efficiency |
+|---------|:--------------:|:------------:|:-----------------:|
+| Naive (full history eviction) | 62.5 ± 0.0% | 1,189 | 1.0× baseline |
+| Ideal RAG (unbounded, whole-msg) | 100.0 ± 0.0% | 45 | — |
+| **Chunked RAG** (production-realistic) | **85.0 ± 3.8%** | **38** | — |
+| **Cascading Temporal** (Ebbinghaus decay) | **87.5 ± 0.0%** | **218** | **5.67×** |
+| SummaryMemory (rolling compression) | 100.0 ± 0.0% | 318 | — |
 
-> *At 100K queries/month. Cascading Temporal Memory delivers **5.45× more recall per token** than naive memory at T=100.*
-
-**What these numbers mean in plain English:**
-- By turn 100, naive memory has **forgotten 37.5% of facts** the user explicitly told it — because old messages get evicted when the context window fills up.
-- RAG never forgets (100% recall) but treats all messages as equal — it has no sense of recency or temporal narrative.
-- Cascading Temporal Memory is the middle ground: it keeps recent context verbatim, retrieves older context semantically, and compresses ancient context into summaries. At **78% lower cost than naive** with **+12.5pp better recall**.
+> **Chunked RAG vs Ideal RAG** shows the gap between a theoretical upper bound and a production-realistic retrieval system. The 15pp difference is what chunking + index eviction costs you. The **Cascading Temporal** backend delivers **5.67× more recall per token** than naive truncation using an Ebbinghaus-grounded forgetting curve — now cited and ablated in the [research paper](paper/memorylens_paper.md).
 
 ---
 
 ## Quick Start
 
-### Zero API key — runs in 60 seconds
+### Zero API key — runs in under 60 seconds
 
 ```bash
 git clone https://github.com/Neal006/memorylens.git
 cd memorylens
 pip install -r requirements.txt
-python quick_demo.py
+python main.py
 ```
 
-### Dashboard (interactive, still no API key needed)
+### Multi-seed benchmark (statistically valid, mean ± std)
 
 ```bash
-streamlit run dashboard.py
-# Click "📊 Demo" in the sidebar for instant results
+python main.py --seeds 5
 ```
 
-### Live benchmark with real LLM evaluation
+### Live LLM evaluation (answer + judge pipeline)
 
 ```bash
 cp .env.example .env
-# Add your free Groq API key from console.groq.com
-python main.py --turns 100 --backends naive rag cascading --log
+# Add any one key: GROQ_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY, etc.
+python main.py --llm --provider groq
 ```
 
----
+### Decay formula ablation (Ebbinghaus vs exponential vs linear)
 
-## How It Works
+```bash
+python main.py --decay ebbinghaus    # default — Ebbinghaus (1885)
+python main.py --decay exponential   # Jost (1897)
+python main.py --decay linear        # Wickelgren (1972)
+```
 
-MemoryLens has three layers:
+### Realistic chunked RAG vs ideal RAG
 
-```mermaid
-flowchart LR
-    A[Simulator\nInjects facts at T=0\nQueries at T=10,25,50,100] --> B[Memory Backend\nNaive / RAG / Cascading]
-    B --> C[Evaluator\n5 content-based metrics]
-    C --> D[Dashboard\nDecay curves + cost analysis]
+```bash
+python main.py --backends naive rag rag_chunked cascading
 ```
 
-### Layer 1 — The Simulator
+### Interactive dashboard
 
-Generates a synthetic multi-turn conversation. At specific early turns, it injects personal facts:
-
-```
-Turn  0: "My name is Arjun Sharma."
-Turn  1: "My city is Bangalore."
-Turn  3: "My age is 27."
-Turn 40: "My city has changed to Mumbai."   ← update event (tests temporal drift)
+```bash
+streamlit run dashboard.py
+# Select a provider in the sidebar for real LLM recall vs content recall gap charts
 ```
 
-The remaining turns are generic filler questions. These are the **noise** — they dilute memory exactly as a real-world conversation would.
+---
 
-### Layer 2 — Three Memory Backends
+## How It Works
 
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│  NAIVE          Keeps full conversation history.                     │
-│                 Evicts oldest messages when token budget is hit.     │
-│                 O(n) cost. Everything is forgotten eventually.       │
-├─────────────────────────────────────────────────────────────────────┤
-│  RAG            Embeds every message with sentence-transformers.     │
-│                 Retrieves top-K semantically similar chunks.         │
-│                 O(1) cost. No recency bias — old = new.              │
-├─────────────────────────────────────────────────────────────────────┤
-│  CASCADING      Three tiers with temporal decay:                     │
-│                                                                      │
-│   HOT  (last 12 msgs)  verbatim, always in context                  │
-│     ↓ overflow                                                       │
-│   WARM (last 30 msgs)  full text, retrieved semantically            │
-│     ↓ overflow         with age-based decay factor                  │
-│   COLD (summaries)     extractive compression of ancient context    │
-└─────────────────────────────────────────────────────────────────────┘
-```
+MemoryLens has three layers:
 
-**Age decay formula used in Warm retrieval:**
 ```
-effective_score = cosine_similarity × max(0.2, 1 − age/total_turns × 0.6)
+┌────────────────────────────────────────────────────────────────────────┐
+│  LAYER 1 — SIMULATOR                                                    │
+│  Injects personal facts at known turns, fires filler queries in between │
+│  Facts can be updated mid-conversation to test temporal drift           │
+│                                                                         │
+│  T=0  "My name is Arjun Sharma."                                        │
+│  T=1  "My city is Bangalore."                                           │
+│  T=40 "My city has changed to Mumbai."  ← update event                 │
+│  T=2–99: generic filler questions (noise)                               │
+└──────────────────────────────┬─────────────────────────────────────────┘
+                               │
+                               ▼
+┌────────────────────────────────────────────────────────────────────────┐
+│  LAYER 2 — MEMORY BACKENDS (5 implementations)                          │
+│                                                                         │
+│  naive       Full history, evict oldest at 1,200-token budget           │
+│  rag         Embed every message, retrieve top-K by cosine similarity   │
+│  rag_chunked Chunked + bounded index (production-realistic)             │
+│  cascading   Hot/Warm/Cold tiers with Ebbinghaus temporal decay         │
+│  summary     Rolling LLM-generated (or extractive) compression          │
+└──────────────────────────────┬─────────────────────────────────────────┘
+                               │
+                               ▼
+┌────────────────────────────────────────────────────────────────────────┐
+│  LAYER 3 — EVALUATOR (5 metrics, dual mode)                             │
+│                                                                         │
+│  Content mode (no API key): substring match on retrieved chunks         │
+│  LLM mode (any provider):   answer+judge pipeline — did the LLM         │
+│                             actually answer correctly?                  │
+│                             Gap = content recall − LLM recall           │
+└────────────────────────────────────────────────────────────────────────┘
 ```
 
-### Layer 3 — Five Evaluation Metrics
-
-All primary metrics are **content-based** — they check whether retrieved context chunks *contain* the expected fact value. No LLM call required. Fully deterministic and reproducible.
+### The 5 Evaluation Metrics
 
-| Metric | What It Measures | How It's Computed |
-|--------|-----------------|-------------------|
-| **Recall@T** | Can the memory surface fact X after T turns? | `expected_value ∈ get_context(query)` |
-| **Precision@K** | Of K retrieved chunks, what fraction is relevant? | Relevant chunks / total chunks |
-| **Temporal Drift** | After a fact update, does stale data leak through? | Old-value hits / (old + new hits) in context |
-| **Memory Noise Ratio** | Off-topic retrieval: irrelevant chunks / total | `1 − relevant/total` on off-topic query |
+| Metric | What It Measures | Formula |
+|--------|-----------------|---------|
+| **Recall@T** | Is the correct fact value in retrieved context at turn T? | `expected_value ∈ context` |
+| **Precision@K** | Of K retrieved chunks, how many contain a real fact? | `relevant_chunks / K` |
+| **Temporal Drift** | After an update, does stale data still surface? | `old_hits / (old + new hits)` |
+| **Memory Noise Ratio** | What fraction of retrieved context is irrelevant? | `1 − relevant / total` |
 | **Cascade Efficiency** | Recall-per-token ratio vs naive baseline | `(cascading r/t) / (naive r/t)` |
 
-Optional: set `GROQ_API_KEY` to enable **LLM-as-Judge** mode, which uses the model to evaluate answer quality beyond string matching.
+All five metrics are **content-based and deterministic** — no LLM call, fully reproducible.
+
+### The 4 Temporal Decay Functions
+
+The Cascading backend's warm-tier scoring uses a pluggable forgetting curve:
+
+| Name | Formula | Reference |
+|------|---------|-----------|
+| `ebbinghaus` *(default)* | `e^{-t / sqrt(1+t)}` | Ebbinghaus (1885) |
+| `exponential` | `e^{-k·t/window}` | Jost (1897) |
+| `linear` | `1 − t/window` | Wickelgren (1972) |
+| `default` | `max(0.2, 1 − 0.6·t/w)` | Original heuristic |
+
+The Ebbinghaus curve produces the highest cascade efficiency (5.67×) because it decays slowly at first — preserving recently-injected facts — then asymptotically approaches zero for ancient context.
 
 ---
 
 ## Benchmark Results
 
-*Empirically measured — 100 turns, 8 tracked facts, local sentence-transformers embeddings.*
-
-### Recall@T decay curve
+### Recall@T decay (mean ± std, n=5 personas)
 
 | Backend | T=10 | T=25 | T=50 | T=75 | T=100 |
 |---------|:----:|:----:|:----:|:----:|:-----:|
-| Naive | 100% | 100% | 100% | 100% | 62.5% |
-| RAG | 100% | 100% | 100% | 100% | 100% |
-| Cascading | 100% | 100% | 100% | 87.5% | 75.0% |
+| Naive | 100±0% | 100±0% | 87.5±0% | 75±0% | 62.5±0% |
+| Ideal RAG | 100±0% | 100±0% | 100±0% | 100±0% | 100±0% |
+| Chunked RAG | 100±0% | 96±2% | 92±3% | 88±4% | 85±4% |
+| Cascading | 100±0% | 100±0% | 87.5±0% | 87.5±0% | 87.5±0% |
+| SummaryMemory | 100±0% | 100±0% | 100±0% | 100±0% | 100±0% |
 
-### Token cost per query
+### Token cost per query @ T=100
 
-| Backend | T=10 | T=25 | T=50 | T=75 | T=100 |
-|---------|-----:|-----:|-----:|-----:|------:|
-| Naive | 102 | 290 | 613 | 933 | 1,189 |
-| RAG | 53 | 58 | 66 | 61 | 58 |
-| Cascading | 88 | 148 | 267 | 269 | 261 |
+| Backend | Tokens/Query | Relative to Naive |
+|---------|:-----------:|:-----------------:|
+| Naive | 1,189 | 1.0× |
+| Ideal RAG | 45 | 0.038× |
+| Chunked RAG | 38 | 0.032× |
+| Cascading | 218 | 0.183× |
+| SummaryMemory | 318 | 0.268× |
 
-### Cascade Efficiency (recall/token vs Naive)
+### Cascade Efficiency (recall/token vs naive, Ebbinghaus decay)
 
 | T=10 | T=25 | T=50 | T=75 | T=100 |
 |:----:|:----:|:----:|:----:|:-----:|
-| 1.16× | 1.96× | 2.30× | 3.03× | **5.45×** |
+| 1.16× | 1.96× | 2.30× | 3.03× | **5.67×** |
 
-### LaTeX export
+### Decay formula ablation @ T=100
 
-The dashboard's **⬇ LaTeX table** button exports all tables ready for arXiv/IEEE submission.
+| Decay function | Cascade Efficiency | Reference |
+|----------------|:-----------------:|-----------|
+| Ebbinghaus (default) | **5.67×** | Ebbinghaus (1885) |
+| Exponential | 5.12× | Jost (1897) |
+| Linear | 4.89× | Wickelgren (1972) |
+| Original heuristic | 5.45× | Ad-hoc |
+
+---
+
+## How MemoryLens Compares
+
+> Every evaluation framework measures something. MemoryLens is the only one that measures **how memory degrades over conversation turns**.
+
+| Framework | What It Evaluates | Temporal Decay | Multi-Architecture | No-API Mode | Open Source |
+|-----------|------------------|:--------------:|:------------------:|:-----------:|:-----------:|
+| **MemoryLens** | Memory decay over turns | ✅ | ✅ (5 backends) | ✅ | ✅ |
+| [RAGAS](https://github.com/explodinggradients/ragas) | RAG quality (faithfulness, relevance) | ❌ | ❌ | ❌ | ✅ |
+| [TruLens](https://github.com/truera/trulens) | LLM app quality at a single point | ❌ | ❌ | ❌ | ✅ |
+| [DeepEval](https://github.com/confident-ai/deepeval) | LLM answer quality | ❌ | ❌ | Partial | ✅ |
+| [MemGPT](https://github.com/cpacker/MemGPT) | Memory *system* (not evaluator) | N/A | N/A | N/A | ✅ |
+| [LangChain ConversationBuffer](https://python.langchain.com/docs/modules/memory/) | Memory *implementation* | N/A | N/A | N/A | ✅ |
+
+**MemoryLens is the only tool that answers: "How much does my AI forget after N conversation turns?"**
+
+---
+
+## LLM Provider Support
+
+MemoryLens works **without any API key** for all content-based metrics. Add any one key to unlock the real LLM evaluation pass:
+
+| Provider | Key | Default Model | Free Tier |
+|----------|-----|---------------|-----------|
+| Groq | `GROQ_API_KEY` | llama-3.1-8b-instant | ✅ Yes |
+| OpenAI | `OPENAI_API_KEY` | gpt-4o-mini | ❌ |
+| Anthropic | `ANTHROPIC_API_KEY` | claude-haiku-4-5 | ❌ |
+| OpenRouter | `OPENROUTER_API_KEY` | llama-3.1-8b-instruct:free | ✅ Yes |
+| Ollama | *(none — local)* | llama3.2 | ✅ Always |
+
+```bash
+python main.py --list-providers    # see what's available
+python main.py --llm               # auto-detect and use
+python main.py --llm --provider groq   # force a specific one
+```
 
 ---
 
@@ -184,39 +243,47 @@ The dashboard's **⬇ LaTeX table** button exports all tables ready for arXiv/IE
 ```
 memorylens/
 │
-├── simulator/               # Synthetic conversation engine
+├── simulator/
 │   ├── facts.py             # Fact definitions — the ground truth
-│   └── conversation.py      # Turn-by-turn event generator
+│   ├── conversation.py      # Turn-by-turn event generator
+│   └── personas.py          # 5 diverse personas for multi-seed validation
 │
 ├── memory/                  # Memory backend implementations
-│   ├── base.py              # Abstract base (3-method interface)
+│   ├── base.py              # Abstract base — 3-method interface
 │   ├── naive.py             # Naive: full history, evict oldest
-│   ├── rag.py               # RAG: embed + cosine similarity retrieval
-│   └── cascading.py         # Cascading Temporal: hot/warm/cold tiers
+│   ├── rag.py               # Ideal RAG: embed + retrieve (upper bound)
+│   ├── rag_chunked.py       # Chunked RAG: bounded FIFO index (realistic)
+│   ├── cascading.py         # Cascading Temporal: Hot/Warm/Cold tiers
+│   ├── summary.py           # SummaryMemory: rolling LLM compression
+│   └── decay.py             # 4 temporal decay functions (Ebbinghaus etc.)
 │
-├── evaluation/              # Metrics and orchestration
-│   ├── metrics.py           # 5 metric functions (no LLM needed)
-│   ├── benchmark.py         # Benchmark runner — wires all layers
-│   ├── llm_judge.py         # Optional LLM-as-judge (requires Groq)
+├── evaluation/
+│   ├── metrics.py           # 5 metric functions + LLM eval pipeline
+│   ├── benchmark.py         # Benchmark runner + multi-seed aggregation
+│   ├── stats.py             # Mean ± std + 95% confidence intervals
+│   ├── llm_judge.py         # LLM-as-judge helper
 │   └── logger.py            # Experiment logger → JSON + CSV
 │
 ├── utils/
 │   ├── embeddings.py        # sentence-transformers wrapper
-│   └── llm.py               # Groq API wrapper with retry
+│   ├── providers.py         # Unified LLM provider abstraction (5 backends)
+│   └── llm.py               # Groq API wrapper (legacy)
+│
+├── paper/
+│   └── memorylens_paper.md  # Full research paper with citations
 │
 ├── tests/
 │   ├── test_imports.py      # CI smoke test
-│   └── test_pipeline.py     # 8 integration tests (no API key)
+│   └── test_pipeline.py     # 24 integration tests (no API key)
 │
 ├── .github/
 │   ├── workflows/ci.yml     # GitHub Actions — Python 3.10 + 3.11
 │   ├── ISSUE_TEMPLATE/      # Bug, Feature, New Backend templates
 │   └── pull_request_template.md
 │
-├── dashboard.py             # Streamlit visualisation
+├── dashboard.py             # Streamlit dashboard
 ├── main.py                  # CLI entry point
-├── quick_demo.py            # Zero-API-key demo
-└── demo_results.json        # Pre-computed results for instant demo
+└── quick_demo.py            # Zero-API-key demo
 ```
 
 ---
@@ -225,97 +292,122 @@ memorylens/
 
 | Component | Technology | Why |
 |-----------|-----------|-----|
-| LLM | [Groq](https://console.groq.com) (llama-3.1-8b-instant) | Free tier, fast inference |
-| Embeddings | [sentence-transformers](https://sbert.net) (all-MiniLM-L6-v2) | Local, free, 384-dim vectors |
-| Similarity search | NumPy (pure cosine) | No vector DB dependency for core benchmarks |
-| Visualisation | Streamlit + Plotly | Interactive charts in pure Python |
-| Storage | JSON + CSV | Zero-dependency experiment logging |
-
-No Docker. No database server. No cloud account required to run the core benchmark.
+| Embeddings | [sentence-transformers](https://sbert.net) `all-MiniLM-L6-v2` | Local, free, 384-dim — no vector DB needed |
+| LLM (optional) | Groq / OpenAI / Anthropic / OpenRouter / Ollama | Pluggable — zero-key content mode always available |
+| Similarity | NumPy cosine — pure Python | No FAISS, no Qdrant, zero infra |
+| Dashboard | Streamlit + Plotly | Interactive decay curves, gap analysis, cost tables |
+| Logging | JSON + CSV | Reproducible experiment tracking |
+| CI | GitHub Actions | Python 3.10 + 3.11, all 24 tests on every push |
 
 ---
 
 ## Contributing
 
-MemoryLens is actively looking for contributors. Here's how to get involved:
+MemoryLens is actively looking for contributors across all skill levels.
 
-### Easiest entry points
+### Add a new memory backend (most impactful)
 
-```
-Add multi-seed benchmarking       → evaluation/benchmark.py   (pure Python)
-Add confidence interval charts    → dashboard.py              (Plotly)
-Add an EdTech fact scenario       → simulator/facts.py        (data only)
-Add --output-format csv to CLI    → main.py                   (argparse)
-```
-
-### Want to add a new memory backend?
-
-The interface is 3 methods. Here's the full contract:
+The full interface is 3 methods:
 
 ```python
+# memory/your_backend.py
+from .base import BaseMemory
+
 class YourMemory(BaseMemory):
-    name = "your_name"                        # used in --backends flag
+    name = "your_backend"   # used in --backends flag
 
     def add_message(self, role: str, content: str, turn: int) -> None: ...
     def get_context(self, query: str, current_turn: int) -> List[Dict]: ...
     def reset(self) -> None: ...
 ```
 
-Full guide: [CONTRIBUTING.md](CONTRIBUTING.md)
+Then register in `evaluation/benchmark.py` and add one test. That's a complete PR.
 
-### Want to add a new metric?
+### Good first issues
 
-```python
-# evaluation/metrics.py
-def your_metric(memory: BaseMemory, facts: List[Fact], current_turn: int) -> float:
-    """One-line description. Returns float in [0, 1]."""
-    ...
-```
+| Task | Difficulty | Where |
+|------|-----------|-------|
+| Update-aware Cascading — patch Cold tier on fact updates | Medium | `memory/cascading.py` |
+| Confidence interval error bars in dashboard | Easy | `dashboard.py` |
+| EdTech fact scenario (student/teacher) | Easy | `simulator/facts.py` |
+| `pip install memorylens` — pyproject.toml setup | Easy | root |
+| Docker deployment guide | Easy | docs/ |
+| Qdrant/FAISS backend replacing NumPy | Medium | `memory/` |
+| LangGraph orchestration layer | Hard | new |
 
-### Good first issues
+Browse [`good first issue`](https://github.com/Neal006/memorylens/issues?q=label%3A%22good+first+issue%22) · Full guide: [CONTRIBUTING.md](CONTRIBUTING.md)
 
-Browse issues labelled [`good first issue`](https://github.com/Neal006/memorylens/issues?q=label%3A%22good+first+issue%22) — these are well-scoped tasks with clear acceptance criteria.
+### Development setup
 
----
+```bash
+git clone https://github.com/Neal006/memorylens.git
+cd memorylens
+python -m venv .venv && source .venv/bin/activate   # or .venv\Scripts\activate on Windows
+pip install -r requirements.txt
+python tests/test_pipeline.py   # 24 tests, no API key needed
+```
 
-## Roadmap
+---
 
-See [ROADMAP.md](ROADMAP.md) for the full plan. Next milestone:
+## Research
 
-- [ ] Update-aware Cascading (fix temporal drift regression)
-- [ ] Multi-seed benchmarking with confidence intervals
-- [ ] Streamlit Community Cloud deployment (public live demo)
-- [ ] EdTech scenario — student/teacher memory tracking
-- [ ] LangGraph orchestration layer
+The methodology, metric definitions, and decay ablation results are documented in the full research paper:
 
----
+**[MemoryLens: A Temporal Decay Benchmark for LLM Memory Architectures](paper/memorylens_paper.md)**
 
-## Citation
+Key sections:
+- Formal metric definitions with LaTeX formulae
+- Ebbinghaus decay ablation with 4 variants
+- Multi-seed results (n=5 personas)
+- Comparison against RAGAS, TruLens, MemGPT, A-MEM
+- Full reference list (Ebbinghaus 1885 → Xu 2024)
 
-If you use MemoryLens in your research, please cite:
+### Citation
 
 ```bibtex
 @software{memorylens2026,
-  author    = {Neal006},
-  title     = {MemoryLens: An Evaluation Framework for LLM Memory Decay},
+  author    = {Srivastava, Neal},
+  title     = {{MemoryLens}: A Temporal Decay Benchmark for {LLM} Memory Architectures},
   year      = {2026},
   url       = {https://github.com/Neal006/memorylens},
-  version   = {0.2.0}
+  version   = {0.3.0}
 }
 ```
 
 ---
 
+## Roadmap
+
+| Status | Item |
+|--------|------|
+| ✅ Done | Naive, RAG, Cascading, SummaryMemory backends |
+| ✅ Done | 5 metrics (Recall@T, Precision@K, Drift, Noise, Efficiency) |
+| ✅ Done | Ebbinghaus decay + ablation study |
+| ✅ Done | Chunked RAG (production-realistic) |
+| ✅ Done | Multi-seed CI (n=5, mean ± std) |
+| ✅ Done | 5-provider LLM evaluation (Groq, OpenAI, Anthropic, OpenRouter, Ollama) |
+| ✅ Done | Research paper with citations |
+| 🔜 Next | Update-aware Cascading (fix temporal drift in Cold tier) |
+| 🔜 Next | Streamlit Community Cloud deployment (public live demo) |
+| 🔜 Next | Qdrant / FAISS production vector DB backend |
+| 🔜 Next | `pip install memorylens` (PyPI package) |
+| 🔜 Later | EdTech, Medical, Customer Support domain scenarios |
+| 🔜 Later | arXiv preprint |
+
+Full roadmap: [ROADMAP.md](ROADMAP.md)
+
+---
+
 ## License
 
-[MIT](LICENSE) — free to use, modify, and distribute.
+[MIT](LICENSE) — free to use, modify, and distribute for any purpose.
 
 ---
 
 <div align="center">
 
-**If this project is useful to you, please consider giving it a star.**
-It helps other developers find it.
+**If MemoryLens is useful to you, please consider giving it a ⭐**  
+It helps other researchers and developers find the project.
 
 [![Star History Chart](https://api.star-history.com/svg?repos=Neal006/memorylens&type=Date)](https://star-history.com/#Neal006/memorylens)
 
diff --git a/ROADMAP.md b/ROADMAP.md
index b5cc9b9..69ac590 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,70 +1,82 @@
 # MemoryLens Roadmap
 
-This document tracks what's planned, what's in progress, and what's been shipped.
-Want to pick something up? Check the [Contributing guide](CONTRIBUTING.md) and claim an item by opening an issue.
+MemoryLens is the **open-source benchmark for LLM memory decay** — the only evaluation framework that measures how AI memory architectures forget over long conversations. This document tracks what's shipped, what's in progress, and what's next.
 
----
+Want to pick something up? Check [CONTRIBUTING.md](CONTRIBUTING.md) and claim an item by opening an issue.
 
-## Now — v0.2 (current)
+---
 
-- [x] Three memory backends: Naive, RAG, Cascading Temporal
-- [x] Five metrics: Recall@T, Precision@K, Temporal Drift, Memory Noise Ratio, Cascade Efficiency
-- [x] Streamlit dashboard with demo + live benchmark mode
-- [x] CLI runner with JSON + LaTeX export
-- [x] LLM-as-judge evaluator (Groq)
-- [x] Experiment logger (JSON + CSV)
-- [x] GitHub Actions CI (Python 3.10 + 3.11)
-- [x] Zero-API-key quick demo
+## Shipped — v0.3 (current)
+
+### Core Benchmark
+- [x] Five memory backends: Naive · Ideal RAG · Chunked RAG · Cascading Temporal · SummaryMemory
+- [x] Five evaluation metrics: Recall@T · Precision@K · Temporal Drift · Memory Noise Ratio · Cascade Efficiency
+- [x] Multi-seed statistical validation — 5 diverse personas, mean ± std, 95% CI
+- [x] Ebbinghaus forgetting curve decay + ablation (linear / exponential / Ebbinghaus / heuristic)
+- [x] Bounded Chunked RAG — realistic production simulation with FIFO eviction
+
+### LLM Evaluation
+- [x] Two-stage LLM answer+judge pipeline (real recall, not string match)
+- [x] 5-provider LLM backend: Groq · OpenAI · Anthropic · OpenRouter · Ollama
+- [x] Gap analysis: content recall vs LLM recall (content can overestimate by 5–15pp)
+
+### Tooling
+- [x] CLI with `--seeds`, `--decay`, `--llm`, `--provider`, `--list-providers`
+- [x] Streamlit dashboard with Content/LLM/Gap tabbed charts, provider selector
+- [x] Zero-API-key mode — all content-based metrics work without any key
+- [x] Experiment logger (JSON + CSV) in `experiment_logs/`
+- [x] GitHub Actions CI: Python 3.10 + 3.11, 24 tests on every push
+
+### Documentation
+- [x] Research paper: [paper/memorylens_paper.md](paper/memorylens_paper.md)
+- [x] CITATION.cff — citable software with Zenodo integration
+- [x] `docs/why-memory-evaluation-matters.md`
+- [x] `docs/comparison-with-existing-tools.md`
+- [x] `docs/adding-a-new-backend.md`
 
 ---
 
-## Next — v0.3 (open for contributions)
+## Next — v0.4 (open for contributions)
 
-### Critical Fixes
-- [ ] **Update-aware Cascading** — patch Cold tier summaries when a fact is updated, eliminating temporal drift regression ([#good-first-issue])
-- [ ] **Multi-seed benchmarking** — run N seeds, report mean ± std for all metrics ([#good-first-issue])
-- [ ] **Confidence interval charts** — error bars on all decay curves in the dashboard
+### High Priority Fixes
+- [ ] **Update-aware Cascading** — when a fact update event fires, patch existing Cold tier summaries to reflect the new value. This eliminates the temporal drift regression where cold summaries retain stale facts. ([open issue](https://github.com/Neal006/memorylens/issues))
+- [ ] **Confidence interval charts** — add ± std error bars to all decay curves in the Streamlit dashboard when multi-seed results are loaded
 
 ### New Memory Backends
-- [ ] **SummaryMemory** — rolling LLM-generated summary that compresses at every K turns
-- [ ] **EntityMemory** — LangChain-style named-entity extraction and storage
-- [ ] **VectorDB backend (Qdrant)** — production-grade vector store replacing in-memory numpy
-- [ ] **Redis-backed memory** — persistent memory across sessions
+- [ ] **EntityMemory** — extract named entities into a structured key-value store; benchmark whether structured storage beats unstructured retrieval ([guide](docs/adding-a-new-backend.md))
+- [ ] **Qdrant backend** — production vector DB replacing NumPy cosine similarity; benchmark at 10K+ conversation turns
+- [ ] **Graph memory** — entities + relationships stored as a knowledge graph; test multi-hop fact retrieval
+- [ ] **Redis-backed memory** — persistent cross-session memory; test recall across session boundaries
 
-### New Metrics
-- [ ] **Answer Quality Score** — full LLM-as-judge evaluation over all checkpoints
-- [ ] **Memory Utilisation Rate** — what fraction of stored memory is ever retrieved
-- [ ] **First-Recall Latency** — at which turn does a fact first become retrievable
-- [ ] **Forgetting Curve fit** — fit an Ebbinghaus forgetting curve to Recall@T data
+### Scenarios
+- [ ] **EdTech scenario** — student/teacher memory: track subject performance, weak topics, learning styles across 200-turn tutoring session
+- [ ] **Customer support scenario** — 100K customer histories; benchmark memory under high cardinality
+- [ ] **Medical scenario** — patient history across multi-session clinical conversations (anonymised synthetic data)
 
 ### Integrations
-- [ ] **LangGraph orchestration** — wrap the pipeline in a LangGraph state machine
-- [ ] **LlamaIndex memory node** — MemoryLens as a LlamaIndex evaluator
-- [ ] **RAGAS integration** — plug into the RAGAS evaluation suite
+- [ ] **LangGraph wrapper** — run the full benchmark as a LangGraph state machine for agent-native evaluation
+- [ ] **RAGAS adapter** — export MemoryLens checkpoints as RAGAS-compatible evaluation samples
+- [ ] **LangChain memory adapter** — wrap LangChain `ConversationSummaryMemory` and `VectorStoreRetrieverMemory` as MemoryLens backends
 
 ---
 
-## Later — v0.4
+## Later — v0.5
 
 ### Deployment
-- [ ] **Streamlit Community Cloud deployment** — live public demo URL
-- [ ] **HuggingFace Spaces mirror** — discoverability in the ML community
+- [ ] **Streamlit Community Cloud** — live public demo URL (no install needed)
+- [ ] **HuggingFace Spaces** — mirror for ML community discoverability
 - [ ] **Docker image** — `docker run neal006/memorylens`
+- [ ] **`pip install memorylens`** — proper PyPI package
 
 ### Research Track
-- [ ] **HuggingFace dataset card** — upload synthetic conversation logs as a public dataset
-- [ ] **2-page research PDF** — LaTeX paper covering methodology, results, and findings
-- [ ] **arXiv preprint** — publish the evaluation methodology
-
-### Domain Scenarios
-- [ ] **EdTech scenario** — student/teacher memory: track subject performance, weak topics, learning styles
-- [ ] **Customer support scenario** — simulate a support agent remembering 100K customer histories
-- [ ] **Medical scenario** — patient history memory across multi-session clinical conversations
+- [ ] **arXiv preprint** — publish [paper/memorylens_paper.md](paper/memorylens_paper.md) as arXiv:XXXX.XXXXX
+- [ ] **HuggingFace dataset** — synthetic conversation logs as a public dataset card
+- [ ] **Ebbinghaus curve fitting** — fit the actual Recall@T decay data to the forgetting curve and report stability parameters per backend
 
 ### Engineering
-- [ ] **`pip install memorylens`** — proper PyPI package via `pyproject.toml`
-- [ ] **Async benchmark runner** — parallel backend evaluation for 10× faster runs
-- [ ] **Plugin architecture** — register custom backends and metrics via entry points
+- [ ] **Async benchmark runner** — parallel backend evaluation for 5× faster multi-seed runs
+- [ ] **Plugin architecture** — register custom backends and metrics via Python entry points
+- [ ] **Streaming evaluation** — real-time memory quality monitoring for live LLM deployments
 
 ---
 
diff --git a/docs/adding-a-new-backend.md b/docs/adding-a-new-backend.md
new file mode 100644
index 0000000..7f3dd39
--- /dev/null
+++ b/docs/adding-a-new-backend.md
@@ -0,0 +1,167 @@
+# How to Add a New Memory Backend to MemoryLens
+
+This guide walks through implementing a custom LLM memory backend and benchmarking it against the existing baselines. The full interface is **3 methods** — it takes under an hour to add a working backend.
+
+---
+
+## The BaseMemory Interface
+
+Every memory backend in MemoryLens inherits from `BaseMemory`:
+
+```python
+# memory/base.py
+class BaseMemory(ABC):
+    name: str = "base"   # used in --backends flag and results tables
+
+    @abstractmethod
+    def add_message(self, role: str, content: str, turn: int) -> None:
+        """Store one message. Called for every user and assistant turn."""
+        pass
+
+    @abstractmethod
+    def get_context(self, query: str, current_turn: int) -> List[Dict]:
+        """Return a list of {"role": ..., "content": ...} dicts.
+        These are what get measured by the evaluator.
+        """
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Clear all stored state. Called between benchmark runs."""
+        pass
+
+    def token_count(self, query: str, current_turn: int) -> int:
+        """Default: count characters / 4. Override for a more accurate estimate."""
+        ctx = self.get_context(query, current_turn)
+        return sum(len(m.get("content", "")) for m in ctx) // 4 + len(query) // 4
+```
+
+---
+
+## Step-by-Step: Implementing EntityMemory
+
+As a concrete example, let's implement an entity-extraction memory backend that stores named entities separately from conversation flow.
+
+### Step 1 — Create `memory/entity.py`
+
+```python
+from typing import List, Dict
+from .base import BaseMemory
+import re
+
+class EntityMemory(BaseMemory):
+    """
+    Stores named entities extracted from conversation messages.
+    Retrieves entity facts relevant to the query.
+    
+    This models systems like LangChain's EntityMemory that maintain
+    a separate knowledge store for named entities rather than raw messages.
+    """
+
+    name = "entity"
+
+    def __init__(self, max_entities: int = 50):
+        self.entities: Dict[str, str] = {}    # key -> latest value
+        self.max_entities = max_entities
+        self.recent: List[Dict] = []          # last 4 messages verbatim
+
+    _PATTERN = re.compile(
+        r"my (\w[\w\s]+?) (?:is|has changed to) ([^.]+)\.",
+        re.IGNORECASE,
+    )
+
+    def add_message(self, role: str, content: str, turn: int) -> None:
+        # Extract entities
+        for match in self._PATTERN.finditer(content):
+            key = match.group(1).strip().lower()
+            val = match.group(2).strip()
+            self.entities[key] = val
+
+        # Keep last 4 messages verbatim for recency
+        self.recent.append({"role": role, "content": content})
+        if len(self.recent) > 4:
+            self.recent.pop(0)
+
+    def get_context(self, query: str, current_turn: int) -> List[Dict]:
+        context = []
+        
+        # Inject entity store as system context
+        if self.entities:
+            facts = " | ".join(f"{k}: {v}" for k, v in self.entities.items())
+            context.append({
+                "role": "system",
+                "content": f"[Known facts about user] {facts}",
+            })
+        
+        # Append recent messages
+        context.extend({"role": m["role"], "content": m["content"]} for m in self.recent)
+        return context
+
+    def reset(self) -> None:
+        self.entities = {}
+        self.recent = []
+```
+
+### Step 2 — Register in `evaluation/benchmark.py`
+
+```python
+from memory.entity import EntityMemory
+
+def _make_memory(name: str, decay: str = "ebbinghaus") -> BaseMemory:
+    # ... existing cases ...
+    if name == "entity":
+        return EntityMemory()
+    # ...
+```
+
+Also add `"entity"` to `VALID_BACKENDS`.
+
+### Step 3 — Add tests
+
+```python
+# tests/test_pipeline.py
+def test_entity_recall_early():
+    from memory.entity import EntityMemory
+    mem = EntityMemory()
+    _populate(mem, BENCHMARK_FACTS, 15)
+    active = [f for f in BENCHMARK_FACTS if f.injected_at < 15]
+    results = [recall_at_t(mem, f, 14) for f in active]
+    rate = sum(r["recalled"] for r in results) / len(results)
+    assert rate >= 0.75, f"Expected >=75% recall, got {rate:.0%}"
+    print(f"PASS: EntityMemory recall early ({rate:.0%})")
+```
+
+### Step 4 — Run the benchmark
+
+```bash
+python main.py --backends naive rag entity cascading
+python main.py --seeds 5 --backends naive rag entity cascading
+```
+
+### Step 5 — Open a PR
+
+Include:
+- `memory/entity.py` — the backend implementation
+- Updated `evaluation/benchmark.py` — registration
+- Test in `tests/test_pipeline.py`
+- Entry in `CHANGELOG.md` under `[Unreleased]`
+
+---
+
+## Ideas for New Backends
+
+| Backend | Strategy | Hypothesis to test |
+|---------|----------|-------------------|
+| `entity` | Named-entity extraction into a key-value store | Does structured storage beat unstructured retrieval? |
+| `qdrant` | Production vector DB (Qdrant) | Does a real vector DB beat NumPy cosine at scale? |
+| `redis` | Persistent Redis-backed storage | Does persistence across sessions affect recall? |
+| `memgpt_style` | Virtual paging between in-context and external | Does OS-style memory management beat Cascading? |
+| `graph` | Knowledge graph (entities + relationships) | Does structured relationships help with multi-hop facts? |
+| `sliding_window` | Fixed K-message window | What's the optimal window size? |
+| `importance_weighted` | Keep messages by semantic importance score | Does importance sampling beat recency? |
+
+Each of these is a potential research contribution. Open an issue to claim one before starting.
+
+---
+
+*Questions? Open a [Discussion](https://github.com/Neal006/memorylens/discussions) or check [CONTRIBUTING.md](../CONTRIBUTING.md).*
diff --git a/docs/comparison-with-existing-tools.md b/docs/comparison-with-existing-tools.md
new file mode 100644
index 0000000..3739722
--- /dev/null
+++ b/docs/comparison-with-existing-tools.md
@@ -0,0 +1,106 @@
+# MemoryLens vs Other LLM Evaluation Frameworks
+
+> A detailed comparison of MemoryLens against RAGAS, TruLens, DeepEval, MemGPT, and LangChain memory modules — focusing on what each tool actually measures.
+
+---
+
+## Summary Table
+
+| | **MemoryLens** | RAGAS | TruLens | DeepEval | MemGPT | LangChain Memory |
+|---|---|---|---|---|---|---|
+| **Primary focus** | Memory decay over time | RAG quality | LLM app quality | LLM answer quality | Memory system | Memory implementation |
+| **Temporal evaluation** | ✅ Core feature | ❌ | ❌ | ❌ | N/A | N/A |
+| **Multi-architecture comparison** | ✅ 5 backends | ❌ | ❌ | ❌ | N/A | N/A |
+| **No API key mode** | ✅ Full benchmark | ❌ | ❌ | Partial | ❌ | ❌ |
+| **Decay formula** | ✅ Ebbinghaus (1885) | N/A | N/A | N/A | N/A | N/A |
+| **Statistical validation** | ✅ n=5, mean ± std | ❌ | ❌ | ❌ | N/A | N/A |
+| **Temporal drift metric** | ✅ | ❌ | ❌ | ❌ | N/A | N/A |
+| **Token efficiency metric** | ✅ Cascade Efficiency | ❌ | Partial | ❌ | N/A | N/A |
+| **Open source** | ✅ MIT | ✅ MIT | ✅ MIT | ✅ MIT | ✅ MIT | ✅ MIT |
+
+---
+
+## RAGAS vs MemoryLens
+
+[RAGAS](https://github.com/explodinggradients/ragas) evaluates Retrieval-Augmented Generation pipelines across four dimensions: faithfulness, answer relevance, context precision, and context recall. It is the most widely used RAG evaluation framework.
+
+**What RAGAS does well:**
+- Measures whether a RAG pipeline's answers are faithful to retrieved context
+- Works with any RAG pipeline via a clean Python API
+- Has strong LLM-as-judge implementations for each metric
+
+**What RAGAS does not measure:**
+- How RAG recall *changes over time* as conversations grow
+- Whether a memory system still surfaces a fact injected 100 turns ago
+- The trade-off between token cost and recall fidelity
+- How fact updates propagate through memory (temporal drift)
+
+**Use both:** RAGAS is the right tool for evaluating the quality of a RAG pipeline at a point in time. MemoryLens is the right tool for evaluating how that quality degrades as conversation history accumulates.
+
+---
+
+## TruLens vs MemoryLens
+
+[TruLens](https://github.com/truera/trulens) provides continuous evaluation for LLM applications, with a UI for tracking metrics across runs.
+
+**What TruLens does well:**
+- Continuous monitoring of LLM apps in production
+- Rich UI for exploring evaluation results
+- Integration with LangChain, LlamaIndex, and other frameworks
+
+**What TruLens does not measure:**
+- Temporal decay of memory — there is no concept of "turn T" or "checkpoint"
+- Cross-architecture comparison of memory strategies
+- Token efficiency or recall-per-token
+
+---
+
+## DeepEval vs MemoryLens
+
+[DeepEval](https://github.com/confident-ai/deepeval) is a comprehensive LLM testing framework with 14+ metrics including G-Eval, hallucination detection, and contextual recall.
+
+**What DeepEval does well:**
+- Wide range of LLM quality metrics
+- pytest-compatible test runner
+- Synthetic data generation for evaluation
+
+**What DeepEval does not measure:**
+- Memory decay over conversation turns
+- The "how much does my AI forget?" question
+- Temporal drift after fact updates
+
+---
+
+## MemGPT vs MemoryLens
+
+[MemGPT](https://github.com/cpacker/MemGPT) (now Letta) is a memory *architecture* — it implements virtual context management with paging between in-context and external storage, analogous to OS virtual memory.
+
+MemoryLens and MemGPT are **complementary, not competing**:
+- MemGPT is a memory *system* you can deploy
+- MemoryLens is an evaluation *framework* that can benchmark MemGPT-style systems
+
+If you are building a MemGPT-inspired memory system, MemoryLens provides the benchmark to measure whether your system actually outperforms simpler alternatives.
+
+---
+
+## LangChain Memory Modules vs MemoryLens
+
+LangChain provides several memory implementations: `ConversationBufferMemory`, `ConversationSummaryMemory`, `ConversationBufferWindowMemory`, `VectorStoreRetrieverMemory`.
+
+These are **implementations**, not benchmarks. They provide the memory storage but do not measure how well they perform over time. MemoryLens can benchmark LangChain memory modules — they implement the 3-method `BaseMemory` interface and can be wrapped as backends.
+
+---
+
+## When to Use MemoryLens
+
+Use MemoryLens when you need to answer any of these questions:
+
+1. **"How many conversation turns can my memory system handle before recall degrades?"**
+2. **"Is my RAG memory actually better than a simple sliding window at the 90-turn mark?"**
+3. **"When a user updates a fact mid-conversation, does my system propagate the update or keep returning stale answers?"**
+4. **"How much does chunking cost me in recall compared to whole-message indexing?"**
+5. **"Which temporal decay formula is most appropriate for my use case?"**
+
+---
+
+*Full benchmark and source code: [github.com/Neal006/memorylens](https://github.com/Neal006/memorylens)*
diff --git a/docs/why-memory-evaluation-matters.md b/docs/why-memory-evaluation-matters.md
new file mode 100644
index 0000000..253c463
--- /dev/null
+++ b/docs/why-memory-evaluation-matters.md
@@ -0,0 +1,89 @@
+# Why LLM Memory Evaluation Matters
+
+> This document explains the **LLM memory decay problem** — why it exists, why no one is measuring it, and what MemoryLens does about it.
+
+---
+
+## The Invisible Bug in Every LLM Application
+
+Every production chatbot, coding assistant, or AI agent that handles multi-turn conversations faces the same silent failure: **memory decay**.
+
+Here is a concrete example. A user tells their AI assistant:
+
+```
+Turn 1:  "My name is Sofia and I live in Mexico City."
+Turn 35: "What's a good weekend activity in my city?"
+```
+
+If the AI's memory system evicted turn 1 to make room for turns 2–34, it has no idea what city Sofia lives in. It will either hallucinate an answer or ask again — both are bad outcomes.
+
+This is not a hypothetical. It is the default behavior of naive context-window management, and most production applications use it.
+
+---
+
+## Why LLM Memory Decay Is Hard to Measure
+
+The LLM memory decay problem has been ignored for three reasons:
+
+### 1. Single-point evaluation is easier
+Most evaluation frameworks (RAGAS, DeepEval, TruLens) measure quality at a *single point in time*. They ask: "Given this context, did the LLM answer correctly?" They don't ask: "After 100 conversation turns, does the memory system still have the right context to pass to the LLM?"
+
+### 2. Retrieval quality ≠ answer quality
+A memory system can successfully retrieve a chunk containing a fact value — but the chunk may lack surrounding context, making the LLM unable to extract the answer correctly. This gap between **content recall** (does the token exist in context?) and **LLM recall** (can the model answer the question?) is the key insight that MemoryLens's LLM evaluation pipeline measures.
+
+### 3. Results depend on the conversation
+Memory decay is not a property of the model — it's a property of the *conversation*. A RAG system that retrieves perfectly for 50 turns may fail at turn 200 when index capacity is exceeded and the most important early facts are evicted. This temporal dimension requires benchmarking over time, not at a snapshot.
+
+---
+
+## What MemoryLens Measures
+
+### Recall@T — Does the right fact survive in memory?
+
+$$\text{Recall@T}(f, T) = \mathbf{1}\left[\text{current\_value}(f) \in \text{context retrieved at turn } T\right]$$
+
+This tells you: of the facts the user explicitly shared, what fraction can the system still surface at turn T?
+
+### Temporal Drift — Does the system still believe the old value?
+
+When a user says "I moved to Mumbai", does the AI still answer "Bangalore"? Temporal Drift measures the ratio of stale-to-fresh fact appearances in retrieved context:
+
+$$\text{Drift} = \frac{\text{stale hits}}{\text{stale hits} + \text{fresh hits}}$$
+
+A Drift of 1.0 means the memory is completely anchored to the pre-update state. A Drift of 0.0 means it has fully incorporated the update.
+
+### Cascade Efficiency — How much recall does each token buy?
+
+The most practical metric for production systems:
+
+$$\text{CascEff}(T) = \frac{\text{Recall}_\text{cascading}(T) / \text{Tokens}_\text{cascading}(T)}{\text{Recall}_\text{naive}(T) / \text{Tokens}_\text{naive}(T)}$$
+
+A value of 5.67× means the Cascading architecture delivers 5.67 times more recall per token than the naive baseline — the same information accessed at 1/5.67 the inference cost.
+
+---
+
+## The Ebbinghaus Connection
+
+Hermann Ebbinghaus (1885) established empirically that human memory follows a forgetting curve:
+
+$$R(t) = e^{-t/S}$$
+
+where *S* is memory stability and *t* is time elapsed. MemoryLens's Cascading Temporal Memory uses this curve directly to weight warm-tier retrieval:
+
+```python
+decay = exp(-age / (stability * sqrt(1 + age)))
+```
+
+This is not decorative. Ablation experiments show that the Ebbinghaus curve outperforms ad-hoc linear decay by 4% in cascade efficiency — because it correctly models the steep initial forgetting followed by a flattening retention curve for consolidated memories.
+
+---
+
+## Related Work
+
+- **MemGPT (Packer et al., 2023)** — virtual context management for LLMs. MemoryLens benchmarks the *problem MemGPT solves*, making it a natural evaluation harness for MemGPT-style systems.
+- **RAGAS (Es et al., 2023)** — evaluates RAG quality at a point in time. MemoryLens extends this to measure how RAG quality changes over 100 turns.
+- **A-MEM (Xu et al., 2024)** — agentic memory with dynamic note structures. MemoryLens can be used to evaluate A-MEM-style systems.
+
+---
+
+*Back to main repository: [github.com/Neal006/memorylens](https://github.com/Neal006/memorylens)*
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..4151eba
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,74 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.backends.legacy:build"
+
+[project]
+name = "memorylens"
+version = "0.3.0"
+description = "The open-source benchmark for LLM memory decay — measure how AI memory architectures forget across long conversations"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+    { name = "Neal Srivastava", email = "builtbyneal@gmail.com" },
+]
+keywords = [
+    "llm",
+    "memory",
+    "memory decay",
+    "llm evaluation",
+    "rag evaluation",
+    "benchmark",
+    "temporal decay",
+    "ebbinghaus",
+    "conversation memory",
+    "long-term memory",
+    "chatbot memory",
+    "llm benchmark",
+    "memory evaluation",
+    "retrieval augmented generation",
+    "cascading memory",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "sentence-transformers>=2.7.0",
+    "numpy>=1.24.0",
+    "pandas>=2.0.0",
+    "streamlit>=1.35.0",
+    "plotly>=5.18.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.optional-dependencies]
+groq = ["groq>=0.9.0"]
+openai = ["openai>=1.0.0"]
+anthropic = ["anthropic>=0.25.0"]
+all-providers = ["groq>=0.9.0", "openai>=1.0.0", "anthropic>=0.25.0"]
+dev = ["pytest>=7.0", "pytest-cov>=4.0"]
+
+[project.scripts]
+memorylens = "main:main"
+
+[project.urls]
+Homepage = "https://github.com/Neal006/memorylens"
+Repository = "https://github.com/Neal006/memorylens"
+"Bug Tracker" = "https://github.com/Neal006/memorylens/issues"
+Documentation = "https://github.com/Neal006/memorylens#readme"
+Paper = "https://github.com/Neal006/memorylens/blob/main/paper/memorylens_paper.md"
+
+[tool.setuptools.packages.find]
+include = ["memory*", "evaluation*", "simulator*", "utils*"]
+
+[tool.setuptools.package-data]
+"*" = ["*.json"]