Naive RAG vs Advanced RAG vs Agentic RAG vs GraphRAG vs Adaptive RAG — Which One Do You Actually Need?

Every six months a new RAG architecture goes viral and engineering teams overcorrect. Here are the five in plain shapes, with a decision tree for picking one.

Naive RAG. Embed everything, top-k vector retrieval, stuff into prompt, generate. One LLM call per question. Latency: ~1-2s. Cost: ~$0.005/query.

Advanced RAG. Naive + query rewriting + hybrid search (BM25 + vectors) + cross-encoder rerank. Two LLM calls (rewrite + answer), one rerank call. Latency: ~2-3s. Cost: ~$0.015/query.

Agentic RAG. The LLM decides when and what to retrieve. Multi-step loop with self-critique. Three to ten LLM calls per question. Latency: 4-15s. Cost: ~$0.05-$0.15/query.

GraphRAG. Index extracts entities and relationships during ingestion. Query traverses the graph for multi-hop questions ("which engineers worked on projects that shipped in Q3 and used Azure?"). Higher ingest cost; query cost similar to Advanced.

Adaptive RAG. A small classifier (or the LLM itself) routes each query to the right pipeline. Simple questions go Naive, complex go Agentic. Best when query distribution is genuinely mixed.

flowchart TD
    Q[Question type] --> A{Single-fact lookup?}
    A -- Yes --> N[Naive RAG]
    A -- No --> B{Multi-hop or relational?}
    B -- Yes --> C{Entities + edges<br/>matter?}
    C -- Yes --> G[GraphRAG]
    C -- No --> Ag[Agentic RAG]
    B -- No --> D{Need exact tokens<br/>error codes, SKUs?}
    D -- Yes --> Adv["Advanced RAG<br/>hybrid + rerank"]
    D -- No --> Adv
    A -. mixed distribution .-> Adapt[Adaptive RAG]

A .NET implementation sketch for each, in one paragraph:

• Naive: Semantic Kernel + a vector store. ITextSearchService + TextSearchProvider + a prompt template. Maybe 100 lines.
• Advanced: same skeleton, plus Cohere Rerank in a search filter, plus an explicit query-rewrite step before retrieval. ~300 lines.
• Agentic: ChatCompletionAgent with a retrieval tool and a critique tool. Loop until confidence threshold or max steps. ~500 lines, more if you do prompt versioning right.
• GraphRAG: entity extraction during ingest (LLM as extractor), Neo4j or pgvector + Postgres graph schema, agent that plans a graph query. Significantly more work — call it ~1500 lines if you build it properly.
• Adaptive: any two of the above, plus a tiny classifier (rules or a small fine-tuned model) on top. The classifier is the hard part. The rest is pre-built.

For a 100-page company knowledge base: Advanced RAG, with reranking, no agent loop. Knowledge bases of that size answer most questions in one retrieval pass. The agent loop and graph indexing don't pay for themselves at that scale — they pay off when you have either a much larger corpus, or a corpus where relationships dominate (HR data, org charts, project lineage).

The wrong answer most teams reach for first: agentic. It looks impressive in demos. It's three to five times slower and more expensive than a well-tuned Advanced setup, and on simple questions the answers aren't measurably better. Build Advanced first. Build Agentic when your eval set demonstrably needs multi-step reasoning. Build GraphRAG when relationships, not retrieval, are the unsolved problem.