notebooks/LangGraph_Hello_World.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Simple CRAG - Corrective Retrieval Augmented Generation\n",
    "\n",
    "Inspiration: https://github.com/langchain-ai/langgraph/blob/main/examples/rag/langgraph_crag.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"OPENAI_API_KEY\"] = 'sk-***'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup / Grabbing Documents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "-47NGgZAvFz-",
    "outputId": "72f0e0c9-0fa5-45b2-fd88-f3c9f710afa5"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "USER_AGENT environment variable not set, consider setting it to identify your requests.\n"
     ]
    }
   ],
   "source": [
    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
    "from langchain_community.document_loaders import WebBaseLoader\n",
    "from langchain_community.vectorstores import Chroma\n",
    "from langchain_openai import OpenAIEmbeddings\n",
    "\n",
    "urls = [\n",
    "    \"https://lilianweng.github.io/posts/2023-06-23-agent/\",\n",
    "    \"https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\",\n",
    "    \"https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\",\n",
    "]\n",
    "\n",
    "docs = [WebBaseLoader(url).load() for url in urls]\n",
    "docs_list = [item for sublist in docs for item in sublist]\n",
    "\n",
    "text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(\n",
    "    chunk_size=250, chunk_overlap=0\n",
    ")\n",
    "doc_splits = text_splitter.split_documents(docs_list)\n",
    "\n",
    "# Add to vectorDB\n",
    "vectorstore = Chroma.from_documents(\n",
    "    documents=doc_splits,\n",
    "    collection_name=\"rag-chroma\",\n",
    "    embedding=OpenAIEmbeddings(),\n",
    ")\n",
    "retriever = vectorstore.as_retriever()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YxTG7Kk2xZhm",
    "outputId": "e08810b4-d44d-4fb6-d3e7-6dad5c406ad8"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zero-shot and few-shot learning are two most basic ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n",
      "Few-shot CoT. It is to prompt the model with a few ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n",
      "Zero-shot generation: This is to find a number of  ... https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\n",
      "Text: i'll bet the video game is a lot more fun th ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/y9/9xqbqkg90tnc0cmm0dxt985m0000gn/T/ipykernel_85152/2952994269.py:2: LangChainDeprecationWarning: The method `BaseRetriever.get_relevant_documents` was deprecated in langchain-core 0.1.46 and will be removed in 1.0. Use :meth:`~invoke` instead.\n",
      "  docs = retriever.get_relevant_documents(question)\n"
     ]
    }
   ],
   "source": [
    "question = \"What is few-shot learning?\"\n",
    "docs = retriever.get_relevant_documents(question)\n",
    "for doc in docs:\n",
    "    print(doc.page_content[:50], '...', doc.metadata['source'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Retrieval Grader / The Corrective Part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MhapNmaowfp-",
    "outputId": "98a6405d-d1bb-49bb-93a1-cb99e4c2636f"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "binary_score='yes' Zero-shot and few-shot learning are two most basic ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n",
      "binary_score='no' Few-shot CoT. It is to prompt the model with a few ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n",
      "binary_score='no' Zero-shot generation: This is to find a number of  ... https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/\n",
      "binary_score='no' Text: i'll bet the video game is a lot more fun th ... https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/\n"
     ]
    }
   ],
   "source": [
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from pydantic import BaseModel, Field\n",
    "from langchain_openai import ChatOpenAI\n",
    "\n",
    "\n",
    "# Data model\n",
    "class GradeDocuments(BaseModel):\n",
    "    \"\"\"Binary score for relevance check on retrieved documents.\"\"\"\n",
    "\n",
    "    binary_score: str = Field(\n",
    "        description=\"Documents are relevant to the question, 'yes' or 'no'\"\n",
    "    )\n",
    "\n",
    "\n",
    "# LLM with function call\n",
    "llm = ChatOpenAI(model=\"gpt-4o-mini\", temperature=0)\n",
    "structured_llm_grader = llm.with_structured_output(GradeDocuments)\n",
    "\n",
    "\n",
    "# Prompt\n",
    "system = \"\"\"Give a binary score 'yes' or 'no' to indicate whether the document is relevant to the question.\"\"\"\n",
    "grade_prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", system),\n",
    "        (\"human\", \"Retrieved document: \\n\\n {document} \\n\\n User question: {question}\"),\n",
    "    ]\n",
    ")\n",
    "\n",
    "retrieval_grader = grade_prompt | structured_llm_grader\n",
    "\n",
    "for doc in docs:\n",
    "    doc_txt = doc.page_content\n",
    "    print(retrieval_grader.invoke({\"question\": question, \"document\": doc_txt}), doc_txt[:50], '...', doc.metadata['source'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "H2X8QeJkxye7"
   },
   "source": [
    "## Generate Compoments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Yfm8E7gvwu3C",
    "outputId": "8d6e0406-b041-448c-eaad-9cefbb745fc0"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/sinanozdemir/Teaching/Pearson/oreilly-ai-agents/.venv/lib/python3.11/site-packages/langsmith/client.py:241: LangSmithMissingAPIKeyWarning: API key must be provided when using hosted LangSmith API\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'langchain_core.prompts.chat.HumanMessagePromptTemplate'>\n",
      "You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.\n",
      "Question: {question} \n",
      "Context: {context} \n",
      "Answer:\n",
      "-----\n"
     ]
    }
   ],
   "source": [
    "from langchain import hub\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "\n",
    "# Prompt\n",
    "prompt = hub.pull(\"rlm/rag-prompt\")\n",
    "for message in prompt.messages:\n",
    "    print(type(message))\n",
    "    print(message.prompt.template)\n",
    "    print('-----')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "bUzV8hwgx0G0",
    "outputId": "78fd6604-2e40-4979-992e-c79323472b8e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Few-shot learning is a machine learning approach where a model is provided with a small number of high-quality examples that include both input and desired output for a specific task. This method helps the model better understand human intentions and criteria, often resulting in improved performance compared to zero-shot learning. However, it requires more tokens and may encounter context length limitations with longer texts.\n"
     ]
    }
   ],
   "source": [
    "# LLM\n",
    "llm = ChatOpenAI(model_name=\"gpt-4o-mini\", temperature=0)\n",
    "\n",
    "# Post-processing\n",
    "def format_docs(docs):\n",
    "    return \"\\n\\n\".join(doc.page_content for doc in docs)\n",
    "\n",
    "# Chain\n",
    "rag_chain = prompt | llm | StrOutputParser()\n",
    "\n",
    "# Run\n",
    "generation = rag_chain.invoke({\"context\": format_docs(docs), \"question\": question})\n",
    "print(generation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Question Re-writer\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rX5WDbN6z010",
    "outputId": "b558819c-b304-4107-c5ce-320b4de76d03"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('What is few-shot learning?',\n",
       " 'What are the key concepts and applications of few-shot learning in machine learning?')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# A different LLM, just to show we can use multiple LLMs in our calls\n",
    "three_five_llm = ChatOpenAI(model=\"gpt-3.5-turbo\", temperature=0)\n",
    "\n",
    "# Prompt\n",
    "system = \"\"\"You are a question re-writer that converts an input question to a better version that is optimized \\n\n",
    "     for web search. Look at the input and try to reason about the underlying semantic intent / meaning.\"\"\"\n",
    "re_write_prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", system),\n",
    "        (\n",
    "            \"human\",\n",
    "            \"Here is the initial question: \\n\\n {question} \\n Formulate an improved question.\",\n",
    "        ),\n",
    "    ]\n",
    ")\n",
    "\n",
    "question_rewriter = re_write_prompt | three_five_llm | StrOutputParser()\n",
    "question, question_rewriter.invoke({\"question\": question})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "xXf2XKOKz1AW"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building the Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "9MlJ26oXzJqw"
   },
   "outputs": [],
   "source": [
    "from typing import List\n",
    "\n",
    "from typing_extensions import TypedDict\n",
    "\n",
    "class GraphState(TypedDict):\n",
    "    \"\"\"\n",
    "    Represents the state of our graph.\n",
    "\n",
    "    Attributes:\n",
    "        question: question\n",
    "        generation: LLM generation\n",
    "        documents: list of documents\n",
    "        times_transformed: number of times the question has been re-written\n",
    "    \"\"\"\n",
    "\n",
    "    question: str\n",
    "    generation: str\n",
    "    documents: List[str]\n",
    "    times_transformed: int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "dE99Sfa-zOvA"
   },
   "outputs": [],
   "source": [
    "from langchain.schema import Document\n",
    "\n",
    "\n",
    "def retrieve(state):\n",
    "    print(state)\n",
    "    \"\"\"\n",
    "    Retrieve documents\n",
    "\n",
    "    Args:\n",
    "        state (dict): The current graph state\n",
    "\n",
    "    Returns:\n",
    "        state (dict): New key added to state, documents, that contains retrieved documents\n",
    "    \"\"\"\n",
    "    print(\"---RETRIEVE---\")\n",
    "    question = state[\"question\"]\n",
    "\n",
    "    # Retrieval\n",
    "    documents = retriever.get_relevant_documents(question)\n",
    "    return {\"documents\": documents, \"question\": question, \"times_transformed\": 0}\n",
    "\n",
    "\n",
    "def generate(state):\n",
    "    \"\"\"\n",
    "    Generate answer\n",
    "\n",
    "    Args:\n",
    "        state (dict): The current graph state\n",
    "\n",
    "    Returns:\n",
    "        state (dict): New key added to state, generation, that contains LLM generation\n",
    "    \"\"\"\n",
    "    print(\"---GENERATE---\")\n",
    "    question = state[\"question\"]\n",
    "    documents = state[\"documents\"]\n",
    "\n",
    "    # RAG generation\n",
    "    generation = rag_chain.invoke({\"context\": format_docs(documents), \"question\": question})\n",
    "    return {\"documents\": documents, \"question\": question, \"generation\": generation}\n",
    "\n",
    "\n",
    "def transform_query(state):\n",
    "    \"\"\"\n",
    "    Transform the query to produce a better question.\n",
    "\n",
    "    Args:\n",
    "        state (dict): The current graph state\n",
    "\n",
    "    Returns:\n",
    "        state (dict): Updates question key with a re-phrased question\n",
    "    \"\"\"\n",
    "\n",
    "    print(\"---TRANSFORM QUERY---\")\n",
    "    question = state[\"question\"]\n",
    "    documents = state[\"documents\"]\n",
    "    times_transformed = state[\"times_transformed\"]\n",
    "    times_transformed += 1\n",
    "\n",
    "    # Re-write question\n",
    "    better_question = question_rewriter.invoke({\"question\": question})\n",
    "    print('---NEW QUESTION---')\n",
    "    print(better_question)\n",
    "    return {\"documents\": documents, \"question\": better_question, \"times_transformed\": times_transformed}\n",
    "\n",
    "\n",
    "def grade_documents(state):\n",
    "    \"\"\"\n",
    "    Determines whether the retrieved documents are relevant to the question.\n",
    "\n",
    "    Args:\n",
    "        state (dict): The current graph state\n",
    "\n",
    "    Returns:\n",
    "        state (dict): Updates documents key with only filtered relevant documents\n",
    "    \"\"\"\n",
    "\n",
    "    print(\"---CHECK DOCUMENT RELEVANCE TO QUESTION---\")\n",
    "    question = state[\"question\"]\n",
    "    documents = state[\"documents\"]\n",
    "\n",
    "    # Score each doc\n",
    "    filtered_docs = []\n",
    "    web_search = \"No\"\n",
    "    for d in documents:\n",
    "        score = retrieval_grader.invoke(\n",
    "            {\"question\": question, \"document\": d.page_content}\n",
    "        )\n",
    "        grade = score.binary_score\n",
    "        print(d.metadata['source'], f'Grade: {grade}')\n",
    "        if grade == \"yes\":\n",
    "            print(\"---GRADE: DOCUMENT RELEVANT---\")\n",
    "            filtered_docs.append(d)\n",
    "    if len(filtered_docs) == 0:\n",
    "        print(\"---GRADE: DOCUMENTS NOT RELEVANT---\")\n",
    "        web_search = \"Yes\"\n",
    "    return {\"documents\": filtered_docs, \"question\": question, \"web_search\": web_search}\n",
    "\n",
    "### Edges\n",
    "\n",
    "\n",
    "def decide_to_generate(state):\n",
    "    \"\"\"\n",
    "    Determines whether to generate an answer, or re-generate a question.\n",
    "\n",
    "    Args:\n",
    "        state (dict): The current graph state\n",
    "\n",
    "    Returns:\n",
    "        str: Binary decision for next node to call\n",
    "    \"\"\"\n",
    "\n",
    "    print(\"---ASSESS GRADED DOCUMENTS---\")\n",
    "    state[\"question\"]\n",
    "    web_search = state[\"web_search\"]\n",
    "    # state[\"documents\"]\n",
    "\n",
    "    if web_search == \"Yes\":\n",
    "        # check times_transformed\n",
    "        if state[\"times_transformed\"] >= 3:\n",
    "            print(\n",
    "                \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION AND WE HAVE TRANSFORMED 3 TIMES, GENERATE---\"\n",
    "            )\n",
    "            return \"should_generate\"\n",
    "\n",
    "        # All documents have been filtered check_relevance\n",
    "        # We will re-generate a new query\n",
    "        print(\n",
    "            \"---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\"\n",
    "        )\n",
    "        return \"should_transform_query\"\n",
    "    else:\n",
    "        # We have relevant documents, so generate answer\n",
    "        print(\"---DECISION: GENERATE---\")\n",
    "        return \"should_generate\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "z2wbXWAAzm1k"
   },
   "outputs": [],
   "source": [
    "from langgraph.graph import END, StateGraph, START\n",
    "\n",
    "workflow = StateGraph(GraphState)\n",
    "\n",
    "# Define the nodes\n",
    "workflow.add_node(\"retrieve\", retrieve)  # retrieve\n",
    "workflow.add_node(\"grade_documents\", grade_documents)  # grade documents\n",
    "workflow.add_node(\"generate\", generate)  # generatae\n",
    "workflow.add_node(\"transform_query\", transform_query)  # transform_query\n",
    "\n",
    "# Build graph\n",
    "workflow.add_edge(START, \"retrieve\")\n",
    "workflow.add_edge(\"retrieve\", \"grade_documents\")\n",
    "workflow.add_conditional_edges(\n",
    "    \"grade_documents\",\n",
    "    decide_to_generate,\n",
    "    {\n",
    "        \"should_transform_query\": \"transform_query\",\n",
    "        \"should_generate\": \"generate\",\n",
    "    },\n",
    ")\n",
    "workflow.add_edge(\"transform_query\", \"grade_documents\")\n",
    "workflow.add_edge(\"generate\", END)\n",
    "\n",
    "# Compile\n",
    "app = workflow.compile()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Running the Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aJ_wjx_M3Db-",
    "outputId": "6ab8e986-702b-4a26-b4ca-74a0ec593d60"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'question': 'What on earth is few shot learning?'}\n",
      "---RETRIEVE---\n",
      "Node 'retrieve':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: yes\n",
      "---GRADE: DOCUMENT RELEVANT---\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: no\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: GENERATE---\n",
      "Node 'grade_documents':\n",
      "---GENERATE---\n",
      "Node 'generate':\n",
      "Few-shot learning is a machine learning approach where a model is provided with a small number of high-quality examples of input-output pairs for a specific task. This helps the model understand the desired outcomes better, often leading to improved performance compared to zero-shot learning. However, it requires more tokens and can be limited by context length.\n"
     ]
    }
   ],
   "source": [
    "# Run\n",
    "inputs = {\"question\": \"What on earth is few shot learning?\"}\n",
    "for output in app.stream(inputs):\n",
    "    for key, value in output.items():\n",
    "        # Node\n",
    "        print(f\"Node '{key}':\")\n",
    "# Final generation\n",
    "print(value[\"generation\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qPsnn1CG5QHG",
    "outputId": "8f9299f3-22d4-4101-e7dc-9dbecdd84fea"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'question': 'How should I talk to LLMs?'}\n",
      "---RETRIEVE---\n",
      "Node 'retrieve':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "https://lilianweng.github.io/posts/2023-06-23-agent/ Grade: yes\n",
      "---GRADE: DOCUMENT RELEVANT---\n",
      "https://lilianweng.github.io/posts/2023-06-23-agent/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-10-25-adv-attack-llm/ Grade: no\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: GENERATE---\n",
      "Node 'grade_documents':\n",
      "---GENERATE---\n",
      "Node 'generate':\n",
      "To talk to LLMs, provide clear prompts and specify the tools you want them to use. Follow the ReAct format by expressing your thoughts, indicating actions, and detailing the expected input and output. This structured approach helps the model understand and respond effectively.\n"
     ]
    }
   ],
   "source": [
    "# Run\n",
    "inputs = {\"question\": \"How should I talk to LLMs?\"}\n",
    "for output in app.stream(inputs):\n",
    "    for key, value in output.items():\n",
    "        # Node\n",
    "        print(f\"Node '{key}':\")\n",
    "# Final generation\n",
    "print(value[\"generation\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0J0TtIcb0CYf",
    "outputId": "ebe8c55a-a6a1-47d3-bd87-194d2a972d8a",
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'question': 'How big is the moon?'}\n",
      "---RETRIEVE---\n",
      "Node 'retrieve':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/ Grade: no\n",
      "https://lilianweng.github.io/posts/2023-06-23-agent/ Grade: no\n",
      "---GRADE: DOCUMENT NOT RELEVANT---\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\n",
      "Node 'grade_documents':\n",
      "---TRANSFORM QUERY---\n",
      "---NEW QUESTION---\n",
      "What is the size of the moon?\n",
      "Node 'transform_query':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "---GRADE: DOCUMENT NOT RELEVANT---\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\n",
      "Node 'grade_documents':\n",
      "---TRANSFORM QUERY---\n",
      "---NEW QUESTION---\n",
      "What are the dimensions of the moon?\n",
      "Node 'transform_query':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "---GRADE: DOCUMENT NOT RELEVANT---\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION, TRANSFORM QUERY---\n",
      "Node 'grade_documents':\n",
      "---TRANSFORM QUERY---\n",
      "---NEW QUESTION---\n",
      "What is the size of the moon in terms of its dimensions?\n",
      "Node 'transform_query':\n",
      "---CHECK DOCUMENT RELEVANCE TO QUESTION---\n",
      "---GRADE: DOCUMENT NOT RELEVANT---\n",
      "---ASSESS GRADED DOCUMENTS---\n",
      "---DECISION: ALL DOCUMENTS ARE NOT RELEVANT TO QUESTION AND WE HAVE TRANSFORMED 3 TIMES, GENERATE---\n",
      "Node 'grade_documents':\n",
      "---GENERATE---\n",
      "Node 'generate':\n",
      "The Moon has a diameter of about 3,474 kilometers (2,159 miles). Its circumference is approximately 10,921 kilometers (6,786 miles). The surface area of the Moon is roughly 38 million square kilometers (14.6 million square miles).\n"
     ]
    }
   ],
   "source": [
    "# Run\n",
    "inputs = {\"question\": \"How big is the moon?\"}\n",
    "for output in app.stream(inputs):\n",
    "    for key, value in output.items():\n",
    "        # Node\n",
    "        print(f\"Node '{key}':\")\n",
    "# Final generation\n",
    "print(value[\"generation\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 473
    },
    "id": "18SWafVC0Yxn",
    "outputId": "55cc9f34-d2e5-4d6c-c60c-726992960383"
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAHICAIAAADMW3rUAAAAAXNSR0IArs4c6QAAIABJREFUeJzs3WdcE1n7N/CTSkKoIRICCChrQawoFixrAQsKCioWVOy4oqy9u2IDe28rKupiA3sFRUQFQVHEtXeU3gktPXlezP7zcAvEoIFJxuv7wg8kk8llMvlx5szJOSSFQoEAAAA/ZLwLAAD86iCGAAA4gxgCAOAMYggAgDOIIQAAziCGAAA4o+JdAABIIVfkfBFWlskqy2QyqUIslONdkVroDLIek8wyorKMKWY8PbzL0WEkGDcE8KKQK149LP38oiLtdWXj5kwanaxvSDE1p4sEuhFDiIRKCyUVpVKGPiXni7BJa1bT1izrZvp4l6V7IIYAPp7cLv73fomtA6tJa1YTRxbe5fys0kLJ5xcVBdmiknyJi4cZz46Jd0W6BGIINLQvbyqij+W2djFy8eDgXYvmZX0UPLhSyLGm9x5hjnctOgNiCDSolNjinDRhvzHmekwK3rXUo69vK2+F545Z1FjfELpfvw9iCDScZ/dKykuk3T0J2AiqrrJMempT+rhlNsQOXI2AGAIN5O7ZfDIV9RzWCO9CGlRY0OfhgdZGbBrehWg1GDcEGsKLRL5cpvjVMggh5LvE9tSmr3hXoe0ghkC9y/kiyPks7DPqV+yypTPIw/6wijmZg3chWg1iCNS7+xcKWrsY410Fbri2DIlI8eFZOd6FaC+IIVC/Pj0v1zekWtgx8C4ETy4enAdXCvCuQntBDIH69fZxWY+hZnhXgTNjDq15R8M3j0vxLkRLQQyBelSUIy7KFRtz6A3zdNnZ2VlZWXg9XDWeHePdEzgvqxnEEKhHn16UN21t0DDPlZGR4enp+erVK1we/l22DqyMd5UyGYyPqQHEEKhHeeki+/YN9H0xqVT6Y4PgsEf98MPV16qbUdqLinp9Ch0FwxdBPQpd/mn8MlsGS/PDiI8ePRoREVFaWtqiRQt/f39ra2tPT0/lvUOGDAkKChKLxaGhodHR0bm5uRwOZ/Dgwf7+/hQKBSHk4+Njb29vb29/+vRpoVAYFhY2ZsyYbx6u8ZoTrxXS6KRObmyN71nXwRdeQH2RyRQSobw+MujRo0d79uwZOHCgi4vLgwcPKisrORzOunXrVqxYMWPGjE6dOrHZbIQQhUJ5+PBhr169rK2t3759e+TIESMjo3HjxmE7SUxMFAqF27dvr6ystLW1rf5wjWMZUYrzJPWxZ10HMQTqS2WpVN+oXg4wrCPZx8enbdu27u7u2I0tW7ZECNnZ2bVv3x67hUKhHDt2jEQiYb9mZGTExsYqY4hKpQYHBzOZzNoernEsY2rGe0E97VynQQyB+iKXK5iseul87NGjh5GR0cqVKxcuXNijRw8VWxYVFYWGhiYlJZWWliKEDA0NlXe1bt1amUENg0IlUSikhnxGXQFd1KC+6BtS6+kchMPhHDlyxNbWds6cOVOmTMnLy6txs8LCQl9f30ePHv3xxx+7d+92cHCQyWTKexs4gxBC5SVSOhM+cTWAFwXUFxqdTCKjeppY2s7ObteuXfv37//w4UNt3cnnzp0rKirat2/fgAEDHB0dLSws6qMS9VXwpSxjOP+oAcQQqEe2LfUrSqX1sWexWIwQcnZ27tmz55s3bxBCDAYDIZSfn6/cpqSkxNTUVJk+JSUlKq4LV3+4xinkyJgDMVQDeFFAPTLi0D79W9HRVcOjqF++fLl48WIfHx99ff0HDx60atUKIcTlcq2srMLDw5lMJp/PHz16dKdOnSIiIvbv39+uXbvY2NiEhAS5XF5SUmJiYlJ9n9Ufrqen4cU2Xjzg+y6z1ew+iQFaQ6AeNW1t8OmF5r/BQKfTmzRpEhYWtmfPng4dOqxcuRIhRCKRgoODWSzWli1brly5UlRU1Ldv36lTp0ZGRi5fvlwikRw9etTOzu7MmTM17rP6wzVbc/ZngYk5nVkPwxcIAIYvgvp1+UCm23gL+Pg9uV1E1yO36VFDQwzASRmoX03bGCRdL+wzstY5z4YPH15YWFj99rZt2/7777/Vbzc2Nr506ZKmy/xWfHz8ihUrqt+uUCgUCgWZXMNpRFRUFNbBVJ1EJE++WTxjo309VEoE0BoC9e7YmjSvWVa1zceck5Mjl9fhahqZTG6Aa15CobDG8zK5XC6Xy6nUGv5+83g85VDJb9w9m29qQWsLTaFaQAyBevfx3/KcNOEvsiBHdRWlkjtn8odMs8S7EO0FXdSg3tm3NcBWKMO7EHyc3pzRd/SvOA+3+iCGQEPo7slJf1f5OvmXm37w7M70/uO5sGiianBSBhpOzKlcy6aMVl1+lenxz+3K6O3TyMxCw+OPiAdaQ6DhuI7hZn4QJl4l/uTwZUWSQys+dRnEhgxSB7SGQENLjSt+GlfiMoTTopOhGpvrGGGl7MGVwspSab8xXKbBrz5aSk0QQwAH5SXSB1cLKvjSpm0MmrRmEWNt5fR3ldmfBc/u8l08zBy7/SonnhoBMQRwU5AlfJVU9vlFBZ1BtrJn6umTWcZUQzZNJtWNY1ImQ+XF4gq+jERCz+P5FnaMZh0MIIB+AMQQwF9Blij3i7CiVFbBl1KopLJiDX8p/927dxYWFkZGRprdrb4hhUYns4wpRmyajYM+jQ49rT8IYggQ38yZM/38/Lp06YJ3IaBmkN8AAJxBDAEAcAYxBIiPx+Nhy5MB7QQxBIgvOzu76mT4QNtADAHiYzKZNc4QBLQEvDeA+AQCQZ2mNAINDGIIEJ+xsTH0DWkziCFAfHw+H/qGtBnEECA+KyurGqdtBVoCYggQX2ZmplRaL6s2Ao2AGALEp/GFD4FmQQwB4hOJRHiXAFSBGAIA4AxiCBCftbU1dFFrM4ghQHwZGRnQRa3NIIYAADiDGALEZ2BgAN8p02bw3gDiKy8vh++UaTOIIUB8PB4Puqi1GcQQIL7s7GzootZmEEMAAJxBDAHig2nPtBy8N4D4YNozLQcxBADAGcQQAABnEEOA+KysrGASWG0GMQSILzMzEyaB1WYQQwAAnEEMAQBwBjEEiA/GDWk5eG8A8cG4IS0HMQQAwBnEECA+DocDF+y1GcQQIL6CggK4YK/NIIYAADiDGALERyaTSSQS3lWAWkEMAeKTy+UKhQLvKkCtIIYA8VlZWcG4IW0G7w0gvszMTBg3pM0ghgDxwZT4Wo4E58yAqPr370+n08lkckFBgYGBAfaznp5eZGQk3qWB/wF/IgBhMRiMrKws7OeioiLsh6lTp+JaFKgBnJQBwho6dOg31+ltbGxGjhyJX0WgZhBDgLBGjRplZWVV9ZZ+/fqZmZnhVxGoGcQQICwDAwN3d3flr7a2tmPHjsW1IlAziCFAZL6+vnZ2dtjPrq6upqameFcEagAxBIiMxWJ5eHhQKBQbGxsfHx+8ywE1gytloOFIxfKiXHEFX9aQg0Q6t/a41/Stk5MTP5vBz65osOelUBDbgm5oSmuwZ9RdMG4INJCHUUXvUsqoNLIxhyYVE/+oY5lSv76qMLOkuww241jp4V2OVoMYAg3h/oUCmRx1dOXgXUhDqyiT3jqe6Tnd0pgDzaJaQd8QqHcPrhYq0K+YQQghliF1WIBtxLZ0YQXMu1YriCFQv8pKJDmfBR36/ooZpOQy1PxhVCHeVWgviCFQv4pzJCTyrz7lmCGblvFeiHcV2gtiCNSv8hKJKZeBdxU4MzKlQxarADEE6pdcjsTCX71bRK5ApYVivKvQXhBDAACcQQwBAHAGMQQAwBnEEAAAZxBDAACcQQwBAHAGMQQAwBnEEAAAZxBDAACcQQwBAHAGMQQAwBnEENB5r16/EIlEqrfZsDFoxh/jG6oiUDcQQ0C3RUVfCZg1USgUqN5Mn8XS12c1VFGgbmBKfKDVFArFNyuvfuO77SBsD4GzFmq6NKAxEENA60ya4tPEzt7Ozv78hdMikTDyTJSBgcHT1Mehh/Z8/PjO1JTdob3z1CkBZmacqOgrO3ZuQAgN83ZFCC1etGrgAI+4uzGr1yxZu3rLmch/3rx5OWa0381b13Jzc1q3brd752HsKWrc25Jlf3769P70yatkMhkhJBAIho/s7zFk+B8z5giFwkOH996OjRKLRY2tbX18xvft0x/v14k4IIaANkpOThSKhMHrtlcKKg0MDJ6kPFqyNNDN1d1r2KiyUv6586fmLZjx9/7wLp27+4wcFxEZHrJ+B4tlYG1to9zDzt0bp04OmDzpD2srmzZtOoSG7lbeVdvehrh7rVy1IPXZE6cOzgih+Pg7AoHAw2O4XC5fvmJuTk6W79hJJibs1NTHa9ctEwoF7oOG4vTyEA3EENBGFCp15fJgJpOJ/bp7z2aPId6Bsxdhv3bq1NVv0ojkx4k9e/SxtLRGCDk4tDY2Nqm6B69howYMGIL93KiReWRkuOD/+o9q25tLt15mZpxbt65jMXQr5nqnjl2srRrH3Y359/nTUyeucDiNEEKu/QYKBJXnzp+CGNIUiCGgjRwcWiszKCcn+8uXz5mZ6VevXai6TV5eroo9ODl1rvF2FXujUCjug4aev3B6zp9LysvLnqQ8WvXXBoRQUlK8VCodO85TubFMJmOxDH7uvwj+P4ghoI2YDKby5+LiQoSQ34TpvXr2rboNm61qtQ99pn6Nt6vem/ugYeEnjjxIvJeXl2Nqynbp1gt7iJkZZ9uWA1W3p1Dhs6Mx8FICbWdgYIgQEomENjZ2tW2j/qqfqvdmYcFzdu52K+Z6bm72YPdhVCoVIWRoaFRSUszl8vT0YPHVegHjhoC2s7a24XItbkRdFgj+69yRSqUSiQT7GWs3FRTka2RvCCGPId5JSfFpaZ8Gu3thtzg5dZbJZJevnFVuo3ws0AiIIaDtSCRSwMz5hYUFAbMnXrwUef786YBZEy9djsTudWzdjkKh7Nm3JTr66uUr535ybwihrl16sNlm3br1NDfnYre4ubq3bOl44O+du/Zsjoq+smfv1klTRgqFsO6YxkAMAR3Qs0efkPU7aFTa3n1bj4cf4nJ5bds6YXdZWVrPn7c8Pf3Lnr1b4uJu/eTeEEJUKtV90FCPIcOVt9BotM0b9w4Z7BUbG71te3DK00eeHiOo0DekOST1T6oB+AEvHvCzPom6eZjjXQieJGJFxJZPMzba412IloLWEAAAZxBDAACcQQwBAHAGMQQAwBnEEAAAZxBDAACcQQwBAHAGMQQAwBnEEAAAZxBDAACcQQwBAHAGMQQAwBnEEAAAZxBDoH7RGWSGPgXvKnCmkCu4Ngy8q9BeEEOgfpma0zM+VOBdBc4Ks4UIJtSpHcQQqF+NrPUYTLJIIMO7EDzlZwjt28HS1bWCGAL1rqdXo5jwLLyrwM2b5JKibFHbniZqbPuLgtkXQUMozhWf2ZreeRDHyIxuYEJFSNWy9MSgUCgKskSl+aL8TOGwP6zwLkerQQyBBiIRyZOji7I+C8VCuVgob8inFovFVCoVW5m+wTSyYpDICttW+o5djRvyeXURxBAgvpkzZ/r5+XXp0gXvQkDNoG8IAIAziCEAAM4ghgDxWVlZwbJi2gxiCBBfZmamVCrFuwpQK4ghQHzm5uYUyq/+hRJtBjEEiC8vL08m+6WHcWs5iCFAfDweD1pD2gxiCBBfdnY2tIa0GcQQID4LCwtoDWkziCFAfDk5OdAa0mYQQwAAnEEMAeIzMDAgkYj/nX7dBTEEiK+8vBy+wq3NIIYA8XG5XPgyhzaDGALEl5ubC1/m0GYQQwAAnEEMAeKzsLCAkzJtBjEEiC8nJwdOyrQZxBAgPiMjI7hgr80ghgDxlZaWwgV7bQYxBADAGcQQID6Y9kzLQQwB4oNpz7QcxBAAAGcQQwAAnEEMAeKztLSE4YvaDGIIEF9WVhYMX9RmEEMAAJxBDAEAcAYxBIgPxg1pOYghQHwwbkjLQQwBAHAGMQSIz8rKCk7KtBnEECC+zMxMOCnTZhBDAACcQQwB4mOz2WQyHOraC94bQHxFRUVyuRzvKkCtIIYA8cE6ZVoOYggQH6xTpuUghgDxwZT4Wo4EU4UDoho5ciSFQqHRaF+/fmWz2Xp6ejQajUqlhoWF4V0a+B9wwgwIS6FQfPjwAfu5oqICu2XIkCF41wW+BSdlgLB69uz5zbmYhYWFn58ffhWBmkEMAcLy8fGxs7NT/qpQKJydnZs2bYprUaAGEEOAsHg8Xvfu3ZUNIi6XO3HiRLyLAjWAGAJE5uPjY21tjTWFunTpUrVxBLQHxBAgMktLy+7duysUCi6XC71CWguulIH/lJdIFAoCDq7x8hibcDelU6dOZsbWZcUEHMSob0ihUHX7jYNxQwDFnc17n1Ju0YRZmCXCuxZQRyRUWSo1s9Jr39OkRSdDvKv5QRBDvzSJWH5o+ec+oyw41gw9JkwMpqtKi8RPYwstmzKc+pjiXcuPgBj6pYUu+zRstg1DH87NieDBlTwzLrWTGxvvQuoMuqh/XUnXC50HciCDCMPFwzzni6gkX4x3IXUGMfTrSn8rMGTT8K4CaJJCjgqzIYaA7qDSSSaN9PCuAmiSeWNmWYnuXQ2EBvmvKz9TBP2CBCMSysgU3bt4D60hAADOIIYAADiDGAIA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCODp2vWLffp1Kiws0MK9NZicnOzsnCy8q8ATxBAAeMrMyhg7zvPt21d4F4IniCHwg/j8ktKy0uq3w3yedSKTSuEVg4k+QB1ER189cSosLy+niZ09iUy24PL+WhkSdzdm9Zola1dvORP5z5s3L8eM9hvnO+X4P6GxsdF5+blmZpz+boMn+vlTKP/Ndf3+w9vdeza/ffvKjM1p3Ni26v6fpj4OPbTn48d3pqbsDu2dp04JMDPjqC5Jxd5u3rx24lRYVlaGmRlnsLuX79hJZDIZISQUCv8JP3Tnzs38gjwul9ffbbDv2ElPUx8vXBSwd3dYq1ZtsIcPGtzDa9io6dNmnz138t792P5ug48dP8jnl9jbN58yeWZMzI2EhDgqjdbfbfD0abOx/51QKDx0eO/t2CixWNTY2tbHZ3zfPv0RQmfPnYy9c3PkCN/Dh/cWFhU0a9ZywbwVNjZ22TlZfpNGIIRWr1myGqEBA4YsWRSUnv5l+46Q129eGBoade3SY+6cpd8sgU08EENAXfEJcRs2BQ0Z7NWlc/eIs+HPn6fOmjlfee/O3RunTg6YPOkPaysbCoXy5MnDbi69LHnWHz68DT9xxNDQyGfkOITQ169pc+dNNzYymTZ1FoVCPf5PqHIPT1IeLVka6Obq7jVsVFkp/9z5U/MWzPh7fziDwaitJBV7i46+umFTUL9+A6dMnvnq1fMjYfsRQuPHTZHJZMuWz3n+ItXba/Rv9s3TvnxKz/iijMjaPH+eSqVQg/7amJuXs3XbuoWLAjyGeG/Zsj8pKf7osb9tbOwGuw+Ty+XLV8zNycnyHTvJxISdmvp47bplQqHAfdBQhNDr1y8iIv6ZP3+FVCrdtm19yMZV+/ceM2Nzli9btz54xaSJMzq072RqykYIbd669uvXtICZ8ysrK56mPiZ8BkEMgTq4dCnSzq7p/HnLEUItWzqOHDUo6WG8su3gNWzUgAFDlBvv23tM+fnJys64dz8Wi6EDB3eSSeS9e46amJgihMhk8o6dG7DNdu/Z7DHEO3D2IuzXTp26+k0akfw4sWePPrWVVNveFArFoSN727Rpv2LZOoRQr559y8pKT585Ntx7TNLD+KepjxcuWImlg/r+WhliYmLq6Nj2UfKDpKR4rJHSornDzZtXU1IeDXYfdu9+7L/Pn546cYXDaYQQcu03UCCoPHf+lPKJ1q/bzmabIYS8vUfv27+dX8o3NjJu3qwlQsjGxq5Nm/bYZjk5Wc2btRwy2AshhL1ohAcxBNSVl59rbW2D/czhNGIwGGVV+oacnDpX3bi4uOj4P6HJj5OwbQwNDLFzluTkRE/PEVhqIISo1P+OwJyc7C9fPmdmpl+9duF/njQvt7Z6VOwtI+NrQUH+KJ/xyo2dnbtdv3EpI/Pro+QHenp6A/oPqWWvtaLT/5swl06j02g0ZchyGpnz+SUIoaSkeKlUOnacp/IhMpmMxTJQ/spgMLEfuFweQqiwIN/YyLj6E7m5up88dXTX7k3jx03F2keEBzEE1GVpaf327SuxWEyn0z99+iAUCn/7rYXyXn2mvvLnoqLC6TN8mUz9yZP+sLS0PnJkX3rGF4RQYVGBVCrlWVhW33lxcSFCyG/C9F49+1a9nc2utW9Ixd7KK8oRQiYm//8zbGhohBAqyM8rLirkmDX67lmY+kik/1bZKi4uNDPjbNtyoOq9FGoNHzEalYYQksllNe5w6pQAU1N2+IkjN6IuT58W6DXMR1Olai2IIaCuMaP85i2YMW/BjI5OnW/dut6yRava2hSXr5wrLi7au/sol2uBEDI3t8BiyMTYFGsoVX+IgYEhQkgkEtrY2KlZj4q9mTfiYtfylLdgmxkaGhkYGBYVF1Z/yM93wRgaGpWUFHO5PD29n1pogEQijRg+dtDAodt3BO/avalzZxcrS+ufrE3LwQV7oK7WrdsN9x4jl8uzsjJGjZqwY3sotaY/9Qih0tISExNTLIMQQvzSEqy9wGKxrKwax92NkUgk3zzE2tqGy7W4EXVZIBBgt0il0uqbVaVib2ZmHAsu79GjBOUtd+/GMBiM335r0aGDs0AguB0brbxLKpUihExN2AihgsJ87MbCwgLVz16dk1NnmUx2+cpZ5S3K/4sKenoM7ARNeYtIJML+dxMnzsBacHUqQxdBawioK/LsiadPk318xpNIJCqVmpHx1d6+WY1btm/f6cLFiCNh+x0d292/H/vwYYJcLufzS4yNTfwmTA8OWTlr9qSBAz3JZPK586ewh5BIpICZ8/9atTBg9kRPjxFymSz65lU3N/cRw8eqKKm2vSGEJvr5b9gUtHnLWmfnbikpj+IT4vwmTGcymW6u7hcvRWzYuOrNm5e/2Tf/9PnDk5SHBw+csLGx43ItwsMPm5qwKwWVhw/vlcvldXp93Fzdr1w9f+Dvndk5Wc2btfzw4V18wp2jR86quNKHEDI351ryrCLOhjOYzNJSvrfX6KA1iw1YBp06dk16GI8QamTOrVMZughiCKirRfNWkWdPrA9eobzFY4j3vLnLqm/Zq2ffCeOnXrgYcfFiRDeXXnv3HA3Z8NeFi2cm+vm7uQ4qLy+LiPjn74M77WybtmrVJj39C/aonj36hKzfEXb0wN59W1ksg7ZtOrRt66S6JBV7GzBgiFAkjDx74uataxyzRtOnzR49agJCSE9Pb+uWA6Ghu2/FXL967byFhWWf3v2lUimdTg9atWnnro0LFwdYWTWe5DdjfcgK1c/+DRqNtnnj3tBDu2Njo69ePW9tbePpMaK2BqMSiURasSJ40+bVe/ZuMTe36NO7v0PL1tE3r967H8vhmM+ft9ySZ1WnMnQRrGH/6zq47JP3n3Z6jDqcmMtkMqxzVywW/x266+LFiOgbD777SQMN5mlsIZNFcu6vY9fX4AAC6rp589qhI3v79O7P41kVFxfevx9rZ9e0vjMoKSm+tlbJnl1htrZN6vXZQcOAGALqsrVr2qZ1+5jbN0pL+WZmnO4uv4/znVLfT9q+faeDf5+s8a5GHPP6fnbQMCCGgLpaNHdYuSK4gZ+UwWDUODIIEAlcsAcA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCACAM/gyx6/LvDGD+Gs+/GLoTIqeqtmNtBS0hn5dMom8OFeEdxVAk3LTKg3ZNLyrqDOIoV+XTUt9fqEY7yqAJpHJpEaNf2ombFxADP26nPuzX9wvLswS4l0I0Iy4yGzbVkwDY93raYHZF39pcpni2Jq0jm4cM0s9IzM63uWAHyGVyEvyxKl3Ch26GLbsZIR3OT8CYgigxGsFH1IrDE2puekimUyKEKJSdO8vqgoyuZxMJpEQzj3yEqlEoUBVFiJSLkpEov7oumkkMpKKFZb2jPa/m9g6sDRUaUMj1NEGfoxVm8qv5UnuQ0e+evX6+fPngwcPZrF09YCu0fz588eOHduxY0d8yzh16tTx48exVYNIJJJcLieRSNhqi3FxcT+2TxIJ0esym7h2gtbQrys/P9/Y2Fgul48ZM2bMmDE+PoRdHfTs2bPOzs62trZ4F4JmzZqVmJhYdWlGhULx5MkTXIvCH8TQL0cul5PJ5KCgoKSkpEuXLtFoNDJZ5/+c6oqCgoIpU6ZkZmYqbzEwMPjhphBhwPH3C3n16tW8efOSkpIQQqNGjYqKitLT0/sVMujOnTs5OTl4V4EQQhwOx8/PT19fH/tVoVCUl5dHRETgXRfOiH8Igvj4+JiYGITQ+/fvhw4d6uLighBycHDAu66GExkZ+eXLF7yr+I+3t7ezszN2FsLhcB4/flxYWDhw4MBbt27hXRpu4KSMsF6/fu3g4BAVFXXjxo3Zs2f/9ttveFeEG+3pG8JUVlaOHj06MzNT2SuUn5+/e/fuz58/z50718npO2vVEg/EENFIJBIajTZ06NC2bduuXbtWKpXCqqrayc3N7ZsW0KtXr7Zv396iRYvRo0dbW1vjV1pDgxgijpMnT547d+7vv//mcDgFBQUcDgfvirTF0aNHXVxcmjdvjnchaklMTNywYUO3bt3mzZtHp/8SY0qhb0i3CYXCM2fOvHz5Euvv3Lp1K5Y+kEFVPXnypKCgAO8q1NWtW7dLly7Z29vPmjXr8OHDeJfTECCGdNWbN28QQocPH/7y5QvW6+Hr62tnZ4d3XdrIz89PV5pCSiNHjjx48KBIJOrbt+/NmzfxLqd+wUmZ7nny5Im/v//69esHDBiAdy2g3vH5/PDw8Lt3786dO7dbt254l1MvIIZ0g0Qi2b59e1lZ2dq1azMyMn6p/sufd+/ePTs7OxsbG7wL+XFUKFtrAAAgAElEQVQfP37cvn27XC6fN28e8S56UoKCgvCuAdSqoKDgxIkTzZo1E4lEhYWFU6dOpdFoRkY6+S1qHB08eFBfX1+nP71sNtvd3Z3D4WzatOnZs2dOTk4Mhg5Os1gL6BvSRmKxOD09HSG0efNmmUxmYGBgamo6atQoJpOJd2k6ydPTU+f6hmrUpUuX8PBwZ2dnLy+v48eP412OxsBJmda5efPmqlWrQkNDW7dujXctQHudPn16165dc+fOHTlyJN61/CyIIa1QXl5+8OBBKpUaGBj44cMHnT590EJ3795lsVidOnXCuxANE4lE27dvT0xMXLRoUffu3fEu58fBSRmeysrKbt++jRB6+fIll8udPn06QggySOPev3+fnJyMdxWap6ent2TJkr179yYmJk6ZMuXFixd4V/SDoDWEm5ycnNGjR8+cOZPAE/1oiefPn5eXlxP1ajcmNTV1+/btlpaW8+bNa9SoEd7l1A3EUEPbuXPngwcPzpw5U1FRQbBJDgHubt68GRUV1bhx47lz5+JdSx3ASVkDuXDhQnl5uUwmMzU1PXToEEIIMqjBZGRkYCe/hNe/f/9t27Y1atTI2dn59OnTeJejLoih+lVWVobNMfby5UsGg0GhUCZMmGBoaIh3Xb+WkpISIl3e/q5x48Y9fPgwPT194cKFCQkJeJfzfXBSVl8ePny4efPmoKAguO6Ou7KyssuXL/v6+uJdSEPLysrasGEDQmjx4sVWVlZ4l1MriCENe/r0aX5+fv/+/WNiYuzt7Zs0aYJ3ReBXl5CQsHHjRi8vr0mTJuFdS83gpEwzpFIpQigpKWnv3r3Y991dXV0hg7THyZMnsZV5fkHdu3e/fPmykZHRoEGDUlJS8C6nBrW2hsRiWN1cXadPn/7w4cOKFSsEAoGmvm/xM/NdSSQSaOR+Y/PmzcOHD2/atCneheCppKTkyJEjFhYWY8eOpdFoVdcpwletMZSXl9fgxegYkUhEoVCoVKpIJNLT09Pszs3NzX/4sUVFRVjrDCiJxWIKhUL50cVRiUQoFFZWVjKZTO2ZnBtOyn5QRUUFdmRjg1nxLgd8B51OhwzCMBgMExOT+fPnX7p0Ce9a/gMxVAcKhaKsrAzrYmCxWIaGhtrTrAWqyWQy6GdQIpPJkZGRz5492717N961IIghdUkkEqwfmk6nw2wbuohEIlVUVOBdhXb566+/mjVrtnTpUrwLgRhSA5/PF4lECCEajQbnXzqKTCbDe1fdwIED+/TpExgYiG8ZPxVDa9as0eB/YN++fWPHjq3t3k2bNmFfQG8wAoEA6+g1NDQ0MDD44f3k5uZqycrFVV28eNHd3V1T17Dv37/v7u6OTdVWXVRUlLu7e1FRkeqdVFRUfPjwQSP11Ei5ZDPm/v3706dP9/b2/ueff+rvSbVf//79f//997///hvHGqA1VLPy8nK5XI4tNPgzq7xnZ2dPnjz5/fv3Gq2OmAICAup1CQqJRKLsHkpLS9u0aZOjo+Py5cv79u1bf0+qE4YPHy6RSEJDQ/EqgMgxxOfzsa90qU8gEJSXlyOEDAwM1PzqqeoROlKpFIbwqEl1F/LPv4wkEqmyshL7OTU1lUKhzJ49u2PHjnX6loP2v5s/VuGsWbNSUlIePXpUDxV9n7rLCguFwn379j18+BAh5Ojo6O/vz+VysbtOnDhx/fp1uVzeo0ePadOmYePupFJpeHh4TExMaWlp48aNx40bh8328vTp0+XLl2/btq1ly5bYw728vDw9PWscZn737t2TJ0/m5eXZ2NjI5XJ16oyJiYmIiMjPz7e1tSWRSFwud8mSJdjkPqGhoU+fPtXT07O3t58wYQI2OfGaNWusra0pFEpUVJRUKu3QocOff/6p3Nu1a9fOnz9fWFjI5XJ79+7t7e2tp6d3//79kJCQlStXnjt37t27dyNGjBg9evTJkyfv3r1bUFDAZrP79u07btw4CoWSk5Pj7++PEAoJCQkJCXF1dZ03b56KYupPRETE1atXy8rK7O3tx40b1759e+z2hISEyMjI/Px8R0fHP//8U7nI4u3btyMiIrKzs9ls9sCBA318fMhkcp3eu48fPx44cOD9+/empqbqrCMyceLEkpKSq1evXr161dzc/OjRowihP/74w9bW1tbW9vLly0KhMDw8PCEh4erVq2lpaUwm08nJyd/f38TEBDvHvHv3rpeX17Fjx4qLi+3t7QMDAxs3bowQevToUVhYWE5ODpfLHTBggJeX19KlS589e4YQGjJkSPfu3ZcvX44NtgoNDX38+LFMJmvVqtWUKVOwQfD79u2Lj48PDAw8dOhQVlZWcHBwWlpaQkJCv379Tpw4UVpa2rRp0wkTJty5cycxMZFKpfbr12/SpEnfHRxw7dq1S5cu5eXlNWnSpGfPnmfPnj158qRUKvX09Jw4caJyCqqgoCA+n799+3bsM3js2LG4uDixWGxtbe3t7f37779jZ5dVD8hhw4bduHFjwIABU6dOxXaSnZ09ZcqUefPmubq6qihp+/bt06ZNO378eMNf/1U3hiIiImJiYsaPH29qanr79m3lqgAfPnzQ09ObPHnyx48fL168yGazx4wZgxDatWvXnTt3Ro0aZWtre+fOnbVr127atKlOX/K8c+fO5s2b27Vr5+XllZubGxkZaWlpqfohiYmJ27ZtGzhwoLOz8/nz51++fImlQFFR0YIFCywtLf39/UkkUmxs7KJFi3bs2IEtLnj+/PmuXbsGBQWlp6fv2rWLy+VOmTIFi9fz5897enra2NhkZGScPXs2MzNzwYIF2HPt27fPz89v/PjxVlZWFAolNTW1S5cuPB7v06dPZ86cMTQ09Pb2ZrPZixYt2rRp0/jx49u2bYt9YFQXUx9SU1OPHj3au3fvTp06PX78uGp/0MmTJ4cPHy4SiU6ePLllyxbsa5AxMTHbtm3r3bv3hAkT3rx5g303ffTo0eo/Y3p6+uLFi42MjCZOnEihUE6ePPndhyxbtmzlypVt2rTx8vKi0WjK2588eSIUCletWiUQCFgs1ps3b6ytrfv27VtSUnLp0iWBQKBcWubt27fnz58PDAyUyWS7d+/etm3b9u3bBQJBSEiIjY1NYGBgWloan89HCI0fP97IyCgxMXHp0qVsNhv7hC9durS0tHTy5Ml6enqRkZHLli0LDQ3F+gQrKyuPHz8eEBAgFArbtWuXlpb28uVLKpW6bNmyvLy8Xbt2LV++fNCgQcHBwcnJyeHh4dbW1gMHDlTxnz158iQ2s/2IESP4fP6ZM2e+G1tyuXz16tW5ubmjRo0yMTF59uzZxo0bhUKhcq26qgekQCCIi4tTpuH9+/f19PRcXFxUPwWDwXBwcDh//vzw4cO/+35plroxlJuby2AwRo4cSaVSq77EPB5vw4YNFAqlX79+6enp9+7dGzNmTHp6ekxMzJgxY8aNG4cQ6tGjx9SpU0+cOBESEqLm04lEooMHD7Zu3XrdunXYS5mdnf3p0yfVj7p69aqtrS3Wa968efPx48c/evSoZcuWp06dMjExCQ4Oxvp6+vbtO3Xq1OjoaKzPm8fjLVmyhEqltmjRIiEh4cmTJ1OmTCksLDxz5syiRYt69OiB7dzMzGzPnj1YriGEPDw8qv5t2b59u/JvSHZ2dkJCgre3N51Ot7e3RwhZW1s7Ojpi99ZWjHLPGod1kHt4eDg4OHzTDxISEoK1aqVS6dGjR/l8vpGR0bFjxxwdHRctWoR9Ham8vDwyMnLo0KHqP+Phw4fJZPK2bduw5CWTyXv37lX9kObNm1MoFDabrXyhMFQqdfHixcpBErNnz1a+zhQK5cyZM1WHsK9atcrU1BRbiiM0NLS0tLSiokIkErm4uPTp0wcbPVRZWdmqVavk5GQSiaScj/HOnTvp6enBwcFYO9HR0XHy5MmXL1/GrpmIxeLAwEBlGxCzePFiExMTBweHJ0+eJCcnz5o1i0QiNWvWLCYm5tmzZypiCMudzp07KwM0Pz8/Pj5e9euTkJDw8uXLsLAwMzMzhFDv3r2FQuGlS5eUMVT1gHR1db127VpKSoqzszNCKD4+vnPnzt/00NdowoQJAQEB2htDffr0iYuLW7lypb+/f9W/2ywWSxnktra22IrG2Jy4yvQlkUhOTk6xsbHql/Xq1Ss+nz979mzlztXpJy4oKFC2mMzMzBgMBtbR8/jx4/z8/KovrkQiycnJwXoKmEwmlggIIS6X+/r1a+zkUSqVbt68efPmzdhd2Cl3YWEh9qvyvAZTUlJy8uTJlJQU7BlV9CvVWEx+fr76L05dde7c2dDQcPPmzTNmzOjcuXPVu5RLnmHvaUFBQVlZWWFhYdXynJycoqOjMzMz1Xw6oVCYkpIyePBgLIOwvPjh4lu0aFF1oJZEIrl8+XJsbGx+fr6enp5cLufz+covvigb6dgthYWFdnZ2Dg4Op0+fZjAYgwYNotPpIpGo+gpf//77L4vFUr6nXC63cePG7969w37V09P7JoOqDp2n0WhUKlUZjhwOB2tz1ebVq1cSiWTQoEF1eh2Sk5OlUunkyZOVt8hksqqHWdUDskWLFra2trdv33Z2ds7Ozv7w4QN2jvJd1tbWHTt2fPTo0TfHSX1TN4Y6deq0evXqw4cPz5w5c8CAAQEBAcqPrhKFQsGucGPjxJRHIXbNWyAQKDsIvwv7Rpuy+0lNPB7v/fv3YrGYTqd//vxZKBRiX2UsLi7u3LnzN10YJBKpelhQqVSZTIadOiGEgoKClN0lyqfALktX/WwUFxfPnj2byWSOHz+ex+MdP35cxYe2xmLqdSZGNpu9ZcuW0NDQoKCgVq1aLVmy5Jv/lDLlZTJZje8dllBqjrspLi6WSqV1fe9qUzUyFApFUFDQ+/fvfX19W7Zs+eDBg7Nnz9bYaYgdnHK5nEQirVmz5ujRo4cPH75w4cL8+fNr7BmorKw0NjaueouhoaFyhEGdBqySSN+ZPKe0tBRLK/X3ib2qbDb7m/OJqp/Bb4p0c3M7fvx4eXl5fHx8nVYlodFoX79+1dIYwpLIycnp0qVLoaGhXC5XRWcB1m4sKyvDfsBeRCqVqqenp2bvF3ZMqP6rUt2IESOWLl26dOnS9u3bx8bGNm/eHGumGhgYYD3l2N9qKpVaPUO/oZwgEXuUatevXy8pKdm2bRv2R9jc3FxFDFUtpsE0btx4zZo1qamp69at27ZtW3BwcG1bYrOpV33lS0pKsBcEG0r+Xdh7hz2qrlR/gJ8/f56amrpo0aLevXtjc3qps08WixUQEODt7b127do1a9YcP368eqyYmZlhDXml4uLieppYHvtQFBYWYifsVan4dBgYGGDtPjX/GPTp0ycsLOzevXvx8fE9evSo2t2mmp2dXVpampoba4q6F+yxi6lkMtnLy8vMzEz1MLOWLVuSSCTlxT+xWJycnOzg4EChULA/s8pTm6rfBafRaEKhEPu1adOmZDL5zp07dfrPtGrVaujQoXK5PDs7e8SIERs3bsTipn379q9evXr//r1MJpNKpVQq9bvD9tq1a0cikS5fvqy8RcVDSktLjY2NlacGfD5f+XHCDhrl/7dqMersWVOwt699+/adO3f++PGjii3ZbDaXy338+LHyFqyDs2nTpqrfO+WMt/r6+paWlvfv31cztpQYDIbqIY5YO0L56cV+/e71aWwEPI/H8/T0rKioyM3Nraio+GYGAgcHh7KyMmUSff78OSsr65teKk1p0qQJlUqNjo6ufheFQqnaClMoFMqJLtq3by+Tya5fv67cWPVhY2pq6uzsfO7cuffv32MX1NSErVSu/vYaoW5r6PLly0lJSX379i0sLCwsLGzWrJmKjXk8nqur64kTJ+RyuYWFRXR0dHFxMXaNydra2tzc/PTp0yYmJgKB4NixY8pGtb29vVAoDA4OnjZtGo/Hc3Nzi46OFovFHTt2LCoqSk5OxnofVbhw4cKzZ8+wfg0qlZqVlYVdc/X19U1OTl6xYsWwYcNMTU2fPHkik8n++usvFbuytLT09PS8dOlSUFBQt27diouLr1y5snr16hoXEWvbtu2VK1eOHz/eqlWrhISEx48fY30WxsbGjRo1srCwuHDhAoPBKCsr8/T0VBbj5eVlYmKiTjE/6e3btyEhIUOGDGEymU+ePFH93mEv17Zt23bu3Onk5JSampqYmOjr68tkMlW8d3Z2dmQyGevCb9euna+v7+bNm+fPn+/m5kYmk9X8Jnfr1q3j4uIiIiIMDQ0dHByqXzps2bIlnU4/evTowIEDP3/+HBERgQ1E5PF4te1TIpH4+/v37NnT1tb22rVrLBbLwsKCwWB8cyrXp0+fiIiIkJCQMWPGkEik06dPGxsbDx48WJ2y68rMzGzAgAHXrl0LCgrq2rVrRUXFgwcPlPc6OTndvn27Xbt2pqam58+fz8jIwGK3b9++UVFRhw8fzs3Ntbe3//TpU2Ji4oEDB1SsZN+7d+8NGzaw2ey2bduqX15WVlbDzxKjbgzxeDyJRHLo0CF9fX1PT8/v9qXPnDlTX1//8uXL5eXltra2q1atwrrQsMuc+/fvX7FiBY/HGz9+/KZNm7CH9O7d+9OnT3FxcV++fOHxeDNmzKDT6XFxcSkpKY6Ojk2bNi0uLlb9pM2aNbtw4YJyhwihQYMGzZ49m8fjrVy58uzZs5GRkdh6hB4eHt/9L0+fPr1Ro0ZXrlxJSUlhs9kuLi7Kc8xvdO/efcyYMdiYly5dumzbtm3r1q1XrlwZN24ciURavHjxjh07/v77b3Nz8169evF4vC1bthw+fBj7FKlZzM+g0+mNGzeOiIhQKBRt2rT5448/VG/v6uoqEokuXLhw+/ZtMzOzSZMmjRgxQvV7Z2FhMXfu3FOnTiUnJ7dr165Pnz7l5eXnz58/cuSIjY1Ny5YtMzIyvlvnpEmTioqKsAiYNm1a9RjicDiLFi06ePBgcHBwy5YtN2zYEB4efunSJRULkGGX2O/cuVNZWWlraxsUFIR9br+ZVY5Kpa5bty40NDQ0NFShUDg6Ok6fPv27f/Z+2LRp06hUalxc3LNnz+zs7Hg8nvIsfvr06WKxeOvWrSwWy93dXSQSYY0+Go22bt26sLCwu3fv3rhxw9LS0t3dXXXfAtat3qtXrzp9DSAjI0OdcV6aRbRpz2QyGXZdRiwWHzly5OrVqxcvXlQoFBQK5We+k9HwYNqz+iYQCBgMhjZM1YKNkFRndFWdfP78OSAgYMeOHTUOjm3UqFGN//dly5b9/vvvynEADaMOXdTaoKKiYuLEiTXeNWXKFBqNduzYsV69ellYWBQXFz948MDGxoZMJutWABHYwoULa+z+7Nq16/z58xu4GCqVWlZWphyyoFmPHj1SDvX4xtatW21sbOrjSZXy8vKuXbt28+bNtm3b1nWAfllZWX2P6a9Ox2KIyWTWNlGTkZFRZmamo6PjnTt3ysrK2Gx2165dPTw8JBIJzPCgJZYsWVJjv7WKDo76Q6PRKBSKQqGojwZR27ZtaztQ63qp/gdgy0P+/vvvfn5+dXrg69evi4uLG34pB6KdlFUll8tlMpn6lyq1CpyUNQzlWfyvpsaTsm3btnG53IZf0I3IZytkMllHMwg0GIVC8WNDnAjpxo0bdR3erRGEjSGJRCIUCvGuAmg7KpVqYGBQ1yFOhHTz5s3OnTtj3/VtYLX2DdVT112DOXToUO/evX/m1EZ3sVgs7Z8WB2ibvXv3fvcbyPWk1hjCpddQU+RyuZeXlzYv2l2voEv+B0yYMGHDhg3fnUyGqC5dutSxY8eGHzGEIeZJGZlM/mUzCPyYY8eOhYWF4V0FbiIiIgICAvB69u98G1hH3b17NyYmZu3atXgXAoAOOHDgAIVCmTZtGl4FELM1VFJSAtfIwA9ITU1dvHgx3lU0qC9fvty8eRPHDCJsawibiB6SCPyA169ff/36tYG/zYCjCRMmLF68uJ6mE1ATMWMIAKAObFp+fJtChD0pO3v27J49e/CuAuiwXbt2nTlzBu8q6ldaWtrx48dxzyDCxhCMXQQ/KTAwUE9PD5tVnaj8/f3xXaxViZgnZSUlJWKx+NccuwiAOlasWNG9e3dcvrpRHTFbQyYmJpBBQCMCAwOxRRCIJCoqisfjaUkGETaGoqOjw8PD8a4CEMGuXbtOnTrVAPOFN5iXL1+ePHkSx8GK1enYfENqKioqwtYIBODnYStHEoNEIpkyZUpSUhLehfwPYraGhg4dOmPGDLyrAMSBrdqMdxUasGDBAi28AkjMLmoANK64uDg1NRVbhFpHzZkzZ/jw4T179sS7kG8RM4bOnz+fk5Mzc+ZMvAsBhCKXy+Vy+XfX2tROmzZtsrW11c42HTFPykQikfoLVQOgJjKZfOXKlXXr1uFdSJ2dPXvWyMhIOzOIsK0hmUymUCh09K8W0HLY4q7YKmAIoYEDB0ZFReFdlCoxMTG3bt3auHEj3oXUilAxNG7cuJcvXyqXW8D+tba2vnjxIt6lAUKRSqUkEolCoQwZMiQ7O7tLly779u3Du6iapaam7t69+/Dhw3gXogqhTsrGjh2LzV2LLTmAHSienp541wWIhkqlLly4sHfv3jk5OSQSKSMjIz8/H++iapCdnf3PP/9oeQYRLYbc3d2/WYjOzs4OW/gYAM1KSUkpLy/Hfi4pKdHCb58JhcIRI0Zs3boV70K+j1AxhDWI9PX1sZ/JZHL//v11fW5/oIW6d++uzCBsMWFtGxCIEBowYEB0dDTeVaiFaDE0aNAgZYOoSZMm0BQCGufh4aGvr/9Np2pqaip+FdXA29v7+PHjBgYGeBeiFqLFEELI19eXxWJRKBQ3NzdjY2O8ywFEc+XKlSVLlvTv39/GxoZOp8vlchKJxOfz3717h3dp/5k2bdqKFStsbW3xLkRdhLpSpuTr6ysUCsPCwuCMDNSfz58/x8XFxcbGFhQU5Ofnz58/f8yYMXgXhZYsWdKvXz83Nze8C6kDzcdQWbHk8a3i7M9CmUQhqJBpdudqksnlCoWCit/a5CxjKseS3qGPiXljHV7uTWuV5IsfxxTnpAklIrlEhP/fUblCLpPJaVowTk0ml5NIiEzSlrMck0Z0fSNK257GNi30VWym4RjKSxddO5TtPJBjZEYzMKERsaWlFmGltDhX9Px+SZdB7KatWXiXQyhZnwQxJ/Kc3MyMOXSWEfWXPcZ0glgkL8wSfnhaat+W1aZ7rT0kmoyh9HeV8ZcKhky3UWPbX0XMiawWHQ1adYFzQ834/KLi8a3igZPxWVwU/LD4C7lmPFrnAewa79Vk4+1RdPHASXB8/A9XX8s3j8sE5VK8CyECuUzxJLZ4wCRYj1f39PDi5meICjJFNd6rsRjKzxCJBDIqTVtOSrUHjUbO+gTz82tATppQIf9viDzQOXosaubHmiex1FhqlOSJrX6DTpAaWDTR5xdI8K6CCPgFEl5TVT2dQJtxbZjlJTWfFmisb18iVghxui6m5SRiuUQux7sKIhCL5CIBvJK6SiZTlPNrjgg4hwIA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCACAM4ghAADOIIYAADiDGAIA4AxiCACAM4ghAADOIIYAADiDGPrWq9cvRKKaZ0UBuqgh31A+v2TtumUenr1Hjx1SVFTYME9KABBD/yMq+krArIlCYc2zogCd08Bv6K7dm579mzJnztI5fy5ls80a5kkJAP9JvJUyMr5aW9f7BLLYwva13QvtIIL57huq+nioq0fJD0aP8uvXd0CdHqXZGupDfVeIZwwVFhbs3rP5yZOHVBqtY8cu9+7d/nt/eJMm9gihp6mPQw/t+fjxnakpu0N756lTAszMOO8/vJ0dOHlD8K6Dh3Z//PiOy+X5Twvs3v13bG/ZOVn79m17kvKQTtdr3qzl5MkzW7ZohRDauWvj3Xu3F8xbse/A9szM9C2b9zW2tj0ctu/hw4SKivLGjW3Hjpnk2m8g9pdzx84NCKFh3q4IocWLVg0c4FFbMTi+bkBNMbejqr+hcXdjVq9Zsnb1ljOR/7x583LMaL9xvlOO/xMaGxudl59rZsbp7zZ4op8/hUJBCHkM7T3nz6Xx8XeSHsazWAYeQ4b7TZiGrcu8Y9eGBw/uIYTatu0wa+aC/PzcwDlTEUKHDu89dHjv4dDTTZv+hhC6efPaiVNhWVkZZmacwe5evmMnkclkPr9kmLfrDP8/3394m5AQ16xZy107DnkM7T07YOHtO9FPnyYbGBi69hvUtm2HsKMHMjK+NrGznzt3WYvmDqr/v0Kh8PCRfXfibgoElU4dOpuZcUpL+X+tDDl8ZN+ZiH9uRiVim715++qPmRM2hOzq0tlFxeE9aYpPEzt7Ozv78xdOi0TCUT4TTp4Ki4yIMjb6b2b79SErX73890T4pZ9/p3A7KZPJZMuWz3n56t8//1wyZrTf3bsx7dt1xDLoScqjRYtn2dk2XTB/pc+Icf/+mzJvwQyhUIj9cVu9dsmI4WN3bDtoweWtC17O55dgiTY7cHJpGX9WwAL/6YESieTPOVM/f/6IPVdFRfnhsH1z/lyyds0Wpw7OUpn0zZuXQz1H/OE/x8jIeH3witdvXiKEunTu7jNyHEIoZP2OXTsOdencXXUxQMt16til+huK2bl74xB3r00b93gMGU6hUJ48edjNpdcfM+Y6degcfuLIufOnlFtu2Ljqt99a7Nge6ubqfvTY30lJ8Qihk6fCoqOvjhg+1n96YGkpn8lk2tg2WR20CSHk5ua+ds0WLpeHEIqOvhqycVWzZi1Xrgju/bvbkbD9J06GKfccHn7YgsvbuuVAwMz52C1bt6936dZr545Dbdt0iDx7YsfODVMnB2wI2SUQClavXiyVqprRXC6XL18x99z5Uz179JkTuITL5V25ev67L5Hqwzs5OfHN25fB67avXbPVY4i3TCa7c+cmdpdEIklKut+3jt/HVZMAABNHSURBVO2+2uDWGnr/4e27929W/bWh9++uCKGvX9NuRF0Wi8V0On33ns0eQ7wDZy/CtuzUqavfpBHJjxMtLCwRQrNnLezbpz9CaOrUWf4zxj37N6VXz77/hB8yNWFv3byfSqUihNxc3cdNGHb1+oXZAQsQQmKxeMG8FQ4OrbEdWvKsjh6JxBqZgwYN9RrumpAQ59DS0dSUbWlpjRBycGhtbGyCbVxbMT179MHplQPqMjExrf6GYryGjRowYIjy1317jylPOrKyM+7dj8XyCyHkPmio79hJCKHf7Jtfu37x0ePErl17ZOdkMZnMsWMmUqnUwe7DsC1duvVCCNnZNu3RvTd2InPoyN42bdqvWLYOIdSrZ9+ystLTZ44N9/5vScVWrdpMnRJQtapBAz2Heo5ACPn7/3n33m3fsZO7deuJEPIdMylk46qsrAwbG7va/rNJSfEpT5P9pweOHjUBS8MnKQ+/+xKpPrwpVOrK5cFMJhO719m5W/TNq8OGjkQIPX6cVF5e3q/vQPXeiu/ALYaKCgsQQthRghCytraRy+UCQWVRUeGXL58zM9OvXrtQdfu8vFwshpiM/14U7A9OQUE+Qujhw4S8/Fz3IT2V20skkvy8XOxnBoOhzCDMh4/vjh77++3bV1i7rLaLGjk52bUVo6GXAeDDyalz1V+Li4uO/xOa/DiprKwUIWRoYKi8i/F/xxuFQmnUyLywIB8h5Npv0O3bUYuXzA6YOR87+aouI+NrQUH+KJ/xylucnbtdv3EpI/Mr19yieg0IIT29/xbXpNPoCCE6nY792sici12GU/E/evL0EULIY8hw9V+E7x7eDg6tlRmEEBo4wGP1miVfv6bZ2NjF3Yuxt29mZ9dU/adTAbcYwjLl+fPU5s1aIoRev37B4TQyNjbJyspACPlNmN6rZ9+q27PZnOyczKq30Kg0hJBcLkMIFRUXduvWc/rU2VU3YLEMsB+YzP+ZRz3lafLiJbM7tO+0aOEqlj7rr6CFckXNMxwXFxfWVsxPvwAAT/pVDomiosLpM3yZTP3Jk/6wtLQ+cmRfesaXGh9FpVBlchlCqEtnl5DgnQf+3jFl2ujB7sPm/LmEWm3J1vKKcoSQicn/X5nL0NAIIVSQn4fFkDLgNKKsrNTAwIDFqsOyFN89vJn/W2F3l9+NjIyjb16d6Of/IOHu2LGTNFQ7fjHUtOlvzp26HgzdlZubXcIvTnhwd8Xy9QghAwNDhJBIJFTR/qzO0NCIzy9R8yH//HPI0tI6eP0O7NBhVjsalEtI/lgxQNuoXhP08pVzxcVFe3cf5XItEELm5ha1xVBVXTq7OHfqeu78qX37t3O5vPHjpnyzgXmjb5swxcVFyjDSOI5Zo/LycoFAULX9gqntIlddD28ajebqOujmrWutHNqUV5T37aOZjiGcxw3NnrXQ2tomPeOLibHpnt1hWCeRtbUNl2txI+qyQPDfWA+pVCqRfGeBHSenzi9ePHv77rXyFuXDq+OXlvxm3xzLILFYXCmolP/fyhlYJGEnej9cDNAe37yhNSotLTExMcUyCDs8vruUsVgsRgiRyeSRI3w5nEbv37+pvo2ZGceCy3v0KEF5y927MQwG47ffWvzo/0aV5s0dEELXr1+sfpexsalEIuGX8rFfc3KysB9+4PAeOMCjoCB/34Htbdq0V75iPw+31pBUKp05y2/kiHFWVo1JJFJZWWl5ebmBgQGJRAqYOf+vVQsDZk/09Bghl8mib151c3MfMXysir35TZielBS/cFGAz8hxpqbsR48eyOSydWu21rhx+/adoqOvXL9xycjQOPLcibKy0rTPH7GREY6t21EolD37tgwa4CkSizw9hv9AMUB7VH9Dq2/Tvn2nCxcjjoTtd3Rsd/9+7MOHCXK5nM8v+aZXu6rzF04nPLjr5upeWJhfUJDfokWrGjeb6Oe/YVPQ5i1rnZ27paQ8ik+I85swnclkisWaH57Wq2dfO7um+w5sz8zOaNHM4XPax8zM9CZ29tgVQxKJtGfvlhHDx6Z9/vh36C7sIT/wWWv2WwsbG7uvX9OUXfgagVtriEqldurY9Z/wQ+vWL1+7btmixbPG+nqkpX1CCPXs0Sdk/Q4albZ339bj4Ye4XF7btk6q92Zlab1n1xFHx7YnTh7Zu29rCb/Ytd+g2jaePPEP507ddu/ZvGvPpo5OXYL+2lhYVPA09TG2n/nzlqenf9mzd0tc3K0fKwZoj+pvaHW9evadMH7qxUuR69cvl0gle/cctbGxu3DxjIrdWlpaS8Ti/Qe2X7t+0dt7dNV+6KoGDBgy588lz/5NWR+8Ijk5cfq02diwo/pAJpM3BO9y6dYrKurynr1bMjK/KmPU1rbJkkVBr189/3PO1NuxUf7TApWP+oHDu5VDGyqVip27aArpu+1PNb1KKk1/L3TxNFf/ITKZDBskplAosrIzp04b7TNy3KSJMzRSj/Z4Hl+M5HIXDxja/7Oe3SspyJZ2HgjXB9SCjT/8a2WIZne78q8FUpk0ZP2Ouj7w479luWmVA8Zzq9+F20mZWCz+I2CCublFu7ZONBr9+fOnQqHQ3r45XvUAoP0C50z9/PlD9dtdXH5funh1fT/7rZgbMbdvJCcnbt2yX7N7xi2GSCRSf7fBsbHRYUcP0On0Jk1+W/XXhm8uHAIAqvprRYhEWkMXcvWrvfXhxo1LEqlk44bdHdp30uyecYshGo02ymd8bSfVAIDqOJxG6m8cdjhCs8++besBze5QCSb6AADgDGIIAIAziCEAAM4ghgAAOIMYAgDgDGIIAIAziCEAAM4ghgAAOIMYAgDgTGOjqMlkkp4+hFoNqHQSSaHVy7/oCjIF0RlwjOkqCo3EqCUiNPamGrKpBRmwXkUNirJFLGMtWg9Odxma0gqz4BjTVcU5IqYBpca7NBZDbAsahQp/82sglyo4VnS8qyACtgVNu1cVBKqIBTJza70a79JYDDENqDYt9ZOu5mlqh8Tw/H4R04Bsbs3AuxAiMGLTuTZ6yTcL8C4E1Nmn52WCcqmdY80z9mts2jPMo5tFhTmSLgMb0fR+9XN4mVT+771isVDmOqYOU8GB70q4XFBZLu/oxqHRf/VjTCfI5Yp3T/hZHyo9/Xm1Tc6v4RhCCD1P4L94wBcJ5KbmehJxzQvv1DeFXI4QIpFxO0zFlXJBhbRND+POA9hqbA7qJjWu5MUDvkymMGLTZDK8qwG1I5NI2WmVbbsb9/RWNUWJ5mMIy7/yYmlZsaq1butVbGxsfn7+qFGj8CqAaUgxbUQjkaEno77IZYqyYml5sRTBa6zF9PTJHMua+4OqqpcrOGQyyciMZmRGq4+dq4OaXCovLbD6rSGmpAO4IFNIxhyaMQe3YwxoEJxdAwBwRswYolKpyvW/AQBajpgxJJVKsXU1AQDaj5gxxGAwjIzqZaVwAIDGETOGhEJhaWkp3lUAANRCzBjS09OD1hAAuoKYMSQSiaA1BICuIGYMAQB0CDFjiEQikfH7JgcAoE6I+VlVKBRyOT5fZwMA1BUxY0hfX9/ExATvKgAAaiFmDFVWVpaUlOBdBQBALcSMIQCADiFmDFEoFPhOGQC6gpgxJJPJ4DtlAOgKYsYQg8EwNjbGuwoAgFqIGUNCoZDP5+NdBQBALcSMIQCADiFmDOnp6RkaGuJdBQBALcSMIZFIVFZWhncVAAC1EDOGYNozAHQIMWMIpj0DQIcQM4YAADoEYggAgDPCxlBtq2UDALQNYWOoPhbFBgDUB8LGEABAV0AMAQBwRswYgnFDAOgQYsYQjBsCQIcQM4YAADqEmDFEp9P19fXxrgIAoBZixpBYLK6srMS7CgCAWogZQwAAHULMGGIymbBOGQC6gpgxJBAIYJ0yAHQFMWMIAKBDiBlDZDKZSqXiXQUAQC3EjCG5XC6VSvGuAgCgFmLGEEyJD4AOIRFpQgwPD4+srKxvbjQ3N79x4wZOFQEAvo9QraGRI0dSqVTS/+rduzfedQEAVCFUDPn4+FhbW1e9xdraesyYMfhVBAD4PkLFEIPBGDZsGIVCwX5VKBTdu3e3sbHBuy4AgCqEiiGE0IgRI6ysrLCfraysfHx88K4IAPAdRIshJpM5dOhQCoWiUCh69Ohha2uLd0UAgO8gWgxhHdW2trZWVlajRo3CuxYAwPfhf8E+431l7ldRaaG0vFRKo5LLSjQw7LCwsEAikVpYWPz8rpiGFLlMwTKiGJhQuY317BxZP79PAEBVuMVQxrvKZ/dLv76pYJnq6RkxqDQylU6lMai4x2I1JKlYKhXLpCKZRCAuya5s3ILVprth0zYGeBcGAEHgEEP5GaK4cwUSCUmfzTJqpE+m6tKJoUKhKMuvFJYKJBXiXt5mjZvDHI8A/KyGjqHYiIK015Xm9mwDM2ZDPq/GCfiivI9F5tb0QX7meNcCgG5r0Bg6uyuTpMc0szFusGesb/zcCn5G8YQVcD0OgB/XcDEUuTOTwTYy5BDtLEZYJs56leu3wpZCJeFdCwA6qYH6ZU5s/MrkGBMvgxBCDEO6jZPloRWf8S4EAF31/9q719imqjgA4Oc+u77X5xhQGANk4TUgIIgEkFeQGCFBwAmJMZIQTUwU/SBGSdQPCjGoQULiAyVhaoSBOBGGAwfbyAbMMB6zyzZ5bOzRlrW9bW/X23tbP1xdJHvAWE/v2v5/n9az9tx/m/Tfc86993+SMRo6dbArIqmMuelceSPkDYe6fBvfGPsQzwUA3Af7aMh5iQtHyPTOQQghrUnN6rWXTncrHQgAqQd7GjpX4jGMSp816UFkjzHUlXuFnpjSgQCQYvCmocu/d5vG6CmGwnqUkcM+yVx5zKN0FACkGLxpyPlnyDphJO4XVnv5+Fvvzee4BKcMs8PQcUfgA1AGG4AhwJiG2pr4mESQVCpdJD18JEPfaggpHQUAqQRjjmiuD2nMaXiGfnA6s6bpCq90FACkEoybefnviXobrvs/L1wsOVf9vZ9zmU2jZ89ctfTJLQyjOn/hhyvXyhcvLDpZvj8Q8IwZXbBh7Q67LU9+yd32xp9/29N6t8Ggt9osuEoy6mxql5PD1DkAaQnjaKi9mWdUWNLc6bNfnSj7YtaMlRvXvTtz2vKKykNHjn8k/+tO2/Vz1cUb1r7zYtFun7/rx6MfyO1d7lv7D7zCce41K19dsvCFux2NOAKTd2r0e4RwUMLUPwDpB9doSOiJEQTCsTDk59xnzn+3+bkPZ05fJrcY9daS0l1r12yXH760+ROD3oIQWrRgY+mpz0O8X6sxnijbSxDka9u+0WlNCCGCJI+W7k54bDJWTYc4Ua3LlPODAAwTrjQU8kd1FhWOnptaLkqSWHxkZ/GRnf+1xRFC/oBLfqBi/71335SdixDiODdDqxqba56Yt17OQQghisQ4G1XraT4gIoTl7QOQfnB9GymG7MFz3poLeBBCL2/Zk228r8KGxTy2qeXS/1toikEIxWISF/BIkmg25eKIpy8hHKMy7PwgAMOBKw1pDXQkjCUNqdUG+Y/etecHkgdBwaAXRzx9RSOSxgAzMgAeFq4fbYomGJYUhcSv1E7On0sQRFXtT70tESE8+EuysrRWi6P+xhlRjCY8nr4EXtQaMU76AEgzGOcOOXlqgU/8195qcSxasKnBWXng0Ju1db+UVxz4+NP1be3OwV+16qmt97rb9n65tbrm8IWLJRXVxQkPTCb0iNl2llXBpAyAh4XxR9sxOavpOq/Jzkp4z88+/Xq20V5Vc7ixucagt06futRoeEAl1jmFq8PhQEV18a+n9+bY8sc7prs9txMeGEIo4OZHjYfFaQCGAGO9Ia9LOLavI39BZpXgaa3vXLLONK4g4y4fB+CRYRwNmeysKYeJBAWVjh3oObs+2xAI9VOjZ7xjxu3Wa33btWrjju1HExjkvq+3dXQ1920fm1vQ1tH/RO/9t8soqv/PTRJjNB2HHATAkOCtvnjrRrCy1O8oHHDbQq+vMx7vr0BPnEBEP4ERBGnKTsAmiL38nFuS+lnAIogBPxmzafRAvXU2egrmqGYtHolFBQAYsfCe0Mmbpqst84W8PVpT/ytEic0pj8BosCWqKyEshrrDsxbnJKpDADIE9hM6K4pswa6MuNWT6/At22RVOgoAUg/2NGTJVRUu0rY3uHAfSFnuv7sdE5kJ02BHaQCGLBmXtxTMM+RNYdv/StvqqK4Wr14fm7/arHQgAKSk5G2XWPeHv6m+Z9SUdJu2uG96Teb4iucTtsYEQKZJ6ubRVyv99VWBnMesrIZJ2kHxkaKS+6Z33ER64TMWpWMBIIUlNQ0hhDpv95z8tjPLqLZPMlN0Ct/x0NXU7WsPLC+yTyqE9SAAhiXZaUh2rcpfd9ZHsYzOpjHYNKmyg1AsFg+4+IA7JAnRqY/r560yKR0RAOlAmTQka7kadNYFW528SkOTFEmxFKtlpejIKp9KM3SEj0iCJEakaETMzdcUzNVNnq0jSULp0ABIE0qmoV5el8BzUogTo5F4VBhZu54yLEkzhMZAaY20OWfAu1IAAI9sRKQhAEAmS+FFYgBAeoA0BABQGKQhAIDCIA0BABQGaQgAoDBIQwAAhf0DK+ynLSiMTPoAAAAASUVORK5CYII=",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Visualize our graph\n",
    "from IPython.display import Image, display\n",
    "try:\n",
    "    display(Image(app.get_graph().draw_mermaid_png()))\n",
    "except Exception:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DNZeqWVQ0nNv"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "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.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}