RAG for Professionals with LangGraph, Python and OpenAI

Create a course-specific environment with Anaconda using the provided environment YAML to install Python 3.11, name it LC graph, and set up Jupyter Notebook in that environment.

Install the Anaconda distribution to get Python and a complete data science environment with pre-installed packages, simplifying dependency management and enabling Jupyter notebooks and IDEs like PyCharm or Spyder.

Explore the Anaconda Navigator and launch Jupyter Notebook to write and run Python code, manage environments, and inspect installed packages with conda list.

Jupyter notebooks offer an interactive coding environment for Python code, text, images, and links, with edit and command modes, markdown support, and headers.

Use OpenAI's API to perform retrieval augmented generation, retrieving external sources before generating informed answers. Set up the API platform account and consider pricing and models like GPT five.

Create your OpenAI account, learn about the native API and LangChain-LangGraph wrappers, and note GPT four mini as a cost-efficient choice with pricing per 1 million tokens.

Demonstrate creating an OpenAI API key, configuring permissions, and securely storing the secret key for Python, LangGraph, and LangChain, with notes on env files and funding up to 5 USD.

Launch a simple one-shot chatbot using Python, lang chain, and the OpenAI API in a Jupyter notebook. Memoryless chat demonstrates testing prompts and responses as the course begins.

download and unzip part one materials, locate and insert your OpenAI API key, and set up four Jupyter notebooks for chatbot, summarization, rag chain, and graph basics.

Dive into a toy chatbot using the OpenAI API and LangChain, showing a GPT-4 mini with deterministic output and a prompt about Lionel Messi's age, highlighting a model cutoff issue.

Replace deprecated predict with invoke to gain structured inputs and async, streaming support, improving compatibility with lang chain, lang graph, and OpenAI workflows.

Learn to initialize and switch between openai models with init chat model and chat openai, and compare context windows and pricing to choose GPT-4 mini for cost efficiency.

Explore token and cost analysis for language models, including input/output tokens, price per million, context windows, and how model choice affects speed and cost.

Explore dynamic prompts and prompt templates, including placeholders and formatted prompts, before invoking the language model. See how templates separate logic from input and boost reusability and scalability.

Learn to build chat prompts with roles using the chat prompt template. Define system and human messages and roles such as system, human, AI, and assistant to shape context.

Explore the LangChain expression language to create three-step AI chains—prompt, model invocation, and string parser—using a pipe syntax for cleaner, modular, and reusable pipelines.

Introduce runnables as standardized, composable building blocks for input and output in a chain language, enabling you to chain prompts, llms, parsers, and tools with a pipe for lego-like workflows.

Learn to build two custom runnables with lambda functions to extend prompts and modify responses. Create a prompt chain where the question is augmented, parsed, and the final answer adjusted.

Wrap up the one-shot memoryless chatbot workflow using an init chat model, LangChain, and a template output parser to run interactive sessions and highlight memory gaps.

Transform a one-shot chain into a memory-enabled conversation by maintaining a message history (system, human, AI), iterating prompts, and preparing for Landgraf integration.

Load a pdf with LangChain, pass it to an LLM, and generate summaries via the API using Python and OpenAI. Learn splitting and chunking for documents and three summarization methods.

Download part one materials, copy your OpenAI API key into the end file, and open notebook two summarization in the Jupyter dashboard to run a toy example.

This toy summarization example demonstrates a standalone pdf workflow in LangChain, summarizing a contract between abc corporation and john doe under Delaware law.

Learn how LangChain's built-in load summarize chain streamlines document summarization, from loading a PDF doc, feeding input documents and prompts to producing an output text dictionary.

Learn how to load pdf files with LangChain using the pi pdf loader, handle file paths and passwords, and produce text from pdf pages for full document extraction.

Use pi pdf loader to load pdfs by page or as a single document, set file path and password, and optionally add a page delimiter to print page content.

Load large pdf documents with the Pi.pdf loader in LangChain to parse the Apple 10-K, inspect metadata, and access content page by page.

Learn to save memory with lazy loading by iterating through 121 pages, loading each page in turn with the Pi PDF loader and dropping it after use.

Learn to split and chunk long documents with text splitters to manage token limits, memory use, and accuracy, comparing full text versus chunking for long texts.

Explore chunking by pages and its limitations when loading large PDFs, and learn how to combine page-based splitting with more specialized methods for effective chunking in RAG workflows.

Explore text splitting with the recursive character text splitter. Learn to create cohesive chunks up to 2000 characters with 500 overlap, preserving paragraph and sentence boundaries for long documents.

Explore pitfalls in loading and splitting PDFs, such as misread line breaks and missing double line breaks, and learn mitigations with larger chunk sizes and overlaps in LangChain PDF reader.

Learn how to split large PDFs with a recursive character text splitter in Langchain, comparing single-mode and page-mode chunking, managing 10k character chunks, overlaps, and metadata.

Compare the recursive character text splitter and the token text splitter from LangChain, highlighting chunk size in tokens vs characters, 20% overlap, and when to prefer each for token-limited models.

Apply stuff summarization by concatenating the full text into a single prompt fed to the LLM, for small to large documents, using customized and built-in chains.

Learn to summarize a contract PDF with the built-in load summarize chain using the stuff type, producing a five bullet summary and guidance on when to use it.

Explore MapReduce summarization for very large documents by chunking text, summarizing chunks in a map step, then refining a final summary in a reduce step.

Apply map-reduce summarization using the built-in chain to process 52 document chunks with map and reduce prompts, enabling intermediate chunk summaries and parallel execution, and produce a final summary.

Explore the pros and cons of map-reduce for chunked inputs and learn when to use parallel map steps, with tips on 1 to 2000 characters and 10 to 15% overlap.

Explore iterative refinement for very large documents, starting with an initial chunk summary and updating it with each new text to preserve coherence, cross-chunk dependencies, and narrative structure.

Refine summaries iteratively with LangChain’s built-in chain, loading large documents as chunks, and using a question prompt plus refine prompt with strict update rules to keep content concise and coherent.

Learn to load and chunk pdfs, generate initial and refined summaries with a question chain and a refine chain, and compare staff, MapReduce, and refine approaches for scalable document summarization.

Build basic retrieval augmented generation workflow with python, lang chain, and OpenAI by loading a single pdf, vectorizing with an embedding model, and retrieving similar vectors to generate a response.

Confirm prerequisites and download the section four downloads and preparations, then load your OpenAI API key and open notebook number three to run the showcase example in the Jupyter dashboard.

Explore retrieval augmented generation (rag) for business docs, grounding answers in private policies, tickets, and contracts using embedding-based vector stores and built-in chains without model retraining.

Build and run built-in LangChain chains for RAG, load Apple 10-K, create embeddings and a vector store, and execute a customized chain to answer 2024 Apple revenue and challenges.

Contrast RAG with stuffing all docs into prompts; RAG scales, reduces tokens, and improves relevance with targeted passages and citations, while stuffing is simple but limited to small, static corpora.

Learn to load and chunk large documents, favoring single mode for coherence and metadata. Use the 10-K example with 7–10k character chunks and 15% overlap.

Explore vectorization and embedding to turn text into numeric vectors with OpenAI embeddings, where similar terms cluster by meaning, enabling retrieval in a vector store for a retrieval generation workflow.

Learn how vector retrieval using FAISS enables similarity search to return the four most similar document chunks for a user query, with retriever wrappers in LangChain.

Explore augmented text generation by merging retrieved chunks with a language model using a prompt template, system and human messages, and a vector retriever to answer questions from context.

Reuse embeddings and the vector store in memory to support multiple queries using a retrieval augmented generation (rg) chain with lang chain, saving the vector store for long-term persistence.

Explore retrieval augmented generation with persistent long-term memory for vector stores using faiss and Chroma, loading embeddings once, saving costs, and enabling seamless Q and A across sessions.

Explore similarity score threshold in retrieval strategies, showing how varying thresholds affect retrieved documents, query sensitivity, and the impact of prompt engineering on RAG performance.

Explore max marginal relevance (mmr) retrieval, balancing similarity and diversity to deliver non-redundant, relevant chunks via a larger candidate set and lambda tuning.

Compare retrieval strategies: similarity, similarity score threshold, and MMR, for precision, diversity, and coverage in retrieval augmented generation.

Apply retrieval augmented generation across four tasks—focused Q&A, exploratory Q&A, summarization, and semantic search—by defining strategies and parameters, evaluating responses, and extracting relevant 10-K passages.

Explore precise fact lookups using focused Q&A with vector retrieval, set similarity thresholds, and step-by-step prompts to extract exact figures like Apple’s 2024 gross margin and share repurchases.

Learn to craft exploratory and multi-aspect Q&A prompts. Compare 2024 vs 2023 regional performance and assess currency effects and supply chain notes.

Leverage RAG for summarization with LangGraph, Python, and OpenAI to generate a ten-bullet executive summary of Apple's 10-K, covering business model, financials, segment mix, liquidity, risk factors, and legal matters.

Explore semantic search and browse tasks in rag with langgraph, python, and openai, retrieving and presenting text passages, snippets, and citations with headings and section references.

Use the multi query retriever from Lang Chain Retrievers to reduce reliance on query wording and reveal Apple's 2024 gross margin and its change from 2023.

Explore data security in retrieval augmented generation by comparing levels two to four, detailing embeddings and llm flows via OpenAI and Azure OpenAI, private endpoints, and EU region compliance.

Explore the Landgraf framework for identifying ai workflows and the LangGraph approach to connect chains into graphs, while integrating r workflows and memory-enabled chats with an llm.

Prepare by downloading part one materials, including four Jupyter notebooks, and paste your OpenAI API key into end file. Then open Jupyter dashboard and notebook four graph basics to begin.

Learn how Landgraf uses a typed dict to define state across a graph of nodes. See how nodes update number and string with partial updates and runtime checks with LangChain.

Build a simple linear graph without memory using LangGraph to process a state with a number and a string through two nodes, yielding updated number and blah appended to string.

Learn robust handling of partial states in LangGraph by treating state as a two-key dictionary (number, string). Use get with defaults to prevent key errors and enable safe updates.

Examine a simple graph chain with memory, showing how to initialize state, invoke with full and partial inputs, and store per-thread history using memory saver and checkpoint.

See how graph states update by default and overwrite. Use annotated types with a reducer to save previous states as lists of integers and strings.

Wrap up a simple real-world example with LangGraph by computing subtotal, vat, and total per order, updating receipts, and tracking billing across a linear graph.

Explore building a simple graph with LangChain messages by adding AI, human, and system messages across three nodes. Learn memory, partial state updates, and graph invocation to evolve the conversation.

Learn how the add_messages reducer builds and maintains a conversation by merging message lists, assigning unique IDs, replacing messages by id, and removing messages by id.

Collect a messages conversation with LangGraph to manage a memory-enabled chat, using an annotated messages list, add messages reducer, and pretty-printed AI and human exchanges for a real chatbot workflow.

Explore using the built-in messages state class in LangChain with Landgraf, importing or subclassing it, and wiring a simple state graph for human and AI messages.

Explore how to build a memory-enabled chatbot with LangChain and OpenAI, wiring an LM, a prompt template, a string output parser, and a chain for an interactive session.

Create a memory-enabled chatbot using LangGraph and OpenAI by leveraging a customized messages state, a system message, and a single chat node to preserve conversation history.

Integrate a lang chain into a lang graph to build a chatbot with memory, using a messages placeholder and a chat prompt template to pass historical messages.

This lecture explains how to manage chat history in long conversations by using a sliding window, a rolling summary, and retrieval memory to control tokens and costs.

Apply a sliding window to truncate chat history to last two turns (four messages) using history and question keys. Build the prompt with system, history, and question, then update messages.

Explore retrieval augmented generation with truncated chat memory, using a vector store for Apple 10-K and a similarity retriever to supply context-rich answers via two nodes in LangChain and LangGraph.

Introduce loading, splitting, and chunking multiple documents across folders and file types, including pdf, word, text, powerpoint, and csv, into a vector store for retrieval.

Prepare for coding by downloading and unzipping the multi-document bundle, then load contract PDFs, exhibits, amendments, waivers, reports, and data with lang chain and lang graph in Python.

Load multiple pdf documents from a directory using the pi pdf directory loader in LangChain, exploring default settings, single versus page mode, and glob patterns to load subfolders.

Explore the PyPDFDirectoryLoader's optional settings, including the globe parameter that recursively scans non-hidden PDFs in a directory and its subfolders, with options for recursive behavior and single versus star patterns.

Load multiple pdf files efficiently with the directory loader, using patterns, loader cls, and recursive options, with multithreading and an optional progress bar for faster ingestion.

Load PDFs with the unstructured loader as the default option, compare it to the directory loader, and explore metadata, page content, and elements versus pages.

Learn to load text files using the lang chain community document loaders, by configuring the path, enabling auto-detect encoding, and loading the document with metadata into docs.

Load word files (.docx) with the docs to text loader from long chain community document loaders, loading report short.docx in single mode; preview the content.

Load PowerPoint files with the unstructured PowerPoint loader in Lang chain, using single mode and elements mode, and review paging options and content like title, executive summary, and market overview.

Load PowerPoint presentations as PDFs with the PDF loader, converting slides into a one-page-per-slide PDF report. Choose between single and page options, view slide metadata, and print the resulting document.

Load csv files into a pandas dataframe with pd.read_csv and the csv loader from Langbein community document loaders, turning a Dow Jones csv into 30 documents.

Load mixed file types from a folder using the unstructured loader and directory loader. The approach experiences errors and is not preferred; switch to specialized loaders for each file type.

Load all files from a directory and subfolders with DirectoryLoader, including pdf, text, word, csv, and powerpoint, comparing csv loader versus unstructured loader and noting metadata differences.

Review loading ten documents, split larger ones to a 10,000 character target with a 2,000 character overlap, then save the vector database after vectorizing with OpenAI embeddings and FAISS.

Harness LangGraph to perform RAG with multiple documents and file types, vectorizing, indexing, and querying a messy folder to answer contract and amendment questions in real-world scenarios.

Load files related to contract id 12345 using a name contains pattern and case-insensitive tokens with lang chain pdf and docs text loaders, excluding drafts and templates to keep documents.

Prepare by downloading the dynamic vector database with chroma, unzipping materials, opening the jupyter notebook, and adding your openai api key in the env file.

Explore two options to build a chroma vector database: start empty and add docs later, or initialize with initial docs, using OpenAI embeddings via PDF loader and text-embedding-3-small, demo collection.

initialize a chroma vector database with initial docs, restart the kernel, and load a contract pdf; then use get to retrieve ids and optionally embeddings.

Learn to load an existing chroma vector database from disk, reuse the same collection name and directory, and work with the two saved vectors in upcoming lectures.

Load the vector database from the chroma demo folder to search by id and access the first document's embeddings, content, and metadata.

Delete vectors by ID from the vector database using the delete method, removing documents and metadata to leave an empty database. Next lecture covers adding documents and advanced workflows.

Load pdf files from a directory using a directory loader into a vector store, then prepare for metadata filtering and retrieve the five most similar vectors to compensation and remuneration.

Filter metadata in vector-based retrieval to fetch the most similar contract pdf documents by doc name and source, using direct filtering or a vector db retriever.

Learn to filter across multiple source documents using query syntax, with in, not equal, not in, and equal operators, illustrated by contract PDFs and hits.

Learn how to filter documents by page in a vector database, using exact, greater than, less than, and range queries to retrieve page-specific results, with examples on contracts and invoices.

Master advanced metadata searching and filtering by combining multiple conditions with logical operators such as and and or, refining vector database searches with page range and source constraints.

Learn to change, add, and update metadata to enable reliable filtering by creation date across documents. Normalize datetime formats, convert to unix timestamps in UTC, and harmonize to datetime objects.

Add Unix timestamp to existing metadata by converting creation dates, updating nine documents in the vector database, and batching updates while validating results.

Filter documents by creation date using utc unix timestamps and greater-than or less-than filters in a similarity search to retrieve relevant pdfs.

Learn to filter documents by content substrings in a retrieval-augmented workflow, using content constraints and the dollar contains predicate alongside metadata filters.

Master advanced searching and filtering by document contents using substrings, case-sensitive rules, and logical operators to refine results across contract documents.

Filter document contents using substrings and optional regex examples from the course. Note that regex is deprecated in modern Chrome, so substrings offer a robust alternative, e.g., matching 2020–2029 years.

Explore practical techniques in Python workflows for adding, updating, and deleting docs in a Chroma vector database, including renaming files, updating metadata, and refreshing embeddings.

Automate vector database updates with chroma and Python for document collections, building a full RAG workflow for professionals using LangGraph and OpenAI.

Detect content changes in a single word file by hashing text with sha256 and hex digest, creating a fingerprints json. Load, compare, and update hashes to flag even small edits.

Detect content changes across all files in a directory by hashing normalized text, comparing current and previous fingerprints, updating the baseline, and discussing pre-filters like file size and timestamp.

Use prefilters for large projects and build a manifest.json in Python to track file updates, detecting added, modified, deleted, and renamed files by size, mtime, and content hashes.

See how pre-filter code classifies files into renamed or moved, added, content modifications, deleted, and unchanged, with live runs showing detection and hashing guiding re-embedding decisions.

Bring together detecting, hashing, loading, chunking, and embedding in a single Python script, updating a chroma vector database with chunked documents and metadata.

Update document embeddings after edits, renames, and new files via a change-detection and re-embedding workflow. The lecture covers metadata and manifest updates, noting extension to formats like PDF and PowerPoint.