No vectors. No chunking. No blind trust.

Open source · vectorless, on-device RAG

A vectorless, reasoning-based RAG that runs fully on your machine. Drop in your own documents (PDF, Word, Markdown, HTML, text); RagIndex builds a hierarchical "table-of-contents" tree per document that a local LLM reasons over to answer your questions — no vector database, no chunk-embedding store, no API keys, no cloud. Every answer comes with cited sources and a 0–100 confidence score so you know when to trust it (and when the system abstains).

100% on-device. The LLM and the embeddings are served locally by Ollama with small Qwen models. Nothing you upload or ask ever leaves your computer. One setup command installs and configures everything; one run command opens the app.

📊 The benchmark story — same recall as a vector DB, but it knows when it's wrong.

In a controlled run (web-crawled Wikipedia science, 6 docs / 90 chunks, local Ollama), Turing Tree retrieved with the same embeddings as a classic vector database — accuracy@5 = 1.00, identical recall, 0.00 cross-contamination. The edge is a confidence layer a vector DB doesn't have: it abstained on 100 % of off-topic questions (the vector DB answered every one silently and wrongly), with a +79.5 / 100 confidence separation between trustworthy and confused retrievals and zero false-abstentions on real questions. Re-indexing unchanged content is 198× faster via the content-hash cache. → Full method & caveats

flowchart LR
    DOC[("Your documents\nPDF · DOCX · MD · HTML · TXT")] --> UP[upload_socket]
    UP -->|extracted text| PI[pageindex_socket]
    PI --> TREE["reasoning tree\n(per document)"]
    Q(("Your question")) --> RAG[rag_socket]
    TREE --> RAG
    RAG --> ANS["grounded answer\n+ sources + confidence"]

• Bring your own documents — upload files or a whole folder; supported types: PDF, .docx, .md/.markdown, .html/.htm, .txt/.text.
• Vectorless retrieval — PageIndex turns each document into a tree the model navigates by reasoning, not nearest-neighbour vector lookup.
• Confidence you can act on — every answer gets a score + verdict (ANSWER / REVIEW / ABSTAIN) with explainable drivers; off-topic questions are flagged instead of answered wrongly.
• Fast on CPU — defaults to the small qwen2.5:3b-instruct for both indexing and answering, so one model stays resident and answers return quickly.
• One app, one URL — a single local process serves the web UI and the API and opens your browser. Reset the index or resume from a shared bundle anytime.

Two commands set everything up and open the app — no API keys, no cloud, no GPU.

git clone https://github.com/1ssb/TuringTree.git RagIndex && cd RagIndex

# 1) Install everything (venv + deps + PageIndex model + Ollama + local models)
#    Windows ......  powershell -ExecutionPolicy Bypass -File scripts\setup.ps1
#    macOS / Linux .  bash scripts/setup.sh

# 2) Open the app (builds the UI once, then opens http://127.0.0.1:8765)
#    Windows ......  run.bat
#    macOS / Linux .  ./run.sh

Then, in the app, do these three things:

1. Upload sample documents — unzip samples/sample-docs.zip (one of every supported type) and drop the files in; wait for Indexing to finish.
2. Ask an in-document question (e.g. "What is photosynthesis?") → you get a grounded answer with cited sources and a 0–100 confidence badge (verdict ANSWER).
3. Ask an off-topic question (e.g. "Who won the 2018 World Cup?") → instead of guessing, the app abstains (verdict ABSTAIN) and says it isn't covered.

What makes this different from a normal RAG chatbot:

• Vectorless — no vector database; each document becomes a reasoning tree the LLM navigates, so retrieval is by reasoning, not nearest-neighbour lookup.
• It knows when it's wrong — every answer carries a confidence score, and off-topic questions are abstained rather than answered incorrectly. In our benchmark: 0% silently-wrong answers vs 100% for a classic vector DB, at the same retrieval accuracy.
• 100% on-device — local Qwen models via Ollama; nothing you upload or ask ever leaves the machine.

No Python on the machine? A packaged, double-click Windows app (no Python needed) is described in docs/desktop.md. Hit a snag? See Troubleshooting.

• Prerequisites
• Install (one command)
• Run the app (one command)
• Using the app
• Local models (Ollama + Qwen)
• Configuration reference
• Reproducibility
• Data, privacy & storage locations
• Developer workflows
• HTTP API reference
• Troubleshooting
• The "socket" architecture
• Retrieval confidence scoring
• Benchmarks vs a vector-DB baseline
• Validation & tests
• Bundled dataset & branch indexing
• Project layout
• Team
• License & attribution

You do not need any API keys or a GPU. Plan for roughly 3–4 GB of disk for the default local models (qwen2.5:3b-instruct ≈ 2 GB + qwen3-embedding:0.6b ≈ 0.6 GB) and 8 GB+ RAM for comfortable CPU inference.

# 1. Get the repository
git clone https://github.com/1ssb/TuringTree.git RagIndex
cd RagIndex

# 2. One command does everything (idempotent — safe to re-run):
#      - creates .venv and installs Python deps (root + backend)
#      - seeds .env from .env.example
#      - clones the PageIndex model and pins it to a known-good commit
#      - installs the frontend's Node deps (npm install)
#      - installs Ollama, starts it, and pulls the pinned local models

Useful setup flags (any OS): --skip-ollama (don't install/start Ollama), --skip-models (set up Ollama but skip the model pulls). Re-running setup never re-downloads what already exists.

After setup, launch the desktop app. It builds the web UI the first time, then serves the UI and the API from a single local process and opens your browser at http://127.0.0.1:8765.

Flags are passed straight through to the launcher:

python scripts/run.py --no-browser     # serve without opening a browser (CI/servers)
python scripts/run.py --port 8765      # pin a specific port

Press Ctrl+C to stop. That's the whole story: setup once, then run.

1. Upload — on the Index your documents screen, click Browse files (pick one or many files) or a whole folder, or drag-and-drop. Supported types: PDF, .docx, .md/.markdown, .html/.htm, .txt/.text. Don't have anything handy? Use the bundled samples in samples/ — including samples/sample-docs.zip (one of every supported type) — unzip and drop them in.
2. Indexing — the app shows an explicit Uploaded → Indexing transition and a live progress bar while it builds a reasoning tree per document with the local model. This is the slow step on CPU; subsequent re-indexes of unchanged content are near-instant thanks to the content-hash cache.
3. Chat — ask questions in plain English. Each answer is grounded in your documents, cites the source documents it used, and carries a confidence badge. Click the badge to expand the drivers (Focus, Cohesion, Consistency) and the reasoning behind the verdict.
4. Trust the verdict — a high score means answer; a low score means the app abstains rather than guess. Off-topic questions (not covered by your documents) are flagged, not answered wrongly.
5. Reset the index — open Settings (bottom-left) → Reset index to clear every indexed document and start fresh (your chat history is kept). You're taken back to the upload screen to build a new index.
6. Share / resume — export a self-contained bundle of your conversation (and optionally the index) and Resume from bundle later or on another machine.

Everything is served by a local Ollama runtime, so the project works completely offline once set up. The exact models are pinned in ollama-models.txt so every machine runs the same thing:

PageIndex and the chat path reach the model through LiteLLM with the ollama_chat/... provider; embeddings use the ollama/... provider — both point at your local server (OLLAMA_HOST, default http://localhost:11434). No request ever leaves your machine.

Prefer higher-quality answers? Pull the 7B and point chat at it:

ollama pull qwen2.5:7b-instruct
# then run with:
RAGINDEX_CHAT_TAG=qwen2.5:7b-instruct python scripts/run.py

Want different models entirely? Change the tags in both ollama-models.txt and config.py (OLLAMA_CHAT_TAG / OLLAMA_EMBED_TAG), then re-run setup.

Every setting lives in config.py and can be overridden with an environment variable (or a git-ignored .env — copy .env.example). No API keys are ever required. The knobs you're most likely to touch:

RagIndex is designed so any machine reproduces the same environment and behaviour:

• Idempotent setup — scripts/setup.* is safe to re-run; it only fetches what's missing.

• Pinned model — the vendored PageIndex is cloned and pinned to a known-good commit (override with RAGINDEX_PAGEINDEX_REF), so the engine is identical everywhere.

• Pinned local models — exact Qwen tags are listed in ollama-models.txt and pulled by setup.

• Deterministic generation — all model calls run at temperature 0.

• Offline by default — a bounded dataset sample is committed in-repo, so no network is needed at run time.

• Tested — install the dev deps and run the suite:

  pip install -r requirements-dev.txt
  python -m pytest -q                 # full backend + sockets suite
  python tests/test_score_api.py      # confidence-scorer contract tests

Nothing you upload or ask ever leaves your computer — the models run locally and the API binds to 127.0.0.1 only. The index, caches, uploads, and audit log are written to a per-user data directory:

(Running from source without the launcher — e.g. scripts/dev.py — uses ./data instead.) Point RAGINDEX_DATA_DIR anywhere to relocate all of it at once. To wipe the index, use Settings → Reset index in the app (or POST /api/index/reset); deleting the data directory clears everything.

With the venv and frontend deps installed, run the backend and frontend together (Ctrl-C stops both):

python scripts/dev.py        # backend :8000 (FastAPI, /docs)  +  frontend :5173 (Vite)

The repo ships a full containerised stack — Ollama + FastAPI backend + nginx-served frontend. A one-shot ollama-pull service downloads the models automatically and healthchecks gate the startup order (ollama → models pulled → backend → frontend), so the first run is turnkey.

Step 1 — Install Docker (bundles Docker Compose v2):

Verify with docker --version and docker compose version.

Step 2a — Run on CPU (works everywhere, no GPU needed):

docker compose up -d --build
# first run pulls ~3 GB of models, then open http://localhost:5173

Step 2b — Run on GPU (NVIDIA, optional, much faster inference). Install these in order, then use the GPU override file:

1. NVIDIA GPU driver — nvidia.com/Download (Windows) or your distro's package (Linux). Confirm with nvidia-smi.
2. Windows only: enable WSL2 and use Docker Desktop's WSL2 backend — the GPU passes through automatically (CUDA on WSL guide).
3. NVIDIA Container Toolkit — install guide (Linux hosts; on Windows it comes with Docker Desktop's WSL2 GPU support).

docker compose -f docker-compose.yml -f docker-compose.gpu.yml up -d --build
docker compose exec ollama nvidia-smi   # confirm the GPU is visible in-container

Manage the stack:

docker compose logs -f     # follow logs
docker compose ps          # services + health status
docker compose down        # stop (keeps the model/data volumes)
docker compose down -v     # stop and delete the ollama + ragdata volumes

Configure ports and models with a .env file (copy from .env.example): FRONTEND_PORT, BACKEND_PORT, OLLAMA_PORT, RAGINDEX_CHAT_TAG, RAGINDEX_EMBED_TAG. Models live in the named ollama volume (pulled once); the index persists in the ragdata volume.

Produce a self-contained app (no Python needed) and a Windows installer:

pip install -r requirements-dev.txt
python scripts/build_desktop.py     # → dist/RagIndex/  (bundles the built UI)

Then package dist/RagIndex/ with Inno Setup using packaging/windows/ragindex.iss. Full build/install/data-location guide: docs/desktop.md.

Building a tree is ~100% local LLM inference (a per-heading summary fan-out plus one document-description call), so RagIndex makes it cheaper out of the box and tunable via env:

• Content-hash cache — section summaries and document descriptions are cached by sha256(model + text) in data/summary_cache.json, so rebuilding unchanged content is near-instant (only new/edited sections reach the model).
• Bounded concurrency — the summary fan-out is capped, since a single Ollama instance thrashes (tail latency + VRAM) past ~4 in-flight calls. Tune with RAGINDEX_INDEX_CONCURRENCY (default 4).
• Small model by default — indexing already uses qwen2.5:3b-instruct; set RAGINDEX_INDEX_CACHE=0 to disable the cache for a cold-build measurement.

python scripts/try_pipeline.py                 # dataset → PageIndex demo (prints a tree)
python scripts/index_branches.py list          # list origin/* branches of the model
python scripts/index_branches.py build         # build the semantic branch index
python scripts/index_branches.py search "markdown tree"   # ask in plain English

When the app is running, interactive docs are at /docs (Swagger UI). The core endpoints (all under /api):

Like a wall socket lets you plug in any appliance without rewiring the house, each module in sockets/ is a thin connector with a simple interface, so the rest of the code never touches the messy details of litellm, PageIndex, or git.

A small, embedding-agnostic scorer that says how much to trust a RAG retrieval — a 0–100 confidence KPI, four explainable drivers, and an actionable verdict (ANSWER / REVIEW / ABSTAIN / ESCALATE), with no extra LLM call and no labels. It analyses the shape of the relevance your query induces over the retrieved passages, plus an absolute topical-grounding check.

from sockets.rag_metrics import score

m = score(query_embedding, passage_embeddings, texts=passages)
m.verdict                 # "ANSWER" | "REVIEW" | "ABSTAIN" | "ESCALATE"
print(m.narrate())        # human-readable, range-based explanation
log(m.to_dict())          # flat JSON contract for dashboards / gating

Try it on real data, or run the broad verification sweep:

python scripts/ask.py "who funds and leads FasterCures?"   # retrieved support + explained scores
python scripts/verify_metrics.py --docs 3 --chunks 500      # docs x query-types, PASS/FAIL
python tests/test_score_api.py                              # 25 contract/invariant/edge tests

Full documentation: docs/confidence_scoring.md — the metrics, the topology behind them, the API + JSON contract, integration, calibration, and limitations.

How does vectorless, confidence‑scored RAG compare to a classic vector database? A reproducible harness (benchmarks/, scripts/benchmark_rag.py) runs both over web‑crawled Wikipedia‑science documents using the same local embeddings, so recall is identical and the comparison isolates the reliability layer.

Headline (6 docs / 90 chunks, top‑k = 5):

python scripts/benchmark_rag.py --docs 6 --per-doc 15 --k 5   # main comparison
python scripts/benchmark_rag.py --scaling 30 60 90            # per‑query latency scaling

Same recall as a vector DB — but it knows when it's wrong. Full method, metrics (cross‑contamination, source entropy, Gini) and results: docs/benchmark.md.

Every push and pull request runs the CI pipeline (.github/workflows/ci.yml):

• Backend — pytest over the socket + API suite (fully mocked; no Ollama or vendored model required).
• Frontend — tsc --noEmit type-check, a vite production build, and the vitest unit suite.
• Containers — the backend and frontend Docker images are built so the stack stays reproducible.

CodeQL scans Python and JavaScript/TypeScript for security issues and Dependabot keeps dependencies patched. Run the same checks locally:

pytest -q                                                # backend
cd frontend && npm ci && npm run build && npm run test   # frontend

Build note. npm run build type-checks the whole src/ tree, including the *.test.tsx files, so the dev dependencies must be present — always npm ci (not --omit=dev) before building.

For the scientific evaluation — same recall as a vector DB, but it abstains on 100% of off-topic questions (a +79.5 / 100 confidence separation) — see Benchmarks vs a vector-DB baseline and docs/benchmark.md.

For demos and the benchmark harness, a bounded sample of the Hugging Face dataset Laz4rz/wikipedia_science_chunked_small_rag_512 (default 30k rows ≈ 13 MB) lives in dataset/, committed directly with Git — small enough that it needs no Git LFS.

• The dataset socket prefers this local file, so the pipeline runs offline. If it's missing (or RAGINDEX_USE_LOCAL_DATASET=0), it falls back to streaming from Hugging Face.

• Regenerate or resize it any time:

  python scripts/make_dataset_sample.py                  # uses the config default
  RAGINDEX_SAMPLE_ROWS=100000 python scripts/make_dataset_sample.py

For a much larger sample, track dataset/*.parquet with Git LFS (git lfs track "*.parquet"). The data derives from Wikipedia (CC BY-SA); keep that attribution if you redistribute it.

1. List every origin/* branch of the cloned PageIndex repo.
2. Profile each branch — a short description from its name, latest commit message, the files it changes vs main, and the top of its README.
3. Embed each profile into a vector (similar meaning → similar numbers).
4. Search by embedding your question the same way and ranking by cosine similarity.

If Ollama is running it uses true semantic embeddings from qwen3-embedding:0.6b; otherwise it falls back to a dependency-free offline embedding. See the heavily-commented sockets/branch_index_socket.py.

RagIndex/  (the desktop app is branded "Turing Tree")
├── run.bat / run.sh           # open the app in one step (after setup)
├── config.py                  # one control panel for every setting
├── ollama-models.txt          # exact local Qwen models pulled by setup
├── requirements*.txt          # runtime deps (+ requirements-dev.txt for tests/build)
├── .env.example               # optional local overrides (NO API keys needed)
├── backend/app/               # FastAPI app (routers: health, chat/index, ingest, …)
├── frontend/                  # React + Vite web UI (built to frontend/dist)
├── desktop/launcher.py        # serve UI + API as one local app, open the browser
├── sockets/                   # the integration layer (see "socket architecture")
├── scripts/
│   ├── setup.sh / .ps1 / .bat / .py   # one-command, cross-platform setup
│   ├── run.py                 # build-if-needed + launch the desktop app
│   ├── dev.py                 # backend :8000 + frontend :5173 (hot reload)
│   ├── build_desktop.py       # PyInstaller build → dist/RagIndex/
│   ├── make_dataset_sample.py # (re)build the bundled dataset sample
│   ├── index_branches.py      # build / search the branch index
│   ├── ask.py · try_pipeline.py · verify_metrics.py · benchmark_rag.py
├── packaging/                 # PyInstaller spec + Windows Inno Setup installer
├── benchmarks/                # vector-DB baseline + comparison harness
├── samples/                   # sample documents (incl. sample-docs.zip) to test uploads
├── docs/                      # desktop.md · confidence_scoring.md · benchmark.md
├── dataset/                   # bundled dataset SAMPLE (parquet, committed)
├── tests/                     # pytest suite + test_score_api.py
├── vendor/PageIndex/          # the model, cloned & pinned by setup (NOT committed)
└── data/                      # index, caches, uploads (git-ignored, regenerable)

A team effort by the Turing Tree interns, developed as part of the Microsoft Global Intern Hackathon 2026:

• Subhransu S. (Rudra) Bhattacharjee
• Himanshu Singh
• Yeredla Koushik Reddy
• Jayesh RL

• Turing Tree (RagIndex) is released under the MIT License — see LICENSE. © 2026 Subhransu S. Bhattacharjee, Himanshu Singh, Yeredla Koushik Reddy, and Jayesh RL. Developed as part of the Microsoft Global Intern Hackathon 2026.
• PageIndex (vendor/PageIndex/) is the upstream VectifyAI/PageIndex project — its own git repository, kept out of ours (it's in .gitignore) so our repo stays small and everyone gets a fresh, correct copy from setup. For stronger reproducibility, setup pins it to a known-good commit (RAGINDEX_PAGEINDEX_REF); you can also convert it to a git submodule.
• The bundled dataset sample derives from Wikipedia and is licensed CC BY-SA — keep the attribution if you redistribute it.
• No API keys, no cloud, no telemetry — RagIndex runs entirely on your machine.