RAGU: A Multi-Step GraphRAG Engine with a Compact Domain-Adapted LLM

Hugging Face Daily Papers Papers
graphrag rag knowledge-graph open-source compact-llm fine-tuning domain-adaptation

Summary

RAGU is an open-source multi-step GraphRAG engine that uses a compact 7B fine-tuned LLM (Meno-Lite-0.1) to achieve high-quality knowledge graph construction at a fraction of the cost of larger models, outperforming larger systems on benchmarks.

Graph retrieval-augmented generation (GraphRAG) enhances large language models with structured knowledge, yet existing systems construct knowledge graphs in a single extraction pass, producing noisy entities and brittle retrieval. RAGU, an open-source modular GraphRAG engine, addresses this by separating extraction from consolidation: entities and relations pass through two-stage typed extraction, DBSCAN-backed deduplication, LLM summarization, and Leiden community detection. A key insight motivates a compact extractor: the skills an in-pipeline LLM needs - comprehension, extraction, reasoning over context - are language skills that grow only weakly with model size, unlike factual world knowledge. Accordingly, we train Meno-Lite-0.1, a 7B model optimized for language skills, which outperforms Qwen2.5-32B on knowledge-graph construction (+12.5% relative harmonic mean) and matches it on English GraphRAG tasks. On GraphRAG-Bench (Medical), RAGU retrieves the most complete context at every factoid level (evidence recall up to 0.84 vs. leq0.76) and overtakes HippoRAG2 on synthesis tasks; on multi-hop factoid QA, the apparent HippoRAG2 advantage is shown to be largely an answer-format artifact. RAGU is installable via pip install graph_ragu, runs on a single GPU, and is released under MIT. The source code is publicly available at https://github.com/RaguTeam/RAGU, and the Meno-Lite-0.1 model can be obtained from https://huggingface.co/bond005/meno-lite-0.1.
Original Article
View Cached Full Text

Cached at: 07/20/26, 09:39 AM

Paper page - RAGU: A Multi-Step GraphRAG Engine with a Compact Domain-Adapted LLM

Source: https://huggingface.co/papers/2607.11683

GraphRAG doesn’t have to be expensive, brittle, or messy.

We’re the team behindRAGU— an open-source GraphRAG engine built jointly by the Laboratory of Applied Digital Technologies at Novosibirsk State University and the Laboratory of Automated Multi-Agent AI at ITMO University. Its compact extractor,Meno-Lite-0.1, also powers our 1st-place system in SemEval-2026 Task 8 (MTRAG) (paper), so this isn’t a toy model. And we’re here to challenge a common assumption:you don’t need a massive LLM to build high-quality knowledge graphs.

What we tested and what we built:

**The “Language vs. World Knowledge” hypothesis.**We ran experiments across 6 model sizes (0.5B to 72B). Language skills — comprehension, extraction, reasoning over context — scale slowly with model size (4× growth), while world knowledge scales steeply (21×). Yet existing GraphRAG systems throw 32B–72B models at extraction, wasting compute on facts they don’t need to recall.

Meno-Lite-0.1is a 7B model fine-tuned specifically for RAG-oriented language tasks. It outperforms Qwen2.5-32B on knowledge-graph construction (+12.5% harmonic mean). On end-to-end GraphRAG QA, its standalone extraction edge shrinks to ≤1pp — not because the fine-tuning failed, but because a good consolidation pipeline reduces sensitivity of QA quality to the extractor. Net result: 32B-class extraction at 7B cost.

RAGU itselfis a modular GraphRAG engine with a 6-stage pipeline that separates extraction from consolidation: two-stage typed extraction, DBSCAN deduplication, LLM summarization, Leiden community detection. Cleaner graphs, better retrieval.

Benchmarks:

  • On GraphRAG-Bench (Medical): RAGU retrieves the most complete context at every factoid level — evidence recall up to 84% vs. ≤76% for competitors.
  • Outperforms HippoRAG 2 on synthesis tasks (Creative Generation AC: 59.0 vs. 56.9).
  • Multi-hop QA gap? Turns out it’s mostly an answer-format artifact. Controlling for format, RAGU ties HippoRAG 2 on BioASQ (72.9 vs. 72.4).
  • RAGU does this with a locally served 7B model against HippoRAG 2’s 20B extractor.
  • Cost: ~0\.001/doc on rented GPUs vs\. ~0.10/doc for API-based alternatives. At 100k docs, that’s $100 vs. $10,000.

Practical details:

  • pip install graph\_ragu— runs on a single consumer GPU.
  • ~374 tests + deterministic mock LLM server, so CI works without API keys.
  • Three swappable storage backends (NetworkX or Neo4j, NanoVDB or Qdrant).
  • MIT-licensed code, Apache-2.0 model weights.

We built RAGU because open-source GraphRAG shouldn’t mean choosing between academic prototypes and expensive APIs. Read the paper, try the code, let us know what breaks.

Code:https://github.com/RaguTeam/RAGU Model:https://huggingface.co/bond005/meno-lite-0.1 Demo videos:

  • 2 min: basic RAGU setup and first run
  • 11 min: exploring alternative pipeline configurations

P.S. Appendix A documents the engineering gaps we found in HippoRAG 2 at a pinned commit: raweval\(\)on LLM outputs, missing retries, no storage abstraction. We show side-by-side how RAGU handles each of these — Pydantic-validated outputs, proper retry logic, swappable backends.

Similar Articles

ScalableRAG: High-Quality RAG at Zero Ingestion Cost

arXiv cs.AI

This paper introduces ScalableRAG, a retrieval-augmented generation method that achieves high accuracy without any ingestion costs (no vector database or knowledge graph) by using regex-based set creation and aggregative reasoning. It outperforms baselines on multiple datasets and also presents a limited-ingestion variant for further accuracy improvements.

LightRAG: Simple and Fast Retrieval-Augmented Generation

Papers with Code Trending

The article introduces LightRAG, an open-source framework that enhances Retrieval-Augmented Generation by integrating graph structures for improved contextual awareness and efficient information retrieval.