Learn
How CC-RAGOS works
A guided tour of the whole system — from uploading a document to getting a cited, grounded answer. Everything is explainable: hover the tags to see plain-language explanations, and each diagram mirrors what actually runs.
The big picture
The app talks to two backend services. Ingestion turns your files into searchable vectors; the Retriever answers questions from them. “models” = the LLM, vision, embeddings and reranking — all reached through OpenRouter (and Deepgram for audio).
Hover any tag to learn what it does:
How a document gets in (ingestion)
When you upload, the file is parsed, split into passages, turned into vectors, and stored. Images are described by a vision model; PDFs are rendered page-by-page so citations can point to the exact page.
Hover any tag to learn what it does:
How a question gets answered (retrieval + guardrails)
If you attach an image, a vision model captions + reads it and folds that into your question. Then every question passes a relevance guardrail; if it's in scope, we embed it, retrieve the best passages (optionally rerank), build a grounded + injection-hardened prompt, and stream a cited answer. If it's off-topic, we refuse before spending an AI call.
Hover any tag to learn what it does:
End-to-end — the whole journey
The two halves joined up. ① Ingestion runs once per document and fills the vector store (and graph). ② Question runs on every chat, reading from that store. Chat history feeds back in so follow-ups (“what about that?”) are condensed into standalone questions before retrieval.
Key concepts
The ideas behind modern RAG, in plain terms.
Chunking
Documents are too big to search whole, so we split them into passages ('chunks'). Smaller chunks = precise matches; larger = more context. You pick the strategy at upload.
Chunking strategies
You choose HOW to split at upload: structure (paragraph/heading-aware, the default) · fixed (equal-size overlapping windows) · sentence (packs whole sentences) · parent-child (embed a small child for a precise match but return its bigger parent for context) · semantic (starts a new chunk where the meaning shifts). Each trades precision vs. context.
Embeddings
A model converts text (or images) into vectors — coordinates in 'meaning space'. Things about the same topic end up near each other.
Contextual retrieval
Before embedding, we prepend a short doc-level context line to each chunk (Anthropic's technique). A lone table row or a pronoun-heavy passage becomes findable because the chunk now carries WHERE it came from — noticeably better recall.
Semantic search
Finds passages by MEANING, not keywords. 'car' can match 'vehicle'. Great for natural questions.
Hybrid search
Combines semantic (meaning) with BM25 (exact keywords) and fuses the rankings — best all-round recall.
HyDE
Hypothetical Document Embeddings: the AI first drafts a guess answer, then searches with it. Helps vague or short questions.
Reranking
A cross-encoder re-scores the top candidates more carefully than the first fast search — boosts precision.
GraphRAG
Answers by following a graph of connected concepts ('what depends on X?'), not just matching text.
Conversational RAG
Follow-ups like 'what about the second one?' don't retrieve well on their own. We first rewrite them into a standalone question using the chat history, THEN retrieve — so context carries across turns.
Metadata filtering
Every chunk stores metadata (source, page, type). You can scope a chat to only selected documents — Qdrant filters by a source index BEFORE searching, so answers come only from what you picked.
Re-ingest dedup
Re-uploading a document deletes its old chunks first, so you never accumulate duplicate or stale passages when a source is updated.
Citations
Inline [1][2] chips linking each claim to its source passage — click to jump to it. Trust through transparency.
Visual citations
For images/PDF pages, the AI highlights the exact region that answers your question with a box.
Attach an image in chat
Paste, upload, or drop a reference image with your question. A vision model describes it and reads any text (OCR); that description is merged into your query so the workspace can be searched by it, and the answer model also 'sees' the image. It's semantic match via the description — not a reverse-image lookup. No image → ordinary text chat.
Guardrails
Relevance gate (blocks off-topic), injection defense (ignores instructions hidden in documents), and strict grounding (answers only from your sources).
Roles & access (RBAC)
Optional login with three roles. Viewer: read + ask questions + inspect. Editor: also upload, generate study material, build the graph, run evals, and delete. Admin: also manage workspaces and users. The UI hides what your role can't do, and both services enforce it — so a viewer literally can't upload or delete, not just visually.
Caching
Repeated questions can skip work: cache the question→vector step, or (semantic cache) return a past answer when a new question is nearly identical — saving cost + latency. NOT used here — we run the full pipeline live so every step stays visible; it's a scale-time optimization, and the trade-off is staleness when documents change.
See it live
Each step above has a hands-on view in the app.