RAG/RAG_Query_Transformation_Technique.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MultiQuery"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dotenv import load_dotenv\n",
    "import os\n",
    "\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.environ[\"GROQ_API_KEY\"] = os.getenv(\"GROQ_API_KEY\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_groq import ChatGroq\n",
    "\n",
    "llm = ChatGroq(\n",
    "    model=\"llama3-8b-8192\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "# multi query: different perspective of one question\n",
    "template = '''\n",
    "You are an AI Language model. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspective on the user question, your goal is to help the user overcome some of the limitations of the distance based similarity search. Provide these alternative questions separated by newlines. Just answer the questions nothing else. Original question: {question}'''\n",
    "\n",
    "prompt_multi_query = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "generate_queries = (\n",
    "    prompt_multi_query\n",
    "    | llm\n",
    "    | (lambda x: x.content)\n",
    "    | (lambda x: x.split(\"\\n\"))\n",
    ")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, template='\\nYou are an AI Language model. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspective on the user question, your goal is to help the user overcome some of the limitations of the distance based similarity search. Provide these alternative questions separated by newlines. Just answer the questions nothing else. Original question: {question}'), additional_kwargs={})])\n",
       "| ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "| RunnableLambda(...)\n",
       "| RunnableLambda(...)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['How can I enhance my academic performance?',\n",
       " '',\n",
       " 'What strategies can I use to optimize my learning?',\n",
       " '',\n",
       " 'What are some effective methods for boosting my intellectual capacity?',\n",
       " '',\n",
       " 'How can I develop a personalized approach to learning?',\n",
       " '',\n",
       " 'What techniques can I employ to improve my knowledge retention and recall?']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries.invoke(\"How can I improve my learning?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Program Files\\Python312\\Lib\\importlib\\__init__.py:90: LangChainDeprecationWarning: As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. The langchain_core.pydantic_v1 module was a compatibility shim for pydantic v1, and should no longer be used. Please update the code to import from Pydantic directly.\n",
      "\n",
      "For example, replace imports like: `from langchain_core.pydantic_v1 import BaseModel`\n",
      "with: `from pydantic import BaseModel`\n",
      "or the v1 compatibility namespace if you are working in a code base that has not been fully upgraded to pydantic 2 yet. \tfrom pydantic.v1 import BaseModel\n",
      "\n",
      "  return _bootstrap._gcd_import(name[level:], package, level)\n",
      "C:\\Users\\acer\\AppData\\Roaming\\Python\\Python312\\site-packages\\sentence_transformers\\cross_encoder\\CrossEncoder.py:11: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from tqdm.autonotebook import tqdm, trange\n",
      "C:\\Users\\acer\\AppData\\Roaming\\Python\\Python312\\site-packages\\huggingface_hub\\file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "from langchain_community.embeddings import HuggingFaceBgeEmbeddings\n",
    "\n",
    "# embedding\n",
    "model_name = \"BAAI/bge-small-en\"\n",
    "model_kwargs = {\"device\": \"cpu\"}\n",
    "encode_kwargs = {\"normalize_embeddings\": True}\n",
    "\n",
    "hf_embeddings = HuggingFaceBgeEmbeddings(\n",
    "    model_name=model_name, model_kwargs=model_kwargs, encode_kwargs=encode_kwargs\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HuggingFaceBgeEmbeddings(client=SentenceTransformer(\n",
       "  (0): Transformer({'max_seq_length': 512, 'do_lower_case': True}) with Transformer model: BertModel \n",
       "  (1): Pooling({'word_embedding_dimension': 384, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})\n",
       "  (2): Normalize()\n",
       "), model_name='BAAI/bge-small-en', cache_folder=None, model_kwargs={'device': 'cpu'}, encode_kwargs={'normalize_embeddings': True}, query_instruction='Represent this question for searching relevant passages: ', embed_instruction='', show_progress=False)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "384"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(hf_embeddings.embed_query(\"How can I improve my learning?\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.document_loaders import TextLoader\n",
    "\n",
    "loader = TextLoader(\"./agent.txt\")\n",
    "document = loader.load()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_text_splitters import RecursiveCharacterTextSplitter\n",
    "\n",
    "splitter = RecursiveCharacterTextSplitter(chunk_size=1000)\n",
    "document_split = splitter.split_documents(document)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(metadata={'source': './agent.txt'}, page_content='What are AI Agents?\\nAn artificial intelligence (AI) agent is a software program that can interact with its environment, collect data, and use the data to perform self-determined tasks to meet predetermined goals. Humans set goals, but an AI agent independently chooses the best actions it needs to perform to achieve those goals. For example, consider a contact center AI agent that wants to resolves customer queries. The agent will automatically ask the customer different questions, look up information in internal documents, and respond with a solution. Based on the customer responses, it determines if it can resolve the query itself or pass it on to a human.\\n\\nWhat are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special?'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content=\"What are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special? \\n\\nAI agents are rational agents. They make rational decisions based on their perceptions and data to produce optimal performance and results. An AI agent senses its environment with physical or software interfaces.\\n\\nFor example, a robotic agent collects sensor data, and a chatbot uses customer queries as input. Then, the AI agent applies the data to make an informed decision. It analyzes the collected data to predict the best outcomes that support predetermined goals. The agent also uses the results to formulate the next action that it should take. For example, self-driving cars navigate around obstacles on the road based on data from multiple sensors.\\n\\nWhat are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\"),\n",
       " Document(metadata={'source': './agent.txt'}, page_content=\"What are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\\n\\nImproved productivity\\nAI agents are autonomous intelligent systems performing specific tasks without human intervention. Organizations use AI agents to achieve specific goals and more efficient business outcomes. Business teams are more productive when they delegate repetitive tasks to AI agents. This way, they can divert their attention to mission-critical or creative activities, adding more value to their organization.\\n\\nReduced costs\\nBusinesses can use intelligent agents to reduce unnecessary costs arising from process inefficiencies, human errors, and manual processes. You can confidently perform complex tasks because autonomous agents follow a consistent model that adapts to changing environments.\"),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Informed decision-making\\nAdvanced intelligent agents use machine learning (ML) to gather and process massive amounts of real-time data. This allows business managers to make better predictions at pace when strategizing their next move. For example, you can use AI agents to analyze product demands in different market segments when running an ad campaign. \\n\\nImproved customer experience\\nCustomers seek engaging and personalized experiences when interacting with businesses. Integrating AI agents allows businesses to personalize product recommendations, provide prompt responses, and innovate to improve customer engagement, conversion, and loyalty. \\n\\nWhat are the key components of AI agent architecture?\\nAgents in artificial intelligence may operate in different environments to accomplish unique purposes. However, all functional agents share these components.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Architecture\\nArchitecture is the base the agent operates from. The architecture can be a physical structure, a software program, or a combination. For example, a robotic AI agent consists of actuators, sensors, motors, and robotic arms. Meanwhile, an architecture that hosts an AI software agent may use a text prompt, API, and databases to enable autonomous operations. \\n\\nAgent function\\nThe agent function describes how the data collected is translated into actions that support the agentâ€™s objective. When designing the agent function, developers consider the type of information, AI capabilities, knowledge base, feedback mechanism, and other technologies required.\\n\\nAgent program\\nAn agent program is the implementation of the agent function. It involves developing, training, and deploying the AI agent on the designated architecture. The agent program aligns the agentâ€™s business logic, technical requirements, and performance elements.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='How does an AI agent work?\\nAI agents work by simplifying and automating complex tasks. Most autonomous agents follow a specific workflow when performing assigned tasks.\\n\\nDetermine goals\\nThe AI agent receives a specific instruction or goal from the user. It uses the goal to plan tasks that make the final outcome relevant and useful to the user. Then, the agent breaks down the goal into several smaller actionable tasks. To achieve the goal, the agent performs those tasks based on specific orders or conditions. \\n\\nAcquire information\\nAI agents need information to act on tasks they have planned successfully. For example, the agent must extract conversation logs to analyze customer sentiments. As such, AI agents might access the internet to search for and retrieve the information they need. In some applications, an intelligent agent can interact with other agents or machine learning models to access or exchange information.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Implement tasks\\nWith sufficient data, the AI agent methodically implements the task at hand. Once it accomplishes a task, the agent removes it from the list and proceeds to the next one. In between task completions, the agent evaluates if it has achieved the designated goal by seeking external feedback and inspecting its own logs. During this process, the agent might create and act on more tasks to reach the final outcome. \\n\\nWhat are the challenges of using AI agents?\\nAI agents are helpful software technologies to automate business workflows for better outcomes. That being said, organizations should address the following concerns when deploying autonomous AI agents for business use cases.\\n\\nData privacy concerns\\nDeveloping and operating advanced AI agents requires acquiring, storing, and moving massive volumes of data. Organizations should be aware of data privacy requirements and employ necessary measures to improve data security posture.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Ethical challenges\\nIn certain circumstances, deep learning models may produce unfair, biased, or inaccurate results. Applying safeguards, such as human reviews, ensures customers receive helpful and fair responses from the agents deployed. \\n\\nTechnical complexities \\nImplementing advanced AI agents requires specialized experience and knowledge of machine learning technologies. Developers must be able to integrate machine learning libraries with software applications and train the agent with enterprise-specific data. \\n\\nLimited compute resources\\nTraining and deploying deep learning AI agents requires substantial computing resources. When organizations implement these agents on-premise, they must invest in and maintain costly infrastructure that is not easily scalable.')]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "document_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.vectorstores import FAISS\n",
    "\n",
    "#!pip install faiss-cpu\n",
    "\n",
    "vectorstore = FAISS.from_documents(\n",
    "    documents=document_split,\n",
    "    embedding=hf_embeddings,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VectorStoreRetriever(tags=['FAISS', 'HuggingFaceBgeEmbeddings'], vectorstore=<langchain_community.vectorstores.faiss.FAISS object at 0x0000022F804E87D0>, search_kwargs={})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retriever = vectorstore.as_retriever()\n",
    "retriever"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.load import dumps, loads\n",
    "\n",
    "def get_unique_union(documents: list[list]):\n",
    "    \"\"\"get unique union of retrieved content\"\"\"\n",
    "    flattened_docs = [dumps(doc) for sublist in documents for doc in sublist]\n",
    "    unique_docs = list(set(flattened_docs))\n",
    "    return [loads(doc) for doc in unique_docs]\n",
    "\n",
    "question = \"Ethical consideration in ai\"\n",
    "chain = generate_queries | retriever.map() | get_unique_union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\acer\\AppData\\Local\\Temp\\ipykernel_18188\\910890659.py:7: LangChainBetaWarning: The function `loads` is in beta. It is actively being worked on, so the API may change.\n",
      "  return [loads(doc) for doc in unique_docs]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Document(metadata={'source': './agent.txt'}, page_content='What are AI Agents?\\nAn artificial intelligence (AI) agent is a software program that can interact with its environment, collect data, and use the data to perform self-determined tasks to meet predetermined goals. Humans set goals, but an AI agent independently chooses the best actions it needs to perform to achieve those goals. For example, consider a contact center AI agent that wants to resolves customer queries. The agent will automatically ask the customer different questions, look up information in internal documents, and respond with a solution. Based on the customer responses, it determines if it can resolve the query itself or pass it on to a human.\\n\\nWhat are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special?'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Ethical challenges\\nIn certain circumstances, deep learning models may produce unfair, biased, or inaccurate results. Applying safeguards, such as human reviews, ensures customers receive helpful and fair responses from the agents deployed. \\n\\nTechnical complexities \\nImplementing advanced AI agents requires specialized experience and knowledge of machine learning technologies. Developers must be able to integrate machine learning libraries with software applications and train the agent with enterprise-specific data. \\n\\nLimited compute resources\\nTraining and deploying deep learning AI agents requires substantial computing resources. When organizations implement these agents on-premise, they must invest in and maintain costly infrastructure that is not easily scalable.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Informed decision-making\\nAdvanced intelligent agents use machine learning (ML) to gather and process massive amounts of real-time data. This allows business managers to make better predictions at pace when strategizing their next move. For example, you can use AI agents to analyze product demands in different market segments when running an ad campaign. \\n\\nImproved customer experience\\nCustomers seek engaging and personalized experiences when interacting with businesses. Integrating AI agents allows businesses to personalize product recommendations, provide prompt responses, and innovate to improve customer engagement, conversion, and loyalty. \\n\\nWhat are the key components of AI agent architecture?\\nAgents in artificial intelligence may operate in different environments to accomplish unique purposes. However, all functional agents share these components.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content=\"What are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\\n\\nImproved productivity\\nAI agents are autonomous intelligent systems performing specific tasks without human intervention. Organizations use AI agents to achieve specific goals and more efficient business outcomes. Business teams are more productive when they delegate repetitive tasks to AI agents. This way, they can divert their attention to mission-critical or creative activities, adding more value to their organization.\\n\\nReduced costs\\nBusinesses can use intelligent agents to reduce unnecessary costs arising from process inefficiencies, human errors, and manual processes. You can confidently perform complex tasks because autonomous agents follow a consistent model that adapts to changing environments.\"),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Implement tasks\\nWith sufficient data, the AI agent methodically implements the task at hand. Once it accomplishes a task, the agent removes it from the list and proceeds to the next one. In between task completions, the agent evaluates if it has achieved the designated goal by seeking external feedback and inspecting its own logs. During this process, the agent might create and act on more tasks to reach the final outcome. \\n\\nWhat are the challenges of using AI agents?\\nAI agents are helpful software technologies to automate business workflows for better outcomes. That being said, organizations should address the following concerns when deploying autonomous AI agents for business use cases.\\n\\nData privacy concerns\\nDeveloping and operating advanced AI agents requires acquiring, storing, and moving massive volumes of data. Organizations should be aware of data privacy requirements and employ necessary measures to improve data security posture.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content=\"What are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special? \\n\\nAI agents are rational agents. They make rational decisions based on their perceptions and data to produce optimal performance and results. An AI agent senses its environment with physical or software interfaces.\\n\\nFor example, a robotic agent collects sensor data, and a chatbot uses customer queries as input. Then, the AI agent applies the data to make an informed decision. It analyzes the collected data to predict the best outcomes that support predetermined goals. The agent also uses the results to formulate the next action that it should take. For example, self-driving cars navigate around obstacles on the road based on data from multiple sensors.\\n\\nWhat are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\")]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "docs = chain.invoke(question)\n",
    "docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Bob', 'Charlie']\n"
     ]
    }
   ],
   "source": [
    "from operator import itemgetter\n",
    "\n",
    "data = [\n",
    "    {\"name\": \"Alice\", \"age\": 10},\n",
    "    {\"name\": \"Bob\", \"age\": 12},\n",
    "    {\"name\": \"Charlie\", \"age\": 11},\n",
    "]\n",
    "\n",
    "names = list(map(itemgetter(\"name\"), data))\n",
    "\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ethical considerations in AI agents include:\\n\\n* Unfair, biased, or inaccurate results\\n* Data privacy concerns\\n* Technical complexities (e.g. integrating machine learning libraries with software applications)\\n* Limited compute resources for training and deploying deep learning AI agents\\n* Need for human reviews to ensure customers receive helpful and fair responses from agents\\n* Potential for AI agents to create and act on more tasks without human oversight'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from  operator import itemgetter\n",
    "from langchain_core.runnables import RunnablePassthrough\n",
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "\n",
    "template = \"\"\"Answer the following question: {question}:< context given > Context: {context} <context> just answer the question nothing else\"\"\"\n",
    "\n",
    "prompt = ChatPromptTemplate.from_template(template)\n",
    "final_rag_chain = (\n",
    "    {\"context\": chain, \"question\": itemgetter(\"question\")}\n",
    "    | prompt\n",
    "    | llm\n",
    "    | (lambda x: x.content)\n",
    ")\n",
    "\n",
    "final_rag_chain.invoke({\"question\": question})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RAG Fusion\n",
    "Reciprocal RAG Fusion\n",
    "\n",
    "EXPLANATION:\n",
    "\n",
    "**According to Question1**\n",
    "Order of doc by relevance\n",
    "1. Doc1\n",
    "2. Doc2\n",
    "3. Doc3\n",
    "4. Doc4\n",
    "\n",
    "**According to Q2**\n",
    "1. Doc3\n",
    "2. Doc1\n",
    "3. Doc2\n",
    "4. Doc4\n",
    "\n",
    "**According to Q3**\n",
    "1. Doc4\n",
    "2. Doc1\n",
    "3. Doc3\n",
    "4. Doc2\n",
    "\n",
    "Rank Positions\n",
    "\n",
    "- Doc1:\n",
    " -- Question 1 rank: 1\n",
    " -- Question 2 rank: 2\n",
    " -- Question 3 rank: 2\n",
    "- Doc2:\n",
    " -- Question 1 rank: 2\n",
    " -- Question 2 rank: 3\n",
    " -- Question 3 rank: 4\n",
    "- Doc3:\n",
    " -- Question 1 rank: 3\n",
    " -- Question 2 rank: 1\n",
    " -- Question 3 rank: 3\n",
    "- Doc4:\n",
    " -- Question 1 rank: 4\n",
    " -- Question 2 rank: 4\n",
    " -- Question 3 rank: 1\n",
    "\n",
    "Reciprocal RAG Fusion\n",
    "\n",
    "using k = 80 (arbitrary value)\n",
    "\n",
    "RRF(Docn): sum[from i=1 to p where p = num of question](1 / (k + n))\n",
    "\n",
    "##### Doc1\n",
    "- Reciprocal Rank (Question1): 1 / (80 + 1) = 1 / 81\n",
    "- Reciprocal Rank (Question2): 1 / (80 + 2) = 1 / 82\n",
    "- Reciprocal Rank (Question3): 1 / (80 + 3) = 1 / 83\n",
    "- RRF(Doc1): 1 / 81 + 1 / 82 + 1 / 83\n",
    "\n",
    "Based on RRF score rank the document."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.load import dumps, loads\n",
    "\n",
    "def reciprocal_rank_fusion(results: list[list], k=80):\n",
    "    \"\"\"Reciprocal rank fusion that takes multiple lists of ranked documents and parameter k to return a single list of ranked documents\"\"\"\n",
    "    fused_scores = {}\n",
    "    \n",
    "    # iterate over each list of ranked document\n",
    "    for docs in results:\n",
    "        # iterate\n",
    "        for rank, doc in enumerate(docs):\n",
    "            # document to a string format to use as a key ( to json )\n",
    "            doc_str = dumps(doc)\n",
    "            # if the document is not in the fused scores, add it with score 0\n",
    "            if doc_str not in fused_scores:\n",
    "                fused_scores[doc_str] = 0\n",
    "                \n",
    "            # retrieve the current score of the document\n",
    "            previous_score = fused_scores[doc_str]\n",
    "            # updat the score\n",
    "            fused_scores[doc_str] = previous_score + 1 / (rank + k)\n",
    "            \n",
    "    # sort the fused scores by the score in desscending order to get the final ranked list\n",
    "    reranked_results = [\n",
    "        (loads(doc), score) for doc, score in sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)\n",
    "    ]\n",
    "    # return the final result\n",
    "    return reranked_results\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, template='\\nYou are an AI Language model. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspective on the user question, your goal is to help the user overcome some of the limitations of the distance based similarity search. Provide these alternative questions separated by newlines. Just answer the questions nothing else. Original question: {question}'), additional_kwargs={})])\n",
       "| ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "| RunnableLambda(...)\n",
       "| RunnableLambda(...)\n",
       "| RunnableEach(bound=VectorStoreRetriever(tags=['FAISS', 'HuggingFaceBgeEmbeddings'], vectorstore=<langchain_community.vectorstores.faiss.FAISS object at 0x0000022F804E87D0>, search_kwargs={}))\n",
       "| RunnableLambda(lambda x: x[1])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieval_chain_rag_fusion = generate_queries | retriever.map() | reciprocal_rank_fusion\n",
    "\n",
    "retrieval_chain_rag_fusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(Document(metadata={'source': './agent.txt'}, page_content='Ethical challenges\\nIn certain circumstances, deep learning models may produce unfair, biased, or inaccurate results. Applying safeguards, such as human reviews, ensures customers receive helpful and fair responses from the agents deployed. \\n\\nTechnical complexities \\nImplementing advanced AI agents requires specialized experience and knowledge of machine learning technologies. Developers must be able to integrate machine learning libraries with software applications and train the agent with enterprise-specific data. \\n\\nLimited compute resources\\nTraining and deploying deep learning AI agents requires substantial computing resources. When organizations implement these agents on-premise, they must invest in and maintain costly infrastructure that is not easily scalable.'),\n",
       "  0.0875),\n",
       " (Document(metadata={'source': './agent.txt'}, page_content='Implement tasks\\nWith sufficient data, the AI agent methodically implements the task at hand. Once it accomplishes a task, the agent removes it from the list and proceeds to the next one. In between task completions, the agent evaluates if it has achieved the designated goal by seeking external feedback and inspecting its own logs. During this process, the agent might create and act on more tasks to reach the final outcome. \\n\\nWhat are the challenges of using AI agents?\\nAI agents are helpful software technologies to automate business workflows for better outcomes. That being said, organizations should address the following concerns when deploying autonomous AI agents for business use cases.\\n\\nData privacy concerns\\nDeveloping and operating advanced AI agents requires acquiring, storing, and moving massive volumes of data. Organizations should be aware of data privacy requirements and employ necessary measures to improve data security posture.'),\n",
       "  0.08596808190304124),\n",
       " (Document(metadata={'source': './agent.txt'}, page_content=\"What are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special? \\n\\nAI agents are rational agents. They make rational decisions based on their perceptions and data to produce optimal performance and results. An AI agent senses its environment with physical or software interfaces.\\n\\nFor example, a robotic agent collects sensor data, and a chatbot uses customer queries as input. Then, the AI agent applies the data to make an informed decision. It analyzes the collected data to predict the best outcomes that support predetermined goals. The agent also uses the results to formulate the next action that it should take. For example, self-driving cars navigate around obstacles on the road based on data from multiple sensors.\\n\\nWhat are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\"),\n",
       "  0.07258664286776736),\n",
       " (Document(metadata={'source': './agent.txt'}, page_content='Informed decision-making\\nAdvanced intelligent agents use machine learning (ML) to gather and process massive amounts of real-time data. This allows business managers to make better predictions at pace when strategizing their next move. For example, you can use AI agents to analyze product demands in different market segments when running an ad campaign. \\n\\nImproved customer experience\\nCustomers seek engaging and personalized experiences when interacting with businesses. Integrating AI agents allows businesses to personalize product recommendations, provide prompt responses, and innovate to improve customer engagement, conversion, and loyalty. \\n\\nWhat are the key components of AI agent architecture?\\nAgents in artificial intelligence may operate in different environments to accomplish unique purposes. However, all functional agents share these components.'),\n",
       "  0.060979237637088554),\n",
       " (Document(metadata={'source': './agent.txt'}, page_content=\"What are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\\n\\nImproved productivity\\nAI agents are autonomous intelligent systems performing specific tasks without human intervention. Organizations use AI agents to achieve specific goals and more efficient business outcomes. Business teams are more productive when they delegate repetitive tasks to AI agents. This way, they can divert their attention to mission-critical or creative activities, adding more value to their organization.\\n\\nReduced costs\\nBusinesses can use intelligent agents to reduce unnecessary costs arising from process inefficiencies, human errors, and manual processes. You can confidently perform complex tasks because autonomous agents follow a consistent model that adapts to changing environments.\"),\n",
       "  0.03658899373464953)]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "docs = retrieval_chain_rag_fusion.invoke({\"question\": question})\n",
    "docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ethical considerations in AI given context:\\n\\n* In certain circumstances, deep learning models may produce unfair, biased, or inaccurate results. Applying safeguards, such as human reviews, ensures customers receive helpful and fair responses from the agents deployed.\\n* Data privacy concerns: Developing and operating advanced AI agents requires acquiring, storing, and moving massive volumes of data. Organizations should be aware of data privacy requirements and employ necessary measures to improve data security posture.'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from langchain_core.runnables import RunnablePassthrough\n",
    "\n",
    "template = '''answer the following question: {question} given context: {context} only answer the question nothing else.'''\n",
    "\n",
    "prompt = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "final_rag_chain = (\n",
    "    {\"context\": retrieval_chain_rag_fusion,\n",
    "     \"question\": itemgetter(\"question\")}\n",
    "    | prompt\n",
    "    | llm\n",
    "    | (lambda x: x.content)\n",
    ")\n",
    "\n",
    "final_rag_chain.invoke({\"question\": question})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decomposition\n",
    "make step by step question and answer the question."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.prompts import ChatPromptTemplate\n",
    "\n",
    "template = \"\"\"\n",
    "You are a assistant that generates multiple sub-questions related to an input question. The goal is to break down the input into a set of sub-problems that can be solved independently. Generate three search queries related to: {question}. Response: just response the queries only \"\"\"\n",
    "\n",
    "prompt_decomposition = ChatPromptTemplate.from_template(template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, template='\\nYou are a assistant that generates multiple sub-questions related to an input question. The goal is to break down the input into a set of sub-problems that can be solved independently. Generate three search queries related to: {question}. Response: just response the queries only '), additional_kwargs={})])\n",
       "| ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "| RunnableLambda(...)\n",
       "| RunnableLambda(...)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries_decomposition = (\n",
    "    prompt_decomposition\n",
    "    | llm\n",
    "    | (lambda x: x.content)\n",
    "    | (lambda x: x.split(\"\\n\"))\n",
    ")\n",
    "generate_queries_decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "question = \"What is llm agent in ai\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Here are three sub-questions:',\n",
       " '',\n",
       " '1. What is Large Language Model (LLM) in AI?',\n",
       " '2. How does an LLM Agent interact with its environment in AI?',\n",
       " '3. What are the applications of LLM Agents in Artificial Intelligence?']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries_decomposition.invoke(question)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Here are three search queries related to \"How can I improve my learning?\":',\n",
       " '',\n",
       " '1. What are the most effective learning strategies for retaining information?',\n",
       " '2. How can I optimize my study routine for better comprehension and retention?',\n",
       " '3. What are some popular learning tools and resources that can help improve my understanding of complex topics?']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries_decomposition.invoke(\"How can I improve my learning?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "template = \"\"\"\n",
    "Here is the question you need to answer\n",
    "\\n---\\n {question}\\n---\\n\n",
    "Here is available background question and answer pairs:\n",
    "\\n---\\n {qa}\\n---\\n\n",
    "Here is other context relevant to the question:\n",
    "\\n---\\n {context}\\n---\\n\n",
    "Use the above context and any background question and answer pair to answer the question {question}\"\"\"\n",
    "\n",
    "decomposition_prompt = ChatPromptTemplate.from_template(template)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['context', 'qa', 'question'], input_types={}, partial_variables={}, template='\\nHere is the question you need to answer\\n\\n---\\n {question}\\n---\\n\\nHere is available background question and answer pairs:\\n\\n---\\n {qa}\\n---\\n\\nHere is other context relevant to the question:\\n\\n---\\n {context}\\n---\\n\\nUse the above context and any background question and answer pair to answer the question {question}'), additional_kwargs={})]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decomposition_prompt.messages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import itemgetter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_qa_pairs(questions, answers):\n",
    "    formatted_string = \"\"\n",
    "    for i, (question, answer) in enumerate(zip(questions, answers), start=1):\n",
    "        formatted_string += f\"Question{i}: {question}\\nAnswer {i}: {answer}\\n\"\n",
    "    # return the string\n",
    "    return formatted_string.strip()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain_core.output_parsers import StrOutputParser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_a_pairs = \"\"\n",
    "question = \"What is an ai agent?\"\n",
    "\n",
    "questions = generate_queries_decomposition.invoke(question)\n",
    "\n",
    "for q in questions:\n",
    "    c = (\n",
    "        {\"context\": itemgetter(\"question\") | retriever,\n",
    "         \"question\": itemgetter(\"question\"),\n",
    "         \"qa\": itemgetter(\"qa\")}\n",
    "        | decomposition_prompt\n",
    "        | llm\n",
    "        | StrOutputParser()\n",
    "    )\n",
    "    answer = c.invoke({\"question\": q, \"qa\": q_a_pairs})\n",
    "    q_a_pair = format_qa_pairs(q, answer)\n",
    "    q_a_pairs += \"\\n\\n\" + q_a_pair"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Based on the provided context and background question and answer pairs, the characteristics and features of AI agents are:\\n\\n1. **Rational Agents**: AI agents make rational decisions based on their perceptions and data to produce optimal performance and results.\\n2. **Autonomous**: AI agents operate independently, making decisions and taking actions without human intervention.\\n3. **Informed Decision-Making**: AI agents use machine learning to gather and process massive amounts of real-time data, allowing for better predictions and informed decision-making.\\n4. **Improved Customer Experience**: AI agents can personalize product recommendations, provide prompt responses, and innovate to improve customer engagement, conversion, and loyalty.\\n5. **Implement Tasks**: AI agents methodically implement tasks at hand, removing them from the list and proceeding to the next one, and evaluating if they have achieved the designated goal.\\n6. **Data-Driven**: AI agents collect data from their environment and use it to make decisions and take actions.\\n7. **Goal-Oriented**: AI agents are designed to achieve specific goals, and they independently choose the best actions to perform to achieve those goals.\\n8. **Self-Determined**: AI agents can determine their own actions and tasks, without human intervention.\\n9. **Machine Learning**: AI agents use machine learning to analyze data, learn from it, and improve their performance over time.\\n10. **Improved Data Security Posture**: Organizations should employ necessary measures to improve data security posture when developing and operating advanced AI agents.\\n\\nThese characteristics and features of AI agents enable them to perform tasks autonomously, make informed decisions, and provide improved customer experiences, while also addressing the challenges of using AI agents, such as data privacy concerns.'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# answer individually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain import hub\n",
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from langchain_core.runnables import RunnablePassthrough, RunnableLambda\n",
    "from langchain_core.output_parsers import StrOutputParser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "promt_rag = hub.pull(\"rlm/rag-prompt\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def retrieve_and_rag(question, prompt_rag, sub_question_generator_chain):\n",
    "    \"\"\"Retrieve and RAG\"\"\"\n",
    "    sub_questions = sub_question_generator_chain.invoke(question)\n",
    "    rag_results = []\n",
    "    for q in sub_questions:\n",
    "        retreived_doc = retriever.get_relevant_documents(q)\n",
    "        answer = (prompt_rag | llm | StrOutputParser()).invoke({\"question\": q, \"context\": retreived_doc})\n",
    "        \n",
    "        rag_results.append(answer)\n",
    "    return rag_results, sub_questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\acer\\AppData\\Local\\Temp\\ipykernel_18188\\2762158091.py:6: 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",
      "  retreived_doc = retriever.get_relevant_documents(q)\n"
     ]
    }
   ],
   "source": [
    "answers, questions = retrieve_and_rag(question, promt_rag, generate_queries_decomposition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_qa_pairs(questions, answers):\n",
    "    formatted_string = \"\"\n",
    "    for i, (question, answer) in enumerate(zip(questions, answers), start=1):\n",
    "        formatted_string += f\"Question {i}: {question}\\n\\n Answer: {answer}\\n\\n\"\n",
    "    return formatted_string.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "context = format_qa_pairs(questions, answers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Question 1: Here are three search queries related to \"What is an AI Agent?\":\\n\\n Answer: An AI agent is a software program that interacts with its environment, collects data, and uses the data to perform self-determined tasks to meet predetermined goals. It makes rational decisions based on its perceptions and data to produce optimal performance and results.\\n\\nQuestion 2: \\n\\n Answer: The key components of AI agent architecture are not specified in the provided context.\\n\\nQuestion 3: 1. What are the characteristics of an AI agent?\\n\\n Answer: AI agents have the following characteristics: they are rational, making decisions based on data and perceptions to produce optimal performance and results, and they are able to sense their environment through physical or software interfaces. They collect data, analyze it to predict the best outcomes, and use the results to formulate their next actions.\\n\\nQuestion 4: 2. What are the types of AI agents (e.g. narrow, general, super)?\\n\\n Answer: There are three main types of AI agents: narrow, general, and super. Narrow AI agents are designed to perform a specific task, general AI agents can perform any intellectual task that a human can, and super AI agents have capabilities that exceed human intelligence.\\n\\nQuestion 5: 3. How does an AI agent interact with its environment?\\n\\n Answer: An AI agent interacts with its environment by acquiring information, determining goals, and implementing tasks. It uses physical or software interfaces to sense its environment, collects data, and applies it to make informed decisions. This enables the agent to perform self-determined tasks to meet predetermined goals.'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "template = \"\"\"\n",
    "Here is a set of qa pairs: {context}\n",
    "Use these to synthesize an answer to the question: {question}\n",
    "\"\"\"\n",
    "\n",
    "prompt = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "rag = (\n",
    "    prompt | llm | StrOutputParser()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['context', 'question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['context', 'question'], input_types={}, partial_variables={}, template='\\nHere is a set of qa pairs: {context}\\nUse these to synthesize an answer to the question: {question}\\n'), additional_kwargs={})])\n",
       "| ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "| StrOutputParser()"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Based on the provided QA pairs, here\\'s a synthesized answer to the question \"What is an AI Agent?\":\\n\\nAn AI agent is a software program that interacts with its environment to collect data, analyze it, and make rational decisions to achieve predetermined goals. It has the following characteristics: it is rational, senses its environment through physical or software interfaces, collects data, analyzes it to predict the best outcomes, and uses the results to formulate its next actions. There are three main types of AI agents: narrow, general, and super, each with different capabilities. An AI agent interacts with its environment by acquiring information, determining goals, and implementing tasks, using physical or software interfaces to sense its environment, collect data, and apply it to make informed decisions.'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rag.invoke({\"question\": question, \"context\": context})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decomposition: Answer recursively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "HuggingFaceBgeEmbeddings(client=SentenceTransformer(\n",
       "  (0): Transformer({'max_seq_length': 512, 'do_lower_case': True}) with Transformer model: BertModel \n",
       "  (1): Pooling({'word_embedding_dimension': 384, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})\n",
       "  (2): Normalize()\n",
       "), model_name='BAAI/bge-small-en', cache_folder=None, model_kwargs={'device': 'cpu'}, encode_kwargs={'normalize_embeddings': True}, query_instruction='Represent this question for searching relevant passages: ', embed_instruction='', show_progress=False)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hf_embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "questions = questions[2:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1. What are the characteristics of an AI agent?',\n",
       " '2. What are the types of AI agents (e.g. narrow, general, super)?',\n",
       " '3. How does an AI agent interact with its environment?']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "questions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# prompt\n",
    "template = \"\"\"\n",
    "Here is the question you need to answer:\n",
    "\\n----\\n {question}\\n --- \\n\n",
    "Here is any available background question and answer pairs:\n",
    "\\n --- \\n {q_a_pairs} \\n --- \\n\n",
    "Here is additional context relevant to the question:\n",
    "\\n -{context}- \\n\n",
    "Use the above context and any background question and answer pairs to answer : {question}\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['context', 'q_a_pairs', 'question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['context', 'q_a_pairs', 'question'], input_types={}, partial_variables={}, template='\\nHere is the question you need to answer:\\n\\n----\\n {question}\\n --- \\n\\nHere is any available background question and answer pairs:\\n\\n --- \\n {q_a_pairs} \\n --- \\n\\nHere is additional context relevant to the question:\\n\\n -{context}- \\n\\nUse the above context and any background question and answer pairs to answer : {question}\\n'), additional_kwargs={})])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decomposition_prompt_recursively = ChatPromptTemplate.from_template(template)\n",
    "decomposition_prompt_recursively"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from operator import itemgetter\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "\n",
    "def format_qa_pair(question, answer):\n",
    "    formatted_string = \"\"\n",
    "    formatted_string += f\"Question: {question}\\n Answer: {answer}\\n\"\n",
    "    return formatted_string.strip()\n",
    "\n",
    "q_a_pairs = \"\"\n",
    "for q in questions:\n",
    "    rag_chain = (\n",
    "        {\"context\": itemgetter(\"question\") | retriever, \"question\": itemgetter(\"question\"), \"q_a_pairs\": itemgetter(\"q_a_pairs\")}\n",
    "        | decomposition_prompt_recursively\n",
    "        | llm\n",
    "        | StrOutputParser()\n",
    "    )\n",
    "    \n",
    "    answer = rag_chain.invoke({\"question\": q, \"q_a_pairs\": q_a_pairs})\n",
    "    q_a_pair = format_qa_pair(q, answer)\n",
    "    q_a_pairs = q_a_pairs + \"\\n-------------------------\\n\" + q_a_pair \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "-------------------------\n",
      "Question: 1. What are the characteristics of an AI agent?\n",
      " Answer: Based on the provided context and background information, the characteristics of an AI agent are:\n",
      "\n",
      "1. **Rational**: AI agents make rational decisions based on their perceptions and data to produce optimal performance and results.\n",
      "2. **Autonomous**: AI agents can independently choose the best actions to perform to achieve predetermined goals, without human intervention.\n",
      "3. **Goal-oriented**: AI agents have specific goals set by humans, and they use data to plan and perform tasks to achieve those goals.\n",
      "4. **Perception**: AI agents sense their environment through physical or software interfaces, collecting data to make informed decisions.\n",
      "5. **Data-driven**: AI agents analyze the collected data to predict the best outcomes that support predetermined goals and formulate the next action.\n",
      "6. **Self-determined**: AI agents can determine the best course of action to achieve their goals, without human intervention.\n",
      "7. **Adaptive**: AI agents can learn from their experiences and adapt to new situations and data.\n",
      "\n",
      "These characteristics define the key principles that make AI agents special and enable them to perform tasks independently and efficiently.\n",
      "-------------------------\n",
      "Question: 2. What are the types of AI agents (e.g. narrow, general, super)?\n",
      " Answer: Based on the provided context and background information, there are three types of AI agents:\n",
      "\n",
      "1. **Narrow AI agents**: Also known as weak AI, narrow AI agents are designed to perform a specific task or set of tasks. They are trained on a specific dataset and are not capable of general intelligence. Examples of narrow AI agents include virtual assistants like Siri or Alexa, which can perform tasks such as setting reminders or making phone calls.\n",
      "2. **General AI agents**: Also known as strong AI, general AI agents are designed to perform any intellectual task that a human can. They are capable of general intelligence and can learn, reason, and apply knowledge to solve complex problems. General AI agents are still in the realm of science fiction and do not yet exist.\n",
      "3. **Super AI agents**: Super AI agents are hypothetical AI agents that possess intelligence surpassing that of the best human minds. They are capable of solving complex problems and making decisions that are beyond human capabilities. Super AI agents, if they ever exist, would have the potential to revolutionize many aspects of society.\n",
      "\n",
      "These three types of AI agents are based on the level of intelligence and capabilities they possess, with narrow AI agents being the most common and general AI agents being the least common.\n",
      "-------------------------\n",
      "Question: 3. How does an AI agent interact with its environment?\n",
      " Answer: Based on the provided context and background information, an AI agent interacts with its environment in the following ways:\n",
      "\n",
      "1. **Determine goals**: AI agents receive specific instructions or goals from users and use them to plan tasks that make the final outcome relevant and useful to the user.\n",
      "2. **Acquire information**: AI agents need information to act on tasks they have planned successfully. They might access the internet to search for and retrieve the necessary information or interact with other agents or machine learning models to access or exchange information.\n",
      "3. **Implement tasks**: With sufficient data, AI agents methodically implement the planned tasks, removing them from the list once they are completed and proceeding to the next one. They evaluate their progress by seeking external feedback and inspecting their own logs.\n",
      "4. **Perception**: AI agents sense their environment with physical or software interfaces, collecting data to make informed decisions. For example, a robotic agent collects sensor data, and a chatbot uses customer queries as input.\n",
      "\n",
      "In summary, an AI agent interacts with its environment by determining goals, acquiring necessary information, implementing tasks, and perceiving its environment to make informed decisions.\n"
     ]
    }
   ],
   "source": [
    "print(q_a_pairs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Step back\n",
    "in decomposition we are generalizing the question but here we are step back question to understand it more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sentence_transformers import SentenceTransformer\n",
    "load_dotenv()\n",
    "\n",
    "embedding_path = os.environ.get(\"EMBEDDING_PATH\")\n",
    "\n",
    "model = SentenceTransformer(embedding_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SentenceTransformer(\n",
       "  (0): Transformer({'max_seq_length': 256, 'do_lower_case': False}) with Transformer model: BertModel \n",
       "  (1): Pooling({'word_embedding_dimension': 384, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False, 'include_prompt': True})\n",
       "  (2): Normalize()\n",
       ")"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    " # few shot example for step back technique\n",
    " from langchain_core.prompts import ChatPromptTemplate, FewShotChatMessagePromptTemplate\n",
    " \n",
    " examples = [\n",
    "     {\n",
    "         \"input\": \"Could the members of the Police perform lawful arrests?\",\n",
    "         \"output\": \"What can the members of the police do?\"\n",
    "     },\n",
    "     {\n",
    "         \"input\": \"John Doe was born in what country?\",\n",
    "         \"output\": \"What is John Doe's history?\"\n",
    "     }\n",
    " ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "FewShotChatMessagePromptTemplate(examples=[{'input': 'Could the members of the Police perform lawful arrests?', 'output': 'What can the members of the police do?'}, {'input': 'John Doe was born in what country?', 'output': \"What is John Doe's history?\"}], input_variables=[], input_types={}, partial_variables={}, example_prompt=ChatPromptTemplate(input_variables=['input', 'output'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['input'], input_types={}, partial_variables={}, template='{input}'), additional_kwargs={}), AIMessagePromptTemplate(prompt=PromptTemplate(input_variables=['output'], input_types={}, partial_variables={}, template='{output}'), additional_kwargs={})]))"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_prompt = ChatPromptTemplate.from_messages([\n",
    "    (\"human\",\"{input}\"),\n",
    "    (\"ai\",\"{output}\")\n",
    "])\n",
    "few_shot_prompt = FewShotChatMessagePromptTemplate(\n",
    "    example_prompt=example_prompt,\n",
    "    examples=examples\n",
    ")\n",
    "few_shot_prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "langchain_core.prompts.few_shot.FewShotChatMessagePromptTemplate"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(few_shot_prompt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, messages=[SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], input_types={}, partial_variables={}, template='You are an expert at world knowledge. Your task is to step back and paraphrase the question to give more generic step back question, which is easier to answer. Here are a few examples: '), additional_kwargs={}), FewShotChatMessagePromptTemplate(examples=[{'input': 'Could the members of the Police perform lawful arrests?', 'output': 'What can the members of the police do?'}, {'input': 'John Doe was born in what country?', 'output': \"What is John Doe's history?\"}], input_variables=[], input_types={}, partial_variables={}, example_prompt=ChatPromptTemplate(input_variables=['input', 'output'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['input'], input_types={}, partial_variables={}, template='{input}'), additional_kwargs={}), AIMessagePromptTemplate(prompt=PromptTemplate(input_variables=['output'], input_types={}, partial_variables={}, template='{output}'), additional_kwargs={})])), HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, template='{question}'), additional_kwargs={})])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_prompt = ChatPromptTemplate.from_messages(\n",
    "    [\n",
    "        (\"system\", \"\"\"You are an expert at world knowledge. Your task is to step back and paraphrase the question to give more generic step back question, which is easier to answer. Here are a few examples: \"\"\"),\n",
    "        few_shot_prompt,\n",
    "        (\"user\",\"{question}\")\n",
    "    ]\n",
    ")\n",
    "final_prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Have large language models been used in a specific social media platform?'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "generate_queries_step_back = final_prompt | llm | StrOutputParser()\n",
    "question = \"has llm used in twitter?\"\n",
    "generate_queries_step_back.invoke(question)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "response_prompt_template = \"\"\"\n",
    "You are an expert of world knowledge. I am going to ask you a question. Your response should be comprehensive and not contradicted with the following context if they are relevant.\n",
    "Otherwise, ignore them if they are not relevant to you.\n",
    "\n",
    "# {normal_context}\n",
    "# {step_back_context}\n",
    "# Original Question: {question}\n",
    "# Answer:\n",
    "\"\"\"\n",
    "\n",
    "response_prompt = ChatPromptTemplate.from_template(response_prompt_template)\n",
    "\n",
    "chain = (\n",
    "    {\n",
    "        # retrieve \n",
    "        \"normal_context\": RunnableLambda(lambda x: x[\"question\"]) | retriever,\n",
    "        # retrieve using step back question\n",
    "        \"step_back_context\": generate_queries_step_back | retriever,\n",
    "        \"question\": lambda x: x[\"question\"]\n",
    "    }\n",
    "    | response_prompt\n",
    "    | llm\n",
    "    | StrOutputParser()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\n",
       "  normal_context: RunnableLambda(...)\n",
       "                  | VectorStoreRetriever(tags=['FAISS', 'HuggingFaceBgeEmbeddings'], vectorstore=<langchain_community.vectorstores.faiss.FAISS object at 0x0000022F804E87D0>, search_kwargs={}),\n",
       "  step_back_context: ChatPromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, messages=[SystemMessagePromptTemplate(prompt=PromptTemplate(input_variables=[], input_types={}, partial_variables={}, template='You are an expert at world knowledge. Your task is to step back and paraphrase the question to give more generic step back question, which is easier to answer. Here are a few examples: '), additional_kwargs={}), FewShotChatMessagePromptTemplate(examples=[{'input': 'Could the members of the Police perform lawful arrests?', 'output': 'What can the members of the police do?'}, {'input': 'John Doe was born in what country?', 'output': \"What is John Doe's history?\"}], input_variables=[], input_types={}, partial_variables={}, example_prompt=ChatPromptTemplate(input_variables=['input', 'output'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['input'], input_types={}, partial_variables={}, template='{input}'), additional_kwargs={}), AIMessagePromptTemplate(prompt=PromptTemplate(input_variables=['output'], input_types={}, partial_variables={}, template='{output}'), additional_kwargs={})])), HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['question'], input_types={}, partial_variables={}, template='{question}'), additional_kwargs={})])\n",
       "                     | ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "                     | StrOutputParser()\n",
       "                     | VectorStoreRetriever(tags=['FAISS', 'HuggingFaceBgeEmbeddings'], vectorstore=<langchain_community.vectorstores.faiss.FAISS object at 0x0000022F804E87D0>, search_kwargs={}),\n",
       "  question: RunnableLambda(...)\n",
       "}\n",
       "| ChatPromptTemplate(input_variables=['normal_context', 'question', 'step_back_context'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['normal_context', 'question', 'step_back_context'], input_types={}, partial_variables={}, template='\\nYou are an expert of world knowledge. I am going to ask you a question. Your response should be comprehensive and not contradicted with the following context if they are relevant.\\nOtherwise, ignore them if they are not relevant to you.\\n\\n# {normal_context}\\n# {step_back_context}\\n# Original Question: {question}\\n# Answer:\\n'), additional_kwargs={})])\n",
       "| ChatGroq(client=<groq.resources.chat.completions.Completions object at 0x0000022FBEFA3800>, async_client=<groq.resources.chat.completions.AsyncCompletions object at 0x0000022FBEFC0290>, model_name='llama3-8b-8192', model_kwargs={}, groq_api_key=SecretStr('**********'))\n",
       "| StrOutputParser()"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "chain"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I'm happy to help! Based on the provided context, an AI Agent is a software program that can interact with its environment, collect data, and use the data to perform self-determined tasks to meet predetermined goals. It's a type of artificial intelligence (AI) that can make rational decisions based on its perceptions and data to produce optimal performance and results.\n",
      "\n",
      "In the context of Large Language Models (LLMs), an agent refers to a software program that can interact with the model to generate text, answer questions, or perform other tasks. In this sense, the agent acts as an intermediary between the user and the LLM, allowing the user to input queries or requests and receive responses or output.\n",
      "\n",
      "The key principles that define AI agents are:\n",
      "\n",
      "1. Autonomy: AI agents can operate independently, making decisions and taking actions on their own.\n",
      "2. Rationality: AI agents make rational decisions based on their perceptions and data to produce optimal performance and results.\n",
      "3. Sensing: AI agents sense their environment with physical or software interfaces, collecting data to inform their decisions.\n",
      "4. Acting: AI agents take actions based on the data they collect, using the results to formulate the next action.\n",
      "\n",
      "The benefits of using AI agents in LLMs include:\n",
      "\n",
      "1. Improved decision-making: AI agents can analyze large amounts of data and make informed decisions at pace.\n",
      "2. Personalized interactions: AI agents can interact with users in a personalized and engaging way, providing tailored responses and recommendations.\n",
      "3. Automation: AI agents can automate repetitive tasks, freeing up human resources for more strategic and creative work.\n",
      "\n",
      "However, there are also challenges to consider when using AI agents in LLMs, including:\n",
      "\n",
      "1. Data privacy concerns: AI agents require access to large amounts of data, which raises concerns about data privacy and security.\n",
      "2. Knowledge limitations: AI agents are only as good as the data they are trained on, and may not have the same level of knowledge or understanding as humans.\n",
      "\n",
      "Overall, AI agents in LLMs have the potential to revolutionize the way we interact with language models, providing more personalized, efficient, and effective interactions.\n"
     ]
    }
   ],
   "source": [
    "print(chain.invoke({\"question\": \"what is agent in llm\"}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HyDE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is a scientific paper passage that answers the question \"How agents work in LLM AI?\":\n",
      "\n",
      "**Title:** Understanding the Mechanisms of Agents in Large Language Models (LLMs)\n",
      "\n",
      "**Abstract:** Large Language Models (LLMs) have revolutionized the field of natural language processing by enabling efficient and effective processing of vast amounts of linguistic data. A key component of LLMs is the agent-based architecture, which allows for the modeling of complex language phenomena through the interaction of multiple agents. In this passage, we delve into the mechanisms of agents in LLMs, exploring their role in language understanding and generation.\n",
      "\n",
      "**Introduction:** LLMs are constructed by training neural networks on vast amounts of text data, which enables them to learn complex patterns and relationships between words, phrases, and sentences. At the heart of these models are agents, which are autonomous entities that interact with each other to generate language outputs. Each agent represents a specific aspect of language, such as syntax, semantics, or pragmatics, and is responsible for contributing to the overall language understanding and generation process.\n",
      "\n",
      "**Mechanisms of Agents:** In LLMs, agents operate through a process of message passing, where each agent communicates with other agents to share information and coordinate their actions. This process is facilitated by a complex network of connections between agents, which is learned during the training process. Each agent receives input from other agents, which it uses to update its internal state and generate output. This output is then passed to other agents, creating a cascade of information exchange that enables the LLM to generate coherent and meaningful language outputs.\n",
      "\n",
      "**Role of Agents in Language Understanding:** During language understanding, agents play a crucial role in identifying and interpreting the meaning of words, phrases, and sentences. For example, the syntax agent may analyze the grammatical structure of a sentence, while the semantics agent may identify the meaning of specific words and phrases. The pragmatics agent may then use this information to determine the context and intended meaning of the language input.\n",
      "\n",
      "**Role of Agents in Language Generation:** In language generation, agents collaborate to produce coherent and meaningful language outputs. The syntax agent may use the grammatical structure of a sentence to generate a sentence skeleton, while the semantics agent may fill in the meaning of specific words and phrases. The pragmatics agent may then use this information to determine the most appropriate language output, taking into account the context and intended meaning of the input.\n",
      "\n",
      "**Conclusion:** In conclusion, agents play a vital role in LLMs, enabling the efficient and effective processing of language data. Through the process of message passing, agents interact and collaborate to generate language outputs that reflect the complex patterns and relationships between words, phrases, and sentences. Understanding the mechanisms of agents in LLMs is crucial for developing more sophisticated and accurate language processing systems, and this passage has provided a foundation for further exploration and research in this area.\n"
     ]
    }
   ],
   "source": [
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "\n",
    "template = \"\"\"\n",
    "please write a scientific paper passage to answer the question.\n",
    "\n",
    "Question: {question}\n",
    "passage: \n",
    "\"\"\"\n",
    "\n",
    "prompt_hyde = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "generate_docs_for_retrieval = (\n",
    "    prompt_hyde | llm | (lambda x: x.content)\n",
    ")\n",
    "\n",
    "response = generate_docs_for_retrieval.invoke({\"question\": \"how agent work in llm ai?\"})\n",
    "\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "retrieval_chain = generate_docs_for_retrieval | retriever\n",
    "retrieved_doc = retrieval_chain.invoke({\"question\": \"how agent work in llm ai?\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(metadata={'source': './agent.txt'}, page_content='Informed decision-making\\nAdvanced intelligent agents use machine learning (ML) to gather and process massive amounts of real-time data. This allows business managers to make better predictions at pace when strategizing their next move. For example, you can use AI agents to analyze product demands in different market segments when running an ad campaign. \\n\\nImproved customer experience\\nCustomers seek engaging and personalized experiences when interacting with businesses. Integrating AI agents allows businesses to personalize product recommendations, provide prompt responses, and innovate to improve customer engagement, conversion, and loyalty. \\n\\nWhat are the key components of AI agent architecture?\\nAgents in artificial intelligence may operate in different environments to accomplish unique purposes. However, all functional agents share these components.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='How does an AI agent work?\\nAI agents work by simplifying and automating complex tasks. Most autonomous agents follow a specific workflow when performing assigned tasks.\\n\\nDetermine goals\\nThe AI agent receives a specific instruction or goal from the user. It uses the goal to plan tasks that make the final outcome relevant and useful to the user. Then, the agent breaks down the goal into several smaller actionable tasks. To achieve the goal, the agent performs those tasks based on specific orders or conditions. \\n\\nAcquire information\\nAI agents need information to act on tasks they have planned successfully. For example, the agent must extract conversation logs to analyze customer sentiments. As such, AI agents might access the internet to search for and retrieve the information they need. In some applications, an intelligent agent can interact with other agents or machine learning models to access or exchange information.'),\n",
       " Document(metadata={'source': './agent.txt'}, page_content=\"What are the key principles that define AI agents?\\nAll software autonomously completes different tasks as determined by the software developer. So, what makes AI or intelligent agents special? \\n\\nAI agents are rational agents. They make rational decisions based on their perceptions and data to produce optimal performance and results. An AI agent senses its environment with physical or software interfaces.\\n\\nFor example, a robotic agent collects sensor data, and a chatbot uses customer queries as input. Then, the AI agent applies the data to make an informed decision. It analyzes the collected data to predict the best outcomes that support predetermined goals. The agent also uses the results to formulate the next action that it should take. For example, self-driving cars navigate around obstacles on the road based on data from multiple sensors.\\n\\nWhat are the benefits of using AI agents?\\nAI agents can improve your business operations and your customers' experiences.\"),\n",
       " Document(metadata={'source': './agent.txt'}, page_content='Implement tasks\\nWith sufficient data, the AI agent methodically implements the task at hand. Once it accomplishes a task, the agent removes it from the list and proceeds to the next one. In between task completions, the agent evaluates if it has achieved the designated goal by seeking external feedback and inspecting its own logs. During this process, the agent might create and act on more tasks to reach the final outcome. \\n\\nWhat are the challenges of using AI agents?\\nAI agents are helpful software technologies to automate business workflows for better outcomes. That being said, organizations should address the following concerns when deploying autonomous AI agents for business use cases.\\n\\nData privacy concerns\\nDeveloping and operating advanced AI agents requires acquiring, storing, and moving massive volumes of data. Organizations should be aware of data privacy requirements and employ necessary measures to improve data security posture.')]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "retrieved_doc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ChatPromptTemplate(input_variables=['context', 'question'], input_types={}, partial_variables={}, messages=[HumanMessagePromptTemplate(prompt=PromptTemplate(input_variables=['context', 'question'], input_types={}, partial_variables={}, template='\\nAnswer the following question based on this context:\\n{context}\\nQuestion: {question}\\n'), additional_kwargs={})])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "template = \"\"\"\n",
    "Answer the following question based on this context:\n",
    "{context}\n",
    "Question: {question}\n",
    "\"\"\"\n",
    "\n",
    "prompt = ChatPromptTemplate.from_template(template)\n",
    "prompt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "rag_chain = (\n",
    "    prompt | llm | StrOutputParser()\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "response = rag_chain.invoke({\"context\": retrieved_doc, \"question\": \"How does agent work in llm artificial intelligence?\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Based on the provided context, it appears that the question is asking how an AI agent works in the context of LLM (Large Language Model) artificial intelligence.\n",
      "\n",
      "According to the provided text, an AI agent works by simplifying and automating complex tasks. It follows a specific workflow when performing assigned tasks, which includes:\n",
      "\n",
      "1. Determining goals: The AI agent receives a specific instruction or goal from the user and breaks it down into smaller actionable tasks.\n",
      "2. Acquiring information: The agent extracts necessary information from various sources, such as the internet, to act on the planned tasks.\n",
      "\n",
      "Additionally, the text mentions that AI agents use machine learning (ML) to gather and process massive amounts of real-time data, which allows them to make informed decisions and improve their performance over time.\n",
      "\n",
      "It is important to note that the provided text does not specifically mention LLM artificial intelligence, but rather provides a general overview of how AI agents work in the context of artificial intelligence.\n"
     ]
    }
   ],
   "source": [
    "print(response)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}