Spring AI + RAG: Build Production-Grade AI with Your Data

Revisit the NexaCorp problem and define clear system boundaries.

Understand what the Internal Knowledge Assistant should and should not do.

Explore all fixed data sources used throughout the course.

Learn how different question types map to different knowledge sources.

Set up PostgreSQL using Docker and load course data using SQL scripts.

Inspect structured knowledge directly from the database.

Run Redis locally using Docker and connect via Redis Insight.

Understand Redis’ future role in the RAG system.

Test plain LLM chat against internal questions and observe failures.

Build a clear mental model of why RAG is required.

Learn what ingestion means in a RAG system and why it must be a pipeline.

Understand repeatability, idempotency, and common ingestion failures.

Load PDF documents and extract raw text using PDFBox.

Understand why PDF text is noisy and difficult to work with.

Ingest clean Markdown-based wiki documents.

Preserve structure and compare wiki ingestion with PDFs.

Ingest structured database records for RAG usage.

Handle time-sensitive data like announcements correctly.

Combine all ingestion sources into a single orchestration pipeline.

Produce a unified IngestedDocument model with content and metadata.

Understand why chunking is mandatory for RAG systems.

See how naive fixed-size chunking breaks semantic meaning.

Implement a basic fixed-size chunker.

Use it as a baseline to evaluate chunking limitations.

Add overlap to fixed-size chunking to reduce boundary issues.

Learn why overlap alone does not solve semantic problems.

Chunk wiki documents using their inherent structure.

Understand why semantic chunking works well for Markdown.

Handle PDFs realistically using pragmatic chunking strategies.

Prioritize traceability and metadata over perfect semantics.

Chunk database records so they participate in retrieval uniformly.

Treat each database record as an atomic chunk.

Unify all chunkers behind a single orchestration pipeline.

Produce a consistent list of Chunk objects across all sources.

Inspect chunk metadata across PDFs, wiki, and database sources.

Understand why metadata is critical for retrieval and filtering.

Understand why keyword search fails for AI systems and how embeddings enable semantic understanding. Learn where embeddings fit in a production-grade RAG architecture.

Implement an embedding pipeline using Spring AI to convert document chunks into vector representations. Generate embeddings in a test-driven, backend-friendly way.

Learn what vector databases do, how similarity search works, and why metadata matters. Compare common vector store options used with Spring AI.

Store embeddings and metadata into a real vector database using Spring AI. Ensure idempotent writes and prepare the system for retrieval in later modules.

Understand what retrieval really means in RAG systems and how it differs from simple similarity search. Learn how retrieval fits into end-to-end AI workflows.

Define clean retrieval outputs instead of returning raw text. Design retrieval models that preserve metadata and support reliable downstream processing.

Implement basic semantic retrieval using embeddings and vector similarity search with Spring AI. Retrieve top-K relevant chunks for a user query.

Prevent incorrect knowledge by applying metadata filters during retrieval. Learn how source type, document identity, and time sensitivity affect results.

Introduce ranking as a separate system concern. Apply simple, practical ranking strategies without heavy machine-learning re-rankers.

Wire the retrieval pipeline into a Spring Boot chat service. Maintain clean separation between controllers, services, and retrieval logic.

Validate retrieval behavior end to end using tests. Inspect retrieved context, verify metadata integrity, and confirm cross-source retrieval works correctly.

Understand why naive prompts fail in real systems and why prompt orchestration is a backend reliability concern, not just prompt wording.

Learn how to design stable prompt models that clearly separate system instructions, retrieved context, and user questions.

Define global system rules that control how the LLM behaves, independent of retrieval or user input.

Convert retrieved chunks into deterministic, prompt-ready context while preserving metadata and traceability.

Implement grounding rules that force the LLM to answer only from retrieved knowledge or safely respond with “I don’t know.”

Generate source-attributed answers using metadata so responses are traceable, explainable, and trustworthy.

Integrate Chat Prompt in Chat Service. Inspect and validate final prompts to ensure reliable behavior before scaling, optimizing, or hardening the system.

Understand why real RAG systems fail over time without proper handling of updates, deletions, and stale knowledge.

Introduce a dedicated lifecycle service to explicitly manage ingestion and deletion without mixing concerns.

Implement stable document identity and idempotent ingestion so the same knowledge is not duplicated or corrupted.

Learn how deleting knowledge affects chunks and embeddings, and how to prevent removed content from being retrieved.

Handle updates by safely removing old embeddings and re-ingesting new content without partial or mixed states.

Integrate all the lifecycle operations together. Expose minimal, explicit API endpoints to trigger lifecycle operations in a controlled and auditable way.