code/L5-add_relationships_to_kg.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lesson 5: Adding Relationships to the SEC Knowledge Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import packages and set up Neo4j"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load from environment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dotenv import load_dotenv\n",
    "import os\n",
    "\n",
    "load_dotenv(dotenv_path=\".env\", override=True)\n",
    "\n",
    "NEO4J_URI = os.getenv(\"NEO4J_URI\")\n",
    "NEO4J_USERNAME = os.getenv(\"NEO4J_USERNAME\")\n",
    "NEO4J_PASSWORD = os.getenv(\"NEO4J_PASSWORD\")\n",
    "NEO4J_DATABASE = os.getenv(\"NEO4J_DATABASE\") or \"neo4j\"\n",
    "\n",
    "# Global constants\n",
    "VECTOR_INDEX_NAME = \"form_10k_chunks\"\n",
    "VECTOR_NODE_LABEL = \"Chunk\"\n",
    "VECTOR_SOURCE_PROPERTY = \"text\"\n",
    "VECTOR_EMBEDDING_PROPERTY = \"textEmbedding\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Common data processing\n",
    "import textwrap\n",
    "\n",
    "# LangChain\n",
    "from langchain_community.graphs import Neo4jGraph\n",
    "from langchain_community.vectorstores import Neo4jVector\n",
    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
    "from langchain.chains import RetrievalQAWithSourcesChain\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_openai import OpenAIEmbeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Warnings control\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "kg = Neo4jGraph(url=NEO4J_URI, username=NEO4J_USERNAME, password=NEO4J_PASSWORD, database=NEO4J_DATABASE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a Form 10-K node\n",
    "- Create a node to represent the entire Form 10-K\n",
    "- Populate with metadata taken from a single chunk of the form"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'formInfo': {'cik': '1002047',\n",
       "   'source': 'https://www.sec.gov/Archives/edgar/data/1002047/000095017023027948/0000950170-23-027948-index.htm',\n",
       "   'formId': '0000950170-23-027948',\n",
       "   'names': ['Netapp Inc', 'NETAPP INC'],\n",
       "   'cusip6': '64110D'}}]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (anyChunk:Chunk)      \n",
    "    WITH anyChunk LIMIT 1\n",
    "    RETURN anyChunk {.names, .source, .formId, .cik, .cusip6} as formInfo\n",
    "\"\"\"\n",
    "\n",
    "form_info_list = kg.query(query=cypher)\n",
    "\n",
    "form_info_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "form_info = form_info_list[0][\"formInfo\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'cik': '1002047',\n",
       " 'source': 'https://www.sec.gov/Archives/edgar/data/1002047/000095017023027948/0000950170-23-027948-index.htm',\n",
       " 'formId': '0000950170-23-027948',\n",
       " 'names': ['Netapp Inc', 'NETAPP INC'],\n",
       " 'cusip6': '64110D'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "form_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MERGE (f:Form {formId: $formInfoParam.formId})\n",
    "        ON CREATE\n",
    "            SET f.names = $formInfoParam.names\n",
    "            SET f.source = $formInfoParam.source\n",
    "            SET f.cik = $formInfoParam.cik\n",
    "            SET f.cusip6 = $formInfoParam.cusip6\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formInfoParam\": form_info})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'formCount': 1}]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kg.query(\"MATCH (f:Form) RETURN count(f) as formCount\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a linked list of Chunk nodes for each section\n",
    "- Start by identifying chunks from the same section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0002',\n",
       "   'chunkSeqId': 2}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0003',\n",
       "   'chunkSeqId': 3}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0004',\n",
       "   'chunkSeqId': 4}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0005',\n",
       "   'chunkSeqId': 5}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0006',\n",
       "   'chunkSeqId': 6}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0007',\n",
       "   'chunkSeqId': 7}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0008',\n",
       "   'chunkSeqId': 8}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0009',\n",
       "   'chunkSeqId': 9}}]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_form:Chunk)\n",
    "        WHERE from_same_form.formId = $formIdParam\n",
    "    RETURN from_same_form {.formId, .f10kItem, .chunkId, .chunkSeqId} as chunkInfo\n",
    "        LIMIT 10\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Order chunks by their sequence ID"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item7a',\n",
       "   'chunkId': '0000950170-23-027948-item7a-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item7',\n",
       "   'chunkId': '0000950170-23-027948-item7-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1a',\n",
       "   'chunkId': '0000950170-23-027948-item1a-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item7a',\n",
       "   'chunkId': '0000950170-23-027948-item7a-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1a',\n",
       "   'chunkId': '0000950170-23-027948-item1a-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item7',\n",
       "   'chunkId': '0000950170-23-027948-item7-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0002',\n",
       "   'chunkSeqId': 2}},\n",
       " {'chunkInfo': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1a',\n",
       "   'chunkId': '0000950170-23-027948-item1a-chunk0002',\n",
       "   'chunkSeqId': 2}}]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_form: Chunk)\n",
    "        WHERE from_same_form.formId = $formIdParam\n",
    "    RETURN from_same_form {.formId, .f10kItem, .chunkId, .chunkSeqId} as chunkInfo\n",
    "        ORDER BY from_same_form.chunkSeqId ASC\n",
    "        LIMIT 10\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Limit chunks to the `Item1` section and organize in ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       "   'chunkSeqId': 0}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       "   'chunkSeqId': 1}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0002',\n",
       "   'chunkSeqId': 2}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0003',\n",
       "   'chunkSeqId': 3}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0004',\n",
       "   'chunkSeqId': 4}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0005',\n",
       "   'chunkSeqId': 5}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0006',\n",
       "   'chunkSeqId': 6}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0007',\n",
       "   'chunkSeqId': 7}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0008',\n",
       "   'chunkSeqId': 8}},\n",
       " {'from_same_section': {'formId': '0000950170-23-027948',\n",
       "   'f10kItem': 'item1',\n",
       "   'chunkId': '0000950170-23-027948-item1-chunk0009',\n",
       "   'chunkSeqId': 9}}]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_section: Chunk)\n",
    "        WHERE from_same_section.formId = $formIdParam\n",
    "        AND from_same_section.f10kItem = $f10kItemParam  // NEW !!\n",
    "    RETURN from_same_section {.formId, .f10kItem, .chunkId, .chunkSeqId}\n",
    "        ORDER BY from_same_section.chunkSeqId ASC\n",
    "        LIMIT 10\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"], \"f10kItemParam\": \"item1\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Collect ordered chunks into a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'collect(from_same_section)': [{'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       "    'chunkSeqId': 0},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       "    'chunkSeqId': 1},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0002',\n",
       "    'chunkSeqId': 2},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0003',\n",
       "    'chunkSeqId': 3},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0004',\n",
       "    'chunkSeqId': 4},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0005',\n",
       "    'chunkSeqId': 5},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0006',\n",
       "    'chunkSeqId': 6},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0007',\n",
       "    'chunkSeqId': 7},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0008',\n",
       "    'chunkSeqId': 8},\n",
       "   {'formId': '0000950170-23-027948',\n",
       "    'f10kItem': 'item1',\n",
       "    'chunkId': '0000950170-23-027948-item1-chunk0009',\n",
       "    'chunkSeqId': 9}]}]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_section: Chunk)\n",
    "        WHERE from_same_section.formId = $formIdParam\n",
    "        AND from_same_section.f10kItem = $f10kItemParam\n",
    "    WITH from_same_section {.formId, .f10kItem, .chunkId, .chunkSeqId}\n",
    "        ORDER BY from_same_section.chunkSeqId ASC\n",
    "        LIMIT 10\n",
    "    RETURN collect(from_same_section)  // NEW !!\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"], \"f10kItemParam\": \"item1\"})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add a NEXT relationship between subsequent chunks\n",
    "- Use the `apoc.nodes.link` function from Neo4j to link ordered list of `Chunk` nodes with a `NEXT` relationship\n",
    "- Do this for just the \"Item 1\" section to start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'size(section_chunk_list)': 20}]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_section: Chunk)\n",
    "        WHERE from_same_section.formId = $formIdParam\n",
    "        AND from_same_section.f10kItem = $f10kItemParam\n",
    "    WITH from_same_section\n",
    "        ORDER BY from_same_section.chunkSeqId ASC\n",
    "    WITH collect(from_same_section) as section_chunk_list\n",
    "        CALL apoc.nodes.link(\n",
    "            section_chunk_list,\n",
    "            \"NEXT\",\n",
    "            {avoidDuplicates: True}\n",
    "        ) // NEW !!\n",
    "    RETURN size(section_chunk_list)\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"], \"f10kItemParam\": \"item1\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node properties:\n",
      "Chunk {chunkId: STRING, names: LIST, formId: STRING, cik: STRING, cusip6: STRING, source: STRING, f10kItem: STRING, chunkSeqId: INTEGER, text: STRING, textEmbedding: LIST}\n",
      "Form {names: LIST, formId: STRING, cik: STRING, cusip6: STRING, source: STRING}\n",
      "Relationship properties:\n",
      "\n",
      "The relationships:\n",
      "(:Chunk)-[:NEXT]->(:Chunk)\n"
     ]
    }
   ],
   "source": [
    "kg.refresh_schema()\n",
    "print(kg.schema)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Loop through and create relationships for all sections of the form 10-K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (from_same_section: Chunk)\n",
    "        WHERE from_same_section.formId = $formIdParam\n",
    "        AND from_same_section.f10kItem = $f10kItemParam\n",
    "    WITH from_same_section\n",
    "        ORDER BY from_same_section.chunkSeqId ASC\n",
    "    WITH collect(from_same_section) as section_chunk_list\n",
    "        CALL apoc.nodes.link(\n",
    "            section_chunk_list,\n",
    "            \"NEXT\",\n",
    "            {avoidDuplicates: True}\n",
    "        )\n",
    "    RETURN size(section_chunk_list)\n",
    "\"\"\"\n",
    "\n",
    "for form10kItemName in [\"item1\", \"item1a\", \"item7\", \"item7a\"]:\n",
    "    kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"], \"f10kItemParam\": form10kItemName})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Connect chunks to their parent form with a PART_OF relationship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'count(newRelationship)': 80}]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (c: Chunk), (f:Form)\n",
    "        WHERE c.formId = f.formId\n",
    "    MERGE (c)-[newRelationship:PART_OF]->(f)\n",
    "    RETURN count(newRelationship)\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create a SECTION relationship on first chunk of each section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'count(r)': 4}]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (first: Chunk), (f:Form)\n",
    "        WHERE first.formId = f.formId\n",
    "        AND first.chunkSeqId = 0\n",
    "    WITH first, f\n",
    "        MERGE (f)-[r: SECTION{f10kItem: first.f10kItem}]->(first)\n",
    "    RETURN count(r)\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example Cypher queries\n",
    "\n",
    "- Return the first chunk of Item1 section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       " 'text': '>Item 1.  \\nBusiness\\n\\n\\nOverview\\n\\n\\nNetApp, Inc. (NetApp, we, us or the Company) is a global cloud-led, data-centric software company. We were incorporated in 1992 and are headquartered in San Jose, California. Building on more than three decades of innovation, we give customers the freedom to manage applications and data across hybrid multicloud environments. Our portfolio of cloud services, and storage infrastructure, powered by intelligent data management software, enables applications to run faster, more reliably, and more securely, all at a lower cost.\\n\\n\\nOur opportunity is defined by the durable megatrends of data-driven digital and cloud transformations. NetApp helps organizations meet the complexities created by rapid data and cloud growth, multi-cloud management, and the adoption of next-generation technologies, such as AI, Kubernetes, and modern databases. Our modern approach to hybrid, multicloud infrastructure and data management, which we term ‘evolved cloud’, provides customers the ability to leverage data across their entire estate with simplicity, security, and sustainability which increases our relevance and value to our customers.\\n\\n\\nIn an evolved cloud state, the cloud is fully integrated into an organization’s architecture and operations. Data centers and clouds are seamlessly united and hybrid multicloud operations are simplified, with consistency and observability across environments. The key benefits NetApp brings to an organization’s hybrid multicloud environment are:\\n\\n\\n•\\nOperational simplicity: NetApp’s use of open source, open architectures and APIs, microservices, and common capabilities and data services facilitate the creation of applications that can run anywhere.\\n\\n\\n•\\nFlexibility and consistency: NetApp makes moving data and applications between environments seamless through a common storage foundation across on-premises and multicloud environments.'}"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (f:Form)-[r:SECTION]->(first:Chunk)\n",
    "        WHERE f.formId = $formIdParam\n",
    "        AND r.f10kItem = $f10kItemParam\n",
    "    RETURN first.chunkId as chunkId, first.text as text\n",
    "\"\"\"\n",
    "\n",
    "first_chunk_info = kg.query(query=cypher, params={\"formIdParam\": form_info[\"formId\"],\n",
    "                                                   \"f10kItemParam\": \"item1\"}\n",
    "                            )[0]\n",
    "\n",
    "first_chunk_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Get the second chunk of `item1` section"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       " 'text': \"•\\nFlexibility and consistency: NetApp makes moving data and applications between environments seamless through a common storage foundation across on-premises and multicloud environments.\\n\\n\\n•\\nCyber resilience: NetApp unifies monitoring, data protection, security, governance, and compliance for total cyber resilience - with consistency and automation across environments. \\n\\n\\n•\\nContinuous operations: NetApp uses AI-driven automation for continuous optimization to service applications and store stateless and stateful applications at the lowest possible costs.\\n\\n\\n•\\nSustainability: NetApp has industry-leading tools to audit consumption, locate waste, and set guardrails to stop overprovisioning.\\n\\n\\nProduct, Solutions and Services Portfolio\\n \\n\\n\\nNetApp's portfolio of cloud services and storage infrastructure is powered by intelligent data management software. Our operations are organized into two segments: Hybrid Cloud and Public Cloud.\\n\\n\\n \\n\\n\\nHybrid Cloud\\n\\n\\nHybrid Cloud \\noffers a portfolio of storage management and infrastructure solutions that help customers recast their traditional data centers into modern data centers with the power of the cloud. Our hybrid cloud portfolio is designed to operate with public clouds to unlock the potential of hybrid, multi-cloud operations. We offer a broad portfolio of cloud-connected all-flash, hybrid-flash, and object storage systems, powered by intelligent data management software. Hybrid Cloud is composed of software, hardware, and related support, as well as professional and other services.\\n\\n\\nIntelligent data management software\"}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (first:Chunk)-[:NEXT]->(nextChunk:Chunk)\n",
    "        WHERE first.chunkId = $chunkIdParam\n",
    "    RETURN nextChunk.chunkId as chunkId, nextChunk.text as text\n",
    "\"\"\"\n",
    "\n",
    "next_chunk_info = kg.query(query=cypher,\n",
    "                           params={\"chunkIdParam\": first_chunk_info[\"chunkId\"]}\n",
    "                            )[0]\n",
    "\n",
    "next_chunk_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's check the first and second chunkId"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0000950170-23-027948-item1-chunk0000 0000950170-23-027948-item1-chunk0001\n"
     ]
    }
   ],
   "source": [
    "print(first_chunk_info[\"chunkId\"], next_chunk_info[\"chunkId\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Return a window of three chunks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'c1.chunkId': '0000950170-23-027948-item1-chunk0000',\n",
       "  'c2.chunkId': '0000950170-23-027948-item1-chunk0001',\n",
       "  'c3.chunkId': '0000950170-23-027948-item1-chunk0002'}]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH (c1:Chunk)-[:NEXT]->(c2:Chunk)-[:NEXT]->(c3:Chunk)\n",
    "        WHERE c2.chunkId = $chunkIdParam\n",
    "    RETURN c1.chunkId, c2.chunkId, c3.chunkId\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"chunkIdParam\": next_chunk_info[\"chunkId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Information is stored in the structure of a graph\n",
    "- Matched patterns of nodes and relationships in a graph are called **paths**\n",
    "- The length of a path is equal to the number of relationships in the path\n",
    "- Paths can be captured as variables and used elsewhere in queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'WindowPathLength': 2}]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH window = (c1:Chunk)-[:NEXT]->(c2:Chunk)-[:NEXT]->(c3:Chunk)\n",
    "        WHERE c1.chunkId = $chunkIdParam\n",
    "    RETURN length(window) as WindowPathLength\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"chunkIdParam\": next_chunk_info[\"chunkId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding variable length windows\n",
    "- A pattern match will fail if the relationship doesn't exist in the graph\n",
    "- For example, the first chunk in a section has no preceding chunk, so the next query won't return anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH window = (c1:Chunk)-[:NEXT]->(c2:Chunk)-[:NEXT]->(c3:Chunk)\n",
    "        WHERE c2.chunkId = $chunkIdParam\n",
    "    RETURN length(window) as WindowPathLength\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"chunkIdParam\": first_chunk_info[\"chunkId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Modify `NEXT` relationship to have variable length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'WindowPathLength': 0}, {'WindowPathLength': 1}]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH window = (:Chunk)-[:NEXT*0..1]->(c:Chunk)-[:NEXT*0..1]->(:Chunk)\n",
    "        WHERE c.chunkId = $chunkIdParam\n",
    "    RETURN length(window) as WindowPathLength\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"chunkIdParam\": first_chunk_info[\"chunkId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Retrieve only the longest path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'length(longestChunkWindow)': 1}]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cypher = \"\"\"\n",
    "    MATCH window = (:Chunk)-[:NEXT*0..1]->(c:Chunk)-[:NEXT*0..1]->(:Chunk)\n",
    "        WHERE c.chunkId = $chunkIdParam\n",
    "    WITH window as longestChunkWindow\n",
    "        ORDER BY length(window) DESC LIMIT 1\n",
    "    RETURN length(longestChunkWindow)\n",
    "\"\"\"\n",
    "\n",
    "kg.query(query=cypher, params={\"chunkIdParam\": first_chunk_info[\"chunkId\"]})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Customize the results of the similarity search using Cypher\n",
    "- Extend the vector store definition to accept a Cypher query\n",
    "- The Cypher query takes the results of the vector similarity search and then modifies them in some way\n",
    "- Start with a simple query that just returns some extra text along with the search results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "retrieval_query_extra_text = \"\"\"\n",
    "    WITH node, score, \"Andreas knows Cypher. \" as extraText\n",
    "    RETURN extraText + \"\\n\" + node.text as text,\n",
    "            score,\n",
    "            node {.source} as metadata\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Set up the vector store to use the query, then instantiate a retriever and Question-Answer chain in LangChain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector_store_extra_text = Neo4jVector.from_existing_index(\n",
    "    embedding=OpenAIEmbeddings(),\n",
    "    url=NEO4J_URI,\n",
    "    username=NEO4J_USERNAME,\n",
    "    password=NEO4J_PASSWORD,\n",
    "    database=NEO4J_DATABASE,\n",
    "    index_name=VECTOR_INDEX_NAME,\n",
    "    text_node_property=VECTOR_SOURCE_PROPERTY,\n",
    "    retrieval_query=retrieval_query_extra_text  # NEW !!!\n",
    ")\n",
    "\n",
    "# Create a retriever from the vector store\n",
    "retriever_extra_text = vector_store_extra_text.as_retriever()\n",
    "\n",
    "# Create a chatbot Question & Answer chain from the retriever\n",
    "chain_extra_text = RetrievalQAWithSourcesChain.from_chain_type(\n",
    "    llm=ChatOpenAI(temperature=0),\n",
    "    chain_type=\"stuff\",\n",
    "    retriever=retriever_extra_text\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ask a question!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': 'Andreas knows about Cypher.\\n',\n",
       " 'sources': 'https://www.sec.gov/Archives/edgar/data/1002047/000095017023027948/0000950170-23-027948-index.htm'}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain_extra_text({\"question\": \"What topics does Andreas know about?\"},\n",
    "                 return_only_outputs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observation: Unlike in the course demo, LLM didn't hallucinated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Modify the prompt to try and get a more accurate answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': 'Andreas knows Cypher.\\n',\n",
       " 'sources': 'https://www.sec.gov/Archives/edgar/data/1002047/000095017023027948/0000950170-23-027948-index.htm'}"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain_extra_text({\"question\": \"What single topic does Andreas know about?\"},\n",
    "                 return_only_outputs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Try for yourself!\n",
    "- Modify the query below to add your own additional text\n",
    "- Try engineering the prompt to refine your results\n",
    "- Note, you'll need to reset the vector store, retriever, and chain each time you change the Cypher query."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': 'Andreas knows Python.\\n',\n",
       " 'sources': 'https://www.sec.gov/Archives/edgar/data/1002047/000095017023027948/0000950170-23-027948-index.htm'}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieval_query_extra_text = \"\"\"\n",
    "    WITH node, score, \"Andreas knows Python. \" as extraText\n",
    "    RETURN extraText + \"\\n\" + node.text as text,\n",
    "            score,\n",
    "            node {.source} as metadata\n",
    "\"\"\"\n",
    "\n",
    "vector_store_extra_text = Neo4jVector.from_existing_index(\n",
    "    embedding=OpenAIEmbeddings(),\n",
    "    url=NEO4J_URI,\n",
    "    username=NEO4J_USERNAME,\n",
    "    password=NEO4J_PASSWORD,\n",
    "    database=NEO4J_DATABASE,\n",
    "    index_name=VECTOR_INDEX_NAME,\n",
    "    text_node_property=VECTOR_SOURCE_PROPERTY,\n",
    "    retrieval_query=retrieval_query_extra_text  # NEW !!!\n",
    ")\n",
    "\n",
    "# Create a retriever from the vector store\n",
    "retriever_extra_text = vector_store_extra_text.as_retriever()\n",
    "\n",
    "# Create a chatbot Question & Answer chain from the retriever\n",
    "chain_extra_text = RetrievalQAWithSourcesChain.from_chain_type(\n",
    "    llm=ChatOpenAI(temperature=0),\n",
    "    chain_type=\"stuff\",\n",
    "    retriever=retriever_extra_text\n",
    ")\n",
    "\n",
    "chain_extra_text(inputs={\"question\": \"Which programming language does Andreas knows?\"},\n",
    "                 return_only_outputs=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': \"I don't know.\\n\", 'sources': ''}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain_extra_text(inputs={\"question\": \"Does Andreas know Java?\"},\n",
    "                 return_only_outputs=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Expand context around a chunk using a window\n",
    "- First, create a regular vector store that retrieves a single node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "neo4j_vector_store = Neo4jVector.from_existing_graph(\n",
    "    embedding=OpenAIEmbeddings(),\n",
    "    url=NEO4J_URI,\n",
    "    username=NEO4J_USERNAME,\n",
    "    password=NEO4J_PASSWORD,\n",
    "    index_name=VECTOR_INDEX_NAME,\n",
    "    node_label=VECTOR_NODE_LABEL,\n",
    "    text_node_properties=[VECTOR_SOURCE_PROPERTY],\n",
    "    embedding_node_property=VECTOR_EMBEDDING_PROPERTY\n",
    ")\n",
    "\n",
    "# Create a retriever from the vector store\n",
    "windowless_retriever = neo4j_vector_store.as_retriever()\n",
    "\n",
    "# Create a chatbot Question and Answer chain from the retriever\n",
    "windowless_chain = RetrievalQAWithSourcesChain.from_chain_type(\n",
    "    llm=ChatOpenAI(temperature=0),\n",
    "    chain_type=\"stuff\",\n",
    "    retriever=windowless_retriever\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Next, define a window retrieval query to get consecutive chunks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "retrieval_query_window = \"\"\"\n",
    "    MATCH window = (:Chunk)-[:NEXT*0..1]->(node)-[:NEXT*0..1]->(:Chunk)\n",
    "    WITH node, score, window as longestWindow\n",
    "        ORDER by length(window) DESC LIMIT 1\n",
    "    WITH nodes(longestWindow) as chunkList, node, score\n",
    "        UNWIND chunkList as chunkRows\n",
    "    WITH collect(chunkRows.text) as textList, node, score\n",
    "    RETURN apoc.text.join(textList, \" \\n \") as text, score, node {.source} AS metadata\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Set up a Question Answer chain that will use the window retrieval query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector_store_window = Neo4jVector.from_existing_index(\n",
    "    embedding=OpenAIEmbeddings(),\n",
    "    url=NEO4J_URI,\n",
    "    username=NEO4J_USERNAME,\n",
    "    password=NEO4J_PASSWORD,\n",
    "    database=NEO4J_DATABASE,\n",
    "    index_name=VECTOR_INDEX_NAME,\n",
    "    text_node_property=VECTOR_SOURCE_PROPERTY,\n",
    "    retrieval_query=retrieval_query_window  # NEW !!\n",
    ")\n",
    "\n",
    "# Create a retriever from the vector store\n",
    "retriever_window = vector_store_window.as_retriever()\n",
    "\n",
    "# Create a chatbot Question & Answer chain from the retriever\n",
    "chain_window = RetrievalQAWithSourcesChain.from_chain_type(\n",
    "    llm=ChatOpenAI(temperature=0),\n",
    "    chain_type=\"stuff\",\n",
    "    retriever=retriever_window\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compare the two chains"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "question = \"In a single sentence, tell me about Netapp's business.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/kaushik/miniconda3/envs/py3_knowledge_graphs_rag_course/lib/python3.12/site-packages/langchain_core/_api/deprecation.py:119: LangChainDeprecationWarning: The method `Chain.__call__` was deprecated in langchain 0.1.0 and will be removed in 0.3.0. Use invoke instead.\n",
      "  warn_deprecated(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetApp, Inc. is a global cloud-led, data-centric software company that\n",
      "enables customers to manage applications and data across hybrid\n",
      "multicloud environments with operational simplicity and flexibility.\n"
     ]
    }
   ],
   "source": [
    "answer = windowless_chain(\n",
    "    inputs={\"question\": question},\n",
    "    return_only_outputs=True\n",
    ")\n",
    "\n",
    "print(textwrap.fill(text=answer[\"answer\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetApp is a global cloud-led, data-centric software company that\n",
      "provides customers with the freedom to manage applications and data\n",
      "across hybrid multicloud environments.\n"
     ]
    }
   ],
   "source": [
    "answer = chain_window(\n",
    "    inputs={\"question\": question},\n",
    "    return_only_outputs=True\n",
    ")\n",
    "\n",
    "print(textwrap.fill(text=answer[\"answer\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "question = \"In a single sentence, tell me about Netapp's ransomware protection.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetApp's ransomware protection includes automatic protection against\n",
      "cyber-attacks.\n"
     ]
    }
   ],
   "source": [
    "answer = windowless_chain(\n",
    "    inputs={\"question\": question},\n",
    "    return_only_outputs=True\n",
    ")\n",
    "\n",
    "print(textwrap.fill(text=answer[\"answer\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NetApp provides automatic ransomware protection against cyber-attacks\n",
      "as part of its ONTAP software.\n"
     ]
    }
   ],
   "source": [
    "answer = chain_window(\n",
    "    inputs={\"question\": question},\n",
    "    return_only_outputs=True\n",
    ")\n",
    "\n",
    "print(textwrap.fill(text=answer[\"answer\"]))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "py3_knowledge_graphs_rag_course",
   "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}