session-1/LangChain_zoomcamp_Session_1_Chat_with_Website_LangChain.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# 🦜🔗 LangChain zoomcamp - Session 1!\n",
        "\n"
      ],
      "metadata": {
        "id": "NFOV3y1pQPrG"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zwn8XYP3_n4m"
      },
      "outputs": [],
      "source": [
        "%%capture\n",
        "!pip install langchain openai gradio tiktoken faiss-cpu"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import re\n",
        "import getpass\n",
        "import langchain\n",
        "from langchain.document_loaders import WebBaseLoader\n",
        "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
        "from langchain.embeddings import CacheBackedEmbeddings\n",
        "from langchain.embeddings import OpenAIEmbeddings\n",
        "from langchain.vectorstores import FAISS\n",
        "from langchain.storage import LocalFileStore\n",
        "from typing import List, Union\n",
        "\n",
        "from langchain.chains import ConversationalRetrievalChain\n",
        "from langchain.memory import ConversationBufferMemory\n",
        "from langchain.chat_models import ChatOpenAI"
      ],
      "metadata": {
        "id": "jinkvtnMBoNw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "os.environ[\"OPENAI_API_KEY\"] = getpass.getpass(\"Enter Your OpenAI API Key:\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SnxyPzchVZft",
        "outputId": "b4fcd759-96a4-4796-89bb-804f4b6bac74"
      },
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter Your OpenAI API Key:··········\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Building a Context-Aware Chatbot using Web Data and OpenAI\n",
        "\n",
        "In the vast ocean of information available on the web, extracting relevant insights can sometimes be a daunting task.\n",
        "\n",
        "But what if you could have a chatbot that can crawl websites, understand their content, and provide you with concise answers?\n",
        "\n",
        "In our latest project, we've built a chatbot that does just that!\n",
        "\n",
        "Let's walk you through the steps:\n",
        "\n",
        "# 1. Extracting URLs from Text\n",
        "\n",
        "First, we identify URLs from a given text.\n",
        "\n",
        "This can be any text containing references to websites that you want the chatbot to understand.\n",
        "\n",
        "```\n",
        "url_lists = find_urls(text)\n",
        "```\n",
        "\n",
        "# 2. Load the documents from the web using the WebBaseLoader.\n",
        "\n",
        "Once we have the list of URLs, we load these websites into a document structure, which makes it easier for further processing.\n",
        "\n",
        "This loader allows you to load documents from various sources such as public websites.\n",
        "\n",
        "You can specify the URL of the website or webpage you want to load.\n",
        "\n",
        "```\n",
        "documents = website_loader(url_lists)\n",
        "```\n",
        "\n",
        "# 3. Transform the loaded documents using document transformers.\n",
        "\n",
        "Large websites can have overwhelming amounts of content.\n",
        "\n",
        "To make it manageable, we split the content into smaller chunks.\n",
        "\n",
        "This step involves preparing the documents for retrieval by applying transformations such as splitting or chunking large documents into smaller chunks. LangChain provides different algorithms for document transformation, optimized for specific document types.\n",
        "\n",
        "```\n",
        "chunks = split_text(documents)\n",
        "```\n",
        "\n",
        "# 4. Create text embeddings for the transformed documents.\n",
        "\n",
        "For our chatbot to understand the content, we convert these chunks into vector representations using an embedding model from OpenAI.\n",
        "\n",
        "Text embeddings capture the semantic meaning of the text and enable efficient searching for similar pieces of text.\n",
        "\n",
        "LangChain offers integrations with various text embedding models, allowing you to choose the one that best suits your needs.\n",
        "\n",
        "There's a couple of ways you can split text, using either the  `CharacterTextSplitter` or the `RecursiveTextSplitter`, the difference lies in how they split the text and measure the chunk size.\n",
        "\n",
        "`CharacterTextSplitter` splits the text based on characters passed in and measures the chunk size by the number of characters.\n",
        "\n",
        "On the other hand, `RecursiveTextSplitter` splits the text into smaller chunks based on semantically meaningful units (such as sentences) and measures the chunk size using a length function (which can be the number of characters or a token counter).\n",
        "\n",
        "To determine which splitter to use, you can consider the following:\n",
        "\n",
        " - If you want to split the text based on characters and measure the chunk size by the number of characters, you can use CharacterTextSplitter.\n",
        "\n",
        " - If you want to split the text into smaller chunks based on semantically meaningful units and measure the chunk size using a length function (such as the number of characters or a token counter), you can use RecursiveTextSplitter.\n",
        "\n",
        "```\n",
        "embedder = get_document_embeddings(chunks)\n",
        "```\n",
        "\n",
        "# 5. Store the embeddings in a vector store.\n",
        "\n",
        "Once embedded, these vectors are stored in a FAISS vector store, a highly efficient structure for similarity searches.\n",
        "\n",
        "Vector stores are databases designed to efficiently store and search embeddings.\n",
        "\n",
        "LangChain provides integrations with different vector stores, both open-source and cloud-hosted proprietary ones.\n",
        "\n",
        "You can select the vector store that suits your requirements.\n",
        "\n",
        "```\n",
        "vectorstore = create_vector_store(chunks, embedder)\n",
        "```\n",
        "\n",
        "## 6. Use a retriever to retrieve the relevant documents.\n",
        "\n",
        "To retrieve relevant chunks based on user queries, we create a retriever from the vector store.\n",
        "\n",
        "LangChain supports various retrieval algorithms, including simple semantic search and advanced methods like the Parent Document Retriever, Self Query Retriever, and Ensemble Retriever.\n",
        "\n",
        "These retrievers help you retrieve the documents based on the user's query.\n",
        "\n",
        "```\n",
        "retriever = create_retriever(vectorstore)\n",
        "```\n",
        "\n",
        "# 7. Building the Chatbot\n",
        "\n",
        "Finally, we assemble our chatbot using the retriever and OpenAI's model. This chatbot understands the context from the web data and can provide relevant answers.\n",
        "\n",
        "We use the `ConversationalRetrievalChain`for having a conversation based on retrieved documents.\n",
        "\n",
        "This chain takes in chat history (a list of messages) and new questions,\n",
        "and then returns an answer to that question.\n",
        "\n",
        "The algorithm for this chain consists of three parts:\n",
        "\n",
        "1. Use the chat history and the new question to create a \"standalone question\".\n",
        "\n",
        "  This is done so that this question can be passed into the retrieval step to fetch relevant documents.\n",
        "\n",
        "  If only the new question was passed in, then relevant context\n",
        "  may be lacking.\n",
        "\n",
        "  If the whole conversation was passed into retrieval, there may\n",
        "  be unnecessary information there that would distract from retrieval.\n",
        "\n",
        "2. This new question is passed to the retriever and relevant documents are\n",
        "returned.\n",
        "\n",
        "3. The retrieved documents are passed to an LLM along with either the new question (default behavior) or the original question and chat history to generate a final response.\n",
        "\n",
        "\n",
        "```\n",
        "chatbot = create_chatbot(retriever)\n",
        "```\n",
        "\n",
        "# Testing the Chatbot\n",
        "\n",
        "Now, it's time for the fun part! We can interact with the chatbot:\n",
        "\n",
        "```\n",
        "response = chat(\"How do I not waste time with my projects\")\n",
        "print(response)\n",
        "```"
      ],
      "metadata": {
        "id": "5dX_lLNXxqFI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def find_urls(text: str) -> List:\n",
        "    \"\"\"\n",
        "    Extract URLs from a given text.\n",
        "\n",
        "    This function looks for patterns starting with 'http://', 'https://', or 'www.'\n",
        "    followed by any non-whitespace characters. It captures common URL formats\n",
        "    but might not capture all possible URL variations.\n",
        "\n",
        "    Args:\n",
        "    - text (str): The input string from which URLs need to be extracted.\n",
        "\n",
        "    Returns:\n",
        "    - list: A list containing all the URLs found in the input text.\n",
        "    \"\"\"\n",
        "    # Regular expression to match common URLs and ones starting with 'www.'\n",
        "    url_pattern = re.compile(r'https?://\\S+|www\\.\\S+')\n",
        "    return url_pattern.findall(text)\n",
        "\n",
        "def website_loader(website: Union[str, list[str]]) -> List[langchain.schema.document.Document]:\n",
        "    \"\"\"\n",
        "    Loads the specified website(s) into Document objects.\n",
        "\n",
        "    This function initiates the WebBaseLoader with the provided website or list of websites,\n",
        "    loads them, and returns the resulting Document objects.\n",
        "\n",
        "    Parameters:\n",
        "    - website (Union[str, list[str]]): A single website URL as a string or a list of website URLs to be loaded.\n",
        "\n",
        "    Returns:\n",
        "    - List[langchain.schema.document.Document]: A list of Document objects corresponding to the loaded website(s).\n",
        "    \"\"\"\n",
        "\n",
        "    print(\"Loading website(s) into Documents...\")\n",
        "    documents = WebBaseLoader(web_path=website).load()\n",
        "    print(\"Done loading website(s).\")\n",
        "    return documents\n",
        "\n",
        "def split_text(documents: List) -> List[langchain.schema.document.Document]:\n",
        "    \"\"\"\n",
        "    Splits the provided documents into chunks using RecursiveCharacterTextSplitter.\n",
        "\n",
        "    This function takes a list of documents, splits each document into smaller chunks\n",
        "    of a specified size with a specified overlap, and returns the chunks as a list of\n",
        "    Document objects.\n",
        "\n",
        "    Parameters:\n",
        "    - documents (List): A list of Document objects to be split into chunks.\n",
        "\n",
        "    Returns:\n",
        "    - List[langchain.schema.document.Document]: A list of Document objects representing the chunks.\n",
        "\n",
        "    Note:\n",
        "    - The chunk size, overlap, and length function are set to 1000, 50, and len respectively. Adjust\n",
        "      these values if necessary.\n",
        "    \"\"\"\n",
        "    print(\"Splitting documents into chunks...\")\n",
        "    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000,\n",
        "                                                   chunk_overlap=50,\n",
        "                                                   length_function=len\n",
        "                                                   )\n",
        "    chunks = text_splitter.transform_documents(documents)\n",
        "    print(\"Done splitting documents.\")\n",
        "    return chunks\n",
        "\n",
        "def get_document_embeddings(chunks: List) -> langchain.embeddings.cache.CacheBackedEmbeddings:\n",
        "    \"\"\"\n",
        "    Generates and retrieves embeddings for the given document chunks using CacheBackedEmbeddings.\n",
        "\n",
        "    This function initializes an embedder backed by a local cache and a core embeddings model\n",
        "    from OpenAI. It then uses this embedder to generate embeddings for the given document chunks.\n",
        "\n",
        "    Parameters:\n",
        "    - chunks (List): A list of Document chunks for which embeddings are to be generated.\n",
        "\n",
        "    Returns:\n",
        "    - langchain.embeddings.cache.CacheBackedEmbeddings: An embedder which can be used to get\n",
        "      embeddings for the document chunks.\n",
        "    \"\"\"\n",
        "    print(\"Creating embedder...\")\n",
        "    store = LocalFileStore(\"./cache/\")\n",
        "    core_embeddings_model= OpenAIEmbeddings()\n",
        "    embedder = CacheBackedEmbeddings.from_bytes_store(\n",
        "        core_embeddings_model,\n",
        "        store,\n",
        "        namespace=core_embeddings_model.model\n",
        "    )\n",
        "    print(\"Done creating embedder\")\n",
        "    return embedder\n",
        "\n",
        "def create_vector_store(chunks: List[langchain.schema.document.Document],\n",
        "                        embedder: langchain.embeddings.cache.CacheBackedEmbeddings) -> langchain.vectorstores.faiss.FAISS:\n",
        "    \"\"\"\n",
        "    Creates a FAISS vector store from the given document chunks using the provided embedder.\n",
        "\n",
        "    This function uses the provided embedder to transform the document chunks into vectors\n",
        "    and then stores them in a FAISS vector store.\n",
        "\n",
        "    Parameters:\n",
        "    - chunks (List[langchain.schema.document.Document]): A list of Document chunks to be vectorized.\n",
        "    - embedder (langchain.embeddings.cache.CacheBackedEmbeddings): An embedder used to generate embeddings\n",
        "      for the document chunks.\n",
        "\n",
        "    Returns:\n",
        "    - langchain.vectorstores.faiss.FAISS: A FAISS vector store containing the vectors of the document chunks.\n",
        "    \"\"\"\n",
        "    print(\"Creating vectorstore...\")\n",
        "    vectorstore = FAISS.from_documents(chunks, embedder)\n",
        "    return vectorstore\n",
        "\n",
        "def create_retriever(vectorstore: langchain.vectorstores) -> langchain.vectorstores.base.VectorStoreRetriever:\n",
        "    \"\"\"\n",
        "    Creates a retriever for the provided FAISS vector store.\n",
        "\n",
        "    This function initializes a retriever for the given vector store, allowing for efficient\n",
        "    querying and retrieval of similar vectors/documents from the vector store.\n",
        "\n",
        "    Parameters:\n",
        "    - vectorstore (langchain.vectorstores): A FAISS vector store containing vectors of document chunks.\n",
        "\n",
        "    Returns:\n",
        "    - langchain.vectorstores.base.VectorStoreRetriever: A retriever object that can be used to query\n",
        "      and retrieve similar vectors/documents from the vector store.\n",
        "\n",
        "    \"\"\"\n",
        "    print(\"Creating vectorstore retriever...\")\n",
        "    retriever = vectorstore.as_retriever()\n",
        "    return retriever\n",
        "\n",
        "def embed_user_query(query: str) -> List[float]:\n",
        "    \"\"\"\n",
        "    Embeds the provided user query using the OpenAIEmbeddings model.\n",
        "\n",
        "    This function takes a user query as input and transforms it into a vector representation\n",
        "    using the OpenAIEmbeddings model.\n",
        "\n",
        "    Parameters:\n",
        "    - query (str): The user query to be embedded.\n",
        "\n",
        "    Returns:\n",
        "    - List[float]: A list of floats representing the embedded vector of the user query.\n",
        "    \"\"\"\n",
        "    core_embeddings_model = OpenAIEmbeddings()\n",
        "    embedded_query = core_embeddings_model.embed_query(query)\n",
        "    return embedded_query\n",
        "\n",
        "def similarity_search(vectorstore: langchain.vectorstores,\n",
        "                      embedded_query: List[float]) -> List[langchain.schema.document.Document]:\n",
        "    \"\"\"\n",
        "    Performs a similarity search on the provided FAISS vector store using an embedded query.\n",
        "\n",
        "    This function takes an embedded query and searches the FAISS vector store for the most\n",
        "    similar vectors/documents based on the embedded query.\n",
        "\n",
        "    Parameters:\n",
        "    - vectorstore (langchain.vectorstores): A FAISS vector store containing vectors of document chunks.\n",
        "    - embedded_query (List[float]): A list of floats representing the embedded vector of the user query.\n",
        "\n",
        "    Returns:\n",
        "    - List[langchain.schema.document.Document]: A list of Document objects that are the most similar to\n",
        "      the embedded query.\n",
        "\n",
        "    Note:\n",
        "    - The function currently retrieves the top 4 most similar documents (k=4). Adjust the value of 'k'\n",
        "      if a different number of results is desired.\n",
        "    \"\"\"\n",
        "    response = vectorstore.similarity_search_by_vector(embedded_query, k=4)\n",
        "    return response\n",
        "\n",
        "\n",
        "def create_chatbot(retriever: langchain.vectorstores) -> langchain.chains.conversational_retrieval:\n",
        "    \"\"\"\n",
        "    Initializes and returns a conversational chatbot using the provided retriever and the OpenAI model.\n",
        "\n",
        "    This function sets up a chatbot based on the ConversationalRetrievalChain from LangChain,\n",
        "    which leverages the OpenAI model for conversational interactions and uses the given retriever\n",
        "    for document retrieval.\n",
        "\n",
        "    Parameters:\n",
        "    - retriever (langchain.vectorstores): A retriever object used for document retrieval based on similarity searches.\n",
        "\n",
        "    Returns:\n",
        "    - langchain.chains.conversational_retrieval: A ConversationalRetrievalChain instance which acts as the chatbot.\n",
        "\n",
        "    Note:\n",
        "\n",
        "    - The conversation history is stored in the 'chat_history' memory key and is used for context in\n",
        "      subsequent interactions.\n",
        "    \"\"\"\n",
        "    llm = ChatOpenAI(model=\"gpt-3.5-turbo\")\n",
        "\n",
        "    memory = ConversationBufferMemory(\n",
        "        memory_key='chat_history',\n",
        "        return_messages=True\n",
        "        )\n",
        "\n",
        "    conversation_chain = ConversationalRetrievalChain.from_llm(\n",
        "        llm=llm,\n",
        "        retriever=retriever,\n",
        "        memory=memory\n",
        "        )\n",
        "    return conversation_chain\n",
        "\n",
        "def chat(conversation_chain, input: str) -> str:\n",
        "    \"\"\"\n",
        "    Interacts with the chatbot using the provided input and returns its response.\n",
        "\n",
        "    This function takes a user input, passes it to the chatbot for processing,\n",
        "    and retrieves the chatbot's response.\n",
        "\n",
        "    Parameters:\n",
        "    - input (str): The user's input/question to the chatbot.\n",
        "\n",
        "    Returns:\n",
        "    - str: The chatbot's response to the user's input.\n",
        "\n",
        "    \"\"\"\n",
        "    return conversation_chain.run(input)\n",
        "\n",
        "text = \"\"\"\n",
        "I need you to go to the following URLs and get information about them\n",
        "https://medium.com/cometheartbeat/how-to-prevent-yourself-from-wasting-time-on-your-data-science-project-728db69a4afc\n",
        "and this one https://medium.com/mlearning-ai/langchain-is-the-past-here-is-the-future-of-llm-based-apps-46663f532c19\n",
        "\"\"\"\n"
      ],
      "metadata": {
        "id": "981zdPQRBoT9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import gradio as gr\n",
        "\n",
        "# This chatbot_instance will be initialized once a URL is provided.\n",
        "chatbot_instance = None\n",
        "\n",
        "def respond(message, chat_history):\n",
        "    global chatbot_instance\n",
        "    urls = find_urls(message)\n",
        "    # If the chatbot is not yet initialized and we have URLs, initialize it\n",
        "    if not chatbot_instance and urls:\n",
        "        documents = website_loader(urls)\n",
        "        chunks = split_text(documents)\n",
        "        embedder = get_document_embeddings(chunks)\n",
        "        vectorstore = create_vector_store(chunks, embedder)\n",
        "        retriever = create_retriever(vectorstore)\n",
        "        chatbot_instance = create_chatbot(retriever)\n",
        "        bot_message = \"Chatbot initialized! How can I help you?\"\n",
        "    else:\n",
        "        if chatbot_instance:\n",
        "            bot_message = chat(chatbot_instance, message)\n",
        "        else:\n",
        "            bot_message = \"Please provide a URL to initialize the chatbot first.\"\n",
        "\n",
        "    chat_history.append((message, bot_message))\n",
        "    return \"\", chat_history\n",
        "\n",
        "with gr.Blocks() as demo:\n",
        "    chatbot = gr.Chatbot()\n",
        "    user_query = gr.Textbox(label=\"Your Query\", placeholder=\"What would you like to chat about?\")\n",
        "    clear = gr.ClearButton([user_query, chatbot])\n",
        "\n",
        "    user_query.submit(respond, [user_query, chatbot], [user_query, chatbot])\n",
        "\n",
        "demo.launch(share=True, debug=True)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 764
        },
        "id": "rRzzjMsm7gv0",
        "outputId": "a75b18dc-923e-4272-8a0e-34903241c661"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Colab notebook detected. This cell will run indefinitely so that you can see errors and logs. To turn off, set debug=False in launch().\n",
            "Running on public URL: https://3f539f1fc49db6c261.gradio.live\n",
            "\n",
            "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ],
            "text/html": [
              "<div><iframe src=\"https://3f539f1fc49db6c261.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loading website(s) into Documents...\n",
            "Done loading website(s).\n",
            "Splitting documents into chunks...\n",
            "Done splitting documents.\n",
            "Creating embedder...\n",
            "Done creating embedder\n",
            "Creating vectorstore...\n",
            "Creating vectorstore retriever...\n",
            "Keyboard interruption in main thread... closing server.\n",
            "Killing tunnel 127.0.0.1:7861 <> https://3f539f1fc49db6c261.gradio.live\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": []
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    }
  ]
}