From Native RAG to Agentic RAG: A Progressive Learning Path with LangChain and LangGraph

This post introduces the open-source project native-to-agentic-rag, which provides a clear learning path from basic LangChain retrieval workflows to LangGraph agentic workflows with quality assessment, routing decisions, and web fallback capabilities. It solves the dilemma for developers: simple RAG examples are too idealized for beginners, while complex agent systems are hard to understand. Focused on paper search and reading scenarios (with a corpus including classic NLP papers), it helps users master the RAG evolution path in two stages.

The project is positioned as a "learning path" rather than a "final demo". Author TheAlanWang realized that jumping directly into complex agent architectures easily confuses learners, so it is split into two stages: the first stage teaches basic retrieval mechanisms, and the second stage demonstrates adding an intelligent decision layer via graph orchestration. Focused on paper search scenarios, the corpus includes classic NLP papers like Attention Is All You Need and BERT, allowing learners to understand RAG evolution in real-world knowledge Q&A scenarios.

Build a linear workflow using LangChain. The core goal is to understand the key cycle: Document → Chunking → Embedding → Vector Storage → Q&A Generation. Specific steps: document loading (converting Markdown to Document objects), text chunking, embedding generation (Ollama's embeddinggemma model), Chroma vector storage, Q&A generation (qwen3:4b model). Advanced features (document quality assessment, web search fallback, hallucination detection, graph logic) are intentionally omitted to let beginners focus on core mechanisms.

Build a stateful agentic workflow using LangGraph, with multi-layered intelligence: document relevance scoring (filtering low-value context), conditional routing (triggering Tavily web search when local retrieval quality is insufficient), answer quality checks (hallucination detection and sufficiency evaluation). Key concepts are LangGraph's shared state mechanism (nodes can read/write shared state) and conditional edges (dynamically selecting the next path), enabling adaptive decisions in non-fixed workflows.

Shared tech stack: Python, Ollama local model service, LangChain document processing, Chroma vector storage. Stage 2 adds LangGraph state orchestration, Firecrawl paper crawling, and Tavily web search. Architecture differences: Native RAG is a linear pipeline, while Agentic RAG is a graph with conditional branches; Native RAG has no fallback behavior or failure handling, while Agentic RAG has recovery paths like web fallback, retries, and quality checks; The mental model shifts from linear flow to state + nodes + edges + conditional routing.

Beginners should start with Stage 1 to build a baseline understanding; those with retrieval basics can quickly browse Stage 1 to get repo context and focus on Stage 2. Reading order: Stage 1 README → index_part.py and query_part.py (to understand implementation details), then after mastering the core cycle, move to Stage 2 README → graph_part.py, state.py, and nodes.py (to understand state, node logic, and routing decisions).

The project's value lies in its progressive learning design, breaking down complex systems into understandable stages to help build a solid foundation before introducing abstract concepts. Architecture insights: Agents are enhancements to basic RAG, not replacements—they share local models, index concepts, and retrieval goals, and achieve recovery when initial attempts are insufficient via state memory, judgment layers, and routing layers. The "layered enhancement" design approach is worth drawing on in practical projects.