🧪 RAG‑LCC — Experimental RAG Under Constraints

🎯 Who this is for

• 🔬 Researchers and practitioners exploring why RAG pipelines succeed or fail
• 🧠 Engineers working with large, multilingual, or conflicting document sets
• 💬 Anyone debugging multi‑turn chat‑context failures in RAG systems
• 💻 Users running RAG on constrained or commodity hardware
• 🧪 People who want to experiment beyond "embed + cosine + top‑k" — see Query Output Example for what a full pipeline run looks like

---

RAG‑LCC is an experimental Retrieval‑Augmented Generation (RAG) lab focused on understanding and controlling retrieval and context assembly under real‑world constraints: limited context windows, modest GPUs, large documents, and multi‑turn chat.

• DocClassify Document classification - results may be used as input filter for RAGLoad
• RAGLoad Text extraction (document formats, pictures, MS Office) and Vector DB ingestion
• RAGChat (CLI GUI) and RAGChatService (Open WebUI integration)

Instead of pushing ever‑larger context sizes, RAG‑LCC treats classification, chunking, retrieval strategies, and staged loading as first‑class architectural tools.

---

🎬 Demo

---

🧠 What it does — and why it exists

Standard RAG is deceptively simple: embed documents, embed query, retrieve by cosine similarity, prompt the LLM. In practice this produces systems that are brittle in exactly the ways that matter most — they hallucinate when the corpus has conflicting information, they drift in multi‑turn chat as pronouns accumulate, they fail silently on minority‑language documents, and they have no principled way to prevent prohibited content from being stored or returned.

RAG‑LCC (Retrieval‑Augmented Generation — Local Corpus & Classification) is an experimental lab for studying and addressing these failure modes. Instead of pushing ever‑larger context windows, it treats classification, chunking, retrieval strategy, and content filtering as first‑class architectural decisions. Documents are analysed, compressed, filtered, and assembled before reaching the LLM — so the model reasons over coherent, non‑contradictory context rather than an arbitrary pile of chunks.

The system is built around four applications that form a deliberate pipeline:

---

🏷️ DocClassify — Know your corpus before you index it

Before anything enters the retrieval indexes, DocClassify runs LLM‑powered keyword extraction and batch classification over your document collection. Every file gets structured metadata — topic, category, language, and any custom fields you define — written to a CSV.

This is not just labelling. It is semantic compression: large documents are reduced to meaning‑dense keyword signals early, before expensive embedding and retrieval. You can then filter that CSV with a plain SQL WHERE clause to decide exactly which documents proceed to indexing:

# Index only English mammal-related documents classified as Science
CLASSIFYCSVQUERY = "Mammal LIKE '%Yes%' AND Language = 'English'"

Documents that fail your criteria never get indexed — reducing token waste, context noise, and compliance surface area.

---

📥 RAGLoad — Index with intent, filter at the gate

RAGLoad ingests the documents you selected and builds three parallel indexes simultaneously:

• ChromaDB — dense embedding vectors (Snowflake Arctic Embed L v2.0) for semantic search
• BM25 — Okapi BM25 keyword index for term‑frequency scoring and lexical recall; complements vector search on precise terminology and rare terms
• Entity co‑occurrence graph — spaCy NER entities and noun phrases extracted from every chunk and linked by document co‑occurrence; enables graph traversal to pull in thematically connected chunks that neither vector nor BM25 search would surface

Before any chunk is stored, it passes through a multi‑algorithm compliance filter chain — Regex+Levenshtein, Jaccard, BM25, KeyBERT — that detects and optionally masks prohibited content. Leet‑speak decoding and Unicode confusable normalization run first, so obfuscated phrases are caught before embedding.

Seven chunking strategies handle different document types: semantic boundary detection for free text, heading‑aware chunking for structured documents, per‑page for PDFs, per‑slide for presentations. Chunk boundaries match the document’s natural discourse structure rather than arbitrary token counts.

Files unchanged since the last run are skipped. Files flagged by prior compliance runs can be automatically excluded.

---

💬 RAGChat — Retrieval that fights context failures

RAGChat is a multi‑turn chat interface backed by the indexes built by RAGLoad. It is designed around the observation that most RAG failures are not retrieval failures — they are context assembly failures: semantically similar chunks that reinforce each other’s errors, pronoun references that resolved to the wrong entity two turns ago, or factually contradictory passages delivered side‑by‑side without scoping. See Query Output Example for an annotated full-pipeline run.

Each query runs through a staged pipeline:

• Compliance pre‑check — the multi‑algorithm filter chain (Regex+Levenshtein, Jaccard, BM25, KeyBERT) runs on the raw query; matched phrases are masked or the request is blocked before anything else happens
• Translation — non‑English queries normalised to English via M2M100 (100 languages, MIT)
• Query rewriting — pronouns and referents from prior turns resolved by a dedicated rewrite LLM; prefix with new: to hard‑switch topics without clearing history
• Multi‑query expansion — the LLM generates N alternate phrasings to broaden vocabulary coverage across the retrieval pool
• Hybrid retrieval — Vector + BM25 + Graph fused via weighted Reciprocal Rank Fusion; optional live DuckDuckGo web leg
• Near‑duplicate removal — chunks sharing ≥ 85% token overlap collapsed before reranking
• Cross‑encoder reranking — neural relevance scoring on top‑k candidates
• Strategy‑gated context assembly — five profiles from NARROW (20 chunks, high precision) to ULTRA_WIDE (1500 chunks, exhaustive), with per‑file diversity caps
• LLM reasoning — context assembled above is passed to the generation model
• Compliance post‑check — the same filter chain re‑runs on the generated answer; matched spans are masked before the response reaches the user

Answers are grounded — every sentence is checked for overlap with retrieved source text and marked visually, in CLI and API output alike. You see exactly which parts of the answer are evidence‑backed and which are not.

---

🌐 RAGChatService — OpenAI‑compatible RAG as a service

RAGChatService wraps the complete RAGChat pipeline in an OpenAI‑compatible REST API (POST /v1/chat/completions). Point OpenWebUI at it — or any OpenAI client — and your local RAG pipeline becomes a selectable model with no prompt engineering required on the client side.

ChromaDB collections appear as models in the OpenWebUI dropdown. RAG‑LCC knobs (strategy, retrieverk, threshold, websearch, web_weight) are exposed as OpenWebUI Advanced Parameters so non‑technical users can tune retrieval without editing config files.

Supports Bearer‑token authentication, optional streaming, configurable host/port, and fully offline operation after initial setup.

---

🧭 Quick mental model

Raw documents
        │
        ▼
┌───────────────────────────────────────────┐
│  DocClassify  (optional first pass)       │
│  ─────────────────────────────────────    │
│  KeyBERT keyword extraction               │
│  LLM classification  →  CSV metadata      │
│  compliance filter chain (load-time)      │
│  purpose: semantic compression +          │
│           domain-scoped ingestion         │
└───────────────────────────────────────────┘
        │  optional: filter CSV with
        │  plain SQL WHERE clause, e.g.
        │  "Mammal LIKE '%Yes%'"
        ▼
┌───────────────────────────────────────────┐
│  RAGLoad  (indexes the corpus)            │
│  ─────────────────────────────────────    │
│  leet-speak + Unicode normalisation       │
│  compliance filter chain  →  masking      │
│  7 chunking strategies (per file type)    │
│  ┌──────────┐ ┌──────────┐ ┌───────────┐  │
│  │ ChromaDB │ │  BM25    │ │   Graph   │  │
│  │ vectors  │ │ keyword  │ │  entity   │  │
│  │ (HNSW)   │ │  index   │ │  co-occur │  │
│  └──────────┘ └──────────┘ └───────────┘  │
│  skips unchanged files (hash check)       │
└───────────────────────────────────────────┘
        │
        ▼
┌─────────────────────────────────────────────────────────────────────┐
│  RAGChat  /  RAGChatService                                         │
│  ─────────────────────────────────────────────────────────────────  │
│                                                                     │
│  RAGChat   — interactive CLI                                        │
│  RAGChatService — OpenAI-compatible REST API  ──► OpenWebUI         │
│              (same pipeline, same config)                           │
│                                                                     │
│  ┌─────────────────────────────────────────────────────────────┐    │
│  │  per-query pipeline                                         │    │
│  │                                                             │    │
│  │  user query                                                 │    │
│  │    │  ① compliance pre-check  (banned-phrase filter chain)  │    │
│  │    │  ② M2M100 translation  →  English (if non-English)     │    │
│  │    │  ③ query rewrite  (coreference resolution via LLM)     │    │
│  │    ▼                                                        │    │
│  │  multi-query expansion  (LLM → N alternate phrasings)       │    │
│  │    │  each variant runs an additional Vector search         │    │
│  │    ▼                                                        │    │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌───────────┐    │    │
│  │  │  Vector  │  │   BM25   │  │  Graph   │  │    Web    │    │    │
│  │  │ (Chroma) │  │ keyword  │  │ entity   │  │ DuckDuckGo│    │    │
│  │  └────┬─────┘  └────┬─────┘  └────┬─────┘  └─────┬─────┘    │    │
│  │       └─────────────┴─────────────┴───────────────┘         │    │
│  │                  weighted RRF fusion                        │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          near-duplicate removal  (Jaccard)                  │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          threshold filter  (sigmoid score ≥ T)              │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          cross-encoder reranker  (mmarco MiniLM)            │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          chunk selection strategy                           │    │
│  │          NARROW · BALANCEDFILECAP · DEFAULT · WIDE        │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          context assembly  →  LLM reasoning                 │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          ④ compliance post-check  (answer validation)       │    │
│  │                      │                                      │    │
│  │                      ▼                                      │    │
│  │          answer grounding  (sentence-level overlap marks)   │    │
│  └─────────────────────────────────────────────────────────────┘    │
│                                                                     │
│  Web leg active only when WEBSEARCHMODE="1" and web_search=on     │
└─────────────────────────────────────────────────────────────────────┘

A few refinements to keep in mind when reading the pipeline above:

• Confidence-gated reranking — the per-strategy threshold is a cross-encoder confidence floor. When no chunk clears it (the reranker is unconfident about the whole pool, common on technical/tabular content), reranking is skipped and chunks fall back to retrieval (RRF) order instead of being dropped — with an orange Rerank skipped notice.
• Metadata filtering — harvested document metadata (author, title, dates, page labels, …) can be used as retrieval filters via the metadata! picker or metadata=Field:Value, narrowing all three local retrievers.
• Correct source pages — citations and highlighted source documents use the document's printed page label (e.g. front-matter iii), while highlighting is placed on the true physical page.

The goal is not to feed the model more text — but to feed it better, safer context.

---

📊 Presentation

A slide deck is available as RAG-LCC_Presentation.pptx. It provides a quick visual overview of the architecture, the four applications, the retrieval pipeline, and the key design decisions — useful as a starting point before diving into the detailed documentation.

---

🔑 Feature Highlights

Key capabilities organized by application. Full configuration details, defaults, and code examples in CONFIGURATION_REFERENCE.md.

🏷️ DocClassify

• Semantic compression — KeyBERT keyword extraction + LLM classification produces meaning-dense CSV metadata (topic, category, language, and any custom fields you define)
• Classify-then-load — filter the output CSV with a plain SQL WHERE clause before indexing: "Mammal LIKE '%Yes%' AND Language = 'English'". Documents that fail the filter are never embedded
• Compliance filter chain runs at classification time — detected phrases are masked before any embedding
• Customisable extraction keys — add or remove fields by editing YOURCLASSIFICATION_KEYS and the matching prompt template; no code changes needed
• Reverse stemming — classification output values are back-projected to original surface forms before CSV export
• STRICT / BALANCED / RECALL extraction profiles control the LLM's sampling parameters

📥 RAGLoad

• 7 chunking strategies with per-format routing: PDF→PDF_PAGE, DOCX/MD→heading, PPTX→slide, plain text→sliding window, sentences→sentence window, code/CSV→recursive, default→semantic boundary detection
• Three parallel indexes built simultaneously: ChromaDB HNSW dense vectors, Okapi BM25 keyword index, spaCy entity co-occurrence graph
• Compliance filter chain + masking — Regex+Levenshtein, Jaccard, BM25, and KeyBERT all run before any chunk is stored; matched spans are redacted in place
• Obfuscation hardening — leet-speak decoding (1→i, 3→e, …) and Unicode confusable normalisation (Cyrillic lookalikes, ß→ss, …) run before detection
• Incremental processing — SHA-256 hash check skips unchanged files; exclusion CSVs automatically drop previously-flagged documents
• Text extraction — PDF (pdfplumber + pdfminer), MS Office via COM (Word, PowerPoint, Excel), images via Tesseract OCR, plain text and Markdown
• Classify-then-load filter — LOADFROMCLASSIFYCSV + CLASSIFYCSV_QUERY (SQLite WHERE) narrows ingestion to documents that passed DocClassify criteria

💬 RAGChat

• 8 retrieval modes — VECTOR, BM25, GRAPH, or any pair/triple fused via weighted Reciprocal Rank Fusion; optional DuckDuckGo web leg as a fourth RRF arm
• 5 retrieval strategies from NARROW (20 chunks, threshold 0.70, high precision) to ULTRAWIDE (1 500 chunks, exhaustive); BALANCEDFILE_CAP enforces per-file diversity caps
• Multi-query expansion — a dedicated LLM generates N alternate phrasings of the query; each variant runs an additional Vector search merged into the main pool before fusion
• Query rewriting / coreference resolution — a second dedicated LLM resolves pronouns and referents from conversation history ("are they mammals?" → "are hedgehogs mammals?"); prefix with new: to hard-switch topics without clearing history
• Near-duplicate chunk removal — Jaccard token-level deduplication of the retrieval pool runs after RRF fusion and before reranking
• Cross-encoder reranking — mmarco MiniLM rescores every candidate; per-strategy sigmoid threshold drops weak matches; when no chunk clears the threshold, reranking is skipped and chunks fall back to retrieval (RRF) order so the top chunk always surfaces
• Answer grounding — every answer sentence is checked for overlap with retrieved source chunks and marked visually; CLI uses ANSI highlights, API returns marked source documents as /marked/<token> links
• Compliance filter chain runs on queries before retrieval and on generated responses before delivery
• Multi-turn conversational memory — rolling topic summary, configurable turn window, batch pruning; new: prefix isolates topics without discarding history
• Translation — M2M100 (100 languages, MIT) normalises non-English queries to English before retrieval and rewriting; Argos Translate expands banlists to the document language
• Per-session web knobs — websearch (localonly / localandweb / webonly), webweight, fetchpagecontent (snippets only / fetch pages); see CONFIGURATION_REFERENCE.md § Web Search Admin Knobs

🌐 RAGChatService

• OpenAI-compatible REST API (POST /v1/chat/completions) — any OpenAI client, LiteLLM proxy, or custom integration works without modification
• OpenWebUI integration — ChromaDB collections appear as selectable models in the dropdown; retrieval knobs (strategy, retrieverk, threshold, websearch, web_weight) surface as Advanced Parameters
• In-memory document cache — highlighted source documents served as short-lived GET /marked/<token> links; configurable TTL, total size cap, and CORS origins
• Bearer-token authentication, configurable host/port, optional streaming, automatic streaming downgrade when document grounding is active
• OPENWEBUIWEBSEARCH — when True (and WEBSEARCH_MODE="1"), the web leg is auto-enabled for every incoming OpenWebUI request that doesn't supply an explicit parameter

🔧 Cross-App

• Compliance pipeline is identical across all apps — same algorithms (Regex+Levenshtein, Jaccard, BM25, KeyBERT), same banlist, per-app consensus thresholds
• 12 named debug levels (0–100) — Standard 30 shows pipeline flow; Chunk Content 32 dumps full retrieved text; Chat Prompt 60 shows the LLM input; all changeable live in-chat with set debug ge 30
• Config hash verification — startup rejects runs where ConfigModels.py or ConfigBanned.py was edited without updating the stored hash (python src/Scripts/RecalcConfigHashes.py to update)
• Fully offline after initial setup — HFHUBOFFLINE="1", TRANSFORMERSOFFLINE="1", WEBSEARCHMODE="0" in ConfigInternet_Env.py
• License consent workflows — RAG‑LCC does not bundle any model; consent is recorded per-model in ModelGovernance/licenses/ before first use

---

🎛️ Configuration at a Glance

RAG‑LCC exposes every significant architectural decision as a configuration slot. Nothing is hardwired — chunking boundaries, retrieval algorithm mix, scoring thresholds, model roles, compliance rules, and answer grounding sensitivity are all independently tunable.

If you have a document corpus and want to optimize retrieval — start with chunking strategies, retrieval mode and strategy profiles, and BM25/HNSW parameters.

If you're studying RAG failure modes — every stage from query rewriting to answer grounding can be inspected at named debug levels, disabled, or replaced independently.

If you need to integrate or deploy it — Ollama or vLLM backend, OpenAI-compatible REST service (RAGChatService), OpenWebUI drop-in, fully offline after initial setup.

| Area | What you configure | Why you'd tune it | |------|--------------------|-------------------| | Chunking | 7 strategies (Semantic, Heading, PDF/Page, Sliding Window, Recursive…); per-format routing; chunk size and overlap | Chunking quality determines retrieval precision — wrong boundaries produce noisy embeddings, referential ambiguity, and incoherent context | | Retrieval mode | VECTOR, BM25, GRAPH, ALL, WEB — any combination with per-retriever RRF weights | Switch between lexical precision, semantic recall, and entity-graph traversal; tune each store's influence independently | | Retrieval strategy | 5 profiles (NARROW → ULTRA_WIDE): chunk count to LLM, score threshold, per-file limits, retriever-k | Dial precision vs recall: 20 chunks for focused Q&A, 1500 for exhaustive exploratory search | | Reranking | Cross-encoder on/off per strategy; sigmoid score threshold | Neural relevance pass after retrieval — switch off for speed, tune threshold for precision | | Query processing | Multi-query expansion (N alternate phrasings); context-dependent rewriting; pronoun/referent resolution; meta-descriptor guard | Boost recall via vocabulary diversity; prevent stale chat history from poisoning retrieval | | Chat session | Turns to keep, history window size, topic summary mode, preferred response language | Control conversational memory budget; isolate topics with new: to prevent referential drift | | Models | Any Ollama or vLLM model; separate roles for generation, query rewriting, and safety checking | Swap models per role — use a large model for generation and a small one for rewriting | | Prompts | Fully customisable per model and task: chat, classification, safety check, query rewrite, topic detect | Adapt RAG‑LCC to any domain by editing prompts; no code changes needed | | Compliance | 5-algorithm detection pipeline (Regex+Levenshtein, Jaccard, BM25, KeyBERT); per-app thresholds; masking; consensus count | Fine-tune false-positive/negative tradeoff independently for indexing vs chat | | Content hardening | Leet-speak and Unicode confusable normalization; WordNet synonym expansion; LLM guard model | Defense-in-depth: obfuscation is neutralized before embedding, LLM gates responses before delivery | | Classification | Customisable extraction keys; STRICT/BALANCED/RECALL profiles; SQLite filter for selective indexing | Classify first, then load only the documents that match your query's domain | | Language | 28-language detection (Lingua); M2M100 query translation (100 languages); Argos banlist translation | Retrieve and filter correctly even in multilingual document corpora | | Web search | DuckDuckGo integration; 3-stage pre-filter (BM25 + cosine + rerank); intent blocking; per-session weight | Augment local retrieval with live web results; configure filtering aggressively enough to suppress noise | | Answer grounding | Sentence-level overlap detection; configurable match strictness; color markers per output mode | Distinguish grounded sentences from hallucinations at the sentence level, in CLI and API | | Deployment | Ollama or vLLM backend; RAGChatService (OpenAI-compatible REST); OpenWebUI drop-in | Same config and pipeline whether you run CLI, a service, or behind OpenWebUI | | Observability | 12 named debug levels (Standard 30 → Streaming 100); in-chat toggle; performance event log | Trace every step: retrieval scores, merged chunk pool, prompt text, grounding markers, raw token stream |

Full slot-level details: CONFIGURATIONREFERENCE.md · per-file reference: CONFIGURATIONREFERENCE.md

---

❓ Documentation

| Document | What's inside | | --- | --- | | 📘 README.md | Project overview · feature summary · quick-start | | 🚀 INSTALL.md | Prerequisites · cloning · dependencies · Ollama / OpenWebUI / Argos / NLTK / Tesseract / spaCy / GPU setup · first-run walkthrough | | 📚 CONFIGURATIONREFERENCE.md | Per-file reference for every Config*.py · CLI overrides · translation config · troubleshooting | | 📸 EXAMPLES.md | End-to-end terminal sessions for RAGLoad, RAGChat, DocClassify, RAGChatService | | 🏗️ ARCHITECTURE.md | Pipeline internals · compliance chain · chunking · query rewrite · graph index | | 🧭 HANDSON_TOUR.md | Curated hands-on session and suggested experiments | | 🔐 SECURITY.md | Security policy · threat model · limitations · web search risks | | ⚖️ LEGAL.md | This document — definitions, governance, disclaimers | | 📋 CHANGELOG.md | Version history and release notes | | 🙏 ACKNOWLEDGMENTS.md | Third-party libraries, models, and attribution |

📚 Background & related write‑ups

Some design decisions in RAG‑LCC are motivated by concrete failure analyses:

• Experimenting with RAG‑LCC on constrained hardware

DEV.to article on classification as semantic compression and context reduction https://dev.to/harinezumigel/experimenting-with-rag-lcc-on-constrained-hardware-3dlg

• When the pronoun “they” breaks your RAG

Reddit write‑up on chat‑context and referential ambiguity failures https://www.reddit.com/r/Rag/comments/1spro5f/whenthepronountheybreaksyourrag_fixing/

• When Your RAG System Confidently Asks About Hedgehog RAM

Reddit write‑up on chat history poisoning and the new: topic‑switch fix https://www.reddit.com/r/Rag/comments/1swbmdr/whenyourragsystemconfidentlyasks_about/

• Filtering the Noise: A Practical Multi-Layer Banlist Pipeline for RAG Systems

Reddit wirte-up on content filtering https://www.reddit.com/r/Rag/comments/1ta1svk/filteringthenoiseapractical_multilayer/

• Speaking the Corpus’s Language: How Multilingual RAG Stays Coherent Across Turns

DEV.to article on two‑pass query translation and multilingual coherence in multi‑turn RAG https://dev.to/harinezumigel/speaking-the-corpuss-language-how-multilingual-rag-stays-coherent-across-turns-4pf5

• Lessons Learned Building an Experimental RAG Lab

Reddit write‑up on failure modes that only surface with end‑to‑end visibility: retrieval pool size, context poisoning, multilingual gaps, scoring assumptions, and why old workarounds become bugs https://www.reddit.com/r/Rag/comments/1to784v/lessonslearnedbuildinganexperimentalrag_lab/

• Adding Web Search to Our RAG Pipeline: What Broke and Why

DEV.to article on integrating internet retrieval into an experimental RAG pipeline — query routing, compliance gating, threshold failures, and the edge cases that only appear in production-like conditions https://dev.to/harinezumigel/adding-web-search-to-our-rag-pipeline-what-broke-and-why-4ge5

• 15 Months Building a RAG System in Retirement: Lessons Learned and What Actually Worked

Reddit write‑up on lessons learned building RAG‑LCC from the ground up — architectural decisions, what worked, what didn't, and practical insights from extended experimentation https://www.reddit.com/r/Rag/comments/1valvk6/15monthsbuildingaragsystemin_retirement/ These are not tutorials — they document observed failure modes that this lab explores programmatically.

---

⚠️ Project status

🧪 Experimental / lab software

RAG‑LCC is intended for:

• architectural exploration
• controlled experimentation
• learning and research

It is not a plug‑and‑play production framework.

---

⭐ Citation & visibility

If this project helps you reason about retrieval, chunking, and context assembly failures in RAG systems, a ⭐ helps other practitioners find it.

A CITATION.cff file is included for academic or technical reference.

---

TL;DR — try it locally

Read INSTALL.md before running anything. You get information what will be done during setup.

git clone <this-repo>; cd RAG-LCC
python -m venv .venv; .\.venv\Scripts\Activate.ps1   # or source .venv/bin/activate
Guided setup, recommended
python src/Scripts/Setup.py                           # guided first-run setup (copies configs, downloads models)
Note: License acceptance is required and recorded on startup
python ./src/Apps/RAGLoad.py  --doc-dir TestDocs
python ./src/Apps/RAGChat.py  --doc-dir TestDocs

Read INSTALL.md before running anything — model licenses must be accepted on first start.

RAG‑LCC — Disclaimer

⚠️ Experimental Research Framework

RAG‑LCC is an experimental research framework intended solely for laboratory use, evaluation, and learning. It is not production software and must not be used in operational, regulated, safety‑critical, or compliance‑critical environments.

🚫 No Support, No Warranty, No SLA

This project is provided as‑is with no:

• support or assistance
• issue response or troubleshooting
• bug fixes, patches, or security updates
• maintenance or compatibility commitments
• service‑level objectives or availability guarantees

No warranty—express or implied—is provided regarding correctness, completeness, security, reliability, or fitness for any purpose.

🔐 Legal, Regulatory, and Security Responsibility

All legal, regulatory, operational, and security risks arising from the use of this software are assumed entirely by the operator.

This project is not a legal, security, governance, or compliance solution. Nothing in the source code, documentation, examples, or logs should be interpreted as legal or security advice.

For definitions, constraints, and further detail, review:

• LEGAL.md
• SECURITY.md

🎯 Intended Use

RAG‑LCC is intended for:

• local experimentation with RAG pipelines
• research into filter chains and scoring
• teaching and learning RAG architectures
• development and testing of custom detection algorithms

It is not intended for end users, enterprises, or regulated operational deployment.

📉 Limitations

Detection and validation mechanisms in this framework are probabilistic. False positives and false negatives will occur.

Scope includes: document ingestion, prompt validation, document classification, and LLM output validation as defined in ./src/Configuration/Config_*.py.

⚠️ Final Notice

Use of RAG‑LCC is entirely at the operator’s own risk. Nothing in this repository guarantees correctness, safety, regulatory conformity, or suitability for any specific environment or risk profile.