Argus RAG Studio
An open-source, self-hosted platform that covers the full RAG lifecycle — Build, Retrieve & Generate, Evaluate, and Operate & Deploy — in one place. Not a "works-once RAG demo": it ships with an evaluation harness that measures quality in numbers, config sweeps that auto-explore optimal settings, a feedback loop, and agent-based remote deployment, so it runs on-premises and in air-gapped (closed) networks.
What is RAG?
An LLM answering on its own has neither current information nor evidence. RAG searches your own documents first, and builds the answer only on what it found.
Put documents in, get answers with citations
Load internal policies, manuals and contracts as they are. The platform retrieves the passages that answer the question and generates a response with [n] citations — every sentence traces back to its place in the source, so staff verify the evidence before acting on it.
Concept diagram
Build, Retrieve & Generate, and Evaluate & Operate run on one shared data plane, while inference servers and deployment attach through standard interfaces.
Highlights
Measure → optimize → improve loop
Quality is measured in numbers with golden sets, Hit Rate/MRR, and 3-axis LLM-as-Judge; config sweeps auto-explore the best combination of chunking, search mode, and reranker; and 👍/👎 user feedback is promoted back into the golden set — the loop most self-built RAG stacks never get to is a built-in feature.
Hybrid search + cited answers
Vector (pgvector) and lexical (tsvector) results are fused with RRF and reordered by reranking (LLM, in-process or cross-encoder), and answers stream over SSE with [n] citations. Federated queries search knowledge bases with heterogeneous embeddings at once.
Built for Korean documents
A dedicated Rust parser for HWP/HWPX (rhwp), kss Korean sentence splitting, a VLM/OCR (PaddleOCR) pipeline for scanned documents, and AI-Hub-compatible annotation — an axis general open-source RAG frameworks do not cover.
Air-gap · agent-based remote deployment
Models are brought in as packs and auto-installed at deploy time, while per-host agents remotely deploy workers, embedding, reranker, and VLM servers. With the zot registry even containers stay fully offline — meeting network-separation requirements in finance, government, and defense.
The whole RAG lifecycle, on one page
From ingestion through retrieval, generation, evaluation, operations and deployment — managed in one platform instead of stitched-together tools.
Document routing — which knowledge base does this belong to?
Classification tells you what a document is; it does not decide where it goes. Routers — from filename, path and metadata through embedding similarity and LLM judgement — combine into a policy that picks the destination before ingestion, and every decision is recorded.
Document parsing — from source file to text
A PDF whose meaning lives in its tables is not read the same way as a scan. The parser is swappable per file type and quality requirement, and every path converges on one Markdown form that still carries tables and headings.
PII — removed before anything is indexed
Personal data is redacted right after parsing, so only the redacted text reaches chunking, embedding and indexing. Where regex is not enough, checksum validation and sandboxed custom functions take over.
Chunking — the unit retrieval matches
A chunk is what retrieval actually matches. Too large and the evidence drowns in noise; too small and the sentence cannot stand on its own. Each collection picks the boundary strategy that fits its documents.
Embedding — into vectors retrieval can match
The embedding settings define a collection's vector space. Provider, model, dimension and distance metric are fixed when the collection is created, and changing them later means reindexing. On closed networks or in CI, the wiring can be verified with no embedding server at all.
Retrieval — how the evidence is found
One question splits into a vector search and a lexical search, then merges again through RRF. Throughout, the collection boundary and the metadata filter constrain what can be read, and the vector store can be swapped without moving any content.
Reranking — search wide, select narrow
First-stage search is built not to miss anything, so it gathers candidates broadly. Reranking looks closely at just those candidates and reorders them. It is a query-time setting, so changing it never triggers a reindex, and if the reranker fails, retrieval survives on the fusion order.
Evaluation — quality as a number
Retrieval is scored without an LLM through Hit Rate and MRR; answers are scored by an LLM judge on faithfulness, relevance and correctness. Configuration sweeps split the search space by whether reindexing is needed, and a holdout split with an overfit flag validates the winner.
Platform Architecture
The frontend dashboard, RAG backend, inference servers, and data stores/registry work together, and inference and workers can be deployed separately via agents to scale in stages.
Core Capabilities
From ingestion, parsing, and chunking to hybrid search & generation, evaluation, config sweeps, retrieval fine-tuning, versions & observability, agent deployment & air-gap, and annotation & images — twelve pillars covering the full RAG lifecycle in a single platform.
Build
Ingest documents, read them, split them, and route them to the right knowledge base
Ingestion pipeline
Multi-format documents are processed by async workers through upload → parse → chunk → embed → index.
5 parse strategies
Pick the parse strategy per collection to match the document (auto-fallback when uninstalled).
8 chunking strategies
Chunking decides half of retrieval quality — implemented down to table preservation and meaning boundaries.
Knowledge base design — fail-closed isolation
Collections are designed as security isolation boundaries, not just topic buckets.
Retrieve & Generate
Find the passages that answer the question and generate a cited response
Hybrid search & generation
Search meaning and keywords in parallel, fuse the results, and generate cited answers.
Model flexibility
Swap embedding, reranker, generation LLM, VLM, and OCR per workload.
Evaluate & Operate
Measure quality as numbers and manage it through versions
Evaluation harness
Measure quality in numbers with golden datasets and an LLM judge.
Config sweeps & improvement loop
Auto-explore combinations of chunking, search mode, top-k, and reranker, compared on a leaderboard.
Pipeline versions & observability
Treat search, rerank, and generation settings as versionable assets, and instrument every query.
Extend & Deploy
Tune for your domain and deploy anywhere, including air-gapped sites
Retrieval fine-tuning
Tune embeddings and rerankers to your domain terms and acronyms.
Agent-based deployment & air-gap
Per-host Argus Agents deploy workers and inference servers; closed networks import models as packs.
Annotation & image pipeline
Turn in-document images and scans into knowledge via OCR and VLM.
A pipeline built for Korean documents
Merged HWP tables, scanned PDFs, footnotes and multi-column layouts — the documents generic RAG frameworks quietly drop are handled on dedicated paths.
- rhwp — a Rust parser for HWP/HWPX that preserves merged table structure
- kss sentence splitting tuned for Korean particles and quotation marks
- VLM and PaddleOCR — text and captions from scans, drawings and images
- AI-Hub compatible annotation — bbox + text labelling, import and export
Deployment that reaches air-gapped sites
The central backend deploys to an agent on every host, and models are brought in as packs and served offline — matching the network separation rules of finance, the public sector and defence.
- servermgr → Agent :4501 — install, start and stop workers, embedding, reranker, detection and VLM remotely
- Automatic GPU variant selection — cpu, gpu (ONNX), gpu-torch
- zot OCI registry — container images stay fully offline
- Model registry — packs are installed on the target host automatically at deploy time
An open-source RAG platform
Argus RAG Studio is published on GitHub under the Apache License 2.0. The entire RAG engine — backend (FastAPI), frontend (Next.js), and the standalone embedding/reranker servers — is open, so enterprises can verify the code directly, extend it to fit their environment, and operate it without sending data outside.
- Apache 2.0 with no commercial-use restrictions
- Verify and extend the code yourself
- Self-host in air-gapped / on-premises