Ultimate RAG Bootcamp Using Langchain,LangGraph & Langsmith

Introduce retrieval augmented generation (rag) and its three-phase pipeline—ingestion, query processing, generation—showing how vector databases, similarity search, and external tools enrich retrieved content with metadata for accurate, up-to-date responses.

Explore retrieval augmented generation with similarity search in vector databases, metadata augmentation, and LLM-driven generation to deliver accurate, context-rich answers; reduce hallucination in customer support and save costs.

Discover how retrieval-augmented generation (rag) drives business impact, from JPMorgan’s $150 million annual savings to high ROI and rapid 6–8 week deployments across finance and beyond.

Compare prompt engineering, fine-tuning, and retrieval augmented generation (RAG) to decide which approach fits a project. Understand how each works and pros and cons, including external knowledge and vector databases.

Examine the data ingestion and preprocessing stage of RAG, where documents from PDFs and websites are chunked, embedded into vectors, and stored in a vector database for similarity search.

Explore the query processing phase of Rag, converting the input query to vectors with embeddings, performing cosine similarity in the vector database, and retrieving context for generation.

Install Anaconda to manage Python environments and packages for data science, then set up VS Code as the ide. Configure path, create environments, and launch Jupyter notebooks with code dot.

Set up a practical rag project using UV package manager, configure the environment, and implement data ingestion from PDFs and web pages with Lang Chain and LangGraph.

Master data ingestion in LangChain by converting documents into a structured document with page content and metadata; embed into vectors for a vector store using document loaders and text splitters.

Ingest and parse text data using document loaders in LangChain, transforming files into documents with page content and metadata. Explore text loader and directory loader workflows for files.

Master text splitting techniques for a RAG pipeline, using LangChain's character, recursive character, and token splitters to create overlapping chunks that feed vector searches and LLM context.

Learn to ingest and parse pdf documents with LangChain using pi pdf loader, pi mu df loader, and unstructured pdf loader, load attention.pdf, extract pages and metadata, and compare methods.

Learn to handle common pdf issues in data parsing with py pdf loader and recursive character text splitter, including cleaning text and creating metadata enriched chunks.

Read and parse word documents for rag using the doc x two txt loader and unstructured word document loader. Add metadata and create chunks to enable downstream retrieval and processing.

Learn to parse structured data from CSV and Excel using Pandas and LangChain, with row-based and custom processing. Convert results to documents with metadata for embeddings in a vector database.

Explore JSON ingestion, parsing, and processing using a JSON loader and jq schema in LangChain to convert JSON data into document structures with metadata.

Learn to read data from an sql database (sqlite) and convert it into a document structure with content and metadata, then chunk and relate tables via joins using Langchain tools.

Learn how embeddings turn text into vectors for vector databases. Compare vector search with traditional databases and explore OpenAI and Hugging Face embeddings in a Rag workflow.

Visualize embeddings by plotting two-dimensional word vectors and apply cosine similarity to measure relationships, illustrating how words like cat and kitten relate across embedding models.

Learn to create embeddings with Hugging Face models in a LangChain workflow for RAG bootcamp, converting text to 384-dimensional vectors without API keys, using embed query or embed documents.

Discover how OpenAI embeddings convert text to 1536-dimensional vectors, compare text embedding three small and large models, and set up API keys and environment variables to run them.

Explore vector embeddings with OpenAI embeddings, compute cosine similarities between sentences, and implement semantic search to retrieve top matching documents.

Compare vector stores and vector databases, their core functionalities like cosine similarity and KNN, architectures, and when to use each—from prototypes with millions of vectors to production-scale deployments.

Build a retrieval augmented generation pipeline using Lang Chain with Chroma DB as vector store. Explore vector stores versus databases and how embeddings enable similarity search with a language model.

Initialize a Chroma DB vector store with OpenAI embeddings, persist it locally, and store five chunks; test similarity search to retrieve top matches.

Build a traditional rag pipeline with Chroma DB and LangChain, LangGraph, and Langsmith, converting vector stores to retrievers, crafting prompts, and using document chains to query a large language model.

Learn to build a RAG pipeline with LCEL to run sequential steps from a vector store and embeddings through a custom prompt and LM and similarity search without inbuilt functions.

Add new documents to an existing vector store by reading, converting to document chunks with metadata, applying text splitting and embeddings, and storing updated vectors for improved rag-based querying.

Learn advanced rag techniques with conversational memory using a history aware retrieval, chat history prompts, and contextual prompts to preserve context across user queries in a vector store.

Learn to use grok LLMs with chroma db vector store in a RAG workflow, load grok API keys via env, and compare free grok access with OpenAI in LangChain.

Explore building a rag system with LangChain using the fires vector store, covering embedding setup, document chunking, vector indexing, and fast similarity search with metadata filters.

Learn to build a retrieval augmented generation system with LangChain and FAISS, using a vector store, retriever, and simple, conversational, and streaming RAG pipelines.

Discover and implement an in-memory vector store using LangChain core and OpenAI embeddings, perform cosine similarity searches, add documents, and convert results into a retriever for retrieval pipelines.

Create and query a full fledged vector database with DataStax Astra DB using LangChain, building a fast, embedding-based vector store, and performing vector search and retrieval with a retriever.

Learn to build a Rag application with Pinecone vector database using LangChain, creating an index and embeddings, then perform cosine similarity searches.

Apply semantic chunking to build more efficient rag pipelines by segmenting documents into meaningful, self-contained chunks using sentence embeddings and cosine similarity, then merge adjacent sentences above a threshold.

Apply semantic chunking in python using sentence transformers for embeddings, cosine similarity, and a 0.7 threshold to build a rag pipeline with modular code in LangChain.

Build a modular rag pipeline with a custom semantic chunker class and threshold 0.7, using sentence transformer embeddings. Incorporate a vector store, retriever, and prompt template for retrieval augmented generation.

Apply semantic chunking with LangChain to load a text document, initialize OpenAI embeddings, and use the semantic chunker to split content into meaningful chunks.

Explore hybrid search strategies that combine dense and sparse retrieval to improve context in rag applications, using tf-idf, BM25, and cosine similarity with vector stores.

Combine dense embeddings and BM25 sparse retrieval in a LangChain hybrid retriever, then build a rag pipeline that queries with a prompt and a chat model to deliver integrated results.

Hybrid search blends dense retrieval with exact keyword search to boost recall. An alpha-weighted score fuses dense and sparse results, capturing synonyms and misspellings.

Learn how reranking enhances hybrid search by reordering top K documents using a cross encoder or LM after retrieval with BM25 or dense and sparse retrievers, improving vector store results.

Implement reranking of top k documents from a retriever using a hybrid strategy in LangChain. Use a prompt and an LLM to reorder results based on the user query.

Explore maximal marginal relevance (MMR) as a diversity-aware retrieval strategy for hybrid search and RAG pipelines, balancing query relevance with novelty and non-redundant, diverse documents using cosine similarity and lambda.

Demonstrates practical MMR retrieval in a Langchain RAG pipeline by loading and chunking data, building a Hugging Face embedding vector store, and configuring an MMR retriever with k=3.

Leverage maximum marginal relevance (MMR) to deliver diverse, relevant results in retrieval augmented generation and reduce redundant inputs for chatbots and document browsers.

Learn how query expansion, a query enhancement technique, reformulates short queries to retrieve more relevant vector store results and improve RAG with grounded LLM answers.

Explore implementing query expansion in a RAG pipeline using a Langchain compatible prompt, an embedding-based vector store, and an MMR retriever to improve document retrieval.

Decompose a complex query into sub-queries to fetch targeted context from the retriever. The decomposer generates sub-queries, and the synthesizer combines the outputs for multi-hop reasoning in LangChain.

Learn the HyDE technique (hypothetical document embeddings) by generating a hypothetical answer with an llm, embedding it, and querying a vector store to improve retrieval for short queries.