Advanced RAG: Build & Deploy Production GenAI Apps

Discover Ragwire, a production-grade REG framework that connects vector databases to document converters and supports multiple LLMs like Ullama, OpenAI, Anthropic, and Grok. Compare Ragwire with basic REG and explore its architecture for easier deployment.

RAGWire presents a three-part production rag pipeline, ingest into a vector store, query relevant chunks, and generate answers with an llm, plus smart markdown chunking and dense plus sparse embeddings.

Master RAGWire's query pipeline with dense and sparse embeddings, reciprocal rank fusion, and metadata-driven retrieval to build robust production GenAI apps.

Ingest documents with a zero-redundancy pipeline, perform hash-based duplicate detection and markdown chunking, then retrieve via hybrid search and generate answers with the llm on the quadrant vector db.

Get started with rag wire setup, load your config, ingest data, and perform a retrieval in a few lines, upload data to quadrant vector db, and leverage hybrid search.

Install ragwire and configure the quick start yaml to enable hybrid search over dense and sparse vectors in the quadrant vector db, with markdown conversion and provider control via config.

Create config.yaml to control the ragwire ingestion pipeline, enabling pdf input and configuring text splitter, chunking (10,000 chars with 20% overlap), and embedding and llm settings.

Configure a production rag setup using config.yaml part 2 by selecting llm providers, embedding models, and the quadrant vector dv, then enable hybrid retrieval with dense and sparse embeddings.

Explore config.yaml part 3: llm and generation settings, where the llm automatically extracts metadata, stores it in a vector store, and enables auto filter with hybrid search and reciprocal rank fusion.

Configure ragwire locally with ollama and Qwen 3.5 by setting up the detailed yaml, selecting the ulama provider and quin3 embedding, and enabling hybrid sparse search for top five results.

Import env vars and enable langsmith tracing, then set up rag wire, check version, and configure info-level logging. Load config.yaml with ulama embedding, ulama llm, vector store, and hybrid retriever.

Connect rag wire to Qdrant vector database by loading config.yaml, initializing document loader, text splitter, and embedding model, then create and verify a hybrid search enabled collection on localhost 6333.

Ingest financial pdfs into a Qdrant vector db by converting to markdown, deduplicating via sha256, smart chunking, and metadata extraction, then generate dense and sparse embeddings for indexing.

Increase model size to improve metadata extraction by using the 35 billion parameter QUIN model and load external YAML metadata; re-ingest into the vector db.

Learn how the ragwire config-driven framework ingests data into a vector store and enables hybrid search—combining BM25 with dense and sparse retrieval and metadata filtering.

Ingest data into VectorDV, explore metadata filtering, and implement manual and auto filtering, then build and test a filter-aware agent for interactive Q&A with a RAG system.

Ingest a full data directory with ragwire, using hybrid, dense and sparse embeddings, perform local PDF conversion to text, generate embeddings, and extract LLM metadata for finance data.

Design a pedantic yaml metadata schema to extract company name, document type, and fiscal year. Configure ragwire prompts for structured output and verify metadata ingestion from documents like a 10-K.

Explore RAGWire APIs and metadata for hybrid search by discovering metadata fields, filtering options, and structured extraction to build production-grade GenAI apps with agents.

Explore how to implement hybrid search with manual metadata filtering in qdrant, applying company name filters and fiscal year to refine rag retrieval results.

Ingest multi-year finance data, index with dense and sparse embeddings, and filter results by fiscal year to enable hybrid search over complex nested data structures.

Learn how LLM-driven auto metadata filtering works in ragwire for hybrid search, enabling internal auto filtering of vector db chunks based on ingestion and user query metadata.

Discover how agentic RAG uses an LLM connected to tools for retrieval, filtering control, memory, and final answer generation.

Launch a simple agentic rag using LangChain and RAGWire, configure a search document tool, retrieve results with optional filtering, and compare results and tracing to produce final answers.

Learn to extract filter context with ragwire, apply exact stored values to build final retrieval filters, and invoke get filter context before search to improve rag accuracy.

Build a filter-aware agentic rag workflow with llm-guided hybrid retrieval, using get filter context and search document to fetch relevant data with citations.

Configure RAGWire with multiple LLM and embedding providers—Gemini, Grok, Olama, and OpenAI—while managing logs and switching Quadrant VectorDB from local to remote.

Explore RAGWire's multi-provider llm and embedding setup, configuring provider-specific yaml files, selecting embeddings, and ingesting data while managing embedding compatibility and collection names.

Set up OpenAI for RAGWire by creating an API key, storing it in environment variables, and configuring YAML with text embedding three small and LLM models (GPT 5.4 or nano).

Master OpenAI hybrid search and batch ingestion with GPT in a config-driven rag pipeline, using YAML config, environment variables, and OpenAI integration.

Configure grok for fast llm inference by setting the grok api key and an external embedding model in a config file, using a quen3 32b model for finance reg grok.

Load the grok config, refresh environment variables, and load grok embeddings and LLM metadata; ingest data with rag grok, switch to hugging face embeddings, and retrieve to build RAG app.

Copy and rename the grok config to Gemini, set the Google API key, and update embedding and llm to Gemini 001 and Gemini models for Ragwire.

Load the Gemini configuration and environment variables, retrieve the Google API key, ingest documents, chunk content, and store embeddings in the local Quadrant vector DB for RAG hybrid search.

Learn how to deploy quadrant cloud's free vector db for rag ingestion, configure API keys and cluster endpoints, and ingest data into a remote collection.

Ingest finance data into Qdrant Cloud, set up an agentic RAG workflow with Google Gemini on Quadrant, and run remote vector retrieval to answer revenue questions.

Transform a finance RAG into health RAG using the ragwire framework, creating a config file and a health metadata YAML to answer questions from health data research papers.

This lecture demonstrates a config-driven ragwire setup to adapt from finance to health data. It covers loading health supplement research PDFs and creating health metadata YAML for proper retrieval.

Ingest health research papers into a health rag setup and run hybrid search with vector-based retrieval to retrieve and synthesize evidence from PDFs.

Implement an end-to-end agentic RAG for health data by converting a finance RAG to health, using a config-driven framework, health-specific prompts, and source-grounded answers from retrieved documents.

Implement a production-ready chat UI for a conversational rag chatbot using chainlit, enabling you to ask questions and receive agent responses from vector database hosted at quadrant.io, including tabular formats.

Explore building a production-ready rag chat UI with chainlit and chainlet, integrating lang chain, querying a quadrant vector DB, and later adding PDF uploads and chat history.

Import tool definitions and load config and finance metadata for a chainlit rag app; initialize llm, memory saver, and system prompt to break questions into sub-questions and synthesize cited answers.

Define and initialize the agent in on chat start, copy the agent, model, system prompt, and memory checkpoint, then set user session and thread IDs before sending the welcome message.

Retrieve the agent and thread id from chainlit sessions, configure memory, and display a thinking indicator while invoking the agent asynchronously; update the frontend with the latest generated response.

Run and test the production rag app by launching app.py in the conversational rag chatbot directory with chainlet, and observe memory, vector db access, and UI at localhost 8000.

Enable automatic document ingestion from uploaded pdfs into the quadrant vector db by implementing production-level changes: detect attachments, save to a temp directory, and ingest files.

Ingest pdf documents into VectorDV by uploading files to a temp directory, writing binary data, and triggering chainlit rag ingestion to populate the vector store.

Upload documents, ingest them into the vector database, track ingestion progress, and chat with RAGWire via Chainlit to query your data.

Explore building a production-grade FastAPI RAG backend and Chainlink chat frontend. Implement a chat UI with persistent histories, OpenAI-compatible endpoints, and an interview-ready RAG architecture.

Build a production-grade rag chat UI with a FastAPI backend and chainlit frontend, including sqlite-backed chat histories, user authentication, and a ready-to-run init db setup.

Learn to build a FastAPI backend that connects multiple AI agents to a chain-lit frontend, exposing OpenAI-compatible endpoints to talk to your agents.

Explore the document ingestion pipeline from raw files through the splitter to chunks, then embeddings in Quadrant VectorDB, and implement an OpenAI-compatible FastAPI endpoint with SSE streaming and RAG config.

Design a baseline LangChain agent for FastAPI RAG endpoints by configuring embeddings, a vector store, and metadata, and implementing search and filter context tools for OpenAI-compatible streaming.

Explore SSE streaming with a LangChain agent as an OpenAI endpoint, streaming chat responses from a Gemini model and filtering for chat model stream events.

Implement OpenAI-compatible endpoints with FastAPI to support health checks, V1 models, model info, chat completions via SSE streaming, and upload ingestion for a production-grade RAG-powered app.

Wire OpenAI compatible routes into FastAPI and initialize the Ragwire server. Test health, models, and chat completions with Postman and observe the API responses.

Connect a fastapi endpoint to a chainlit app, add a chat histories sidebar, and enable downloading responses as PDFs.

Load chat histories from a database, ingest uploaded files to the vector database, and stream chat completions in a Chainlit RAG app setup.

Perform end-to-end testing of a production RAG agent and chainlit chat app using a FastAPI OpenAI-compatible endpoint, featuring core RAG, LangChain agent, and API layers with Chainlit UI.

Detect JSON blocks in chat responses to fix data display in production chat UI. Apply a clean display method to replace JSON metadata with a user-friendly display and update history.

Explore Ragwire’s integration with four multi-agent frameworks—LionGraph, CRIU AI, Autogen, and Microsoft Agent Framework—to build agentic RAG systems and learn which approach fits each task.

Launch a line graph self-correcting agent by wiring rewrite query, retrieve query, and conditional nodes, with up to three retries to avoid hallucinations.

Operate a LangGraph RAG workflow to retrieve from a vector store, break complex questions into sub-questions, and generate sourced answers while citing sources to prevent hallucinations.

LangGraph self-correcting RAG: explore end-to-end testing by implementing rewrite query, retriever, generate, and conditional ages nodes to route and refine results.

Test LangGraph self-correcting RAG end-to-end by implementing a public stream interface that ingests user messages, streams AI chunks, and connects a front-end chat to a production gen AI app.

Build a line-graph supervisor multi-agent system that coordinates financial, legal risk, technical, and summary agents with a synthesizer to answer queries.

LangGraph uses a supervisor to dynamically derive specialist agents (financial, legal, risk, technical, summary) at runtime. A focus area guides the query; the synthesizer aggregates outputs into the final answer.

Learn to implement a LangGraph supervisor workflow that streams the agent’s final response from a synthesizer, coordinating multiple expert agents and dynamically adding specialists for end-to-end testing.

Explore how crew AI simplifies building rag agents by packaging role, goal, and backstory into a streamlined workflow, contrasts with line chain concepts, and supports streaming responses and OpenAI endpoints.

Set up the crew.ai document assistant rag agent by configuring the model id and llm (gemini), integrating crib-ai tools, and enabling streaming and tracing for the knowledge base.

Build a KrivAI multi-agent pipeline with researcher, analyst, and writer to retrieve documents from a vector DB, structure findings, and produce a final cited answer.

Test and deploy a crew.ai multi-agent workflow end-to-end, from login and tracing enablement to setting the agent environment and running the document researcher, research analyst, and technical writer.

Build a multi-agent autogen pipeline with planner, researcher, writer, critic, and compiler to iteratively produce a detailed report, including setup for autogen and OpenAI Azure and Google Gemini integration.

Configure a Microsoft AutoGen Gemini client using the OpenAI chat completion workaround, loading the API queue from environment and the base URL from Google APIs. Create five agents.

Learn to build a research collaboration team with Microsoft AutoGen, configuring planner, researcher, writer, critic, and compiler agents to produce structured reports for production genai apps.

Explore the Microsoft agent framework to build your first rag agent, comparing lang chain and lang graph workflows. Learn setup steps, tools, and streaming outputs with OpenAI and other providers.

Design a multi-agent system with the Microsoft agent framework, using a workflow executor to run parallel specialist agents, then collect, aggregate, and synthesize results into a detailed report.

Build and orchestrate task specialist agents using the Microsoft agent framework, defining query and specialist outputs, then connecting entry points, collectors, aggregators, and synthesizers to produce final results.

Build and configure specialist agents with makeSpecialist, convert llm clients into agents, and implement collectors to gather outputs. Aggregate results with an aggregator and synthesizer to generate final responses.

Learn to design an end-to-end RAG workflow with a synthesizer agent, multiple specialist agents, and an aggregator, then test streaming outputs and deploy the Microsoft multi-agent framework.