sophisticated_rag_agent_harry_potter.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Importing Necessary Libraries\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "XIL5OCqJ7bh8"
      },
      "outputs": [],
      "source": [
        "from langchain_openai import ChatOpenAI \n",
        "from langchain_groq import ChatGroq\n",
        "from langchain.document_loaders import  PyPDFLoader\n",
        "from langchain.vectorstores import  FAISS\n",
        "from langchain.text_splitter import  RecursiveCharacterTextSplitter\n",
        "from langchain.embeddings import OpenAIEmbeddings \n",
        "from langchain.prompts import PromptTemplate\n",
        "from langchain.docstore.document import Document\n",
        "from langchain.chains.summarize import load_summarize_chain\n",
        "from langchain_core.pydantic_v1 import BaseModel, Field\n",
        "from langchain_core.output_parsers import JsonOutputParser\n",
        "from langchain_core.runnables.graph import MermaidDrawMethod\n",
        "\n",
        "from langgraph.graph import END, StateGraph\n",
        "\n",
        "from time import monotonic\n",
        "from dotenv import load_dotenv\n",
        "from pprint import pprint\n",
        "import os\n",
        "from datasets import Dataset\n",
        "from typing_extensions import TypedDict\n",
        "from IPython.display import display, Image\n",
        "from typing import List, TypedDict\n",
        "\n",
        "from ragas import evaluate\n",
        "from ragas.metrics import (\n",
        "    answer_correctness,\n",
        "    faithfulness,\n",
        "    answer_relevancy,\n",
        "    context_recall,\n",
        "    answer_similarity\n",
        ")\n",
        "\n",
        "import langgraph\n",
        "\n",
        "\n",
        "### Helper functions for the notebook\n",
        "from helper_functions import num_tokens_from_string, replace_t_with_space, replace_double_lines_with_one_line, split_into_chapters,\\\n",
        "analyse_metric_results, escape_quotes, text_wrap,extract_book_quotes_as_documents\n",
        "\n",
        "load_dotenv()\n",
        "\n",
        "os.environ[\"PYDEVD_WARN_EVALUATION_TIMEOUT\"] = \"100000\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Setting Preferred Encoding for PyPDF ** ONLY FOR GOOGLE COLAB **\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "c6QeKRm37HwC"
      },
      "outputs": [],
      "source": [
        "import locale\n",
        "def getpreferredencoding(do_setlocale = True):\n",
        "    return \"UTF-8\"\n",
        "locale.getpreferredencoding = getpreferredencoding # For using PyPDF on google colab "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Setting OPENAI and GROQ API keys"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {},
      "outputs": [],
      "source": [
        "os.environ[\"OPENAI_API_KEY\"] = os.getenv('OPENAI_API_KEY')\n",
        "groq_api_key = os.getenv('GROQ_API_KEY')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Data preprocessing"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Defining Path to Harry Potter PDF\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "8mUYHG_S6y22"
      },
      "outputs": [],
      "source": [
        "hp_pdf_path =\"Harry_Potter_Book_1_The_Sorcerers_Stone.pdf\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Splitting the PDF into Chapters and Preprocessing\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "cDHfDODdTIBY"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "17\n"
          ]
        }
      ],
      "source": [
        "chapters = split_into_chapters(hp_pdf_path) \n",
        "chapters = replace_t_with_space(chapters)\n",
        "print(len(chapters))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Creating a list of quotes taken from the book"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "loader = PyPDFLoader(hp_pdf_path)\n",
        "document = loader.load()\n",
        "document_cleaned = replace_t_with_space(document)\n",
        "book_quotes_list = extract_book_quotes_as_documents(document_cleaned)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Defining Prompt Template for Summarization\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "49RqsAhDxjFg"
      },
      "outputs": [],
      "source": [
        "summarization_prompt_template = \"\"\"Write an extensive summary of the following:\n",
        "\n",
        "{text}\n",
        "\n",
        "SUMMARY:\"\"\"\n",
        "\n",
        "summarization_prompt = PromptTemplate(template=summarization_prompt_template, input_variables=[\"text\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Defining Function to Create Chapter Summaries using LLMs\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "ehe6iObnx4l9"
      },
      "outputs": [],
      "source": [
        "def create_chapter_summary(chapter):\n",
        "    \"\"\"\n",
        "    Creates a summary of a chapter using a large language model (LLM).\n",
        "\n",
        "    Args:\n",
        "        chapter: A Document object representing the chapter to summarize.\n",
        "\n",
        "    Returns:\n",
        "        A Document object containing the summary of the chapter.\n",
        "    \"\"\"\n",
        "\n",
        "    chapter_txt = chapter.page_content  # Extract chapter text\n",
        "    model_name = \"gpt-3.5-turbo-0125\"  # Specify LLM model\n",
        "    llm = ChatOpenAI(temperature=0, model_name=model_name)  # Create LLM instance\n",
        "    gpt_35_turbo_max_tokens = 16000  # Maximum token limit for the LLM\n",
        "    verbose = False  # Set to True for more detailed output\n",
        "\n",
        "    # Calculate number of tokens in the chapter text\n",
        "    num_tokens = num_tokens_from_string(chapter_txt, model_name)\n",
        "\n",
        "    # Choose appropriate chain type based on token count\n",
        "    if num_tokens < gpt_35_turbo_max_tokens:\n",
        "        chain = load_summarize_chain(llm, chain_type=\"stuff\", prompt=summarization_prompt, verbose=verbose) \n",
        "    else:\n",
        "        chain = load_summarize_chain(llm, chain_type=\"map_reduce\", map_prompt=summarization_prompt, combine_prompt=summarization_prompt, verbose=verbose)\n",
        "\n",
        "    start_time = monotonic()  # Start timer\n",
        "    doc_chapter = Document(page_content=chapter_txt)  # Create Document object for chapter\n",
        "    summary = chain.invoke([doc_chapter])  # Generate summary using the chain\n",
        "    print(f\"Chain type: {chain.__class__.__name__}\")  # Print chain type\n",
        "    print(f\"Run time: {monotonic() - start_time}\")  # Print execution time\n",
        "\n",
        "    # Clean up summary text\n",
        "    summary = replace_double_lines_with_one_line(summary[\"output_text\"])\n",
        "\n",
        "    # Create Document object for summary\n",
        "    doc_summary = Document(page_content=summary, metadata=chapter.metadata)\n",
        "\n",
        "    return doc_summary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Generating Summaries for Each Chapter\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l4UBurLsMCHj",
        "outputId": "668932cf-02d8-446d-e0ed-3f85b30d3bba"
      },
      "outputs": [],
      "source": [
        "chapter_summaries = []\n",
        "for chapter in chapters:\n",
        "    chapter_summaries.append(create_chapter_summary(chapter))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Encoding the data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Function to Encode a Book into a Vector Store using OpenAI Embeddings\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "9t1Kq6fGS0EA"
      },
      "outputs": [],
      "source": [
        "def encode_book(path, chunk_size=1000, chunk_overlap=200):\n",
        "    \"\"\"\n",
        "    Encodes a PDF book into a vector store using OpenAI embeddings.\n",
        "\n",
        "    Args:\n",
        "        path: The path to the PDF file.\n",
        "        chunk_size: The desired size of each text chunk.\n",
        "        chunk_overlap: The amount of overlap between consecutive chunks.\n",
        "\n",
        "    Returns:\n",
        "        A FAISS vector store containing the encoded book content.\n",
        "    \"\"\"\n",
        "\n",
        "    # Load PDF documents\n",
        "    loader = PyPDFLoader(path)\n",
        "    documents = loader.load()\n",
        "\n",
        "    # Split documents into chunks\n",
        "    text_splitter = RecursiveCharacterTextSplitter(\n",
        "        chunk_size=chunk_size, chunk_overlap=chunk_overlap, length_function=len\n",
        "    )\n",
        "    texts = text_splitter.split_documents(documents)\n",
        "    cleaned_texts = replace_t_with_space(texts)\n",
        "\n",
        "    # Create embeddings and vector store\n",
        "    embeddings = OpenAIEmbeddings()\n",
        "    vectorstore = FAISS.from_documents(cleaned_texts, embeddings)\n",
        "\n",
        "    return vectorstore"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Encoding Chapter Summaries into Vector Store\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "FHt9Y12gMp2z"
      },
      "outputs": [],
      "source": [
        "def encode_chapter_summaries(chapter_summaries):\n",
        "    \"\"\"\n",
        "    Encodes a list of chapter summaries into a vector store using OpenAI embeddings.\n",
        "\n",
        "    Args:\n",
        "        chapter_summaries: A list of Document objects representing the chapter summaries.\n",
        "\n",
        "    Returns:\n",
        "        A FAISS vector store containing the encoded chapter summaries.\n",
        "    \"\"\"\n",
        "\n",
        "    embeddings = OpenAIEmbeddings()  # Create OpenAI embeddings\n",
        "    chapter_summaries_vectorstore = FAISS.from_documents(chapter_summaries, embeddings)  # Create vector store\n",
        "    return chapter_summaries_vectorstore"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Encoding Quotes into Vector Store"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [],
      "source": [
        "def encode_quotes(book_quotes_list):\n",
        "    \"\"\"\n",
        "    Encodes a list of quotes into a vector store using OpenAI embeddings.\n",
        "\n",
        "    Args:\n",
        "        quote_list: A list of quotes.\n",
        "\n",
        "    Returns:\n",
        "        A FAISS vector store containing the encoded quotes.\n",
        "    \"\"\"\n",
        "\n",
        "    embeddings = OpenAIEmbeddings()  # Create OpenAI embeddings\n",
        "    quotes_vectorstore = FAISS.from_documents(book_quotes_list, embeddings)  # Create vector store\n",
        "    return quotes_vectorstore"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Creating vector stores and retrievers "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Creating Vector Stores and Retrievers for Book and Chapter Summaries\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "# ### IF VECTOR STORES ALREADY EXIST, LOAD THEM\n",
        "if os.path.exists(\"chunks_vector_store\") and os.path.exists(\"chapter_summaries_vector_store\") and os.path.exists(\"book_quotes_vectorstore\"):\n",
        "    embeddings = OpenAIEmbeddings()\n",
        "    chunks_vector_store =  FAISS.load_local(\"chunks_vector_store\", embeddings, allow_dangerous_deserialization=True)\n",
        "    chapter_summaries_vector_store =  FAISS.load_local(\"chapter_summaries_vector_store\", embeddings, allow_dangerous_deserialization=True)\n",
        "    book_quotes_vectorstore =  FAISS.load_local(\"book_quotes_vectorstore\", embeddings, allow_dangerous_deserialization=True)\n",
        "\n",
        "else:\n",
        "    # Encode the book and chapter summaries\n",
        "    chunks_vector_store = encode_book(hp_pdf_path, chunk_size=1000, chunk_overlap=200)\n",
        "    chapter_summaries_vector_store = encode_chapter_summaries(chapter_summaries)\n",
        "    book_quotes_vectorstore = encode_quotes(book_quotes_list)\n",
        "\n",
        "\n",
        "    # Save the vector stores\n",
        "    chunks_vector_store.save_local(\"chunks_vector_store\")\n",
        "    chapter_summaries_vector_store.save_local(\"chapter_summaries_vector_store\")\n",
        "    book_quotes_vectorstore.save_local(\"book_quotes_vectorstore\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Create retrievers from the vector stores"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [],
      "source": [
        "chunks_query_retriever = chunks_vector_store.as_retriever(search_kwargs={\"k\": 1})     \n",
        "chapter_summaries_query_retriever = chapter_summaries_vector_store.as_retriever(search_kwargs={\"k\": 1})\n",
        "book_quotes_query_retriever = book_quotes_vectorstore.as_retriever(search_kwargs={\"k\": 10})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# For advanced RAGing\n",
        "## For questions that can be answered by retrieval based on the original query, we create a `langgraph` graph for answering the query.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Agrregate retrieved content as string context"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {},
      "outputs": [],
      "source": [
        "def retrieve_context_per_question(state):\n",
        "    \"\"\"\n",
        "    Retrieves relevant context for a given question. The context is retrieved from the book chunks and chapter summaries.\n",
        "\n",
        "    Args:\n",
        "        state: A dictionary containing the question to answer.\n",
        "    \"\"\"\n",
        "    # Retrieve relevant documents\n",
        "    print(\"Retrieving relevant chunks...\")\n",
        "    question = state[\"question\"]\n",
        "    docs = chunks_query_retriever.get_relevant_documents(question)\n",
        "\n",
        "    # Concatenate document content\n",
        "    context = \" \".join(doc.page_content for doc in docs)\n",
        "\n",
        "\n",
        "\n",
        "    print(\"Retrieving relevant chapter summaries...\")\n",
        "    docs_summaries = chapter_summaries_query_retriever.get_relevant_documents(state[\"question\"])\n",
        "\n",
        "    # Concatenate chapter summaries with citation information\n",
        "    context_summaries = \" \".join(\n",
        "        f\"{doc.page_content} (Chapter {doc.metadata['chapter']})\" for doc in docs_summaries\n",
        "    )\n",
        "\n",
        "    print(\"Retrieving relevant book quotes...\")\n",
        "    docs_book_quotes = book_quotes_query_retriever.get_relevant_documents(state[\"question\"])\n",
        "    book_qoutes = \" \".join(doc.page_content for doc in docs_book_quotes)\n",
        "\n",
        "\n",
        "    all_contexts = context + context_summaries + book_qoutes\n",
        "    all_contexts = escape_quotes(all_contexts)\n",
        "\n",
        "    return {\"context\": all_contexts, \"question\": question}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM based function to distill only relevant retrieved content"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {},
      "outputs": [],
      "source": [
        "keep_only_relevant_content_prompt_template = \"\"\"you receive a query: {query} and retrieved documents: {retrieved_documents} from a\n",
        " vector store.\n",
        " You need to filter out all the non relevant information that don't supply important information regarding the {query}.\n",
        " your goal is just to filter out the non relevant information.\n",
        " you can remove parts of sentences that are not relevant to the query or remove whole sentences that are not relevant to the query.\n",
        " DO NOT ADD ANY NEW INFORMATION THAT IS NOT IN THE RETRIEVED DOCUMENTS.\n",
        " output the filtered relevant content.\n",
        "\"\"\"\n",
        "\n",
        "\n",
        "class KeepRelevantContent(BaseModel):\n",
        "    relevant_content: str = Field(description=\"The relevant content from the retrieved documents that is relevant to the query.\")\n",
        "\n",
        "keep_only_relevant_content_prompt = PromptTemplate(\n",
        "    template=keep_only_relevant_content_prompt_template,\n",
        "    input_variables=[\"query\", \"retrieved_documents\"],\n",
        ")\n",
        "\n",
        "\n",
        "keep_only_relevant_content_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "keep_only_relevant_content_chain = keep_only_relevant_content_prompt | keep_only_relevant_content_llm.with_structured_output(KeepRelevantContent)\n",
        "\n",
        "\n",
        "def keep_only_relevant_content(state):\n",
        "    \"\"\"\n",
        "    Keeps only the relevant content from the retrieved documents that is relevant to the query.\n",
        "\n",
        "    Args:\n",
        "        question: The query question.\n",
        "        context: The retrieved documents.\n",
        "        chain: The LLMChain instance.\n",
        "\n",
        "    Returns:\n",
        "        The relevant content from the retrieved documents that is relevant to the query.\n",
        "    \"\"\"\n",
        "    question = state[\"question\"]\n",
        "    context = state[\"context\"]\n",
        "\n",
        "    input_data = {\n",
        "    \"query\": question,\n",
        "    \"retrieved_documents\": context\n",
        "}\n",
        "    print(\"keeping only the relevant content...\")\n",
        "    pprint(\"--------------------\")\n",
        "    output = keep_only_relevant_content_chain.invoke(input_data)\n",
        "    relevant_content = output.relevant_content\n",
        "    relevant_content = \"\".join(relevant_content)\n",
        "    relevant_content = escape_quotes(relevant_content)\n",
        "\n",
        "    return {\"relevant_context\": relevant_content, \"context\": context, \"question\": question}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM based function to re-write a question"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {},
      "outputs": [],
      "source": [
        "class RewriteQuestion(BaseModel):\n",
        "    \"\"\"\n",
        "    Output schema for the rewritten question.\n",
        "    \"\"\"\n",
        "    rewritten_question: str = Field(description=\"The improved question optimized for vectorstore retrieval.\")\n",
        "    explanation: str = Field(description=\"The explanation of the rewritten question.\")\n",
        "\n",
        "rewrite_question_string_parser = JsonOutputParser(pydantic_object=RewriteQuestion)\n",
        "\n",
        "\n",
        "rewrite_llm = ChatGroq(temperature=0, model_name=\"llama3-70b-8192\", groq_api_key=groq_api_key, max_tokens=4000)\n",
        "rewrite_prompt_template = \"\"\"You are a question re-writer that converts an input question to a better version optimized for vectorstore retrieval.\n",
        " Analyze the input question {question} and try to reason about the underlying semantic intent / meaning.\n",
        " {format_instructions}\n",
        " \"\"\"\n",
        "\n",
        "rewrite_prompt = PromptTemplate(\n",
        "    template=rewrite_prompt_template,\n",
        "    input_variables=[\"question\"],\n",
        "    partial_variables={\"format_instructions\": rewrite_question_string_parser.get_format_instructions()},\n",
        ")\n",
        "\n",
        "question_rewriter = rewrite_prompt | rewrite_llm | rewrite_question_string_parser  # Combine prompt, LLM, and parser\n",
        "\n",
        "def rewrite_question(state):\n",
        "    \"\"\"Rewrites the given question using the LLM.\n",
        "\n",
        "    Args:\n",
        "        state: A dictionary containing the question to rewrite.\n",
        "    \"\"\"\n",
        "    question = state[\"question\"]\n",
        "    print(\"Rewriting the question...\")\n",
        "    result = question_rewriter.invoke({\"question\": question})\n",
        "    new_question = result[\"rewritten_question\"]\n",
        "    return {\"question\": new_question}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM based function to answer a question given context, using Chain of Thought"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {},
      "outputs": [],
      "source": [
        "class QuestionAnswerFromContext(BaseModel):\n",
        "    answer_based_on_content: str = Field(description=\"generates an answer to a query based on a given context.\")\n",
        "\n",
        "question_answer_from_context_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "\n",
        "\n",
        "question_answer_cot_prompt_template = \"\"\" \n",
        "Examples of Chain-of-Thought Reasoning\n",
        "\n",
        "Example 1\n",
        "\n",
        "Context: Mary is taller than Jane. Jane is shorter than Tom. Tom is the same height as David.\n",
        "Question: Who is the tallest person?\n",
        "Reasoning Chain:\n",
        "The context tells us Mary is taller than Jane\n",
        "It also says Jane is shorter than Tom\n",
        "And Tom is the same height as David\n",
        "So the order from tallest to shortest is: Mary, Tom/David, Jane\n",
        "Therefore, Mary must be the tallest person\n",
        "\n",
        "Example 2\n",
        "Context: Harry was reading a book about magic spells. One spell allowed the caster to turn a person into an animal for a short time. Another spell could levitate objects.\n",
        " A third spell created a bright light at the end of the caster's wand.\n",
        "Question: Based on the context, if Harry cast these spells, what could he do?\n",
        "Reasoning Chain:\n",
        "The context describes three different magic spells\n",
        "The first spell allows turning a person into an animal temporarily\n",
        "The second spell can levitate or float objects\n",
        "The third spell creates a bright light\n",
        "If Harry cast these spells, he could turn someone into an animal for a while, make objects float, and create a bright light source\n",
        "So based on the context, if Harry cast these spells he could transform people, levitate things, and illuminate an area\n",
        "Instructions.\n",
        "\n",
        "Example 3 \n",
        "Context: Harry Potter woke up on his birthday to find a present at the end of his bed. He excitedly opened it to reveal a Nimbus 2000 broomstick.\n",
        "Question: Why did Harry receive a broomstick for his birthday?\n",
        "Reasoning Chain:\n",
        "The context states that Harry Potter woke up on his birthday and received a present - a Nimbus 2000 broomstick.\n",
        "However, the context does not provide any information about why he received that specific present or who gave it to him.\n",
        "There are no details about Harry's interests, hobbies, or the person who gifted him the broomstick.\n",
        "Without any additional context about Harry's background or the gift-giver's motivations, there is no way to determine the reason he received a broomstick as a birthday present.\n",
        "\n",
        "For the question below, provide your answer by first showing your step-by-step reasoning process, breaking down the problem into a chain of thought before arriving at the final answer,\n",
        " just like in the previous examples.\n",
        "Context\n",
        "{context}\n",
        "Question\n",
        "{question}\n",
        "\"\"\"\n",
        "\n",
        "question_answer_from_context_cot_prompt = PromptTemplate(\n",
        "    template=question_answer_cot_prompt_template,\n",
        "    input_variables=[\"context\", \"question\"],\n",
        ")\n",
        "question_answer_from_context_cot_chain = question_answer_from_context_cot_prompt | question_answer_from_context_llm.with_structured_output(QuestionAnswerFromContext)\n",
        "\n",
        "\n",
        "def answer_question_from_context(state):\n",
        "    \"\"\"\n",
        "    Answers a question from a given context.\n",
        "\n",
        "    Args:\n",
        "        question: The query question.\n",
        "        context: The context to answer the question from.\n",
        "        chain: The LLMChain instance.\n",
        "\n",
        "    Returns:\n",
        "        The answer to the question from the context.\n",
        "    \"\"\"\n",
        "    question = state[\"question\"]\n",
        "    context = state[\"aggregated_context\"] if \"aggregated_context\" in state else state[\"context\"]\n",
        "\n",
        "    input_data = {\n",
        "    \"question\": question,\n",
        "    \"context\": context\n",
        "}\n",
        "    print(\"Answering the question from the retrieved context...\")\n",
        "\n",
        "    output = question_answer_from_context_cot_chain.invoke(input_data)\n",
        "    answer = output.answer_based_on_content\n",
        "    print(f'answer before checking hallucination: {answer}')\n",
        "    return {\"answer\": answer, \"context\": context, \"question\": question}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create graph edges"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM based function to determine if retrieved content is relevant to the question"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {},
      "outputs": [],
      "source": [
        "is_relevant_content_prompt_template = \"\"\"you receive a query: {query} and a context: {context} retrieved from a vector store. \n",
        "You need to determine if the document is relevant to the query. \n",
        "\n",
        "{format_instructions}\"\"\"\n",
        "\n",
        "class Relevance(BaseModel):\n",
        "    is_relevant: bool = Field(description=\"Whether the document is relevant to the query.\")\n",
        "    explanation: str = Field(description=\"An explanation of why the document is relevant or not.\")\n",
        "\n",
        "is_relevant_json_parser = JsonOutputParser(pydantic_object=Relevance)\n",
        "is_relevant_llm = ChatGroq(temperature=0, model_name=\"llama3-70b-8192\", groq_api_key=groq_api_key, max_tokens=4000)\n",
        "\n",
        "is_relevant_content_prompt = PromptTemplate(\n",
        "    template=is_relevant_content_prompt_template,\n",
        "    input_variables=[\"query\", \"context\"],\n",
        "    partial_variables={\"format_instructions\": is_relevant_json_parser.get_format_instructions()},\n",
        ")\n",
        "is_relevant_content_chain = is_relevant_content_prompt | is_relevant_llm | is_relevant_json_parser\n",
        "\n",
        "def is_relevant_content(state):\n",
        "    \"\"\"\n",
        "    Determines if the document is relevant to the query.\n",
        "\n",
        "    Args:\n",
        "        question: The query question.\n",
        "        context: The context to determine relevance.\n",
        "    \"\"\"\n",
        "\n",
        "    question = state[\"question\"]\n",
        "    context = state[\"context\"]\n",
        "\n",
        "    input_data = {\n",
        "    \"query\": question,\n",
        "    \"context\": context\n",
        "}\n",
        "\n",
        "    # Invoke the chain to determine if the document is relevant\n",
        "    output = is_relevant_content_chain.invoke(input_data)\n",
        "    print(\"Determining if the document is relevant...\")\n",
        "    if output[\"is_relevant\"] == True:\n",
        "        print(\"The document is relevant.\")\n",
        "        return \"relevant\"\n",
        "    else:\n",
        "        print(\"The document is not relevant.\")\n",
        "        return \"not relevant\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM chain to check if an answer is a hallucination or grounded on facts"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {},
      "outputs": [],
      "source": [
        "class is_grounded_on_facts(BaseModel):\n",
        "    \"\"\"\n",
        "    Output schema for the rewritten question.\n",
        "    \"\"\"\n",
        "    grounded_on_facts: bool = Field(description=\"Answer is grounded in the facts, 'yes' or 'no'\")\n",
        "\n",
        "is_grounded_on_facts_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "is_grounded_on_facts_prompt_template = \"\"\"You are a fact-checker that determines if the given answer {answer} is grounded in the given context {context}\n",
        "you don't mind if it doesn't make sense, as long as it is grounded in the context.\n",
        "output a json containing the answer to the question, and appart from the json format don't output any additional text.\n",
        "\n",
        " \"\"\"\n",
        "is_grounded_on_facts_prompt = PromptTemplate(\n",
        "    template=is_grounded_on_facts_prompt_template,\n",
        "    input_variables=[\"context\", \"answer\"],\n",
        ")\n",
        "is_grounded_on_facts_chain = is_grounded_on_facts_prompt | is_grounded_on_facts_llm.with_structured_output(is_grounded_on_facts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### LLM chain to determine if a question can be fully answered given a context"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {},
      "outputs": [],
      "source": [
        "can_be_answered_prompt_template = \"\"\"You receive a query: {question} and a context: {context}. \n",
        "You need to determine if the question can be fully answered based on the context.\n",
        "{format_instructions}\n",
        "\"\"\"\n",
        "\n",
        "class QuestionAnswer(BaseModel):\n",
        "    can_be_answered: bool = Field(description=\"binary result of whether the question can be fully answered or not\")\n",
        "    explanation: str = Field(description=\"An explanation of why the question can be fully answered or not.\")\n",
        "\n",
        "can_be_answered_json_parser = JsonOutputParser(pydantic_object=QuestionAnswer)\n",
        "\n",
        "answer_question_prompt = PromptTemplate(\n",
        "    template=can_be_answered_prompt_template,\n",
        "    input_variables=[\"question\",\"context\"],\n",
        "    partial_variables={\"format_instructions\": can_be_answered_json_parser.get_format_instructions()},\n",
        ")\n",
        "\n",
        "can_be_answered_llm = ChatGroq(temperature=0, model_name=\"llama3-70b-8192\", groq_api_key=groq_api_key, max_tokens=4000)\n",
        "can_be_answered_chain = answer_question_prompt | can_be_answered_llm | can_be_answered_json_parser"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### function to check both cases - hallucination and full answer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {},
      "outputs": [],
      "source": [
        "def grade_generation_v_documents_and_question(state):\n",
        "    \"\"\"\n",
        "    Grades the generation of the answer to the question based on the context, if it is grounded in the facts, and if the question can be fully answered\n",
        "\n",
        "    Args:\n",
        "        state: A dictionary containing the context, question, and answer.\n",
        "    \"\"\"\n",
        "    \n",
        "    print(\"Checking if the answer is grounded in the facts...\")\n",
        "    context = state[\"context\"]\n",
        "    answer = state[\"answer\"]\n",
        "    question = state[\"question\"]\n",
        "    \n",
        "    result = is_grounded_on_facts_chain.invoke({\"context\": context, \"answer\": answer})\n",
        "    grounded_on_facts = result.grounded_on_facts\n",
        "    if not grounded_on_facts:\n",
        "        print(\"The answer is hallucination.\")\n",
        "        return \"hallucination\"\n",
        "    else:\n",
        "        print(\"The answer is grounded in the facts.\")\n",
        "\n",
        "        input_data = {\n",
        "            \"question\": question,\n",
        "            \"context\": context\n",
        "        }\n",
        "\n",
        "        # Invoke the chain to determine if the question can be answered\n",
        "        print(\"Determining if the question is fully answered...\")\n",
        "        output = can_be_answered_chain.invoke(input_data)\n",
        "        can_be_answered = output[\"can_be_answered\"]\n",
        "        if can_be_answered == True:\n",
        "            print(\"The question can be fully answered.\")\n",
        "            return \"useful\"\n",
        "        else:\n",
        "            print(\"The question cannot be fully answered.\")\n",
        "            return \"not_useful\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Test a pipeline of all parts"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 179,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Retrieving relevant chunks...\n",
            "Retrieving relevant chapter summaries...\n",
            "keeping only the relevant content...\n",
            "'--------------------'\n",
            "Determining if the document is relevant...\n",
            "The document is relevant.\n",
            "Answering the question from the retrieved context...\n",
            "answer before checking hallucination: Fluffy is a three-headed dog.\n",
            "Checking if the answer is grounded in the facts...\n",
            "The answer is grounded in the facts.\n",
            "Determining if the question is fully answered...\n",
            "The question can be fully answered.\n",
            "Fluffy is a three-headed dog.\n"
          ]
        }
      ],
      "source": [
        "init_state = {\"question\": \"who is fluffy?\"}  # The question to answer\n",
        "context_state = retrieve_context_per_question(init_state)  # Retrieve context for the question\n",
        "relevant_content_state = keep_only_relevant_content(context_state)  # Keep only the relevant content\n",
        "is_relevant_content_state = is_relevant_content(relevant_content_state) # Check if the content is relevant\n",
        "answer_state = answer_question_from_context(relevant_content_state) # Answer the question from the context\n",
        "final_answer = grade_generation_v_documents_and_question(answer_state) # Grade the answer\n",
        "print(answer_state[\"answer\"])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Build the Graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "class QualitativeRetievalAnswerGraphState(TypedDict):\n",
        "\n",
        "    question: str\n",
        "    context: str\n",
        "    answer: str\n",
        "\n",
        "# Create the graph\n",
        "qualitative_retrieval_answer_workflow = StateGraph(QualitativeRetievalAnswerGraphState)\n",
        "\n",
        "# Define the nodes\n",
        "\n",
        "# Add the nodes to the graph\n",
        "qualitative_retrieval_answer_workflow.add_node(\"retrieve_context_per_question\",retrieve_context_per_question)\n",
        "qualitative_retrieval_answer_workflow.add_node(\"keep_only_relevant_content\",keep_only_relevant_content)\n",
        "qualitative_retrieval_answer_workflow.add_node(\"rewrite_question\",rewrite_question)\n",
        "qualitative_retrieval_answer_workflow.add_node(\"answer_question_from_context\",answer_question_from_context)\n",
        "\n",
        "# Build the graph\n",
        "qualitative_retrieval_answer_workflow.set_entry_point(\"retrieve_context_per_question\")\n",
        "qualitative_retrieval_answer_workflow.add_edge(\"retrieve_context_per_question\", \"keep_only_relevant_content\")\n",
        "qualitative_retrieval_answer_workflow.add_conditional_edges(\n",
        "    \"keep_only_relevant_content\",\n",
        "    is_relevant_content,\n",
        "    {\"relevant\":\"answer_question_from_context\",\n",
        "      \"not relevant\":\"rewrite_question\"},\n",
        "    )\n",
        "qualitative_retrieval_answer_workflow.add_edge(\"rewrite_question\", \"retrieve_context_per_question\")\n",
        "qualitative_retrieval_answer_workflow.add_conditional_edges(\n",
        "\"answer_question_from_context\",\n",
        "grade_generation_v_documents_and_question,\n",
        "{\"hallucination\":\"answer_question_from_context\",\n",
        "\"not_useful\":\"rewrite_question\",\n",
        "\"useful\":END},\n",
        ")\n",
        "\n",
        "qualitative_retrieval_answer_retrival_app = qualitative_retrieval_answer_workflow.compile()\n",
        "\n",
        "display(\n",
        "    Image(\n",
        "        qualitative_retrieval_answer_retrival_app.get_graph().draw_mermaid_png(\n",
        "            draw_method=MermaidDrawMethod.API,\n",
        "        )\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# For more complex tasks, where the question cannot be answered solely by retrieving information based on semantic similarity, we need a more sophisticated pipeline. To achieve this, we may first break down the graph into several sub-graphs that will serve as functions for the sophisticated pipeline.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Let's add a function that Verifies that the distilled content is grounded in the original context"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {},
      "outputs": [],
      "source": [
        "is_distilled_content_grounded_on_content_prompt_template = \"\"\"you receive some distilled content: {distilled_content} and the original context: {original_context}.\n",
        "    you need to determine if the distilled content is grounded on the original context.\n",
        "    if the distilled content is grounded on the original context, set the grounded field to true.\n",
        "    if the distilled content is not grounded on the original context, set the grounded field to false. {format_instructions}\"\"\"\n",
        "  \n",
        "\n",
        "class IsDistilledContentGroundedOnContent(BaseModel):\n",
        "    grounded: bool = Field(description=\"Whether the distilled content is grounded on the original context.\")\n",
        "    explanation: str = Field(description=\"An explanation of why the distilled content is or is not grounded on the original context.\")\n",
        "\n",
        "is_distilled_content_grounded_on_content_json_parser = JsonOutputParser(pydantic_object=IsDistilledContentGroundedOnContent)\n",
        "\n",
        "is_distilled_content_grounded_on_content_prompt = PromptTemplate(\n",
        "    template=is_distilled_content_grounded_on_content_prompt_template,\n",
        "    input_variables=[\"distilled_content\", \"original_context\"],\n",
        "    partial_variables={\"format_instructions\": is_distilled_content_grounded_on_content_json_parser.get_format_instructions()},\n",
        ")\n",
        "\n",
        "is_distilled_content_grounded_on_content_llm = ChatGroq(temperature=0, model_name=\"llama3-70b-8192\", groq_api_key=groq_api_key, max_tokens=4000)\n",
        "\n",
        "is_distilled_content_grounded_on_content_chain = is_distilled_content_grounded_on_content_prompt | is_distilled_content_grounded_on_content_llm | is_distilled_content_grounded_on_content_json_parser\n",
        "\n",
        "\n",
        "def is_distilled_content_grounded_on_content(state):\n",
        "    pprint(\"--------------------\")\n",
        "\n",
        "    \"\"\"\n",
        "    Determines if the distilled content is grounded on the original context.\n",
        "\n",
        "    Args:\n",
        "        distilled_content: The distilled content.\n",
        "        original_context: The original context.\n",
        "\n",
        "    Returns:\n",
        "        Whether the distilled content is grounded on the original context.\n",
        "    \"\"\"\n",
        "\n",
        "    print(\"Determining if the distilled content is grounded on the original context...\")\n",
        "    distilled_content = state[\"relevant_context\"]\n",
        "    original_context = state[\"context\"]\n",
        "\n",
        "    input_data = {\n",
        "        \"distilled_content\": distilled_content,\n",
        "        \"original_context\": original_context\n",
        "    }\n",
        "\n",
        "    output = is_distilled_content_grounded_on_content_chain.invoke(input_data)\n",
        "    grounded = output[\"grounded\"]\n",
        "\n",
        "    if grounded:\n",
        "        print(\"The distilled content is grounded on the original context.\")\n",
        "        return \"grounded on the original context\"\n",
        "    else:\n",
        "        print(\"The distilled content is not grounded on the original context.\")\n",
        "        return \"not grounded on the original context\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Create functions for each type of retrieval"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {},
      "outputs": [],
      "source": [
        "def retrieve_chunks_context_per_question(state):\n",
        "    \"\"\"\n",
        "    Retrieves relevant context for a given question. The context is retrieved from the book chunks and chapter summaries.\n",
        "\n",
        "    Args:\n",
        "        state: A dictionary containing the question to answer.\n",
        "    \"\"\"\n",
        "    # Retrieve relevant documents\n",
        "    print(\"Retrieving relevant chunks...\")\n",
        "    question = state[\"question\"]\n",
        "    docs = chunks_query_retriever.get_relevant_documents(question)\n",
        "\n",
        "    # Concatenate document content\n",
        "    context = \" \".join(doc.page_content for doc in docs)\n",
        "    context = escape_quotes(context)\n",
        "    return {\"context\": context, \"question\": question}\n",
        "\n",
        "def retrieve_summaries_context_per_question(state):\n",
        "\n",
        "    print(\"Retrieving relevant chapter summaries...\")\n",
        "    question = state[\"question\"]\n",
        "\n",
        "    docs_summaries = chapter_summaries_query_retriever.get_relevant_documents(state[\"question\"])\n",
        "\n",
        "    # Concatenate chapter summaries with citation information\n",
        "    context_summaries = \" \".join(\n",
        "        f\"{doc.page_content} (Chapter {doc.metadata['chapter']})\" for doc in docs_summaries\n",
        "    )\n",
        "    context_summaries = escape_quotes(context_summaries)\n",
        "    return {\"context\": context_summaries, \"question\": question}\n",
        "\n",
        "def retrieve_book_quotes_context_per_question(state):\n",
        "    question = state[\"question\"]\n",
        "\n",
        "    print(\"Retrieving relevant book quotes...\")\n",
        "    docs_book_quotes = book_quotes_query_retriever.get_relevant_documents(state[\"question\"])\n",
        "    book_qoutes = \" \".join(doc.page_content for doc in docs_book_quotes)\n",
        "    book_qoutes_context = escape_quotes(book_qoutes)\n",
        "\n",
        "    return {\"context\": book_qoutes_context, \"question\": question}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Create sub graph for each type of retrieval"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### The first sub-graph would be for retrieval and distillation of the relevant information with some modification"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 54,
      "metadata": {},
      "outputs": [],
      "source": [
        "class QualitativeRetrievalGraphState(TypedDict):\n",
        "    \"\"\"\n",
        "    Represents the state of our graph.\n",
        "    \"\"\"\n",
        "\n",
        "    question: str\n",
        "    context: str\n",
        "    relevant_context: str"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 61,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "qualitative_chunks_retrieval_workflow = StateGraph(QualitativeRetrievalGraphState)\n",
        "\n",
        "# Define the nodes\n",
        "qualitative_chunks_retrieval_workflow.add_node(\"retrieve_chunks_context_per_question\",retrieve_chunks_context_per_question)\n",
        "qualitative_chunks_retrieval_workflow.add_node(\"keep_only_relevant_content\",keep_only_relevant_content)\n",
        "\n",
        "# Build the graph\n",
        "qualitative_chunks_retrieval_workflow.set_entry_point(\"retrieve_chunks_context_per_question\")\n",
        "\n",
        "qualitative_chunks_retrieval_workflow.add_edge(\"retrieve_chunks_context_per_question\", \"keep_only_relevant_content\")\n",
        "\n",
        "qualitative_chunks_retrieval_workflow.add_conditional_edges(\n",
        "    \"keep_only_relevant_content\",\n",
        "    is_distilled_content_grounded_on_content,\n",
        "    {\"grounded on the original context\":END,\n",
        "      \"not grounded on the original context\":\"keep_only_relevant_content\"},\n",
        "    )\n",
        "\n",
        "\n",
        "qualitative_chunks_retrieval_workflow_app = qualitative_chunks_retrieval_workflow.compile()\n",
        "\n",
        "display(\n",
        "    Image(\n",
        "        qualitative_chunks_retrieval_workflow_app.get_graph().draw_mermaid_png(\n",
        "            draw_method=MermaidDrawMethod.API,\n",
        "        )\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 62,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "qualitative_summaries_retrieval_workflow = StateGraph(QualitativeRetrievalGraphState)\n",
        "\n",
        "# Define the nodes\n",
        "qualitative_summaries_retrieval_workflow.add_node(\"retrieve_summaries_context_per_question\",retrieve_summaries_context_per_question)\n",
        "qualitative_summaries_retrieval_workflow.add_node(\"keep_only_relevant_content\",keep_only_relevant_content)\n",
        "\n",
        "# Build the graph\n",
        "qualitative_summaries_retrieval_workflow.set_entry_point(\"retrieve_summaries_context_per_question\")\n",
        "\n",
        "qualitative_summaries_retrieval_workflow.add_edge(\"retrieve_summaries_context_per_question\", \"keep_only_relevant_content\")\n",
        "\n",
        "qualitative_summaries_retrieval_workflow.add_conditional_edges(\n",
        "    \"keep_only_relevant_content\",\n",
        "    is_distilled_content_grounded_on_content,\n",
        "    {\"grounded on the original context\":END,\n",
        "      \"not grounded on the original context\":\"keep_only_relevant_content\"},\n",
        "    )\n",
        "\n",
        "\n",
        "qualitative_summaries_retrieval_workflow_app = qualitative_summaries_retrieval_workflow.compile()\n",
        "\n",
        "display(\n",
        "    Image(\n",
        "        qualitative_summaries_retrieval_workflow_app.get_graph().draw_mermaid_png(\n",
        "            draw_method=MermaidDrawMethod.API,\n",
        "        )\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 63,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "qualitative_book_quotes_retrieval_workflow = StateGraph(QualitativeRetrievalGraphState)\n",
        "\n",
        "# Define the nodes\n",
        "qualitative_book_quotes_retrieval_workflow.add_node(\"retrieve_book_quotes_context_per_question\",retrieve_book_quotes_context_per_question)\n",
        "qualitative_book_quotes_retrieval_workflow.add_node(\"keep_only_relevant_content\",keep_only_relevant_content)\n",
        "\n",
        "# Build the graph\n",
        "qualitative_book_quotes_retrieval_workflow.set_entry_point(\"retrieve_book_quotes_context_per_question\")\n",
        "\n",
        "qualitative_book_quotes_retrieval_workflow.add_edge(\"retrieve_book_quotes_context_per_question\", \"keep_only_relevant_content\")\n",
        "\n",
        "qualitative_book_quotes_retrieval_workflow.add_conditional_edges(\n",
        "    \"keep_only_relevant_content\",\n",
        "    is_distilled_content_grounded_on_content,\n",
        "    {\"grounded on the original context\":END,\n",
        "      \"not grounded on the original context\":\"keep_only_relevant_content\"},\n",
        "    )\n",
        "\n",
        "qualitative_book_quotes_retrieval_workflow_app = qualitative_book_quotes_retrieval_workflow.compile()\n",
        "\n",
        "display(\n",
        "    Image(\n",
        "        qualitative_book_quotes_retrieval_workflow_app.get_graph().draw_mermaid_png(\n",
        "            draw_method=MermaidDrawMethod.API,\n",
        "        )\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Test the retreive-and-keep-relevant-content graphs"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [],
      "source": [
        "init_state = {\"question\": \"worse than getting killed\"}  # The question to answer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "## test the book chunks retrieval\n",
        "for output in qualitative_chunks_retrieval_workflow_app.stream(init_state):    \n",
        "    for _, value in output.items():\n",
        "        pass \n",
        "    pprint(\"--------------------\")\n",
        "print(f'relevant context: {value[\"relevant_context\"]}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "## test the chapter summaries retrieval\n",
        "for output in qualitative_summaries_retrieval_workflow_app.stream(init_state):    \n",
        "    for _, value in output.items():\n",
        "        pass \n",
        "    pprint(\"--------------------\")\n",
        "print(f'relevant context: {value[\"relevant_context\"]}')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "## test the book quotes retrieval\n",
        "for output in qualitative_book_quotes_retrieval_workflow_app.stream(init_state):    \n",
        "    for _, value in output.items():\n",
        "        pass \n",
        "    pprint(\"--------------------\")\n",
        "print(f'relevant context: {value[\"relevant_context\"]}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Add a shorter version of the answer verification, checking only if grounded on context"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 78,
      "metadata": {},
      "outputs": [],
      "source": [
        "def is_answer_grounded_on_context(state):\n",
        "    \"\"\"Determines if the answer to the question is grounded in the facts.\n",
        "    \n",
        "    Args:\n",
        "        state: A dictionary containing the context and answer.\n",
        "    \"\"\"\n",
        "    print(\"Checking if the answer is grounded in the facts...\")\n",
        "    context = state[\"context\"]\n",
        "    answer = state[\"answer\"]\n",
        "    \n",
        "    result = is_grounded_on_facts_chain.invoke({\"context\": context, \"answer\": answer})\n",
        "    grounded_on_facts = result.grounded_on_facts\n",
        "    if not grounded_on_facts:\n",
        "        print(\"The answer is hallucination.\")\n",
        "        return \"hallucination\"\n",
        "    else:\n",
        "        print(\"The answer is grounded in the facts.\")\n",
        "        return \"grounded on context\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### The last sub-graph will be a component that answers a question given context, without hallucinations"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "class QualitativeAnswerGraphState(TypedDict):\n",
        "    \"\"\"\n",
        "    Represents the state of our graph.\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    question: str\n",
        "    context: str\n",
        "    answer: str\n",
        "\n",
        "qualitative_answer_workflow = StateGraph(QualitativeAnswerGraphState)\n",
        "\n",
        "# Define the nodes\n",
        "\n",
        "qualitative_answer_workflow.add_node(\"answer_question_from_context\",answer_question_from_context)\n",
        "\n",
        "# Build the graph\n",
        "qualitative_answer_workflow.set_entry_point(\"answer_question_from_context\")\n",
        "\n",
        "qualitative_answer_workflow.add_conditional_edges(\n",
        "\"answer_question_from_context\",is_answer_grounded_on_context ,{\"hallucination\":\"answer_question_from_context\", \"grounded on context\":END}\n",
        "\n",
        ")\n",
        "\n",
        "qualitative_answer_workflow_app = qualitative_answer_workflow.compile()\n",
        "\n",
        "display(\n",
        "    Image(\n",
        "        qualitative_answer_workflow_app.get_graph().draw_mermaid_png(\n",
        "            draw_method=MermaidDrawMethod.API,\n",
        "        )\n",
        "    )\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Test the answer-from-question-graph"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 81,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Answering the question from the retrieved context...\n",
            "answer before checking hallucination: The context states that Harry Potter is a cat. Therefore, Harry is a cat.\n",
            "Checking if the answer is grounded in the facts...\n",
            "The answer is grounded in the facts.\n",
            "'--------------------'\n",
            "answer: The context states that Harry Potter is a cat. Therefore, Harry is a cat.\n"
          ]
        }
      ],
      "source": [
        "question = \"who is harry?\" # The question to answer\n",
        "context = \"Harry Potter is a cat.\" # The context to answer the question from\n",
        "init_state = {\"question\": question, \"context\": context} # The initial state\n",
        "for output in qualitative_answer_workflow_app.stream(init_state): \n",
        "    for _, value in output.items():\n",
        "        pass  # Node\n",
        "        # ... (your existing code)\n",
        "    pprint(\"--------------------\")\n",
        "print(f'answer: {value[\"answer\"]}')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Now let's define the sophisticated pipeline components"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### The state of each step of the graph should be in this structure:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 82,
      "metadata": {},
      "outputs": [],
      "source": [
        "class PlanExecute(TypedDict):\n",
        "    curr_state: str\n",
        "    question: str\n",
        "    anonymized_question: str\n",
        "    query_to_retrieve_or_answer: str\n",
        "    plan: List[str]\n",
        "    past_steps: List[str]\n",
        "    mapping: dict \n",
        "    curr_context: str\n",
        "    aggregated_context: str\n",
        "    tool: str\n",
        "    response: str"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define the Plan node - constructs a plan composed of steps, of how to tackle a question"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 83,
      "metadata": {},
      "outputs": [],
      "source": [
        "class Plan(BaseModel):\n",
        "    \"\"\"Plan to follow in future\"\"\"\n",
        "\n",
        "    steps: List[str] = Field(\n",
        "        description=\"different steps to follow, should be in sorted order\"\n",
        "    )\n",
        "\n",
        "planner_prompt =\"\"\" For the given query {question}, come up with a simple step by step plan of how to figure out the answer. \n",
        "\n",
        "This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \n",
        "The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "planner_prompt = PromptTemplate(\n",
        "    template=planner_prompt,\n",
        "      input_variables=[\"question\"], \n",
        "     )\n",
        "\n",
        "planner_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "\n",
        "planner = planner_prompt | planner_llm.with_structured_output(Plan)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### A function to break down each task to either retrieve or answer"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 84,
      "metadata": {},
      "outputs": [],
      "source": [
        "break_down_plan_prompt_template = \"\"\"You receive a plan {plan} which contains a series of steps to follow in order to answer a query. \n",
        "you need to go through the plan refine it according to this:\n",
        "1. every step has to be able to be executed by either:\n",
        "    i. retrieving relevant information from a vector store of book chunks\n",
        "    ii. retrieving relevant information from a vector store of chapter summaries\n",
        "    iii. retrieving relevant information from a vector store of book quotes\n",
        "    iv. answering a question from a given context.\n",
        "2. every step should contain all the information needed to execute it.\n",
        "\n",
        "output the refined plan\n",
        "\"\"\"\n",
        "\n",
        "break_down_plan_prompt = PromptTemplate(\n",
        "    template=break_down_plan_prompt_template,\n",
        "    input_variables=[\"plan\"],\n",
        ")\n",
        "\n",
        "break_down_plan_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "\n",
        "break_down_plan_chain = break_down_plan_prompt | break_down_plan_llm.with_structured_output(Plan)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Example of how to use the planner\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 85,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "steps=['Identify the main character and the villain in the story.', 'Locate the climax or the final confrontation between the main character and the villain.', 'Analyze the actions taken by the main character during this confrontation.', 'Determine the specific action or strategy that led to the defeat of the villain.', 'Summarize the findings to answer how the main character beat the villain.']\n",
            "steps=['Identify the main character and the villain in the story by retrieving relevant information from a vector store of book chunks, chapter summaries, or book quotes.', 'Locate the climax or the final confrontation between the main character and the villain by retrieving relevant information from a vector store of book chunks, chapter summaries, or book quotes.', 'Analyze the actions taken by the main character during this confrontation by retrieving relevant information from a vector store of book chunks, chapter summaries, or book quotes.', 'Determine the specific action or strategy that led to the defeat of the villain by retrieving relevant information from a vector store of book chunks, chapter summaries, or book quotes.', 'Summarize the findings to answer how the main character beat the villain by answering a question from a given context.']\n"
          ]
        }
      ],
      "source": [
        "question = {\"question\": \"how did the main character beat the villain?\"} # The question to answer\n",
        "my_plan = planner.invoke(question) # Generate a plan to answer the question\n",
        "print(my_plan)\n",
        "refined_plan = break_down_plan_chain.invoke(my_plan.steps) # Refine the plan\n",
        "print(refined_plan)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Given the original question, the current plan, the past steps, and the so far aggregated information, update the plan"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 86,
      "metadata": {},
      "outputs": [],
      "source": [
        "class ActPossibleResults(BaseModel):\n",
        "    \"\"\"Possible results of the action.\"\"\"\n",
        "    plan: Plan = Field(description=\"Plan to follow in future.\")\n",
        "    explanation: str = Field(description=\"Explanation of the action.\")\n",
        "    \n",
        "\n",
        "act_possible_results_parser = JsonOutputParser(pydantic_object=ActPossibleResults)\n",
        "\n",
        "replanner_prompt_template =\"\"\" For the given objective, come up with a simple step by step plan of how to figure out the answer. \n",
        "This plan should involve individual tasks, that if executed correctly will yield the correct answer. Do not add any superfluous steps. \n",
        "The result of the final step should be the final answer. Make sure that each step has all the information needed - do not skip steps.\n",
        "\n",
        "assume that the answer was not found yet and you need to update the plan accordingly, so the plan should never be empty.\n",
        "\n",
        "Your objective was this:\n",
        "{question}\n",
        "\n",
        "Your original plan was this:\n",
        "{plan}\n",
        "\n",
        "You have currently done the follow steps:\n",
        "{past_steps}\n",
        "\n",
        "You already have the following context:\n",
        "{aggregated_context}\n",
        "\n",
        "Update your plan accordingly. If further steps are needed, fill out the plan with only those steps.\n",
        "Do not return previously done steps as part of the plan.\n",
        "\n",
        "the format is json so escape quotes and new lines.\n",
        "\n",
        "{format_instructions}\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "replanner_prompt = PromptTemplate(\n",
        "    template=replanner_prompt_template,\n",
        "    input_variables=[\"question\", \"plan\", \"past_steps\", \"aggregated_context\"],\n",
        "    partial_variables={\"format_instructions\": act_possible_results_parser.get_format_instructions()},\n",
        ")\n",
        "\n",
        "replanner_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "\n",
        "\n",
        "\n",
        "replanner = replanner_prompt | replanner_llm | act_possible_results_parser"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define the task handler - decides whether to use the first sub-graph or the second sub-graph to handle each task from the plan"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 103,
      "metadata": {},
      "outputs": [],
      "source": [
        "tasks_handler_prompt_template = \"\"\"You are a task handler that receives a task {curr_task} and have to decide with tool to use to execute the task.\n",
        "You have the following tools at your disposal:\n",
        "Tool A: a tool that retrieves relevant information from a vector store of book chunks based on a given query.\n",
        "- use Tool A when you think the current task should search for information in the book chunks.\n",
        "Took B: a tool that retrieves relevant information from a vector store of chapter summaries based on a given query.\n",
        "- use Tool B when you think the current task should search for information in the chapter summaries.\n",
        "Tool C: a tool that retrieves relevant information from a vector store of quotes from the book based on a given query.\n",
        "- use Tool C when you think the current task should search for information in the book quotes.\n",
        "Tool D: a tool that answers a question from a given context.\n",
        "- use Tool D ONLY when you the current task can be answered by the aggregated context {aggregated_context}\n",
        "\n",
        "you also receive the last tool used {last_tool}\n",
        "if {last_tool} was retrieve_chunks, use other tools than Tool A.\n",
        "\n",
        "You also have the past steps {past_steps} that you can use to make decisions and understand the context of the task.\n",
        "You also have the initial user's question {question} that you can use to make decisions and understand the context of the task.\n",
        "if you decide to use Tools A,B or C, output the query to be used for the tool and also output the relevant tool.\n",
        "if you decide to use Tool D, output the question to be used for the tool, the context, and also that the tool to be used is Tool D.\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "class TaskHandlerOutput(BaseModel):\n",
        "    \"\"\"Output schema for the task handler.\"\"\"\n",
        "    query: str = Field(description=\"The query to be either retrieved from the vector store, or the question that should be answered from context.\")\n",
        "    curr_context: str = Field(description=\"The context to be based on in order to answer the query.\")\n",
        "    tool: str = Field(description=\"The tool to be used should be either retrieve_chunks, retrieve_summaries, retrieve_quotes, or answer_from_context.\")\n",
        "\n",
        "\n",
        "task_handler_prompt = PromptTemplate(\n",
        "    template=tasks_handler_prompt_template,\n",
        "    input_variables=[\"curr_task\", \"aggregated_context\", \"last_tool\" \"past_steps\", \"question\"],\n",
        ")\n",
        "\n",
        "task_handler_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "task_handler_chain = task_handler_prompt | task_handler_llm.with_structured_output(TaskHandlerOutput)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### In order to generate a general plan, without any biases based on prior knowledge of any LLM, we anonymize the input question, first, and map the name entities into variables"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 88,
      "metadata": {},
      "outputs": [],
      "source": [
        "class AnonymizeQuestion(BaseModel):\n",
        "    \"\"\"Anonymized question and mapping.\"\"\"\n",
        "    anonymized_question : str = Field(description=\"Anonymized question.\")\n",
        "    mapping: dict = Field(description=\"Mapping of original name entities to variables.\")\n",
        "    explanation: str = Field(description=\"Explanation of the action.\")\n",
        "\n",
        "anonymize_question_parser = JsonOutputParser(pydantic_object=AnonymizeQuestion)\n",
        "\n",
        "\n",
        "anonymize_question_prompt_template = \"\"\" You are a question anonymizer. The input You receive is a string containing several words that\n",
        " construct a question {question}. Your goal is to changes all name entities in the input to variables, and remember the mapping of the original name entities to the variables.\n",
        " ```example1:\n",
        "        if the input is \\\"who is harry potter?\\\" the output should be \\\"who is X?\\\" and the mapping should be {{\\\"X\\\": \\\"harry potter\\\"}} ```\n",
        "```example2:\n",
        "        if the input is \\\"how did the bad guy played with the alex and rony?\\\"\n",
        "          the output should be \\\"how did the X played with the Y and Z?\\\" and the mapping should be {{\\\"X\\\": \\\"bad guy\\\", \\\"Y\\\": \\\"alex\\\", \\\"Z\\\": \\\"rony\\\"}}```\n",
        " you must replace all name entities in the input with variables, and remember the mapping of the original name entities to the variables.\n",
        "  output the anonymized question and the mapping in a json format. {format_instructions}\"\"\"\n",
        "\n",
        "\n",
        "\n",
        "anonymize_question_prompt = PromptTemplate(\n",
        "    template=anonymize_question_prompt_template,\n",
        "    input_variables=[\"question\"],\n",
        "    partial_variables={\"format_instructions\": anonymize_question_parser.get_format_instructions()},\n",
        ")\n",
        "\n",
        "anonymize_question_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "anonymize_question_chain = anonymize_question_prompt | anonymize_question_llm | anonymize_question_parser"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### After the plan is constructed based on the anonymized question, we de-anonymize the plan, using the mapped variables"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 89,
      "metadata": {},
      "outputs": [],
      "source": [
        "class DeAnonymizePlan(BaseModel):\n",
        "    \"\"\"Possible results of the action.\"\"\"\n",
        "    plan: List = Field(description=\"Plan to follow in future. with all the variables replaced with the mapped words.\")\n",
        "\n",
        "de_anonymize_plan_prompt_template = \"\"\" you receive a list of tasks: {plan}, where some of the words are replaced with mapped variables. you also receive\n",
        "the mapping for those variables to words {mapping}. replace all the variables in the list of tasks with the mapped words. if no variables are present,\n",
        "return the original list of tasks. in any case, just output the updated list of tasks in a json format as described here, without any additional text apart from the\n",
        "\"\"\"\n",
        "\n",
        "\n",
        "de_anonymize_plan_prompt = PromptTemplate(\n",
        "    template=de_anonymize_plan_prompt_template,\n",
        "    input_variables=[\"plan\", \"mapping\"],\n",
        ")\n",
        "\n",
        "de_anonymize_plan_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "de_anonymize_plan_chain = de_anonymize_plan_prompt | de_anonymize_plan_llm.with_structured_output(DeAnonymizePlan)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Example of how to build a plan\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 72,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "question: how did the harry beat quirrell? \n",
            "\n",
            "anonimized_querry: how did the X beat Y? \n",
            "\n",
            "mapping: {'X': 'harry', 'Y': 'quirrell'} \n",
            "\n",
            "plan: ['Identify the context or domain of the query (e.g., sports, competition, game, etc.).', 'Gather information about\n",
            "the event or competition where X and Y participated.', 'Find the specific instance or match where X competed against\n",
            "Y.', 'Look up the results of that specific instance or match.', 'Analyze the details of the match to understand how X\n",
            "managed to beat Y.', 'Summarize the key points that explain how X beat Y.']\n",
            "\n",
            "deanonimized_plan: ['Identify the context or domain of the query (e.g., sports, competition, game, etc.).', 'Gather\n",
            "information about the event or competition where harry and quirrell participated.', 'Find the specific instance or match\n",
            "where harry competed against quirrell.', 'Look up the results of that specific instance or match.', 'Analyze the details\n",
            "of the match to understand how harry managed to beat quirrell.', 'Summarize the key points that explain how harry beat\n",
            "quirrell.']\n"
          ]
        }
      ],
      "source": [
        "state1 = {'question': \"how did the harry beat quirrell? \\n\"}  # The question to answer\n",
        "print(f'question: {state1[\"question\"]}')\n",
        "anonymized_question_output = anonymize_question_chain.invoke(state1) # Anonymize the question\n",
        "anonymized_question = anonymized_question_output[\"anonymized_question\"] # Get the anonymized question\n",
        "mapping = anonymized_question_output[\"mapping\"] # Get the mapping of the original name entities to the variables\n",
        "print(f'anonimized_querry: {anonymized_question} \\n')\n",
        "print(f'mapping: {mapping} \\n')\n",
        "plan = planner.invoke({\"question\": anonymized_question}) # Generate a plan to answer the question\n",
        "print(text_wrap(f'plan: {plan.steps}'))\n",
        "print(\"\")\n",
        "deanonimzed_plan = de_anonymize_plan_chain.invoke({\"plan\": plan.steps, \"mapping\": mapping}) # De-anonymize the plan\n",
        "print(text_wrap(f'deanonimized_plan: {deanonimzed_plan.plan}'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### A function that checks if the final answer can be deduced already, based on the aggregated information"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 90,
      "metadata": {},
      "outputs": [],
      "source": [
        "class CanBeAnsweredAlready(BaseModel):\n",
        "    \"\"\"Possible results of the action.\"\"\"\n",
        "    can_be_answered: bool = Field(description=\"Whether the question can be fully answered or not based on the given context.\")\n",
        "\n",
        "can_be_answered_already_prompt_template = \"\"\"You receive a query: {question} and a context: {context}.\n",
        "You need to determine if the question can be fully answered relying only the given context.\n",
        "The only infomation you have and can rely on is the context you received. \n",
        "you have no prior knowledge of the question or the context.\n",
        "if you think the question can be answered based on the context, output 'true', otherwise output 'false'.\n",
        "\"\"\"\n",
        "\n",
        "can_be_answered_already_prompt = PromptTemplate(\n",
        "    template=can_be_answered_already_prompt_template,\n",
        "    input_variables=[\"question\",\"context\"],\n",
        ")\n",
        "\n",
        "can_be_answered_already_llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=2000)\n",
        "can_be_answered_already_chain = can_be_answered_already_prompt | can_be_answered_already_llm.with_structured_output(CanBeAnsweredAlready)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define the sophisticated pipeline graph functions"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {},
      "outputs": [],
      "source": [
        "def run_task_handler_chain(state: PlanExecute):\n",
        "    \"\"\" Run the task handler chain to decide which tool to use to execute the task.\n",
        "    Args:\n",
        "       state: The current state of the plan execution.\n",
        "    Returns:\n",
        "       The updated state of the plan execution.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"task_handler\"\n",
        "    print(\"the current plan is:\")\n",
        "    print(state[\"plan\"])\n",
        "    pprint(\"--------------------\") \n",
        "\n",
        "    if not state['past_steps']:\n",
        "        state[\"past_steps\"] = []\n",
        "\n",
        "    curr_task = state[\"plan\"][0]\n",
        "\n",
        "    inputs = {\"curr_task\": curr_task,\n",
        "               \"aggregated_context\": state[\"aggregated_context\"],\n",
        "                \"last_tool\": state[\"tool\"],\n",
        "                \"past_steps\": state[\"past_steps\"],\n",
        "                \"question\": state[\"question\"]}\n",
        "    \n",
        "    output = task_handler_chain.invoke(inputs)\n",
        "  \n",
        "    state[\"past_steps\"].append(curr_task)\n",
        "    state[\"plan\"].pop(0)\n",
        "\n",
        "    if output.tool == \"retrieve_chunks\":\n",
        "        state[\"query_to_retrieve_or_answer\"] = output.query\n",
        "        state[\"tool\"]=\"retrieve_chunks\"\n",
        "    \n",
        "    elif output.tool == \"retrieve_summaries\":\n",
        "        state[\"query_to_retrieve_or_answer\"] = output.query\n",
        "        state[\"tool\"]=\"retrieve_summaries\"\n",
        "\n",
        "    elif output.tool == \"retrieve_quotes\":\n",
        "        state[\"query_to_retrieve_or_answer\"] = output.query\n",
        "        state[\"tool\"]=\"retrieve_quotes\"\n",
        "\n",
        "    \n",
        "    elif output.tool == \"answer_from_context\":\n",
        "        state[\"query_to_retrieve_or_answer\"] = output.query\n",
        "        state[\"curr_context\"] = output.curr_context\n",
        "        state[\"tool\"]=\"answer\"\n",
        "    else:\n",
        "        raise ValueError(\"Invalid tool was outputed. Must be either 'retrieve' or 'answer_from_context'\")\n",
        "    return state  \n",
        "\n",
        "\n",
        "\n",
        "def retrieve_or_answer(state: PlanExecute):\n",
        "    \"\"\"Decide whether to retrieve or answer the question based on the current state.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        updates the tool to use .\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"decide_tool\"\n",
        "    print(\"deciding whether to retrieve or answer\")\n",
        "    if state[\"tool\"] == \"retrieve_chunks\":\n",
        "        return \"chosen_tool_is_retrieve_chunks\"\n",
        "    elif state[\"tool\"] == \"retrieve_summaries\":\n",
        "        return \"chosen_tool_is_retrieve_summaries\"\n",
        "    elif state[\"tool\"] == \"retrieve_quotes\":\n",
        "        return \"chosen_tool_is_retrieve_quotes\"\n",
        "    elif state[\"tool\"] == \"answer\":\n",
        "        return \"chosen_tool_is_answer\"\n",
        "    else:\n",
        "        raise ValueError(\"Invalid tool was outputed. Must be either 'retrieve' or 'answer_from_context'\")  \n",
        "\n",
        "def run_qualitative_chunks_retrieval_workflow(state):\n",
        "    \"\"\"\n",
        "    Run the qualitative chunks retrieval workflow.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The state with the updated aggregated context.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"retrieve_chunks\"\n",
        "    print(\"Running the qualitative chunks retrieval workflow...\")\n",
        "    question = state[\"query_to_retrieve_or_answer\"]\n",
        "    inputs = {\"question\": question}\n",
        "    for output in qualitative_chunks_retrieval_workflow_app.stream(inputs):\n",
        "        for _, _ in output.items():\n",
        "            pass \n",
        "        pprint(\"--------------------\")\n",
        "    if not state[\"aggregated_context\"]:\n",
        "        state[\"aggregated_context\"] = \"\"\n",
        "    state[\"aggregated_context\"] += output['relevant_context']\n",
        "    return state\n",
        "\n",
        "def run_qualitative_summaries_retrieval_workflow(state):\n",
        "    \"\"\"\n",
        "    Run the qualitative summaries retrieval workflow.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The state with the updated aggregated context.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"retrieve_summaries\"\n",
        "    print(\"Running the qualitative summaries retrieval workflow...\")\n",
        "    question = state[\"query_to_retrieve_or_answer\"]\n",
        "    inputs = {\"question\": question}\n",
        "    for output in qualitative_summaries_retrieval_workflow_app.stream(inputs):\n",
        "        for _, _ in output.items():\n",
        "            pass \n",
        "        pprint(\"--------------------\")\n",
        "    if not state[\"aggregated_context\"]:\n",
        "        state[\"aggregated_context\"] = \"\"\n",
        "    state[\"aggregated_context\"] += output['relevant_context']\n",
        "    return state\n",
        "\n",
        "def run_qualitative_book_quotes_retrieval_workflow(state):\n",
        "    \"\"\"\n",
        "    Run the qualitative book quotes retrieval workflow.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The state with the updated aggregated context.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"retrieve_book_quotes\"\n",
        "    print(\"Running the qualitative book quotes retrieval workflow...\")\n",
        "    question = state[\"query_to_retrieve_or_answer\"]\n",
        "    inputs = {\"question\": question}\n",
        "    for output in qualitative_book_quotes_retrieval_workflow_app.stream(inputs):\n",
        "        for _, _ in output.items():\n",
        "            pass \n",
        "        pprint(\"--------------------\")\n",
        "    if not state[\"aggregated_context\"]:\n",
        "        state[\"aggregated_context\"] = \"\"\n",
        "    state[\"aggregated_context\"] += output['relevant_context']\n",
        "    return state\n",
        "   \n",
        "\n",
        "\n",
        "def run_qualtative_answer_workflow(state):\n",
        "    \"\"\"\n",
        "    Run the qualitative answer workflow.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The state with the updated aggregated context.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"answer\"\n",
        "    print(\"Running the qualitative answer workflow...\")\n",
        "    question = state[\"query_to_retrieve_or_answer\"]\n",
        "    context = state[\"curr_context\"]\n",
        "    inputs = {\"question\": question, \"context\": context}\n",
        "    for output in qualitative_answer_workflow_app.stream(inputs):\n",
        "        for _, _ in output.items():\n",
        "            pass \n",
        "        pprint(\"--------------------\")\n",
        "    if not state[\"aggregated_context\"]:\n",
        "        state[\"aggregated_context\"] = \"\"\n",
        "    state[\"aggregated_context\"] += output[\"answer\"]\n",
        "    return state\n",
        "\n",
        "def run_qualtative_answer_workflow_for_final_answer(state):\n",
        "    \"\"\"\n",
        "    Run the qualitative answer workflow for the final answer.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The state with the updated response.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"get_final_answer\"\n",
        "    print(\"Running the qualitative answer workflow for final answer...\")\n",
        "    question = state[\"question\"]\n",
        "    context = state[\"aggregated_context\"]\n",
        "    inputs = {\"question\": question, \"context\": context}\n",
        "    for output in qualitative_answer_workflow_app.stream(inputs):\n",
        "        for _, value in output.items():\n",
        "            pass  \n",
        "        pprint(\"--------------------\")\n",
        "    state[\"response\"] = value\n",
        "    return state\n",
        "\n",
        "\n",
        "def anonymize_queries(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    Anonymizes the question.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The updated state with the anonymized question and mapping.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"anonymize_question\"\n",
        "    print(\"Anonymizing question\")\n",
        "    pprint(\"--------------------\")\n",
        "    anonymized_question_output = anonymize_question_chain.invoke(state['question'])\n",
        "    anonymized_question = anonymized_question_output[\"anonymized_question\"]\n",
        "    print(f'anonimized_querry: {anonymized_question}')\n",
        "    pprint(\"--------------------\")\n",
        "    mapping = anonymized_question_output[\"mapping\"]\n",
        "    state[\"anonymized_question\"] = anonymized_question\n",
        "    state[\"mapping\"] = mapping\n",
        "    return state\n",
        "\n",
        "\n",
        "def deanonymize_queries(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    De-anonymizes the plan.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The updated state with the de-anonymized plan.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"de_anonymize_plan\"\n",
        "    print(\"De-anonymizing plan\")\n",
        "    pprint(\"--------------------\")\n",
        "    deanonimzed_plan = de_anonymize_plan_chain.invoke({\"plan\": state[\"plan\"], \"mapping\": state[\"mapping\"]})\n",
        "    state[\"plan\"] = deanonimzed_plan.plan\n",
        "    print(f'de-anonimized_plan: {deanonimzed_plan.plan}')\n",
        "    return state\n",
        "\n",
        "\n",
        "def plan_step(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    Plans the next step.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The updated state with the plan.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"planner\"\n",
        "    print(\"Planning step\")\n",
        "    pprint(\"--------------------\")\n",
        "    plan = planner.invoke({\"question\": state['anonymized_question']})\n",
        "    state[\"plan\"] = plan.steps\n",
        "    print(f'plan: {state[\"plan\"]}')\n",
        "    return state\n",
        "\n",
        "\n",
        "def break_down_plan_step(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    Breaks down the plan steps into retrievable or answerable tasks.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The updated state with the refined plan.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"break_down_plan\"\n",
        "    print(\"Breaking down plan steps into retrievable or answerable tasks\")\n",
        "    pprint(\"--------------------\")\n",
        "    refined_plan = break_down_plan_chain.invoke(state[\"plan\"])\n",
        "    state[\"plan\"] = refined_plan.steps\n",
        "    return state\n",
        "\n",
        "\n",
        "\n",
        "def replan_step(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    Replans the next step.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        The updated state with the plan.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"replan\"\n",
        "    print(\"Replanning step\")\n",
        "    pprint(\"--------------------\")\n",
        "    inputs = {\"question\": state[\"question\"], \"plan\": state[\"plan\"], \"past_steps\": state[\"past_steps\"], \"aggregated_context\": state[\"aggregated_context\"]}\n",
        "    output = replanner.invoke(inputs)\n",
        "    state[\"plan\"] = output['plan']['steps']\n",
        "    return state\n",
        "\n",
        "\n",
        "def can_be_answered(state: PlanExecute):\n",
        "    \"\"\"\n",
        "    Determines if the question can be answered.\n",
        "    Args:\n",
        "        state: The current state of the plan execution.\n",
        "    Returns:\n",
        "        whether the original question can be answered or not.\n",
        "    \"\"\"\n",
        "    state[\"curr_state\"] = \"can_be_answered_already\"\n",
        "    print(\"Checking if the ORIGINAL QUESTION can be answered already\")\n",
        "    pprint(\"--------------------\")\n",
        "    question = state[\"question\"]\n",
        "    context = state[\"aggregated_context\"]\n",
        "    inputs = {\"question\": question, \"context\": context}\n",
        "    output = can_be_answered_already_chain.invoke(inputs)\n",
        "    if output.can_be_answered == True:\n",
        "        print(\"The ORIGINAL QUESTION can be fully answered already.\")\n",
        "        pprint(\"--------------------\")\n",
        "        print(\"the aggregated context is:\")\n",
        "        print(text_wrap(state[\"aggregated_context\"]))\n",
        "        print(\"--------------------\")\n",
        "        return \"can_be_answered_already\"\n",
        "    else:\n",
        "        print(\"The ORIGINAL QUESTION cannot be fully answered yet.\")\n",
        "        pprint(\"--------------------\")\n",
        "        return \"cannot_be_answered_yet\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Define the sophisticated graph structure"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 100,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/jpeg": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from langgraph.graph import StateGraph\n",
        "\n",
        "agent_workflow = StateGraph(PlanExecute)\n",
        "\n",
        "# Add the anonymize node\n",
        "agent_workflow.add_node(\"anonymize_question\", anonymize_queries)\n",
        "\n",
        "# Add the plan node\n",
        "agent_workflow.add_node(\"planner\", plan_step)\n",
        "\n",
        "# Add the break down plan node\n",
        "\n",
        "agent_workflow.add_node(\"break_down_plan\", break_down_plan_step)\n",
        "\n",
        "# Add the deanonymize node\n",
        "agent_workflow.add_node(\"de_anonymize_plan\", deanonymize_queries)\n",
        "\n",
        "# Add the qualitative chunks retrieval node\n",
        "agent_workflow.add_node(\"retrieve_chunks\", run_qualitative_chunks_retrieval_workflow)\n",
        "\n",
        "# Add the qualitative summaries retrieval node\n",
        "agent_workflow.add_node(\"retrieve_summaries\", run_qualitative_summaries_retrieval_workflow)\n",
        "\n",
        "# Add the qualitative book quotes retrieval node\n",
        "agent_workflow.add_node(\"retrieve_book_quotes\", run_qualitative_book_quotes_retrieval_workflow)\n",
        "\n",
        "\n",
        "# Add the qualitative answer node\n",
        "agent_workflow.add_node(\"answer\", run_qualtative_answer_workflow)\n",
        "\n",
        "# Add the task handler node\n",
        "agent_workflow.add_node(\"task_handler\", run_task_handler_chain)\n",
        "\n",
        "# Add a replan node\n",
        "agent_workflow.add_node(\"replan\", replan_step)\n",
        "\n",
        "# Add answer from context node\n",
        "agent_workflow.add_node(\"get_final_answer\", run_qualtative_answer_workflow_for_final_answer)\n",
        "\n",
        "# Set the entry point\n",
        "agent_workflow.set_entry_point(\"anonymize_question\")\n",
        "\n",
        "# From anonymize we go to plan\n",
        "agent_workflow.add_edge(\"anonymize_question\", \"planner\")\n",
        "\n",
        "# From plan we go to deanonymize\n",
        "agent_workflow.add_edge(\"planner\", \"de_anonymize_plan\")\n",
        "\n",
        "# From deanonymize we go to break down plan\n",
        "\n",
        "agent_workflow.add_edge(\"de_anonymize_plan\", \"break_down_plan\")\n",
        "\n",
        "# From break_down_plan we go to task handler\n",
        "agent_workflow.add_edge(\"break_down_plan\", \"task_handler\")\n",
        "\n",
        "# From task handler we go to either retrieve or answer\n",
        "agent_workflow.add_conditional_edges(\"task_handler\", retrieve_or_answer, {\"chosen_tool_is_retrieve_chunks\": \"retrieve_chunks\", \"chosen_tool_is_retrieve_summaries\":\n",
        "                                                                           \"retrieve_summaries\", \"chosen_tool_is_retrieve_quotes\": \"retrieve_book_quotes\", \"chosen_tool_is_answer\": \"answer\"})\n",
        "\n",
        "# After retrieving we go to replan\n",
        "agent_workflow.add_edge(\"retrieve_chunks\", \"replan\")\n",
        "\n",
        "agent_workflow.add_edge(\"retrieve_summaries\", \"replan\")\n",
        "\n",
        "agent_workflow.add_edge(\"retrieve_book_quotes\", \"replan\")\n",
        "\n",
        "# After answering we go to replan\n",
        "agent_workflow.add_edge(\"answer\", \"replan\")\n",
        "\n",
        "# After replanning we check if the question can be answered, if yes we go to get_final_answer, if not we go to task_handler\n",
        "agent_workflow.add_conditional_edges(\"replan\",can_be_answered, {\"can_be_answered_already\": \"get_final_answer\", \"cannot_be_answered_yet\": \"break_down_plan\"})\n",
        "\n",
        "# After getting the final answer we end\n",
        "agent_workflow.add_edge(\"get_final_answer\", END)\n",
        "\n",
        "\n",
        "plan_and_execute_app = agent_workflow.compile()\n",
        "\n",
        "display(Image(plan_and_execute_app.get_graph(xray=True).draw_mermaid_png()))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Run the sophisticated graph function"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {},
      "outputs": [],
      "source": [
        "def execute_plan_and_print_steps(inputs, recursion_limit=45):\n",
        "    \"\"\"\n",
        "    Execute the plan and print the steps.\n",
        "    Args:\n",
        "        inputs: The inputs to the plan.\n",
        "        recursion_limit: The recursion limit.\n",
        "    Returns:\n",
        "        The response and the final state.\n",
        "    \"\"\"\n",
        "    \n",
        "    config = {\"recursion_limit\": recursion_limit}\n",
        "    try:    \n",
        "        for plan_output in plan_and_execute_app.stream(inputs, config=config):\n",
        "            for _, agent_state_value in plan_output.items():\n",
        "                pass\n",
        "                print(f' curr step: {agent_state_value}')\n",
        "        response = agent_state_value['response']\n",
        "    except langgraph.pregel.GraphRecursionError:\n",
        "        response = \"The answer wasn't found in the data.\"\n",
        "    final_state = agent_state_value\n",
        "    print(text_wrap(f' the final answer is: {response}'))\n",
        "    return response, final_state"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Examples"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### An example we want the model to fail"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "input = {\"question\": \"what did professor lupin teach?\"}\n",
        "final_answer, final_state = execute_plan_and_print_steps(input)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### An example we want the model to succeed"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "input = {\"question\": \"what is the class that the proffessor who helped the villain is teaching?\"}\n",
        "final_answer, final_state = execute_plan_and_print_steps(input)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### An example that demonstrates the CoT reasoning, when answering a question"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "input = {\"question\": \"how did harry beat quirrell?\"}\n",
        "final_answer, final_state = execute_plan_and_print_steps(input)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JBKQkR-W4ZyV"
      },
      "source": [
        "### Model Evaluation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {
        "id": "ME52zvjPNv47"
      },
      "outputs": [],
      "source": [
        "questions = [\n",
        "    \"What is the name of the three-headed dog guarding the Sorcerer's Stone?\",\n",
        "    \"Who gave Harry Potter his first broomstick?\",\n",
        "    \"Which house did the Sorting Hat initially consider for Harry?\",\n",
        "    # \"What is the name of Harry's owl?\"\n",
        "]\n",
        "#     \"How did Harry and his friends get past Fluffy?\",\n",
        "#     \"What is the Mirror of Erised?\",\n",
        "#     \"Who tried to steal the Sorcerer's Stone?\",\n",
        "#     \"How did Harry defeat Quirrell?\",\n",
        "#     \"What is Harry's parent's secret weapon against Voldemort?\",\n",
        "# ]\n",
        "\n",
        "ground_truth_answers = [\n",
        "    \"Fluffy\",\n",
        "    \"Professor McGonagall\",\n",
        "    \"Slytherin\",\n",
        "    # \"Hedwig\",\n",
        "    # \"They played music to put Fluffy to sleep.\",\n",
        "    # \"A magical mirror that shows the 'deepest, most desperate desire of our hearts.'\",\n",
        "    # \"Professor Quirrell, possessed by Voldemort\",\n",
        "    # \"Harry's mother's love protected him, causing Quirrell/Voldemort pain when they touched him.\",\n",
        "]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Generating Answers and Retrieving Documents for Predefined Questions\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 460
        },
        "id": "Wo9EEV0j4mJA",
        "outputId": "14c46214-8fb8-41aa-9845-73367d9a738f"
      },
      "outputs": [],
      "source": [
        "generated_answers = [] # To store the generated answers\n",
        "retrieved_documents = [] # To store the retrieved documents\n",
        "for question in questions:\n",
        "    input = {\"question\": question} # The input to the plan\n",
        "    print(f\"Answering the question: {question}\")\n",
        "    final_answer, final_state = execute_plan_and_print_steps(input) # Execute the pipeline \n",
        "    generated_answers.append(final_answer) # Append the generated answer\n",
        "    retrieved_documents.append(final_state['aggregated_context']) # Append the retrieved documents"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Displaying Retrieved Documents and Generated Answers\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "print(text_wrap(f'retrieved_documents: {retrieved_documents}\\n'))\n",
        "print(text_wrap(f'generated_answers: {generated_answers}'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Preparing Data and Conducting Ragas Evaluation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Evaluating: 100%|██████████| 15/15 [00:51<00:00,  3.44s/it]\n"
          ]
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "                                            question                answer  \\\n",
            "0  What is the name of the three-headed dog guard...                Fluffy   \n",
            "1        Who gave Harry Potter his first broomstick?  Professor McGonagall   \n",
            "2  Which house did the Sorting Hat initially cons...             Slytherin   \n",
            "\n",
            "                                            contexts          ground_truth  \\\n",
            "0  [I, n,  , C, h, a, p, t, e, r,  , S, i, x, t, ...                Fluffy   \n",
            "1  [I, n,  , C, h, a, p, t, e, r,  , E, i, g, h, ...  Professor McGonagall   \n",
            "2  [T, h, e,  , S, o, r, t, i, n, g,  , H, a, t, ...             Slytherin   \n",
            "\n",
            "   answer_correctness  faithfulness  answer_relevancy  context_recall  \\\n",
            "0                 1.0           1.0          1.000000             1.0   \n",
            "1                 1.0           1.0          0.946824             1.0   \n",
            "2                 1.0           0.0          0.889830             0.0   \n",
            "\n",
            "   answer_similarity  \n",
            "0                1.0  \n",
            "1                1.0  \n",
            "2                1.0  \n"
          ]
        }
      ],
      "source": [
        "# Prepare data for Ragas evaluation\n",
        "data_samples = {\n",
        "    'question': questions,  # Replace with your list of questions\n",
        "    'answer': generated_answers,  # Replace with your list of generated answers\n",
        "    'contexts': retrieved_documents,  # Your retrieved_documents list\n",
        "    'ground_truth': ground_truth_answers  # Replace with your list of ground truth answers\n",
        "}\n",
        "\n",
        "# Convert contexts to list of strings (if necessary)\n",
        "data_samples['contexts'] = [list(context) for context in data_samples['contexts']]\n",
        "\n",
        "dataset = Dataset.from_dict(data_samples)\n",
        "\n",
        "# Evaluate using Ragas with the specified metrics\n",
        "metrics = [\n",
        "    answer_correctness,\n",
        "    faithfulness,\n",
        "    answer_relevancy,\n",
        "    context_recall,\n",
        "    answer_similarity\n",
        "]\n",
        "llm = ChatOpenAI(temperature=0, model_name=\"gpt-4o\", max_tokens=4000)\n",
        "score = evaluate(dataset, metrics=metrics, llm=llm)\n",
        "\n",
        "# Print results and explanations\n",
        "results_df = score.to_pandas()\n",
        "print(results_df)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Analyzing Metric Results from Ragas Evaluation\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 124,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "**QUESTION**\n",
            "\n",
            "**ANSWER**\n",
            "\n",
            "**CONTEXTS**\n",
            "\n",
            "**GROUND_TRUTH**\n",
            "\n",
            "**ANSWER_CORRECTNESS**\n",
            "Measures whether the generated answer is factually correct.\n",
            "Score: 1.0000\n",
            "\n",
            "**FAITHFULNESS**\n",
            "Measures how well the generated answer is supported by the retrieved documents.\n",
            "Score: 1.0000\n",
            "\n",
            "**ANSWER_RELEVANCY**\n",
            "Measures how relevant the generated answer is to the question.\n",
            "Score: 1.0000\n",
            "\n",
            "**CONTEXT_RECALL**\n",
            "Measures the proportion of relevant documents that are successfully retrieved.\n",
            "Score: 1.0000\n",
            "\n",
            "**ANSWER_SIMILARITY**\n",
            "Measures the semantic similarity between the generated answer and the ground truth answer.\n",
            "Score: 1.0000\n"
          ]
        }
      ],
      "source": [
        "analyse_metric_results(results_df) # Analyse the results"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.12.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}