diff --git a/README.md b/README.md index 316425a..a0865d7 100644 --- a/README.md +++ b/README.md @@ -23,6 +23,7 @@ For more examples, you may also find our [Blog](https://haystack.deepset.ai/blog | Improving Retrieval with Auto-Merging | Open In Colab| | Speaker Diarization with AssemblyAI | Open In Colab| | Advance Prompt Customization for Anthropic | Open In Colab| +| Advanced RAG: Query Decomposition and Reasoning | Open In Colab| | Techcrunch News Digest with Local LLMs using TitanML Takeoff | Open In Colab| | Use Gemini Models with Vertex AI| Open In Colab| | Gradient AI Embedders and Generators for RAG | Open In Colab| diff --git a/index.toml b/index.toml index 77b41fd..6236756 100644 --- a/index.toml +++ b/index.toml @@ -38,7 +38,7 @@ topics = ["Model Serving", "Chat"] [[cookbook]] title = "Chat With Your SQL Database" notebook = "chat_with_SQL_3_ways.ipynb" -topics = ["Chat", "SQL"] +topics = ["Chat", "SQL", "Agents"] [[cookbook]] title = "Chroma Indexing and RAG Examples" @@ -59,7 +59,7 @@ experimental = true [[cookbook]] title = "Conversational RAG using Memory" notebook = "conversational_rag_using_memory.ipynb" -topics = ["Chat", "RAG"] +topics = ["Chat", "RAG", "Agents"] experimental = true discuss = "https://github.com/deepset-ai/haystack-experimental/discussions/75" @@ -71,7 +71,7 @@ topics = ["Advanced Retrieval", "Metadata"] [[cookbook]] title = "Function Calling with OpenAIChatGenerator" notebook = "function_calling_with_OpenAIChatGenerator.ipynb" -topics = ["Function Calling", "Chat"] +topics = ["Function Calling", "Chat", "Agents"] [[cookbook]] title = "Build with Gemma and Haystack 2.x" @@ -228,3 +228,8 @@ topics = ["Model Serving"] title = "🪁 RAG pipelines with Haystack 2.0 + Zephyr 7B Beta" notebook = "zephyr-7b-beta-for-rag.ipynb" topics = ["RAG"] + +[[cookbook]] +title = "Advanced RAG: Query Decomposition and Reasoning" +notebook = "query_decomposition.ipynb" +topics = ["Advanced Retrieval", "RAG", "Agents"] diff --git a/notebooks/query_decomposition.ipynb b/notebooks/query_decomposition.ipynb new file mode 100644 index 0000000..2d9c195 --- /dev/null +++ b/notebooks/query_decomposition.ipynb @@ -0,0 +1,840 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "iYhPbdnTN_9v" + }, + "source": [ + "# Advanced RAG: Query Decomposition and Reasoning\n", + "\n", + "by Tuana Celik ([LI](https://www.linkedin.com/in/tuanacelik/), [Twitter](https://x.com/tuanacelik))\n", + "\n", + "Query decomposition is a technique we can use to decompose complex queries into simpler steps, answering each sub-question, and getting an LLM to reason about the final answer based on the answers to the sub-questions.\n", + "\n", + "In this recipe, we're using the structured output functionality (currently in beta) by OpenAI to construct `Questions` which lists the sub-questions based on the original question, as well as keeping track of the intermediate answers to each question." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9mhsRh7zjCQO", + "outputId": "c517618a-313e-4344-dd01-daf1c5c0b47f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting haystack-ai\n", + " Downloading haystack_ai-2.5.1-py3-none-any.whl.metadata (13 kB)\n", + "Collecting haystack-experimental (from haystack-ai)\n", + " Downloading haystack_experimental-0.1.1-py3-none-any.whl.metadata (6.9 kB)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (3.1.4)\n", + "Collecting lazy-imports (from haystack-ai)\n", + " Downloading lazy_imports-0.3.1-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (10.5.0)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (3.3)\n", + "Requirement already satisfied: numpy<2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (1.26.4)\n", + "Collecting openai>=1.1.0 (from haystack-ai)\n", + " Downloading openai-1.46.1-py3-none-any.whl.metadata (24 kB)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.1.4)\n", + "Collecting posthog (from haystack-ai)\n", + " Downloading posthog-3.6.6-py2.py3-none-any.whl.metadata (2.0 kB)\n", + "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.8.2)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (6.0.2)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (2.32.3)\n", + "Requirement already satisfied: tenacity!=8.4.0 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (9.0.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (4.66.5)\n", + "Requirement already satisfied: typing-extensions>=4.7 in /usr/local/lib/python3.10/dist-packages (from haystack-ai) (4.12.2)\n", + "Requirement already satisfied: anyio<5,>=3.5.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (3.7.1)\n", + "Requirement already satisfied: distro<2,>=1.7.0 in /usr/lib/python3/dist-packages (from openai>=1.1.0->haystack-ai) (1.7.0)\n", + "Collecting httpx<1,>=0.23.0 (from openai>=1.1.0->haystack-ai)\n", + " Downloading httpx-0.27.2-py3-none-any.whl.metadata (7.1 kB)\n", + "Collecting jiter<1,>=0.4.0 (from openai>=1.1.0->haystack-ai)\n", + " Downloading jiter-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.6 kB)\n", + "Requirement already satisfied: pydantic<3,>=1.9.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (2.9.2)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai) (1.3.1)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->haystack-ai) (2.1.5)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil->haystack-ai) (1.16.0)\n", + "Collecting monotonic>=1.5 (from posthog->haystack-ai)\n", + " Downloading monotonic-1.6-py2.py3-none-any.whl.metadata (1.5 kB)\n", + "Collecting backoff>=1.10.0 (from posthog->haystack-ai)\n", + " Downloading backoff-2.2.1-py3-none-any.whl.metadata (14 kB)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->haystack-ai) (2024.8.30)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio<5,>=3.5.0->openai>=1.1.0->haystack-ai) (1.2.2)\n", + "Collecting httpcore==1.* (from httpx<1,>=0.23.0->openai>=1.1.0->haystack-ai)\n", + " Downloading httpcore-1.0.5-py3-none-any.whl.metadata (20 kB)\n", + "Collecting h11<0.15,>=0.13 (from httpcore==1.*->httpx<1,>=0.23.0->openai>=1.1.0->haystack-ai)\n", + " Downloading h11-0.14.0-py3-none-any.whl.metadata (8.2 kB)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.10/dist-packages (from pydantic<3,>=1.9.0->openai>=1.1.0->haystack-ai) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.23.4 in /usr/local/lib/python3.10/dist-packages (from pydantic<3,>=1.9.0->openai>=1.1.0->haystack-ai) (2.23.4)\n", + "Downloading haystack_ai-2.5.1-py3-none-any.whl (351 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m351.9/351.9 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading openai-1.46.1-py3-none-any.whl (375 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m375.1/375.1 kB\u001b[0m \u001b[31m19.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading haystack_experimental-0.1.1-py3-none-any.whl (41 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.8/41.8 kB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading lazy_imports-0.3.1-py3-none-any.whl (12 kB)\n", + "Downloading posthog-3.6.6-py2.py3-none-any.whl (54 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.3/54.3 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading backoff-2.2.1-py3-none-any.whl (15 kB)\n", + "Downloading httpx-0.27.2-py3-none-any.whl (76 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m3.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading httpcore-1.0.5-py3-none-any.whl (77 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jiter-0.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (318 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m318.9/318.9 kB\u001b[0m \u001b[31m9.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading monotonic-1.6-py2.py3-none-any.whl (8.2 kB)\n", + "Downloading h11-0.14.0-py3-none-any.whl (58 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m2.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: monotonic, lazy-imports, jiter, h11, backoff, posthog, httpcore, httpx, openai, haystack-experimental, haystack-ai\n", + "Successfully installed backoff-2.2.1 h11-0.14.0 haystack-ai-2.5.1 haystack-experimental-0.1.1 httpcore-1.0.5 httpx-0.27.2 jiter-0.5.0 lazy-imports-0.3.1 monotonic-1.6 openai-1.46.1 posthog-3.6.6\n", + "Collecting pyarrow==15.0.2\n", + " Downloading pyarrow-15.0.2-cp310-cp310-manylinux_2_28_x86_64.whl.metadata (3.0 kB)\n", + "Requirement already satisfied: numpy<2,>=1.16.6 in /usr/local/lib/python3.10/dist-packages (from pyarrow==15.0.2) (1.26.4)\n", + "Downloading pyarrow-15.0.2-cp310-cp310-manylinux_2_28_x86_64.whl (38.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m38.3/38.3 MB\u001b[0m \u001b[31m15.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: pyarrow\n", + " Attempting uninstall: pyarrow\n", + " Found existing installation: pyarrow 14.0.2\n", + " Uninstalling pyarrow-14.0.2:\n", + " Successfully uninstalled pyarrow-14.0.2\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "cudf-cu12 24.4.1 requires pyarrow<15.0.0a0,>=14.0.1, but you have pyarrow 15.0.2 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0mSuccessfully installed pyarrow-15.0.2\n", + "Collecting datasets\n", + " Downloading datasets-3.0.0-py3-none-any.whl.metadata (19 kB)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from datasets) (3.16.0)\n", + "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.10/dist-packages (from datasets) (1.26.4)\n", + "Requirement already satisfied: pyarrow>=15.0.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (15.0.2)\n", + "Collecting dill<0.3.9,>=0.3.0 (from datasets)\n", + " Downloading dill-0.3.8-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from datasets) (2.1.4)\n", + "Requirement already satisfied: requests>=2.32.2 in /usr/local/lib/python3.10/dist-packages (from datasets) (2.32.3)\n", + "Requirement already satisfied: tqdm>=4.66.3 in /usr/local/lib/python3.10/dist-packages (from datasets) (4.66.5)\n", + "Collecting xxhash (from datasets)\n", + " Downloading xxhash-3.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n", + "Collecting multiprocess (from datasets)\n", + " Downloading multiprocess-0.70.16-py310-none-any.whl.metadata (7.2 kB)\n", + "Requirement already satisfied: fsspec<=2024.6.1,>=2023.1.0 in /usr/local/lib/python3.10/dist-packages (from fsspec[http]<=2024.6.1,>=2023.1.0->datasets) (2024.6.1)\n", + "Requirement already satisfied: aiohttp in /usr/local/lib/python3.10/dist-packages (from datasets) (3.10.5)\n", + "Requirement already satisfied: huggingface-hub>=0.22.0 in /usr/local/lib/python3.10/dist-packages (from datasets) (0.24.7)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from datasets) (24.1)\n", + "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from datasets) (6.0.2)\n", + "Requirement already satisfied: aiohappyeyeballs>=2.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (2.4.0)\n", + "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.3.1)\n", + "Requirement already satisfied: attrs>=17.3.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (24.2.0)\n", + "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.4.1)\n", + "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (6.1.0)\n", + "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (1.11.1)\n", + "Requirement already satisfied: async-timeout<5.0,>=4.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp->datasets) (4.0.3)\n", + "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub>=0.22.0->datasets) (4.12.2)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests>=2.32.2->datasets) (2024.8.30)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->datasets) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas->datasets) (1.16.0)\n", + "Downloading datasets-3.0.0-py3-none-any.whl (474 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m474.3/474.3 kB\u001b[0m \u001b[31m14.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading dill-0.3.8-py3-none-any.whl (116 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m7.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading multiprocess-0.70.16-py310-none-any.whl (134 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m134.8/134.8 kB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading xxhash-3.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (194 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m194.1/194.1 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: xxhash, dill, multiprocess, datasets\n", + "Successfully installed datasets-3.0.0 dill-0.3.8 multiprocess-0.70.16 xxhash-3.5.0\n", + "Collecting cohere-haystack\n", + " Downloading cohere_haystack-2.0.0-py3-none-any.whl.metadata (2.5 kB)\n", + "Collecting cohere==5.* (from cohere-haystack)\n", + " Downloading cohere-5.9.4-py3-none-any.whl.metadata (3.4 kB)\n", + "Requirement already satisfied: haystack-ai in /usr/local/lib/python3.10/dist-packages (from cohere-haystack) (2.5.1)\n", + "Collecting boto3<2.0.0,>=1.34.0 (from cohere==5.*->cohere-haystack)\n", + " Downloading boto3-1.35.23-py3-none-any.whl.metadata (6.6 kB)\n", + "Collecting fastavro<2.0.0,>=1.9.4 (from cohere==5.*->cohere-haystack)\n", + " Downloading fastavro-1.9.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.5 kB)\n", + "Requirement already satisfied: httpx>=0.21.2 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (0.27.2)\n", + "Collecting httpx-sse==0.4.0 (from cohere==5.*->cohere-haystack)\n", + " Downloading httpx_sse-0.4.0-py3-none-any.whl.metadata (9.0 kB)\n", + "Collecting parameterized<0.10.0,>=0.9.0 (from cohere==5.*->cohere-haystack)\n", + " Downloading parameterized-0.9.0-py2.py3-none-any.whl.metadata (18 kB)\n", + "Requirement already satisfied: pydantic>=1.9.2 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (2.9.2)\n", + "Requirement already satisfied: pydantic-core<3.0.0,>=2.18.2 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (2.23.4)\n", + "Requirement already satisfied: requests<3.0.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (2.32.3)\n", + "Requirement already satisfied: tokenizers<1,>=0.15 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (0.19.1)\n", + "Collecting types-requests<3.0.0,>=2.0.0 (from cohere==5.*->cohere-haystack)\n", + " Downloading types_requests-2.32.0.20240914-py3-none-any.whl.metadata (1.9 kB)\n", + "Requirement already satisfied: typing_extensions>=4.0.0 in /usr/local/lib/python3.10/dist-packages (from cohere==5.*->cohere-haystack) (4.12.2)\n", + "Requirement already satisfied: haystack-experimental in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (0.1.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (3.1.4)\n", + "Requirement already satisfied: lazy-imports in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (0.3.1)\n", + "Requirement already satisfied: more-itertools in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (10.5.0)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (3.3)\n", + "Requirement already satisfied: numpy<2 in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (1.26.4)\n", + "Requirement already satisfied: openai>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (1.46.1)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (2.1.4)\n", + "Requirement already satisfied: posthog in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (3.6.6)\n", + "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (2.8.2)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (6.0.2)\n", + "Requirement already satisfied: tenacity!=8.4.0 in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (9.0.0)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from haystack-ai->cohere-haystack) (4.66.5)\n", + "Collecting botocore<1.36.0,>=1.35.23 (from boto3<2.0.0,>=1.34.0->cohere==5.*->cohere-haystack)\n", + " Downloading botocore-1.35.23-py3-none-any.whl.metadata (5.7 kB)\n", + "Collecting jmespath<2.0.0,>=0.7.1 (from boto3<2.0.0,>=1.34.0->cohere==5.*->cohere-haystack)\n", + " Downloading jmespath-1.0.1-py3-none-any.whl.metadata (7.6 kB)\n", + "Collecting s3transfer<0.11.0,>=0.10.0 (from boto3<2.0.0,>=1.34.0->cohere==5.*->cohere-haystack)\n", + " Downloading s3transfer-0.10.2-py3-none-any.whl.metadata (1.7 kB)\n", + "Requirement already satisfied: anyio in /usr/local/lib/python3.10/dist-packages (from httpx>=0.21.2->cohere==5.*->cohere-haystack) (3.7.1)\n", + "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from httpx>=0.21.2->cohere==5.*->cohere-haystack) (2024.8.30)\n", + "Requirement already satisfied: httpcore==1.* in /usr/local/lib/python3.10/dist-packages (from httpx>=0.21.2->cohere==5.*->cohere-haystack) (1.0.5)\n", + "Requirement already satisfied: idna in /usr/local/lib/python3.10/dist-packages (from httpx>=0.21.2->cohere==5.*->cohere-haystack) (3.10)\n", + "Requirement already satisfied: sniffio in /usr/local/lib/python3.10/dist-packages (from httpx>=0.21.2->cohere==5.*->cohere-haystack) (1.3.1)\n", + "Requirement already satisfied: h11<0.15,>=0.13 in /usr/local/lib/python3.10/dist-packages (from httpcore==1.*->httpx>=0.21.2->cohere==5.*->cohere-haystack) (0.14.0)\n", + "Requirement already satisfied: distro<2,>=1.7.0 in /usr/lib/python3/dist-packages (from openai>=1.1.0->haystack-ai->cohere-haystack) (1.7.0)\n", + "Requirement already satisfied: jiter<1,>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from openai>=1.1.0->haystack-ai->cohere-haystack) (0.5.0)\n", + "Requirement already satisfied: annotated-types>=0.6.0 in /usr/local/lib/python3.10/dist-packages (from pydantic>=1.9.2->cohere==5.*->cohere-haystack) (0.7.0)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->cohere==5.*->cohere-haystack) (3.3.2)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->cohere==5.*->cohere-haystack) (2.0.7)\n", + "Requirement already satisfied: huggingface-hub<1.0,>=0.16.4 in /usr/local/lib/python3.10/dist-packages (from tokenizers<1,>=0.15->cohere==5.*->cohere-haystack) (0.24.7)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->haystack-ai->cohere-haystack) (2.1.5)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai->cohere-haystack) (2024.2)\n", + "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas->haystack-ai->cohere-haystack) (2024.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil->haystack-ai->cohere-haystack) (1.16.0)\n", + "Requirement already satisfied: monotonic>=1.5 in /usr/local/lib/python3.10/dist-packages (from posthog->haystack-ai->cohere-haystack) (1.6)\n", + "Requirement already satisfied: backoff>=1.10.0 in /usr/local/lib/python3.10/dist-packages (from posthog->haystack-ai->cohere-haystack) (2.2.1)\n", + "Requirement already satisfied: exceptiongroup in /usr/local/lib/python3.10/dist-packages (from anyio->httpx>=0.21.2->cohere==5.*->cohere-haystack) (1.2.2)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->tokenizers<1,>=0.15->cohere==5.*->cohere-haystack) (3.16.0)\n", + "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->tokenizers<1,>=0.15->cohere==5.*->cohere-haystack) (2024.6.1)\n", + "Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub<1.0,>=0.16.4->tokenizers<1,>=0.15->cohere==5.*->cohere-haystack) (24.1)\n", + "Downloading cohere_haystack-2.0.0-py3-none-any.whl (20 kB)\n", + "Downloading cohere-5.9.4-py3-none-any.whl (233 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m233.1/233.1 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading httpx_sse-0.4.0-py3-none-any.whl (7.8 kB)\n", + "Downloading boto3-1.35.23-py3-none-any.whl (139 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m139.2/139.2 kB\u001b[0m \u001b[31m8.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading fastavro-1.9.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (3.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m3.1/3.1 MB\u001b[0m \u001b[31m67.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading parameterized-0.9.0-py2.py3-none-any.whl (20 kB)\n", + "Downloading types_requests-2.32.0.20240914-py3-none-any.whl (15 kB)\n", + "Downloading botocore-1.35.23-py3-none-any.whl (12.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.6/12.6 MB\u001b[0m \u001b[31m69.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading jmespath-1.0.1-py3-none-any.whl (20 kB)\n", + "Downloading s3transfer-0.10.2-py3-none-any.whl (82 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m82.7/82.7 kB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: types-requests, parameterized, jmespath, httpx-sse, fastavro, botocore, s3transfer, boto3, cohere, cohere-haystack\n", + "Successfully installed boto3-1.35.23 botocore-1.35.23 cohere-5.9.4 cohere-haystack-2.0.0 fastavro-1.9.7 httpx-sse-0.4.0 jmespath-1.0.1 parameterized-0.9.0 s3transfer-0.10.2 types-requests-2.32.0.20240914\n" + ] + } + ], + "source": [ + "!pip install haystack-ai\n", + "!pip install pyarrow==15.0.2\n", + "!pip install datasets\n", + "!pip install cohere-haystack" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "nYsEFBwnOIb8" + }, + "outputs": [], + "source": [ + "from haystack import Document, component\n", + "from haystack.components.builders import PromptBuilder\n", + "from haystack.components.retrievers import InMemoryEmbeddingRetriever\n", + "from haystack.components.generators import OpenAIGenerator\n", + "from haystack.components.generators.openai_utils import _convert_message_to_openai_format\n", + "from haystack.dataclasses import ChatMessage, StreamingChunk\n", + "from haystack.document_stores.in_memory import InMemoryDocumentStore\n", + "from haystack_integrations.components.embedders.cohere import CohereDocumentEmbedder, CohereTextEmbedder\n", + "\n", + "from datasets import load_dataset\n", + "from openai import OpenAI, Stream\n", + "from openai.types.chat import ChatCompletion, ChatCompletionChunk\n", + "from typing import List, Any, Dict, Optional, Callable, Union" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1UiRnsA9k92Q" + }, + "source": [ + "## Load the Dataset\n", + "\n", + "For this demo, we're using the `Tuana/game-of-thrones` dataset on Hugging Face, and we are using a Cohere embedding model to embed the contents." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G-dE1FGzObVa", + "outputId": "b999c3b5-c7cb-45de-c0a5-481d78c2b644" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Calculating embeddings: 100%|██████████| 74/74 [01:24<00:00, 1.15s/it]\n" + ] + }, + { + "data": { + "text/plain": [ + "2357" + ] + }, + "execution_count": 242, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "document_store = InMemoryDocumentStore()\n", + "\n", + "dataset = load_dataset(\"Tuana/game-of-thrones\", split=\"train\")\n", + "docs = [Document(content=doc[\"content\"], meta=doc[\"meta\"]) for doc in dataset]\n", + "\n", + "doc_embedder = CohereDocumentEmbedder(model=\"embed-multilingual-v3.0\")\n", + "docs_with_embeddings = doc_embedder.run(docs)\n", + "document_store.write_documents(docs_with_embeddings[\"documents\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0m05uf0c-ahX" + }, + "source": [ + "## 🧪 Experimental Addition to the OpenAIGenerator for Structured Output Support\n", + "\n", + "> 🚀 This step is a completely optional advanced step\n", + "\n", + "Let's extend the `OpenAIGeneraotor` to be able to make use of the [strctured output option by OpenAI](https://platform.openai.com/docs/guides/structured-outputs/introduction). Below, we extend the class to call `self.client.beta.chat.completions.parse` if the user has provides a `respose_format` in `generation_kwargs`. This will allow us to provifde a Pydantic Model to the gnerator and request our generator to respond with structured outputs that adhere to this Pydantic schema." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "6ihGheQx-gSk" + }, + "outputs": [], + "source": [ + "class OpenAIGenerator(OpenAIGenerator):\n", + " def __init__(self, **kwargs):\n", + " super().__init__(**kwargs)\n", + "\n", + " @component.output_types(replies=List[str], meta=List[Dict[str, Any]], structured_reply=BaseModel)\n", + " def run(self, prompt: str, streaming_callback: Optional[Callable[[StreamingChunk], None]] = None, generation_kwargs: Optional[Dict[str, Any]] = None,):\n", + " generation_kwargs = {**self.generation_kwargs, **(generation_kwargs or {})}\n", + " if \"response_format\" in generation_kwargs.keys():\n", + " message = ChatMessage.from_user(prompt)\n", + " if self.system_prompt:\n", + " messages = [ChatMessage.from_system(self.system_prompt), message]\n", + " else:\n", + " messages = [message]\n", + "\n", + " streaming_callback = streaming_callback or self.streaming_callback\n", + " openai_formatted_messages = [_convert_message_to_openai_format(message) for message in messages]\n", + " completion: Union[Stream[ChatCompletionChunk], ChatCompletion] = self.client.beta.chat.completions.parse(\n", + " model=self.model,\n", + " messages=openai_formatted_messages,\n", + " **generation_kwargs)\n", + " completions = [self._build_structured_message(completion, choice) for choice in completion.choices]\n", + " for response in completions:\n", + " self._check_finish_reason(response)\n", + "\n", + " return {\n", + " \"replies\": [message.content for message in completions],\n", + " \"meta\": [message.meta for message in completions],\n", + " \"structured_reply\": completions[0].content\n", + " }\n", + " else:\n", + " return super().run(prompt, streaming_callback, generation_kwargs)\n", + "\n", + " def _build_structured_message(self, completion: Any, choice: Any) -> ChatMessage:\n", + " chat_message = ChatMessage.from_assistant(choice.message.parsed or \"\")\n", + " chat_message.meta.update(\n", + " {\n", + " \"model\": completion.model,\n", + " \"index\": choice.index,\n", + " \"finish_reason\": choice.finish_reason,\n", + " \"usage\": dict(completion.usage),\n", + " }\n", + " )\n", + " return chat_message" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7JGz6wd6mZ2M", + "outputId": "9d577b8c-7aff-4604-f9b6-847ff2b5534a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OpenAI API Key:··········\n", + "Cohere API Key:··········\n" + ] + } + ], + "source": [ + "import os\n", + "from getpass import getpass\n", + "\n", + "if \"OPENAI_API_KEY\" not in os.environ:\n", + " os.environ[\"OPENAI_API_KEY\"] = getpass(\"OpenAI API Key:\")\n", + "\n", + "if \"COHERE_API_KEY\" not in os.environ:\n", + " os.environ[\"COHERE_API_KEY\"] = getpass(\"Cohere API Key:\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9Ht7fsHPl_jI" + }, + "source": [ + "## Define the Pydantic Model\n", + "\n", + "For query expansion, we want to keep track of intermediate questions that can be answered independently. So, below we define a `Questions` schema. Each `Question` is made up a `question` and an `answer`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "qlKb8fwln5ha" + }, + "outputs": [], + "source": [ + "from pydantic import BaseModel\n", + "\n", + "class Question(BaseModel):\n", + " question: str\n", + " answer: Optional[str] = None\n", + "\n", + "class Questions(BaseModel):\n", + " questions: list[Question]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LmJqxCdGmYDS" + }, + "source": [ + "## Define the Query Decomposition Prompt\n", + "\n", + "The first step in our application will be to decompose a question. We define our first `splitter_prompt` instructing an LLM to take the question step by steo and produce multiple sub questions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vTKZz86UmEUC" + }, + "outputs": [], + "source": [ + "from haystack import Pipeline\n", + "from haystack.components.builders import PromptBuilder\n", + "\n", + "splitter_prompt = \"\"\"\n", + "You are a helpful assistant that prepares queries that will be sent to a search component.\n", + "Sometimes, these queries are very complex.\n", + "Your job is to simplify complex queries into multiple queries that can be answered\n", + "in isolation to eachother.\n", + "\n", + "If the query is simple, then keep it as it is.\n", + "Examples\n", + "1. Query: Did Microsoft or Google make more money last year?\n", + " Decomposed Questions: [Question(question='How much profit did Microsoft make last year?', answer=None), Question(question='How much profit did Google make last year?', answer=None)]\n", + "2. Query: What is the capital of France?\n", + " Decomposed Questions: [Question(question='What is the capital of France?', answer=None)]\n", + "3. Query: {{question}}\n", + " Decomposed Questions:\n", + "\"\"\"\n", + "\n", + "builder = PromptBuilder(splitter_prompt)\n", + "llm = OpenAIGenerator(model=\"gpt-4o-mini\", generation_kwargs={\"response_format\": Questions})" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jua4UQCBmdbj" + }, + "source": [ + "## Define a Multi Text Embedder and Retriever\n", + "\n", + "Since we will likely be needing to answer multiple question, let's define a Milti Question Embedder and Retriever. This way, we can have 1 component that can accept multiple questsions, embed them, and another component that can retireve documents that relate to each question too." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WaEQBMggpkDi" + }, + "outputs": [], + "source": [ + "@component\n", + "class CohereMultiTextEmbedder:\n", + " def __init__(self, model: str = \"embed-multilingual-v3.0\"):\n", + " self.model = model\n", + " self.query_embedder = CohereTextEmbedder(model=self.model)\n", + "\n", + " @component.output_types(embeddings=List[List[float]])\n", + " def run(self, questions: BaseModel):\n", + " embeddings = []\n", + " for question in questions.questions:\n", + " embeddings.append(self.query_embedder.run(question.question)[\"embedding\"])\n", + " return {\"embeddings\": embeddings}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Oy6xaAs9HxCc" + }, + "outputs": [], + "source": [ + "@component\n", + "class MultiQueryInMemoryEmbeddingRetriever:\n", + "\n", + " def __init__(self, retriever: InMemoryEmbeddingRetriever, top_k: int = 3):\n", + "\n", + " self.retriever = retriever\n", + " self.question_context_pairs = []\n", + " self.top_k = top_k\n", + "\n", + " @component.output_types(question_context_pairs=List[Dict])\n", + " def run(self, queries: BaseModel, query_embeddings: List[List[float]],top_k: int = None):\n", + " if top_k != None:\n", + " self.top_k = top_k\n", + " for query, embedding in zip(queries.questions, query_embeddings):\n", + " result = self.retriever.run(query_embedding = embedding, top_k = self.top_k)\n", + " self.question_context_pairs.append({\"question\": query.question, \"documents\": {doc.content for doc in result[\"documents\"]}})\n", + " return {\"question_context_pairs\": self.question_context_pairs}" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "17W5KYoHnJSl" + }, + "source": [ + "## Define the Prompt to Answer Multiple Questions\n", + "\n", + "Once we have our decomposed questions, we need to instruct an LLM to answer each question based on the context for each question." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "hwsbnlnSmXhX" + }, + "outputs": [], + "source": [ + "multi_query_template = \"\"\"\n", + "You are a helpful assistant that can answer complex queries.\n", + "Here is the original question you were asked: {{question}}\n", + "\n", + "And you have split the task into the following questions:\n", + "{% for pair in question_context_pairs %}\n", + " {{pair.question}}\n", + "{% endfor %}\n", + "\n", + "Here are the question and context pairs for each question.\n", + "For each question, generate the question answer pair as a structured output\n", + "{% for pair in question_context_pairs %}\n", + " Question: {{pair.question}}\n", + " Context: {{pair.documents}}\n", + "{% endfor %}\n", + "Answers:\n", + "\"\"\"\n", + "\n", + "multi_query_prompt = PromptBuilder(multi_query_template)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3e3XPsddnRLo" + }, + "source": [ + "## Define the Prompt to Reason About the Final Answer\n", + "\n", + "Our final step will be to instruct the LLM to reason about the final answer based on the decomposed questions and answers to each." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "voZXYLhfyAHW" + }, + "outputs": [], + "source": [ + "reasoning_template = \"\"\"\n", + "You are a helpful assistant that can answer complex queries.\n", + "Here is the original question you were asked: {{question}}\n", + "\n", + "You have split this question up into simpler questoins that can be answered in\n", + "isolation.\n", + "Here are the questions and answers that you've generated\n", + "{% for pair in question_answer_pair %}\n", + " {{pair}}\n", + "{% endfor %}\n", + "\n", + "Reason about the final answer to the original query based on these questions and\n", + "aswers\n", + "Final Answer:\n", + "\"\"\"\n", + "\n", + "resoning_prompt = PromptBuilder(reasoning_template)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "poh24mgznda8" + }, + "source": [ + "## Final Step: Construct the Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XdwPoeOdJarm", + "outputId": "953c200d-1c06-472f-cf69-315178e7fcb1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "questions=[Question(question='How many siblings does Jamie have?', answer=None), Question(question='How many siblings does Sansa have?', answer=None)]\n" + ] + } + ], + "source": [ + "query_decomposition_pipeline = Pipeline()\n", + "\n", + "query_decomposition_pipeline.add_component(\"prompt\", PromptBuilder(splitter_prompt))\n", + "query_decomposition_pipeline.add_component(\"llm\", OpenAIGenerator(model=\"gpt-4o-mini\", generation_kwargs={\"response_format\": Questions}))\n", + "\n", + "query_decomposition_pipeline.connect(\"prompt\", \"llm\")\n", + "\n", + "question = \"Who has more siblings, Jamie or Sansa?\"\n", + "result = query_decomposition_pipeline.run({\"prompt\":{\"question\": question}})\n", + "print(result[\"llm\"][\"structured_reply\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "y2vtCTjOBWgu", + "outputId": "480f0dee-1152-42e5-fbba-d1470638fbfe" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "🚅 Components\n", + " - prompt: PromptBuilder\n", + " - llm: OpenAIGenerator\n", + " - embedder: CohereMultiTextEmbedder\n", + " - multi_query_retriever: MultiQueryInMemoryEmbeddingRetriever\n", + " - multi_query_prompt: PromptBuilder\n", + " - query_resolver_llm: OpenAIGenerator\n", + " - reasoning_prompt: PromptBuilder\n", + " - reasoning_llm: OpenAIGenerator\n", + "🛤️ Connections\n", + " - prompt.prompt -> llm.prompt (str)\n", + " - llm.structured_reply -> embedder.questions (BaseModel)\n", + " - llm.structured_reply -> multi_query_retriever.queries (BaseModel)\n", + " - embedder.embeddings -> multi_query_retriever.query_embeddings (List[List[float]])\n", + " - multi_query_retriever.question_context_pairs -> multi_query_prompt.question_context_pairs (List[Dict])\n", + " - multi_query_prompt.prompt -> query_resolver_llm.prompt (str)\n", + " - query_resolver_llm.structured_reply -> reasoning_prompt.question_answer_pair (BaseModel)\n", + " - reasoning_prompt.prompt -> reasoning_llm.prompt (str)" + ] + }, + "execution_count": 258, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pipeline = Pipeline()\n", + "\n", + "pipeline.add_component(\"prompt\", PromptBuilder(splitter_prompt))\n", + "pipeline.add_component(\"llm\", OpenAIGenerator(model=\"gpt-4o-mini\", generation_kwargs={\"response_format\": Questions}))\n", + "pipeline.add_component(\"embedder\", CohereMultiTextEmbedder(model=\"embed-multilingual-v3.0\"))\n", + "pipeline.add_component(\"multi_query_retriever\", MultiQueryInMemoryEmbeddingRetriever(InMemoryEmbeddingRetriever(document_store=document_store)))\n", + "pipeline.add_component(\"multi_query_prompt\", PromptBuilder(multi_query_template))\n", + "pipeline.add_component(\"query_resolver_llm\", OpenAIGenerator(model=\"gpt-4o-mini\", generation_kwargs={\"response_format\": Questions}))\n", + "pipeline.add_component(\"reasoning_prompt\", PromptBuilder(reasoning_template))\n", + "pipeline.add_component(\"reasoning_llm\", OpenAIGenerator(model=\"gpt-4o-mini\"))\n", + "\n", + "pipeline.connect(\"prompt\", \"llm\")\n", + "pipeline.connect(\"llm.structured_reply\", \"embedder.questions\")\n", + "pipeline.connect(\"embedder.embeddings\", \"multi_query_retriever.query_embeddings\")\n", + "pipeline.connect(\"llm.structured_reply\", \"multi_query_retriever.queries\")\n", + "pipeline.connect(\"llm.structured_reply\", \"embedder.questions\")\n", + "pipeline.connect(\"multi_query_retriever.question_context_pairs\", \"multi_query_prompt.question_context_pairs\")\n", + "pipeline.connect(\"multi_query_prompt\", \"query_resolver_llm\")\n", + "pipeline.connect(\"query_resolver_llm.structured_reply\", \"reasoning_prompt.question_answer_pair\")\n", + "pipeline.connect(\"reasoning_prompt\", \"reasoning_llm\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Kh20rSWqzHky" + }, + "outputs": [], + "source": [ + "question = \"Who has more siblings, Jamie or Sansa?\"\n", + "result = pipeline.run({\"prompt\":{\"question\": question},\n", + " \"multi_query_prompt\": {\"question\": question},\n", + " \"reasoning_prompt\": {\"question\": question}},\n", + " include_outputs_from=[\"query_resolver_llm\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "oibz0C6hEg5B", + "outputId": "e1d7c90b-947e-4df7-ef75-aed8a9b3f23e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The original query was split and resolved:\n", + "\n", + "question='How many siblings does Jamie have?' answer='Jaime Lannister has one sibling, Cersei Lannister, who is his twin sister.'\n", + "question='How many siblings does Sansa have?' answer='Sansa Stark has five siblings: one older brother (Robb), one younger sister (Arya), and two younger brothers (Bran and Rickon), plus one older illegitimate half-brother (Jon Snow).'\n", + "\n", + "So the original query is answered as follows:\n", + "\n", + "To determine who has more siblings between Jaime and Sansa, we can analyze the information provided in the answers to the simpler questions.\n", + "\n", + "- Jaime Lannister has **1 sibling**, which is Cersei Lannister.\n", + "- Sansa Stark has **5 siblings**, which include Robb, Arya, Bran, Rickon, and Jon Snow (considered a half-brother).\n", + "\n", + "Since 5 (Sansa's siblings) is greater than 1 (Jaime's siblings), we can conclude that Sansa has more siblings than Jaime.\n", + "\n", + "**Final Answer:** Sansa has more siblings than Jaime.\n" + ] + } + ], + "source": [ + "print(\"The original query was split and resolved:\\n\")\n", + "for pair in result[\"query_resolver_llm\"][\"structured_reply\"].questions:\n", + " print(pair)\n", + "print(\"\\nSo the original query is answered as follows:\\n\")\n", + "print(result[\"reasoning_llm\"][\"replies\"][0])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "3zhRqBM6zwl5", + "outputId": "e46a5e10-481e-4e36-944d-1d0b004ddb1d" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pipeline.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QXsolrmKEVbR" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +}