D3: Multi-Query Retrieval Pipeline.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5q2FHwPY-wqJ"
      },
      "source": [
        "# Multi-Query Retrieval Pipeline\n",
        "\n",
        "Task: Build a system to answer questions over BBC news dataset. However, to increase recall, your system should be able to generate questions similar to the ones asked.\n",
        "\n",
        "Example: \n",
        "For instance, if asked, `\"How are cybersecurity threats evolving with new technologies?\"` the system should be able to generate similar questions like:\n",
        "\n",
        "- `\"What impact do emerging technologies like AI and IoT have on the landscape of cybersecurity threats?\"`\n",
        "- `\"How are organizations adapting their cybersecurity strategies in response to the evolution of threats driven by technological advancements?\"`\n",
        "- `\"In what ways are cybercriminals leveraging new technologies to enhance their attack methods and tactics?\"`\n",
        "\n",
        "All these questions are similar to the original question, but they are not the same. The idea is that by generating similar questions, you can increase the system's recall, as the system will be able to retrieve more documents that could contain the answer to the original question.\n",
        "For that, you will use a large language model (LLM) to generate alternative similar questions based on the original question.\n",
        "Each of these similar questions will query a document store with news articles; all the documents retrieved by each similar question will be used to compose an answer to the original question.\n",
        "\n",
        "\n",
        "### Components to use:\n",
        "\n",
        "- [`InMemoryDocumentStore`](https://docs.haystack.deepset.ai/docs/inmemorydocumentstore): to store the news articles.\n",
        "- [`InMemoryEmbeddingRetriever`](https://docs.haystack.deepset.ai/docs/inmemoryembeddingretriever): to retrieve the documents from the document store.\n",
        "- [`OpenAIGenerator`](https://docs.haystack.deepset.ai/docs/openaigenerator): to instantiate the LLM to generate similar questions and compose an answer to the original question.\n",
        "- [`PromptBuilder`](https://docs.haystack.deepset.ai/docs/promptbuilder): to build the prompts to query the LLM\n",
        "- [`AnswerBuilder`](https://docs.haystack.deepset.ai/docs/answerbuilder): (optional) to build the answers to the original question.\n",
        "- [`SentenceTransformersTextEmbedder`](https://docs.haystack.deepset.ai/docs/sentencetransformerstextembedder): to embed the questions\n",
        "- [`SentenceTransformersDocumentEmbedder`](https://docs.haystack.deepset.ai/docs/sentencetransformersdocumentembedder): to embed the news articles\n",
        "- [`DocumentJoiner`](https://docs.haystack.deepset.ai/docs/documentjoiner): to join the documents retrieved by similar query questions\n",
        "\n",
        "### Your task is to build two custom components:\n",
        "\n",
        "- `MultiQueryGenerator`: a custom component that uses an LLM to generate similar questions based on the original question.\n",
        "- `MultiQueryHandler`: a custom component that queries the document store with a set of query questions and collects all the documents"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZALZDx-LFebK"
      },
      "source": [
        "### 1) Installation\n",
        "\n",
        "Installed packages and the BBC news dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "QJJ5AT3Z79e3"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\u001b[2mAudited \u001b[1m3 packages\u001b[0m \u001b[2min 40ms\u001b[0m\u001b[0m\n",
            "--2024-12-21 12:55:15--  https://raw.githubusercontent.com/amankharwal/Website-data/master/bbc-news-data.csv\n",
            "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.108.133, 185.199.109.133, ...\n",
            "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... connected.\n",
            "HTTP request sent, awaiting response... 200 OK\n",
            "Length: 5080260 (4.8M) [text/plain]\n",
            "Saving to: ‘bbc-news-data.csv’\n",
            "\n",
            "bbc-news-data.csv   100%[===================>]   4.84M  20.8MB/s    in 0.2s    \n",
            "\n",
            "2024-12-21 12:55:16 (20.8 MB/s) - ‘bbc-news-data.csv’ saved [5080260/5080260]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "!uv pip install haystack-ai \"sentence-transformers>=3.0.0\" lazy_imports\n",
        "#!uv pip install -q --upgrade openai # not to get the OpenAI proxies error: https://community.openai.com/t/error-with-openai-1-56-0-client-init-got-an-unexpected-keyword-argument-proxies/1040332/2\n",
        "!wget https://raw.githubusercontent.com/amankharwal/Website-data/master/bbc-news-data.csv"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W3jwS4A_FmEV"
      },
      "source": [
        "### 2) Enter API keys for LLM\n",
        "If you want to use OpenAI models, comment out the following & save your API key as `OPENAI_API_KEY` environment variable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zy4xBS6v8n1s",
        "outputId": "303b3c51-2268-4f20-c292-c7e0f63a77b4",
        "scrolled": true
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "' from getpass import getpass\\nimport os\\n\\nos.environ[\"OPENAI_API_KEY\"] = getpass(\"Enter OpenAI API key:\") '"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "\"\"\" from getpass import getpass\n",
        "import os\n",
        "\n",
        "os.environ[\"OPENAI_API_KEY\"] = getpass(\"Enter OpenAI API key:\") \"\"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "85pAAbaPFtZc"
      },
      "source": [
        "### 3) Parsing the news dataset and indexing it"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "oXMwKWzUAEaW"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/home/kalki/genAI/adventOfHaystack/.venv/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
            "  from .autonotebook import tqdm as notebook_tqdm\n",
            "Batches: 100%|██████████| 70/70 [00:03<00:00, 17.62it/s]\n"
          ]
        },
        {
          "data": {
            "text/plain": [
              "{'writer': {'documents_written': 2225}}"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import csv\n",
        "from typing import List\n",
        "\n",
        "from haystack import Document\n",
        "from haystack.components.embedders import SentenceTransformersDocumentEmbedder\n",
        "from haystack.document_stores.in_memory import InMemoryDocumentStore\n",
        "from haystack.document_stores.types import DuplicatePolicy\n",
        "from haystack.components.writers import DocumentWriter\n",
        "from haystack import Pipeline\n",
        "\n",
        "def read_documents(file: str) -> List[Document]:\n",
        "    with open(file, \"r\") as file:\n",
        "        reader = csv.reader(file, delimiter=\"\\t\")\n",
        "        next(reader, None)  # skip the headers\n",
        "        docs = []\n",
        "        for row in reader:\n",
        "            category = row[0].strip()\n",
        "            title = row[2].strip()\n",
        "            text = row[3].strip()\n",
        "            docs.append(Document(content=text, meta={\"category\": category, \"title\": title}))\n",
        "\n",
        "    return docs\n",
        "\n",
        "\n",
        "embedding_model = \"sentence-transformers/all-MiniLM-L6-v2\"\n",
        "doc_store = InMemoryDocumentStore()\n",
        "\n",
        "indexing_pipeline = Pipeline()\n",
        "indexing_pipeline.add_component(\"embedder\", SentenceTransformersDocumentEmbedder(model=embedding_model))\n",
        "indexing_pipeline.add_component(\"writer\", DocumentWriter(doc_store, policy=DuplicatePolicy.OVERWRITE))\n",
        "indexing_pipeline.connect(\"embedder\", \"writer\")\n",
        "\n",
        "documents = read_documents(\"bbc-news-data.csv\")\n",
        "indexing_pipeline.run({\"embedder\":{\"documents\": documents}})"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JQbBLYVI1cXZ"
      },
      "source": [
        "### 4) Defining a custom component `MultiQueryGenerator`\n",
        "This custom component will generate `n` alternatives to each query using a [Generator](https://docs.haystack.deepset.ai/docs/generators) and a [PromptBuilder](https://docs.haystack.deepset.ai/docs/promptbuilder).\n",
        "\n",
        "\n",
        "I am going to be using the following template for this component👇  \n",
        "```python\n",
        "template =\n",
        "\"\"\"\n",
        "You are an AI language model assistant. Your task is to generate {{n_variations}} different versions of the\n",
        "given user question by expanding the meaning of it.\n",
        "By generating multiple perspectives on the user question, you will help gather diverse information that will be useful to answer the user question in more comprehensive manner.\n",
        "The generated questions should be concise. Do not just rephrase the question, think about the other topics that are relevent to the user question.\n",
        "\n",
        "Provide these alternative questions separated by newlines.\n",
        "Original question: {{question}}\n",
        "Alternative: questions:\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "yMtN6v5n1cXZ"
      },
      "outputs": [],
      "source": [
        "from haystack import component\n",
        "from haystack_integrations.components.generators.ollama import OllamaGenerator\n",
        "from haystack.components.builders import PromptBuilder\n",
        "\n",
        "@component\n",
        "class MultiQueryGenerator:\n",
        "    def __init__(self):\n",
        "        \n",
        "        self.template = \"\"\"\n",
        "Your task is to generate {{n_variations}} different versions of the\n",
        "given user question: \n",
        "By generating multiple perspectives on the user question, you will help gather diverse information that will be useful to answer the user question in more comprehensive manner.\n",
        "The generated questions should be concise. Do not just rephrase the question, think about the other topics that are relevent to the user question.\n",
        "\n",
        "Provide these alternative questions separated by newlines. Just Give the alternatives without any additional context.\n",
        "Original question: {{question}}\n",
        "Alternative: questions:\"\"\"\n",
        "        \n",
        "        prompt_builder = PromptBuilder(template=self.template)\n",
        "        generator = OllamaGenerator(model = \"llama3.2\")\n",
        "        \n",
        "        # initialize the pipeline\n",
        "        self.pipeline = Pipeline()\n",
        "        \n",
        "        # add the components to the pipeline\n",
        "        self.pipeline.add_component(\"prompt_builder\", prompt_builder)\n",
        "        self.pipeline.add_component(\"generator\", generator)\n",
        "        \n",
        "        # connect the components\n",
        "        self.pipeline.connect(\"prompt_builder\", \"generator\")\n",
        "        \n",
        "\n",
        "    @component.output_types(queries=List[str])\n",
        "    def run(self, query: str, n_variations: int = 3):\n",
        "        result = self.pipeline.run({\"prompt_builder\": {\"question\": query, \"n_variations\": n_variations}})\n",
        "        \n",
        "        # Get the generated queries from Ollama's response\n",
        "        # Ollama returns a list of replies, we take the first one\n",
        "        generated_text = result[\"generator\"][\"replies\"][0]\n",
        "        \n",
        "        # Split the generated text into individual questions\n",
        "        generated_queries = [q.strip() for q in generated_text.split(\"\\n\") if q.strip()]\n",
        "        \n",
        "        # Return original query plus generated variations\n",
        "        queries = [query] + generated_queries[:n_variations]\n",
        "        \n",
        "        return {\"queries\": list(queries)}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wyu5dZXH1cXZ"
      },
      "source": [
        "### 5) Defining the custom component `MultiQueryHandler`\n",
        "\n",
        "This component will query the document store with multiple questions and collect all the retrieved documents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "m5CM7YsO1cXZ"
      },
      "outputs": [],
      "source": [
        "from haystack.components.embedders import SentenceTransformersTextEmbedder\n",
        "from haystack.components.retrievers import InMemoryEmbeddingRetriever\n",
        "\n",
        "@component\n",
        "class MultiQueryHandler:\n",
        "    def __init__(self, document_store, embedding_model: str):\n",
        "        embedder = SentenceTransformersTextEmbedder(model=embedding_model)\n",
        "        retriever = InMemoryEmbeddingRetriever(document_store=document_store)\n",
        "        self.ids = set()\n",
        "        self.results = []\n",
        "        \n",
        "        self.pipeline = Pipeline()\n",
        "        self.pipeline.add_component(\"text_embedder\", embedder)\n",
        "        self.pipeline.add_component(\"retriever\", retriever)\n",
        "        self.pipeline.connect(\"text_embedder.embedding\", \"retriever.query_embedding\")\n",
        "    \n",
        "    \n",
        "    # Add the document to the list of results    \n",
        "    def add_document(self, document: Document):\n",
        "        if document.id not in self.ids:\n",
        "            self.results.append(document)\n",
        "            self.ids.add(document.id)\n",
        "\n",
        "    @component.output_types(answers=List[Document])\n",
        "    def run(self, queries: List[str], top_k: int = 3):\n",
        "        for query in queries:\n",
        "            result = self.pipeline.run({\"text_embedder\": {\"text\": query}})\n",
        "            documents = result[\"retriever\"][\"documents\"]\n",
        "            for doc in documents:\n",
        "                self.add_document(doc)\n",
        "            \n",
        "        self.results.sort(key=lambda x: x.score, reverse=True)\n",
        "        return {\"answers\": self.results}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynhmh2Y-1cXZ"
      },
      "source": [
        "### 6) Defining the RAG Pipeline with Multi-Query Retrieval\n",
        "\n",
        "Given a question, this RAG pipeline will generate multiple similar questions, query the document store and collect all the retrieved documents"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "EuOfXHrP1cXZ",
        "outputId": "2dbbb7c9-825c-41a7-b27c-19faa6537448"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<haystack.core.pipeline.pipeline.Pipeline object at 0x7ff6f842e8a0>\n",
              "🚅 Components\n",
              "  - multi_query_generator: MultiQueryGenerator\n",
              "  - multi_query_handler: MultiQueryHandler\n",
              "  - reranker: DocumentJoiner\n",
              "  - prompt_builder: PromptBuilder\n",
              "  - llm: OllamaGenerator\n",
              "  - answer_builder: AnswerBuilder\n",
              "🛤️ Connections\n",
              "  - multi_query_generator.queries -> multi_query_handler.queries (List[str])\n",
              "  - multi_query_handler.answers -> reranker.documents (List[Document])\n",
              "  - reranker.documents -> prompt_builder.documents (List[Document])\n",
              "  - prompt_builder.prompt -> llm.prompt (str)\n",
              "  - llm.replies -> answer_builder.replies (List[str])\n",
              "  - llm.meta -> answer_builder.meta (List[Dict[str, Any]])"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from haystack import component, Pipeline, Document\n",
        "from haystack import component, Pipeline, Document\n",
        "from haystack.components.builders import PromptBuilder, AnswerBuilder\n",
        "from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder\n",
        "from haystack.components.joiners import DocumentJoiner\n",
        "from haystack.components.retrievers import InMemoryEmbeddingRetriever\n",
        "from haystack.document_stores.in_memory import InMemoryDocumentStore\n",
        "from haystack.document_stores.types import DuplicatePolicy\n",
        "\n",
        "template = \"\"\"\n",
        "You have to answer the following question based on the given context information only.\n",
        "If the context is empty or just a '\\\\n' answer with None, example: \"None\".\n",
        "\n",
        "Context:\n",
        "{% for document in documents %}\n",
        "    {{ document.content }}\n",
        "{% endfor %}\n",
        "\n",
        "Question: {{question}}\n",
        "Answer:\n",
        "\"\"\"\n",
        "\n",
        "pipeline = Pipeline()\n",
        "\n",
        "\n",
        "# add components\n",
        "pipeline.add_component(\"multi_query_generator\", MultiQueryGenerator())\n",
        "pipeline.add_component(\"multi_query_handler\", MultiQueryHandler(document_store=doc_store,embedding_model=embedding_model))\n",
        "pipeline.add_component(\"reranker\", DocumentJoiner(join_mode=\"reciprocal_rank_fusion\"))\n",
        "pipeline.add_component(\"prompt_builder\", PromptBuilder(template=template))\n",
        "pipeline.add_component(\"llm\", OllamaGenerator(model = \"llama3.2\"))\n",
        "pipeline.add_component(\"answer_builder\", AnswerBuilder())\n",
        "\n",
        "# connect components\n",
        "pipeline.connect(\"multi_query_generator.queries\", \"multi_query_handler.queries\")\n",
        "pipeline.connect(\"multi_query_handler.answers\", \"reranker.documents\")\n",
        "pipeline.connect(\"reranker\", \"prompt_builder.documents\")\n",
        "pipeline.connect(\"prompt_builder\", \"llm\")\n",
        "pipeline.connect(\"llm.replies\", \"answer_builder.replies\")\n",
        "pipeline.connect(\"llm.meta\", \"answer_builder.meta\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "pipeline.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "kvmVQ85X1cXZ"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "Batches: 100%|██████████| 1/1 [00:00<00:00, 125.13it/s]\n",
            "Batches: 100%|██████████| 1/1 [00:00<00:00, 85.82it/s]\n",
            "Batches: 100%|██████████| 1/1 [00:00<00:00, 122.16it/s]\n",
            "Batches: 100%|██████████| 1/1 [00:00<00:00, 184.11it/s]\n"
          ]
        }
      ],
      "source": [
        "# Sample Questions to ask\n",
        "\n",
        "#question = \"Can you give me some suggestions do you have for Christmas presents? Please provide a variety of options.\"\n",
        "question = \"What is popular in the music industry today?\"\n",
        "#question = \"How are cybersecurity threats evolving with new technologies?\"\n",
        "#question = \"What does UK do to prevent piracy in music industry?\"\n",
        "\n",
        "n_variations = 3\n",
        "top_k = 3\n",
        "\n",
        "result = pipeline.run(\n",
        "    {'multi_query_generator':{'query':question, 'n_variations':n_variations},\n",
        "     'multi_query_handler':{'top_k':top_k},\n",
        "     'prompt_builder': {'template_variables': {'question':question}},\n",
        "     'answer_builder':{'query':question}\n",
        "     }, include_outputs_from={\"multi_query_generator\"}\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "h-ixCJwuSGny"
      },
      "source": [
        "Print the answer and the queries used to retrieve more data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "vTgGCbO91cXZ"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "Questions:\n",
            "\n",
            "What is popular in the music industry today?\n",
            "What musical genres are currently trending on streaming platforms?\n",
            "How do contemporary artists collaborate with producers and songwriters?\n",
            "What role do social media influencers play in promoting emerging musicians?\n",
            "\n",
            "\n",
            "Answer:\n",
            "\n",
            "Based on the text, several trends and topics appear to be popular in the music industry:\n",
            "\n",
            "1. Hip-hop music, particularly through Kanye West's successful solo album \"The College Dropout\" and his collaborations with other artists.\n",
            "2. The use of samples from various songs, including classic rock and R&B tracks, in hip-hop music.\n",
            "3. Reggae music, despite a recent controversy surrounding homophobic lyrics.\n",
            "4. The commercial success of dancehall reggae stars, such as Beenie Man, Sizzla, and Elephant Man.\n",
            "\n",
            "Overall, it seems that hip-hop is currently a dominant force in the music industry, with West's innovative production style and collaborations contributing to its popularity.\n"
          ]
        }
      ],
      "source": [
        "print(\"\\n\\nQuestions:\\n\")\n",
        "for q in result['multi_query_generator']['queries']:\n",
        "    print(q)\n",
        "print(\"\\n\\nAnswer:\\n\")\n",
        "print(result['answer_builder']['answers'][0].data)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": ".venv",
      "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": 0
}