Designing Production Ready RAG System Crash Course

Production RAG is not just about splitting documents into fragments, creating embeddings, and passing the found context into a prompt. In a real application, a RAG system must work with PDFs, scans, images, access rights, metadata, multiple storages, queues, background processing, hybrid search, and AI agents. In this practical course, you will learn how to design a production-ready RAG pipeline and integrate it into a full-fledged application.

About the Course

The course focuses on developing production-ready RAG systems: from the architecture of loading and processing documents to searching for relevant context and connecting RAG to a conversational AI agent. You will learn the important decisions needed when transitioning from a notebook prototype to a reliable system that can be maintained, scaled, and debugged.

The main focus of the course is practical design of a RAG pipeline for real documents and real user workflow: file uploading, storage, background processing, chunking, indexing, retrieval, metadata filtering, and generating responses with found context.

Who the Course is For

• Developers already familiar with the basic principles of RAG who want to transition to a production architecture.
• ML and AI engineers designing document search systems, knowledge bases, and AI assistants.
• Backend developers needing to integrate RAG with databases, file storage, queues, and workers.
• Technical leads and architects choosing approaches to storage, indexing, updating, and data retrieval.

What You Will Learn

1. Transitioning from Simple RAG to Production RAG

You will understand what changes when transitioning from a demonstration prototype to a product-ready RAG system:

• Processing real documents: PDFs, scans, images, and other unstructured files.
• Using OCR where text cannot be extracted directly.
• Adding and applying metadata: source, timestamps, document type, tags, access rights, and other attributes.
• Designing search considering access restrictions so the user only gets answers based on permissible data.
• Understanding why production RAG requires specialized architecture, not just a set of calls to LLM and vector store.

2. Designing Retrieval and Document Search

The course will help you understand how to improve search quality and manage the trade-off between precision, completeness, speed, and cost:

• Applying metadata filtering to narrow the search scope and increase result relevancy.
• Using hybrid search that combines keyword search and vector search.
• Understanding when hybrid search is more effective than pure vector search.
• Using user query processing: self-query, query expansion, and post-processing of retrieved results.
• Evaluating the impact of retrieval strategy on AI agent response quality.

3. Choosing a Chunking Strategy

Correct document chunking directly affects RAG system quality. In the course, you will explore:

• Fixed and semantic chunking.
• Using overlap between fragments.
• Chunking considering document structure: sections, headings, tables, and logical blocks.
• The impact of chunk size on recall, latency, and cost.
• Common mistakes when indexing long documents and knowledge bases.

4. Integrating RAG with the Main Application Database

You will learn to separate responsibilities between the relational database, file storage, and vector index:

• Determining which data should be stored in a relational database and which in a vector store.
• Designing models for documents, chunks, embeddings, metadata, and access rights.
• Maintaining index consistency during source content changes.
• Planning for re-indexing and data updates.
• Handling scenarios where a document is updated, deleted, or becomes inaccessible to the user.

5. Embedding RAG into the Product Workflow

You will review the complete architecture: from user file upload to its content being used by an AI agent.

1. The user uploads a file via the frontend.
2. The file is saved in blob storage.
3. The background pipeline processes the file via queues and workers, such as Redis Workers.
4. Content extraction, OCR, chunking, and metadata enrichment are performed asynchronously.
5. Processed data is indexed and made available to the RAG service.
6. RAG integrates with the main conversational AI agent, which uses the found context when formulating responses.

Practical Outcome

After the course, you will understand how to turn a simple RAG prototype into a reliable production system. You will be able to design an architecture where documents are uploaded, processed, indexed, updated, and utilized by an AI agent with consideration of metadata, access rights, and search quality.

• Develop an understanding of production architecture for RAG applications.
• Understand how to connect RAG with databases, blob storage, queues, and workers.
• Learn to choose chunking, retrieval, and index update strategies.
• Understand how to enhance response quality through hybrid search and query processing.
• Gain a foundation for developing AI assistants, corporate knowledge bases, and document search systems.

What's Included in the Course

• 2 hours of video lectures detailing production RAG architecture.
• 100 pages of detailed documentation on key concepts and solutions.
• Workshop slides for material review and use as a reference guide.

Prerequisites

This course is intended for an intermediate level. It is recommended to understand the basic principles of LLMs, embeddings, vector search, and backend development. If you have already built a simple RAG prototype and want to understand how to elevate it to a production level, this course will help you systematize architectural decisions.

Key Course Topics

• Production RAG and RAG system architecture.
• Vector search and hybrid retrieval.
• Chunking, OCR, processing PDFs, and unstructured documents.
• Metadata, filtering, and access rights.
• Integration with relational databases and vector stores.
• Blob storage, queues, Redis Workers, and background processing.
• Integration of RAG with conversational AI agents.