Build Chat Applications with OpenAI and LangChain

Explore how tokenization drives OpenAI models by breaking text into tokens, understanding vocabulary, and balancing token size for context, pricing, and performance.

Explore how tokens drive pricing for OpenAI models, distinguish input and output tokens, and compare GPT-4 prices and context windows, then set up an Anaconda environment and API key.

Set up a Conda environment for LangChain and add it as a Jupyter kernel. Install OpenAI, ipykernel, and Jupyter tools, and configure the OpenAI API key as an environment variable.

Learn how to obtain and securely store your OpenAI API key or secret key, copy it to a text file, and understand billing when accessing OpenAI's API and language models.

learn to set the OpenAI API key as an environment variable to protect tokens and avoid hard coding, then load it from a dot env file using os.environ.

Set up isolated Python environments and a Jupyter kernel, configure OpenAI API keys, and build a first chatbot using OpenAI's chat model.

Explore system, user, and assistant roles in chat completion objects. Learn how the system message directs model behavior and persona, while user prompts and assistant outputs shape responses.

Configure a sarcastic chatbot named Marv in a Jupyter notebook, using a system message and user prompt, explore completion choices, n parameter, and token costs.

Explore how input tokens, completion tokens, and max tokens influence model outputs and API pricing. Use temperature and the stream option to deliver real-time, delta content in chat responses.

Explore the LangChain framework, including model input and output, prompts and prompt templates, output parsers, retrieval components, and agent tooling with the Lang Chain expression language.

Explore the Lang Chain chat OpenAI integration, learn about chat message types, prompt templates, and the chain concept, and build your first Lang Chain mini project with a sarcastic chatbot.

Explore how Lang Chain uses system and human messages to steer chat models, define a chat model, and invoke it with multiple messages to generate a sarcastic response.

Explore using AI messages in LangChain to shape model responses with few-shot prompting, removing system messages, and demonstrating sarcasm via dog and cat name examples.

Discover how to design reusable prompt templates with LangChain’s prompt template class, converting system and user messages into a prompt value by invoking with a dictionary of input variables.

Learn to create and combine chat prompt templates and chat prompt values, define system and human message templates, and invoke a chat model to generate AI responses.

Master few shot chat message prompts by using the few shot chat message prompt template, replacing cluttered per-example human AI pairs with a scalable chat prompt template approach.

Learn to use the string output parser to extract content from an AI message object in a hands-on Jupyter notebook, converting chat results into a string for easy use.

Explore the comma separated list output parser in LangChain, converting chat outputs into a clean list of values and using get format instructions to refine formatting.

Explore the LangChain date time output parser, replace the old parser, and configure format instructions so the model returns a date in the required format.

Build a chain with a chat template, a chat model, and a comma separated list output parser using long chain expression language and invoke, stream, and batch methods.

Explore batching in LangChain, running multiple input sets in parallel with the batch method, using pet and breed like dog and shepherd or dragon and nightfury to boost time efficiency.

Learn to stream chat responses using LangChain's stream method, via Python generators that yield message chunk objects, manage tokens, and print content incrementally.

Explore how LangChain chains runnables with a pipe, enabling invoke, batch, stream, and transform across chat prompt templates and output parsers in a runnable sequence.

Learn to pipe chains with a runnable passthrough identity, build tools and strategy chat templates, and combine chains to generate personalized learning plans for a data scientist.

Visualize lang chain graphs by rendering chain components with the Gandalf Python package, showing two chat prompt templates feeding a chain and illustrating parallel branches.

Run the books chain and the projects chain in parallel with the runnable parallel class, compare to sequential execution, visualize the graph, and show faster results for a Python input.

Learn how a runnable parallel object runs multiple runnables in parallel and how to chain it with a time estimation template in LangChain, using books and projects as input.

Convert Python lambda functions into runnable objects with the runnable lambda, then compose them into a chain using pipe to compute list sum and its square, and visualize the graph.

Explore the @chain decorator in LangChain, wrapping functions into runnable lambdas to build chained data processing with examples, type checks, and cautions about name conflicts.

Discover three methods to inject custom data into large language models—prompting, fine tuning, and retrieval augmented generation (rag)—and compare their trade-offs for proprietary information.

Explore retrieval augmented generation for chat apps, comparing prompt-based, fine-tuning, and augmented data approaches, and learn how indexing, retrieval, and generation deliver context-aware responses.

Explore document loading and splitting in LangChain, converting diverse formats into standardized document objects, and creating meaningful chunks to fit model context windows for efficient retrieval augmented generation.

Learn how document embedding converts text into vectors to capture semantic meaning and enable similarity searches using dot product, cosine similarity, and Euclidean distance.

Learn how LangChain loads data into document objects, splits text into chunks, embeds them as vectors, and stores them for semantic search with diverse retrievers and augmented generation.

Load PDF and DOCX files in Lang Chain with PyPDFLoader, preprocess text to remove newlines, and prepare a chatbot that answers from the transcript.

Learn to load a docx file with the DocXToTextLoader in Langshan, producing a single document text and file path metadata for reliable indexing.

Learn to split documents into chunks to fit a model’s context and improve chatbot responses. Explore character-based splitting, chunk size, and overlaps, and plan to code the approach next.

Explore indexing documents with a LangChain character text splitter by splitting text into 500-character chunks, adjusting overlap, and using custom separators to control where chunks end.

Learn to index lecture content by splitting documents with LangChain's markdown header text splitter, using markdown headings to create organized chunks while preserving course and lecture metadata.

Load and split text with a doc X loader and text splitter, generate OpenAI embeddings, and assess semantic similarity between chunks to prepare for a vector database in chat apps.

Embed all 20 document chunks into a chroma vector store with LangChain's from_documents, a chosen embedding model, and a persist directory for persistent, context-aware retrieval.

Explore indexing in vector stores by adding, updating, and deleting documents with OpenAI embeddings and Chroma, inspect documents via the vector store's get method, and prepare for retrieval.

Discover retrieval in a vector store using similarity search and maximal marginal relevance. See LangChain's vector store retriever, embeddings, and an LLM generate responses.

Use maximal marginal relevance (mmr) search to balance relevance and diversity in retrieval, improving on similarity methods. Tune lambda and filters to target the second lecture and observe result diversity.

Implement a vector store retriever in a LangChain workflow, configure MMR search with k=3 and lambda=0.7, and invoke it to retrieve documents for rag technique generation.

Build the generation step of the Rag technique with a vector store and an expression language chain, using three documents and maximal marginal relevance for a context-specific response.

Develop a retrieval chain for generation by wiring a prompt, an OpenAI chat instance, and a string output parser, while evaluating stuffing versus document refinement for context handling.