
Explore large language models with LangChain and Hugging Face, using Google Colab to build prompts, chat bots, RAG pipelines, agents, and PDF/video QA applications.
Explore what large language models are and how they use neural networks, machine learning, and natural language processing to understand and generate language, with examples like chatbots and text generation.
Explore how large language models train using unsupervised learning on massive text datasets. See how transformers, GPUs, and parallel processing enable context-aware generation, summarization, translation, and more.
Learn how transformers use self-attention to overcome encoder-decoder limitations and how foundation models underpin LLMs with broad capabilities across text and other modalities.
Explore how embeddings convert text into numerical vectors for similarity search, and how tokenization uses a vocabulary and attention to place words as tokens.
Explore the evolution and historical context of language models from early statistical and neural approaches to transformer giants like GPT and Bert, including open‑source milestones and ChatGPT's impact.
Explore why LLMs matter today and see applications like chatbots, code generation, text generation, translation, and content summarization, which boost automation and analyze market trends and customer feedback.
Analyze the cost, privacy, bias, and ethics of LMS, highlighting open-source options that run locally, fact-checking needs, and risks of hallucinations.
Compare proprietary and open source LM models, highlighting open source transparency, customization, and cost benefits, alongside proprietary advantages like dedicated support and security; note small language models for local use.
Explore Hugging Face, an open source hub for models and tools including text generation, and learn to create an account and a read token for Python workflows.
Explore the three main llm types—base, instruct, and chat models—and how prompt engineering and model choice affect chat bot and task performance.
Install and configure Hugging Face transformers on Google Colab, enable GPU, set up token access, load the phi three mini 4K instructs model, and create a text generation pipeline.
Learn to generate text using generation args, including max new tokens, return full text, temperature, and sampling, and see templates refine prompts for controlled output.
Learn to build prompt templates in LangChain that translate user input into model instructions. Use system, user, and assistant roles with special tokens to guide responses.
Master prompt engineering in LangChain by crafting system and user prompts, using templates to tailor AI outputs, and experimenting with language, code, and structured prompts.
Implement examples using message format and prompt engineering by defining system and user roles with templates. Test with code and prompts, and discuss strategies to reduce hallucinations across models.
Quantization lowers model precision from 32-bit to 16-bit or 8-bit, reducing memory usage and speeding up inference with minimal accuracy loss; four-bit quantization enables running larger models on limited hardware.
Explore link chain, an open source library that unifies llms with data sources, prompts, vector stores, memory, agents, chains, indexes, and retrieval strategies, using the lcl language.
Install LangChain and related libraries via pip in Google Colab, restart the runtime to manage memory, and prepare imports for transformers and LangChain components.
Explore LangChain models and long chain with a Hugging Face pipeline, loading a phi three mini model and tuning temperature 0.1, max new tokens 500, and repetition penalty 1.1.
Explore open source models such as Lemma, with 8B and 70B parameter versions and an 8000-token context, and learn to load and test them for text or code outputs.
Load chat modules using link chain, define human and system messages, and build a chat model with the Hugging Face class, using the lemma three model.
Explore prompt templates in LangChain, including string and chat templates, learn to create and invoke templates with topics like artificial intelligence, and reuse prompts in future implementations.
Connect prompts into chains to build complex ai applications, then extend with custom functions using runnable lambda to count words and enhance workflows with LangChain.
Learn how streaming improves user experience by displaying each token as it is generated, visualizing text step by step, and using the string function with topic and size per chunk.
Discover how to access models with LangChain using Hugging Face Hub and other providers, including OpenAI, Anthropic, and Google generative AI, with API tokens and model parameters.
Install and configure a full local environment for LangChain, including Python, Visual Studio Code, an .env file for keys, and essential libraries like Hugging Face, OpenAI, torch, and transformers.
Run llms on your own machine with Ollama, install from the official site, and test llama 3 models offline while integrating with LangChain for local code-based experiments.
Discover how retrieval augmented generation blends language models with external data sources, enabling up to date, domain specific answers through indexing, embeddings, and vector databases while reducing hallucinations.
Prepare the environment for LangChain by installing libraries, setting up the chroma vector store for embeddings, loading the model and tokenizer, and defining the prompt template.
Explore tests with RAG by wiring prompts, context, and questions in a chain, using a system prompt and template to feed retrieved data to the algorithm.
Enable debugging in LangChain, visualize inputs and outputs at each chain step, and inspect prompts, LLM calls, and parser results to ensure correct outputs.
Index and embed documents by loading via document loaders, splitting into chunked texts within token limits, and storing them in a vector store for retrieval by an llm.
Implement the Rag indexing pipeline by loading content, chunking into 1000-character pieces with 200 overlap, embedding with Hugging Face sentence transformer mp net base v2, and storing vectors in Chroma.
Learn how to recover documents with a retrieval and generation pipeline using vector stores, embeddings, and similarity search to feed an LLM with relevant context.
Implement a complete rag pipeline by retrieving relevant documents with a similarity retriever, building a prompt, and generating answers from a language model.
Learn how large language models use agents and toolkits to perform actions with tools like Google search and Wikipedia, enabling dynamic reasoning and adaptive task execution.
Explore building agents with LangChain by wiring a Wikipedia tool, installing the package, configuring Wikipedia query run with an API wrapper, and testing with searches like deep learning.
Learn to create a custom tool in LangChain with a Python function that returns the current day, month, and year for LM execution, and assemble a toolkit.
Explore ReAct, which blends chain-of-thought reasoning with iterative actions and observations to solve complex problems using tools and memory in LangChain workflows.
Create and test an agent by loading a model from Hugging Face endpoints, importing LangChain components, and configuring the prompt. Run an agent executor to manage tools and errors.
Learn how to run tests with ChatGPT in LangChain by installing the package, setting the OpenAI API key, and probing GPT-4 mini with a zero temperature for population queries.
Learn to use Tavileh with LangChain to fetch internet data beyond Wikipedia, configure an API key in Google Colab, and compare Wikipedia results with table-based sources.
Demonstrate chat templates by using human message and ai message classes, binding tools like Wikipedia, and running an agent to fetch current data such as Nvidia market cap.
Discover Lang Smith with the Lang Graph library to inspect multi-step LLM chains, enable chain tracing, recreate agents, and visualize step-by-step execution for debugging complex Lang Chain apps.
Set up an environment to transcribe and summarize videos with YouTube transcript API, Pi tube, LangChain, and OpenAI tools, enabling an app that analyzes video content via chat.
Load transcripts with YouTube loader, extract subtitles, fetch the video title, and save the transcript to a utf-8 file for a lecture on biological fundamentals of artificial neural networks.
Load models from three sources—huggingface hub, OpenAI, and Oklahoma—by defining functions with default parameters, setting API keys, and testing model loading.
Create a prompt template by defining system prompts and inputs (the query and transcripts). Implement model-aware prompts for Hugging Face versus other models like ChatGPT or Llama.
Create a chain of prompts linked to a language model and output parser, then invoke it with a transcript and user query to produce summaries and translations across languages.
Join existing code into functional modules, enabling video info retrieval, transcript extraction, and interpretive summarization via a modular lm chain and YouTube loader.
Master markdown for visualization to render engaging video info, titles, and topic lists with IPython's markdown class, bold and italic formatting, and lists, enabling English language outputs via LangChain.
Develop a custom chatbot with memory and conversation history and a web interface using streamlit, running locally in Visual Studio Code, with optional Google Colab code.
Implement model loading with multiple providers, configure prompts and chain prompts, store chat history, and generate step-by-step responses in multiple languages using LangChain.
Learn session control with Streamlit session state to store chat history as a session variable and remember past interactions via AI and human messages.
Implement a chat input and store messages in the session chat history as human and ai messages. Use a prompt template and chain to produce model responses in Streamlit app.
Run project two in Google Colab by installing libraries, configuring API keys with a .env file, and using a local tunnel to expose the Streamlit app built from proj_two.py.
Prepare the environment to implement project three, building a document chat with an advanced rag pipeline, set up files-based embeddings, and run a local web interface in VS Code.
Build a side panel in the web interface to select pdf files and send them as context to the llm via a rag pipeline that extracts file information.
Implement indexing and retrieval for the rag pipeline by loading pdfs, chunking, embedding with hugging face baibgem3, and storing vectors in the faes vector db for mmr-based user query retrieval.
Design an advanced conversation chain using history-aware retrieval to reformulate queries based on chat history, integrate a Rag pipeline, and contextualize prompts for more coherent responses.
Finish implementing a document-aware chat bot using a rag pipeline with file uploads, session state, and a retriever, showing sources and page references in the conversation.
Learn to run a Google Colab notebook by saving a drive copy, installing libraries, and launching a Streamlit interface to interact with the chatbot.
Recap of master LLMs with LangChain: large language models, Hugging Face, Rag and agents, plus video transcription, memory chatbot with a web interface, and document extraction.
Master llms with LangChain offers an online ai and data science platform with monthly courses, certificates, memberships, and practical demonstrations across machine learning, deep learning, and natural language processing.
In this course, you will dive deep into the world of Generative AI with LLMs (Large Language Models), exploring the potential of combining LangChain with Python. You will implement proprietary solutions (like ChatGPT) and modern open-source models like Llama and Phi. Through practical, real-world projects, you'll develop innovative applications, including a custom virtual assistant and a chatbot that interacts with documents and videos. We'll explore advanced techniques such as RAG and agents, and use tools like Streamlit to create intuitive interfaces. You'll learn how to use these technologies for free in Google Colab and also how to run projects locally.
In the introduction, you’ll be introduced to the theory of Large Language Models (LLMs) and their fundamental concepts. Additionally, we’ll explore the Hugging Face ecosystem, which offers modern solutions for Natural Language Processing (NLP). You'll learn to implement LLMs using both the Hugging Face pipeline and the LangChain library, understanding the advantages of each approach.
The second part is focused on mastering LangChain. You'll learn to access open-source models, like Meta's Llama and Microsoft’s Phi, as well as proprietary LLMs, like OpenAI's ChatGPT. We'll explain model quantization to enhance performance and scalability. Key LangChain components, such as chains, templates, and tools, will be presented, along with how to use them to develop robust NLP solutions. Prompt engineering techniques will be covered to help you achieve more accurate results. The concept of RAG (Retrieval-Augmented Generation) will be explored, including information storage and retrieval processes. You’ll learn to implement vector stores and understand the importance of embeddings and how to use them effectively. We’ll also demonstrate how to use RAG to interact with PDF documents and web pages. Additionally, you'll have the opportunity to explore integrating agents and tools, like using LLMs to perform web searches and retrieve recent information. Solutions will be implemented locally, enabling access to open-source models even without an internet connection.
In the project development phase, you’ll learn to create a custom chatbot with an interface and memory for Q&A. You’ll also learn to develop interactive applications using Streamlit, making it easy to build intuitive interfaces. One project involves developing an advanced application using RAG to interact with multiple documents and extract relevant information through a chat interface. Another project will focus on building an application that automatically summarizes videos and answers related questions, resulting in a powerful tool for instant, automated video comprehension.