production-agentic-rag-course

Product Introduction

1. Definition: The production-agentic-rag-course is a comprehensive, hands-on educational repository and codebase designed to teach developers, ML engineers, and AI practitioners how to build production-grade Retrieval-Augmented Generation (RAG) systems enhanced with autonomous AI agents. It is a project-based course structured as a weekly, incremental build of a fully functional AI research assistant called the "arXiv Paper Curator."
2. Core Value Proposition: This course exists to bridge the critical gap between simple RAG prototypes and robust, scalable, intelligent systems capable of handling complex, real-world queries and workflows. Its primary value is providing a learner-focused journey that mirrors professional software development practices, emphasizing a foundation-first approach (mastering keyword search before vectors) and culminating in agentic RAG with multi-step reasoning.

Main Features

1. End-to-End Production Infrastructure: The course provides a complete, Dockerized microservices architecture. How it works: Learners deploy and manage interconnected services using Docker Compose, including a FastAPI backend (Port 8000), PostgreSQL for metadata (Port 5432), OpenSearch for hybrid search (Ports 9200, 5601), Apache Airflow for orchestration (Port 8080), Ollama for local LLMs (Port 11434), Redis for caching, and Langfuse for observability. This teaches modern MLOps and DevOps for AI systems.
2. Professional-Grade Hybrid Search Pipeline: Implements a layered search strategy critical for production RAG. How it works: It starts with a solid BM25 keyword search foundation using OpenSearch (Week 3), then adds semantic search via Jina AI embeddings (Week 4), and finally combines them using Reciprocal Rank Fusion (RRF) for superior retrieval. The system includes intelligent, section-aware chunking and a unified API endpoint.
3. Agentic RAG with LangGraph: Moves beyond basic RAG to implement intelligent, stateful agents. How it works: Using LangGraph, the system (Week 7) creates a workflow with decision nodes for guardrails, document grading, query rewriting, and adaptive retrieval. This enables the AI to evaluate search results, refine queries autonomously, and provide transparent reasoning, all accessible via a integrated Telegram bot for mobile interaction.

Problems Solved

1. Pain Point: The "prototype-to-production gap" in AI, where developers can build simple RAG demos but lack the skills to create scalable, observable, and intelligent systems that perform reliably under complex, real-world conditions.
2. Target Audience: AI/ML Engineers seeking production deployment skills; Software Engineers transitioning into AI/ML roles; Data Scientists needing to operationalize models; and Tech Leads/Managers architecting AI-powered applications.
3. Use Cases: Building an automated academic research assistant that fetches, parses, and answers questions from arXiv papers; creating a customer support chatbot with deep domain knowledge and reasoning capabilities; developing an internal enterprise search system that combines structured data with intelligent document retrieval.

Unique Advantages

1. Differentiation: Unlike most tutorials that jump straight to vector embeddings, this course enforces a professional "search-first" methodology. It teaches that effective RAG is built on a foundation of robust keyword search (BM25), which is then enhanced with semantic understanding, mirroring the approach used by successful tech companies. It also provides a complete, working system rather than isolated code snippets.
2. Key Innovation: The structured, incremental weekly release model coupled with a complete, production-ready codebase. Each week builds logically on the last (Infrastructure -> Data -> Keyword Search -> Hybrid Search -> LLM -> Monitoring -> Agents), allowing learners to understand the architectural dependencies and rationale behind every component. The integration of LangGraph for agentic workflows and a Telegram bot for delivery showcases cutting-edge, practical AI application design.

Frequently Asked Questions (FAQ)

1. What are the prerequisites for the production-agentic-rag-course? You need Docker Desktop, Python 3.12+, the UV package manager, and a machine with at least 8GB RAM. Basic knowledge of Python and APIs is helpful. The course is designed to be followed step-by-step, with detailed notebooks guiding each week's implementation.
2. How does this RAG course handle embeddings and LLMs to control costs? The course architecture is designed for cost-efficiency and privacy. It uses Ollama for local LLM inference, eliminating API costs for generation. For embeddings, it integrates Jina AI's API but structures the code to allow for easy fallback or switching to other providers, teaching critical production patterns for managing external service dependencies and costs.
3. Can I use this arXiv Paper Curator system for my own documents, not just academic papers? Absolutely. While the use case focuses on arXiv papers, the core architecture is domain-agnostic. The data ingestion pipeline (Airflow, PDF parsing), hybrid search engine (OpenSearch), and agentic RAG workflow (LangGraph) are designed to be adapted. You would replace the arXiv fetcher with your own data connector and adjust the text chunking strategy for your document formats.
4. What makes the "agentic" RAG in Week 7 different from a standard RAG pipeline? Standard RAG follows a linear retrieve-then-generate process. Agentic RAG introduces a stateful, decision-making loop. The system (via LangGraph) can evaluate initial results, decide they are insufficient, automatically rewrite the query for a second retrieval attempt, grade individual documents for relevance, and apply guardrails to reject out-of-domain questions. This leads to more reliable, accurate, and context-aware answers.
5. How is the production readiness and monitoring of the RAG system addressed? Week 6 is dedicated entirely to production monitoring and optimization. It integrates Langfuse for end-to-end tracing of the RAG pipeline (tracking latency, token usage, retrieval steps). It also implements Redis caching for embeddings and frequent queries, demonstrating patterns that can achieve 150-400x speedups and reduce LLM costs, which are critical for scalable deployments.