Add files using upload-large-folder tool

testbed/deepset-ai__haystack/.gitignore

@@ -0,0 +1,162 @@
+# Local run files
+qa.db
+**/qa.db
+**/*qa*.db
+**/test-reports
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# documentation
+docs/pydoc/temp/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# PyCharm
+.idea
+
+# VSCode
+.vscode
+
+# haystack files
+haystack/document_store/qa.db
+data
+**/mlruns/**
+src
+models
+saved_models
+*_build
+rest_api/file-upload/*
+**/feedback_squad_direct.json
+haystack/json-schemas
+.haystack_debug
+
+.DS_Store
+
+# http cache (requests-cache)
+**/http_cache.sqlite
+
+# ruff
+.ruff_cache

testbed/deepset-ai__haystack/.pre-commit-config.yaml

@@ -0,0 +1,37 @@
+fail_fast: true
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-ast # checks Python syntax
+      - id: check-json # checks JSON syntax
+      - id: check-merge-conflict # checks for no merge conflict strings
+      - id: check-shebang-scripts-are-executable # checks all shell scripts have executable permissions
+      - id: check-toml # checks TOML syntax
+      - id: check-yaml # checks YAML syntax
+      - id: end-of-file-fixer # checks there is a newline at the end of the file
+      - id: mixed-line-ending # normalizes line endings
+      - id: no-commit-to-branch # prevents committing to main
+      - id: trailing-whitespace # trims trailing whitespace
+        args: [--markdown-linebreak-ext=md]
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.5.0
+    hooks:
+      - id: ruff
+      - id: ruff-format
+
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.3.0
+    hooks:
+      - id: codespell
+        args: ["--toml", "pyproject.toml"]
+        additional_dependencies:
+          - tomli
+
+  - repo: https://github.com/rhysd/actionlint
+    rev: v1.7.1
+    hooks:
+      - id: actionlint-docker
+        args: ["-ignore", "SC2102"]

testbed/deepset-ai__haystack/CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it using these metadata."
+title: "Haystack: the end-to-end NLP framework for pragmatic builders"
+date-released: 2019-11-14
+url: "https://github.com/deepset-ai/haystack"
+authors:
+- family-names: Pietsch
+  given-names: Malte
+- family-names: Möller
+  given-names: Timo
+- family-names: Kostic
+  given-names: Bogdan
+- family-names: Risch
+  given-names: Julian
+- family-names: Pippi
+  given-names: Massimiliano
+- family-names: Jobanputra
+  given-names: Mayank
+- family-names: Zanzottera
+  given-names: Sara
+- family-names: Cerza
+  given-names: Silvano
+- family-names: Blagojevic
+  given-names: Vladimir
+- family-names: Stadelmann
+  given-names: Thomas
+- family-names: Soni
+  given-names: Tanay
+- family-names: Lee
+  given-names: Sebastian

testbed/deepset-ai__haystack/CONTRIBUTING.md

@@ -0,0 +1,382 @@
+# Contributing to Haystack
+
+First off, thanks for taking the time to contribute! :blue_heart:
+
+All types of contributions are encouraged and valued. See the [Table of Contents](#table-of-contents)
+for different ways to help and details about how this project handles them. Please make sure to read
+the relevant section before making your contribution. It will make it a lot easier for us maintainers
+and smooth out the experience for all involved. The community looks forward to your contributions!
+
+> [!TIP]
+> If you like Haystack but just don't have time to contribute, that's fine. There are other easy ways to support the
+> project and show your appreciation, which we would also be very happy about:
+> - Star this repository
+> - Tweet about it
+> - Mention Haystack at local meetups and tell your friends/colleagues
+
+**Table of Contents**
+
+- [Contributing to Haystack](#contributing-to-haystack)
+  - [Code of Conduct](#code-of-conduct)
+  - [I Have a Question](#i-have-a-question)
+  - [Reporting Bugs](#reporting-bugs)
+    - [Before Submitting a Bug Report](#before-submitting-a-bug-report)
+    - [How Do I Submit a Good Bug Report?](#how-do-i-submit-a-good-bug-report)
+  - [Suggesting Enhancements](#suggesting-enhancements)
+    - [Before Submitting an Enhancement](#before-submitting-an-enhancement)
+    - [How Do I Submit a Good Enhancement Suggestion?](#how-do-i-submit-a-good-enhancement-suggestion)
+  - [Contribute code](#contribute-code)
+    - [Where to start](#where-to-start)
+    - [Setting up your development environment](#setting-up-your-development-environment)
+    - [Clone the git repository](#clone-the-git-repository)
+    - [Run the tests locally](#run-the-tests-locally)
+  - [Requirements for Pull Requests](#requirements-for-pull-requests)
+    - [Release notes](#release-notes)
+  - [CI (Continuous Integration)](#ci-continuous-integration)
+  - [Working from GitHub forks](#working-from-github-forks)
+  - [Writing tests](#writing-tests)
+    - [Unit test](#unit-test)
+    - [Integration test](#integration-test)
+    - [End to End (e2e) test](#end-to-end-e2e-test)
+  - [Contributor Licence Agreement (CLA)](#contributor-licence-agreement-cla)
+
+## Code of Conduct
+
+This project and everyone participating in it is governed by our [Code of Conduct](code_of_conduct.txt).
+By participating, you are expected to uphold this code. Please report unacceptable behavior to haystack@deepset.ai.
+
+## I Have a Question
+
+> [!TIP]
+> If you want to ask a question, we assume that you have read the available [Documentation](https://docs.haystack.deepset.ai/docs/intro).
+
+Before you ask a question, it is best to search for existing [Issues](/issues) that might help you. In case you have
+found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to
+search the internet for answers first.
+
+If you then still feel the need to ask a question and need clarification, you can use one of our
+[Community Channels](https://haystack.deepset.ai/community), Discord, in particular, is often very helpful.
+
+## Reporting Bugs
+
+### Before Submitting a Bug Report
+
+A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to
+investigate carefully, collect information, and describe the issue in detail in your report. Please complete the
+following steps in advance to help us fix any potential bug as fast as possible.
+
+- Make sure that you are using the latest version.
+- Determine if your bug is really a bug and not an error on your side, for example using incompatible versions.
+  Make sure that you have read the [documentation](https://docs.haystack.deepset.ai/docs/intro). If you are looking
+  for support, you might want to check [this section](#i-have-a-question).
+- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there
+  is not already a bug report existing for your bug or error in the [bug tracker](/issues).
+- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have
+  discussed the issue.
+- Collect information about the bug:
+  - OS, Platform and Version (Windows, Linux, macOS, x86, ARM)
+  - Version of Haystack and the integrations you're using
+  - Possibly your input and the output
+  - If you can reliably reproduce the issue, a snippet of code we can use
+
+### How Do I Submit a Good Bug Report?
+
+> [!IMPORTANT]
+> You must never report security-related issues, vulnerabilities, or bugs, including sensitive information to the issue
+> tracker, or elsewhere in public. Instead, sensitive bugs must be reported using [this link](https://github.com/deepset-ai/haystack/security/advisories/new).
+>
+
+We use GitHub issues to track bugs and errors. If you run into an issue with the project:
+
+- Open an [Issue of type Bug Report](/issues/new?assignees=&labels=bug&projects=&template=bug_report.md&title=).
+- Explain the behavior you would expect and the actual behavior.
+- Please provide as much context as possible and describe the *reproduction steps* that someone else can follow to
+  recreate the issue on their own. This usually includes your code. For good bug reports, you should isolate the problem
+  and create a reduced test case.
+- Provide the information you collected in the previous section.
+
+Once it's filed:
+
+- The project team will label the issue accordingly.
+- A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no
+  obvious way to reproduce the issue, the team will ask you for those steps.
+- If the team is able to reproduce the issue, the issue will scheduled for a fix or left to be
+  [implemented by someone](#your-first-code-contribution).
+
+## Suggesting Enhancements
+
+This section guides you through submitting an enhancement suggestion, including new integrations and improvements
+to existing ones. Following these guidelines will help maintainers and the community to understand your suggestion and
+find related suggestions.
+
+### Before Submitting an Enhancement
+
+- Make sure that you are using the latest version.
+- Read the [documentation](https://docs.haystack.deepset.ai/docs/intro) carefully and find out if the functionality
+  is already covered, maybe by an individual configuration.
+- Perform a [search](/issues) to see if the enhancement has already been suggested. If it has, add a comment to the
+  existing issue instead of opening a new one.
+- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to
+  convince the project's developers of the merits of this feature. Keep in mind that we want features that will be
+  useful to the majority of our users and not just a small subset. If you're just targeting a minority of users,
+  consider writing and distributing the integration on your own.
+
+### How Do I Submit a Good Enhancement Suggestion?
+
+Enhancement suggestions are tracked as GitHub issues of type [Feature request for existing integrations](/issues/new?assignees=&labels=feature+request&projects=&template=feature-request-for-existing-integrations.md&title=).
+
+- Use a **clear and descriptive title** for the issue to identify the suggestion.
+- Fill the issue following the template
+
+## Contribute code
+
+> [!IMPORTANT]
+> When contributing to this project, you must agree that you have authored 100% of the content, that you have the
+> necessary rights to the content and that the content you contribute may be provided under the project license.
+
+### Where to start
+
+If this is your first contribution, a good starting point is looking for an open issue that's marked with the label
+["good first issue"](https://github.com/deepset-ai/haystack/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22).
+The core contributors periodically mark certain issues as good for first-time contributors. Those issues are usually
+limited in scope, easily fixable and low priority, so there is absolutely no reason why you should not try fixing them,
+it's a good excuse to start looking into the project and a safe space for experimenting failure: if you don't get the
+grasp of something, pick another one! Once you become comfortable contributing to Haystack, you can have a look at the
+list of issues marked as [contributions wanted](https://github.com/orgs/deepset-ai/projects/14/views/1) to look for your
+next contribution!
+
+### Setting up your development environment
+
+Haystack makes heavy use of [Hatch](https://hatch.pypa.io/latest/), a Python project manager that we use to set up the
+virtual environments, build the project, and publish packages. As you can imagine, the first step towards becoming a
+Haystack contributor is installing Hatch. There are a variety of installation methods depending on your operating system
+platform, version, and personal taste: please have a look at [this page](https://hatch.pypa.io/latest/install/#installation)
+and keep reading once you can run from your terminal:
+
+```console
+$ hatch --version
+Hatch, version 1.9.3
+```
+
+You can create a new virtual environment for Haystack with `hatch` by running:
+
+```console
+$ hatch shell
+```
+
+### Clone the git repository
+
+You won't be able to make changes directly to this repo, so the first step is to [create a fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/fork-a-repo).
+Once your fork is ready, you can clone a local copy with:
+
+```console
+$ git clone https://github.com/YOUR-USERNAME/haystack
+```
+
+If everything worked, you should be able to do something like this (the output might be different):
+
+```console
+$ cd haystack
+$ hatch version
+2.3.0-rc0
+```
+
+Last, install the pre-commit hooks with:
+
+```bash
+pre-commit install
+```
+
+This utility will run some tasks right before all `git commit` operations. From now on, your `git commit` output for
+Haystack should look something like this:
+
+```
+> git commit -m "test"
+check python ast.........................................................Passed
+check json...........................................(no files to check)Skipped
+check for merge conflicts................................................Passed
+check that scripts with shebangs are executable..........................Passed
+check toml...........................................(no files to check)Skipped
+check yaml...........................................(no files to check)Skipped
+fix end of files.........................................................Passed
+mixed line ending........................................................Passed
+don't commit to branch...................................................Passed
+trim trailing whitespace.................................................Passed
+ruff.....................................................................Passed
+codespell................................................................Passed
+Lint GitHub Actions workflow files...................(no files to check)Skipped
+[massi/contrib d18a2577] test
+ 2 files changed, 178 insertions(+), 45 deletions(-)
+```
+
+### Run the tests locally
+
+Tests will automatically run in our CI for every commit you push to your PR on Github. In order to save precious CI time
+we encourage you to run the tests locally before pushing new commits to Github. From the root of the git repository,
+you can run all the unit tests like this:
+
+```sh
+hatch run test:unit
+```
+
+Hatch will create a dedicated virtual environment, sync the required dependencies and run all the unit tests from the
+project. If you want to run a subset of the tests or even one test in particular, `hatch` will accept all the
+options you would normally pass to `pytest`, for example:
+
+```sh
+# run one test method from a specific test class in a test file
+hatch run test:unit test/test_logging.py::TestSkipLoggingConfiguration::test_skip_logging_configuration
+```
+
+### Run code quality checks locally
+
+We also use tools to ensure consistent code style, quality, and static type checking. The quality of your code will be
+tested by the CI, but once again, running the checks locally will speed up the review cycle.
+
+
+To check your code type checking, run:
+```sh
+hatch run test:types
+```
+
+
+To check your code format run:
+```sh
+hatch run format-check
+```
+
+
+To format your code, you can run:
+```sh
+hatch run format
+````
+
+
+To check your code style according to linting rules run:
+```sh
+hatch run check
+hatch run test:lint
+````
+
+
+If the linters spot any error, you can fix it before checking in your code:
+```sh
+hatch run fix
+```
+
+
+## Requirements for Pull Requests
+
+To ease the review process, please follow the instructions in this paragraph when creating a Pull Request:
+
+- For the title, use the [conventional commit convention](https://www.conventionalcommits.org/en/v1.0.0/).
+- For the body, follow the existing [pull request template](https://github.com/deepset-ai/haystack/blob/main/.github/pull_request_template.md) to describe and document your changes.
+
+### Release notes
+
+Each PR must include a release notes file under the `releasenotes/notes` path created with `reno`, and a CI check will
+fail if that's not the case. Pull requests with changes limited to tests, code comments or docstrings, and changes to
+the CI/CD systems can be labeled with `ignore-for-release-notes` by a maintainer in order to bypass the CI check.
+
+For example, if your PR is bumping the `transformers` version in the `pyproject.toml` file, that's something that
+requires release notes. To create the corresponding file, from the root of the repo run:
+
+```
+$ hatch run release-note bump-transformers-to-4-31
+```
+
+A release notes file in YAML format will be created in the appropriate folder, appending a unique id to the name of the
+release note you provided (in this case, `bump-transformers-to-4-31`). To add the actual content of the release notes,
+you must edit the file that's just been created. In the file, you will find multiple sections along with an explanation
+of what they're for. You have to remove all the sections that don't fit your release notes, in this case for example
+you would fill in the `enhancements` section to describe the change:
+
+```yaml
+enhancements:
+  - |
+    Upgrade transformers to the latest version 4.31.0 so that Haystack can support the new LLama2 models.
+```
+
+You can now add the file to the same branch containing the code changes. Your release note will be part of your pull
+request and reviewed along with any code you changed.
+
+## CI (Continuous Integration)
+
+We use GitHub Action for our Continuous Integration tasks. This means that as soon as you open a PR, GitHub will start
+executing some workflows on your changes, like automated tests, linting, formatting, api docs generation, etc.
+
+If all goes well, at the bottom of your PR page you should see something like this, where all checks are green.
+
+![Successful CI](docs/img/ci-success.png)
+
+If you see some red checks (like the following), then something didn't work, and action is needed from your side.
+
+![Failed CI](docs/img/ci-failure-example.png)
+
+Click on the failing test and see if there are instructions at the end of the logs of the failed test.
+For example, in the case above, the CI will give you instructions on how to fix the issue.
+
+![Logs of failed CI, with instructions for fixing the failure](docs/img/ci-failure-example-instructions.png)
+
+## Working from GitHub forks
+
+In order for maintainers to be able to help you, we usually ask contributors to give us push access to their fork.
+
+To do so, please verify that "Allow edits and access to secrets by maintainers" on the PR preview page is checked
+(you can check it later on the PR's sidebar once it's created).
+
+![Allow access to your branch to maintainers](docs/img/first_time_contributor_enable_access.png)
+
+## Writing tests
+
+We formally define three scopes for tests in Haystack with different requirements and purposes:
+
+### Unit test
+- Tests a single logical concept
+- Execution time is a few milliseconds
+- Any external resource is mocked
+- Always returns the same result
+- Can run in any order
+- Runs at every commit in PRs, automated through `hatch run test:unit`
+- Can run locally with no additional setup
+- **Goal: being confident in merging code**
+
+### Integration test
+- Tests a single logical concept
+- Execution time is a few seconds
+- It uses external resources that must be available before execution
+- When using models, cannot use inference
+- Always returns the same result or an error
+- Can run in any order
+- Runs at every commit in PRs, automated through `hatch run test:integration`
+- Can run locally with some additional setup (e.g. Docker)
+- **Goal: being confident in merging code**
+
+### End to End (e2e) test
+- Tests a sequence of multiple logical concepts
+- Execution time has no limits (can be always on)
+- Can use inference
+- Evaluates the results of the execution or the status of the system
+- It uses external resources that must be available before execution
+- Can return different results
+- Can be dependent on the order
+- Can be wrapped into any process execution
+- Runs outside the development cycle (nightly or on demand)
+- Might not be possible to run locally due to system and hardware requirements
+- **Goal: being confident in releasing Haystack**
+
+## Contributor Licence Agreement (CLA)
+
+Significant contributions to Haystack require a Contributor License Agreement (CLA). If the contribution requires a CLA,
+we will get in contact with you. CLAs are quite common among company-backed open-source frameworks, and our CLA’s wording
+is similar to other popular projects, like [Rasa](https://cla-assistant.io/RasaHQ/rasa) or
+[Google's Tensorflow](https://cla.developers.google.com/clas/new?domain=DOMAIN_GOOGLE&kind=KIND_INDIVIDUAL)
+(retrieved 4th November 2021).
+
+The agreement's main purpose is to protect the continued open use of Haystack. At the same time, it also helps in
+\protecting you as a contributor. Contributions under this agreement will ensure that your code will continue to be
+open to everyone in the future (“You hereby grant to Deepset **and anyone** [...]”) as well as remove liabilities on
+your end (“you provide your Contributions on an AS IS basis, without warranties or conditions of any kind [...]”). You
+can find the Contributor Licence Agreement [here](https://cla-assistant.io/deepset-ai/haystack).
+
+If you have further questions about the licensing, feel free to reach out to contributors@deepset.ai.

testbed/deepset-ai__haystack/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 deepset GmbH
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

testbed/deepset-ai__haystack/README.md

@@ -0,0 +1,121 @@
+<div align="center">
+  <a href="https://haystack.deepset.ai/"><img src="https://raw.githubusercontent.com/deepset-ai/haystack/main/docs/img/banner_20.png" alt="Green logo of a stylized white 'H' with the text 'Haystack, by deepset. Haystack 2.0 is live 🎉' Abstract green and yellow diagrams in the background."></a>
+
+|         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| CI/CD   | [![Tests](https://github.com/deepset-ai/haystack/actions/workflows/tests.yml/badge.svg)](https://github.com/deepset-ai/haystack/actions/workflows/tests.yml) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/python/mypy) [![Coverage Status](https://coveralls.io/repos/github/deepset-ai/haystack/badge.svg?branch=main)](https://coveralls.io/github/deepset-ai/haystack?branch=main) [![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff) |
+| Docs    | [![Website](https://img.shields.io/website?label=documentation&up_message=online&url=https%3A%2F%2Fdocs.haystack.deepset.ai)](https://docs.haystack.deepset.ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| Package | [![PyPI](https://img.shields.io/pypi/v/haystack-ai)](https://pypi.org/project/haystack-ai/) ![PyPI - Downloads](https://img.shields.io/pypi/dm/haystack-ai?color=blue&logo=pypi&logoColor=gold) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/haystack-ai?logo=python&logoColor=gold) [![Conda Version](https://img.shields.io/conda/vn/conda-forge/haystack-ai.svg)](https://anaconda.org/conda-forge/haystack-ai) [![GitHub](https://img.shields.io/github/license/deepset-ai/haystack?color=blue)](LICENSE) [![License Compliance](https://github.com/deepset-ai/haystack/actions/workflows/license_compliance.yml/badge.svg)](https://github.com/deepset-ai/haystack/actions/workflows/license_compliance.yml) |
+| Meta    | [![Discord](https://img.shields.io/discord/993534733298450452?logo=discord)](https://discord.com/invite/VBpFzsgRVF) [![Twitter Follow](https://img.shields.io/twitter/follow/haystack_ai)](https://twitter.com/haystack_ai)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+</div>
+
+[Haystack](https://haystack.deepset.ai/) is an end-to-end LLM framework that allows you to build applications powered by
+LLMs, Transformer models, vector search and more. Whether you want to perform retrieval-augmented generation (RAG),
+document search, question answering or answer generation, Haystack can orchestrate state-of-the-art embedding models
+and LLMs into pipelines to build end-to-end NLP applications and solve your use case.
+
+## Installation
+
+The simplest way to get Haystack is via pip:
+
+```sh
+pip install haystack-ai
+```
+
+Install from the `main` branch to try the newest features:
+```sh
+pip install git+https://github.com/deepset-ai/haystack.git@main
+```
+
+Haystack supports multiple installation methods including Docker images. For a comprehensive guide please refer
+to the [documentation](https://docs.haystack.deepset.ai/docs/installation).
+
+## Documentation
+
+If you're new to the project, check out ["What is Haystack?"](https://haystack.deepset.ai/overview/intro) then go
+through the ["Get Started Guide"](https://haystack.deepset.ai/overview/quick-start) and build your first LLM application
+in a matter of minutes. Keep learning with the [tutorials](https://haystack.deepset.ai/tutorials). For more advanced
+use cases, or just to get some inspiration, you can browse our Haystack recipes in the
+[Cookbook](https://haystack.deepset.ai/cookbook).
+
+At any given point, hit the [documentation](https://docs.haystack.deepset.ai/docs/intro) to learn more about Haystack, what can it do for you and the technology behind.
+
+## Features
+
+> [!IMPORTANT]
+> **You are currently looking at the readme of Haystack 2.0**. We are still maintaining Haystack 1.x to give everyone
+> enough time to migrate to 2.0. [Switch to Haystack 1.x here](https://github.com/deepset-ai/haystack/tree/v1.x).
+
+- **Technology agnostic:** Allow users the flexibility to decide what vendor or technology they want and make it easy to switch out any component for another. Haystack allows you to use and compare models available from OpenAI, Cohere and Hugging Face, as well as your own local models or models hosted on Azure, Bedrock and SageMaker.
+- **Explicit:** Make it transparent how different moving parts can “talk” to each other so it's easier to fit your tech stack and use case.
+- **Flexible:** Haystack provides all tooling in one place: database access, file conversion, cleaning, splitting, training, eval, inference, and more. And whenever custom behavior is desirable, it's easy to create custom components.
+- **Extensible:** Provide a uniform and easy way for the community and third parties to build their own components and foster an open ecosystem around Haystack.
+
+Some examples of what you can do with Haystack:
+
+-   Build **retrieval augmented generation (RAG)** by making use of one of the available vector databases and customizing your LLM interaction, the sky is the limit 🚀
+-   Perform Question Answering **in natural language** to find granular answers in your documents.
+-   Perform **semantic search** and retrieve documents according to meaning.
+-   Build applications that can make complex decisions making to answer complex queries: such as systems that can resolve complex customer queries, do knowledge search on many disconnected resources and so on.
+-   Scale to millions of docs using retrievers and production-scale components.
+-   Use **off-the-shelf models** or **fine-tune** them to your data.
+-   Use **user feedback** to evaluate, benchmark, and continuously improve your models.
+
+> [!TIP]
+><img src="https://github.com/deepset-ai/haystack/raw/main/docs/img/deepset-cloud-logo-lightblue.png"  width=30% height=30%>
+>
+> Are you looking for a managed solution that benefits from Haystack? [deepset Cloud](https://www.deepset.ai/deepset-cloud?utm_campaign=developer-relations&utm_source=haystack&utm_medium=readme) is our fully managed, end-to-end platform to integrate LLMs with your data, which uses Haystack for the LLM pipelines architecture.
+
+## 🔜 Visual Pipeline Editor
+
+Use **deepset Studio** to visually create and export your Haystack pipeline architecture as a YAML or as Python code. Learn more about it in [our announcement post](https://haystack.deepset.ai/blog/announcing-studio).
+
+![studio](https://github.com/user-attachments/assets/e4f09746-20b5-433e-8261-eca224ac23b3)
+
+
+👉 [Join the waitlist](https://landing.deepset.ai/deepset-studio-waitlist?utm_campaign=2408%20-%20Campaign%20-%20Studio%20Launch&utm_source=github&utm_medium=referral)!
+
+## Telemetry
+
+Haystack collects **anonymous** usage statistics of pipeline components. We receive an event every time these components are initialized. This way, we know which components are most relevant to our community.
+
+Read more about telemetry in Haystack or how you can opt out in [Haystack docs](https://docs.haystack.deepset.ai/docs/telemetry).
+
+## 🖖 Community
+
+If you have a feature request or a bug report, feel free to open an [issue in Github](https://github.com/deepset-ai/haystack/issues). We regularly check these and you can expect a quick response. If you'd like to discuss a topic, or get more general advice on how to make Haystack work for your project, you can start a thread in [Github Discussions](https://github.com/deepset-ai/haystack/discussions) or our [Discord channel](https://discord.com/invite/VBpFzsgRVF). We also check [𝕏 (Twitter)](https://twitter.com/haystack_ai) and [Stack Overflow](https://stackoverflow.com/questions/tagged/haystack).
+
+## Contributing to Haystack
+
+We are very open to the community's contributions - be it a quick fix of a typo, or a completely new feature! You don't need to be a Haystack expert to provide meaningful improvements. To learn how to get started, check out our [Contributor Guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md) first.
+
+There are several ways you can contribute to Haystack:
+- Contribute to the main Haystack project
+- Contribute an integration on [haystack-core-integrations](https://github.com/deepset-ai/haystack-core-integrations)
+
+> [!TIP]
+>👉 **[Check out the full list of issues that are open to contributions](https://github.com/orgs/deepset-ai/projects/14)**
+
+## Who Uses Haystack
+
+Here's a list of projects and companies using Haystack. Want to add yours? Open a PR, add it to the list and let the
+world know that you use Haystack!
+
+-   [Airbus](https://www.airbus.com/en)
+-   [Alcatel-Lucent](https://www.al-enterprise.com/)
+-   [Apple](https://www.apple.com/)
+-   [BetterUp](https://www.betterup.com/)
+-   [Databricks](https://www.databricks.com/)
+-   [Deepset](https://deepset.ai/)
+-   [Etalab](https://www.deepset.ai/blog/improving-on-site-search-for-government-agencies-etalab)
+-   [Infineon](https://www.infineon.com/)
+-   [Intel](https://github.com/intel/open-domain-question-and-answer#readme)
+-   [Intelijus](https://www.intelijus.ai/)
+-   [Intel Labs](https://github.com/IntelLabs/fastRAG#readme)
+-   [LEGO](https://github.com/larsbaunwall/bricky#readme)
+-   [Netflix](https://netflix.com)
+-   [NOS Portugal](https://www.nos.pt/en/welcome)
+-   [Nvidia](https://developer.nvidia.com/blog/reducing-development-time-for-intelligent-virtual-assistants-in-contact-centers/)
+-   [PostHog](https://github.com/PostHog/max-ai#readme)
+-   [Rakuten](https://www.rakuten.com/)
+-   [Sooth.ai](https://www.deepset.ai/blog/advanced-neural-search-with-sooth-ai)

testbed/deepset-ai__haystack/SECURITY.md

@@ -0,0 +1,26 @@
+# Security Policy
+
+## Report a Vulnerability
+
+If you found a security vulnerability in Haystack, send a message to
+[security@deepset.ai](mailto:security@deepset.ai).
+
+In your message, please include:
+
+1. Reproducible steps to trigger the vulnerability.
+2. An explanation of what makes you think there is a vulnerability.
+3. Any information you may have on active exploitations of the vulnerability (zero-day).
+
+## Vulnerability Response
+
+We'll review your report within 5 business days and we will do a preliminary analysis
+to confirm that the vulnerability is plausible. Otherwise, we'll decline the report.
+
+We won't disclose any information you share with us but we'll use it to get the issue
+fixed or to coordinate a vendor response, as needed.
+
+We'll keep you updated of the status of the issue.
+
+Our goal is to disclose bugs as soon as possible once a user mitigation is available.
+Once we get a good understanding of the vulnerability, we'll set a disclosure date after
+consulting the author of the report and Haystack maintainers.

testbed/deepset-ai__haystack/VERSION.txt

@@ -0,0 +1 @@
+2.8.0-rc0

testbed/deepset-ai__haystack/code_of_conduct.txt

@@ -0,0 +1,98 @@
+CONTRIBUTOR COVENANT CODE OF CONDUCT
+====================================
+
+Our Pledge
+----------
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for
+everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics,
+gender identity and expression, level of experience, education, socioeconomic status, nationality, personal appearance,
+race, caste, color, religion, or sexual identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community.
+
+Our Standards
+-------------
+
+Examples of behavior that contributes to a positive environment for our community include:
+    - Demonstrating empathy and kindness toward other people
+    - Being respectful of differing opinions, viewpoints, and experiences
+    - Giving and gracefully accepting constructive feedback
+    - Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience
+    - Focusing on what is best not just for us as individuals, but for the overall community
+
+Examples of unacceptable behavior include:
+    - The use of sexualized language or imagery, and sexual attention or advances of any kind
+    - Trolling, insulting or derogatory comments, and personal or political attacks
+    - Public or private harassment
+    - Publishing others’ private information, such as a physical or email address, without their explicit permission
+    - Other conduct which could reasonably be considered inappropriate in a professional setting
+
+Enforcement Responsibilities
+----------------------------
+
+Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take
+appropriate and fair corrective action in response to any behavior that they deem inappropriate,
+threatening, offensive, or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits,
+issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for
+moderation decisions when appropriate.
+
+Scope
+-----
+
+This Code of Conduct applies within all community spaces, and also applies when an individual is officially
+representing the community in public spaces. Examples of representing our community include using an official
+e-mail address, posting via an official social media account, or acting as an appointed representative
+at an online or offline event.
+
+Enforcement
+-----------
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible
+for enforcement at engage@deepset.ai. All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the reporter of any incident.
+
+Enforcement Guidelines
+----------------------
+
+Community leaders will follow these Community Impact Guidelines in determining the consequences for any action
+they deem in violation of this Code of Conduct:
+
+1. Correction
+    Community Impact: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community.
+
+    Consequence: A private, written warning from community leaders, providing clarity around the nature of the violation
+    and an explanation of why the behavior was inappropriate. A public apology may be requested.
+
+2. Warning
+    Community Impact: A violation through a single incident or series of actions.
+
+    Consequence: A warning with consequences for continued behavior. No interaction with the people involved,
+    including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time.
+    This includes avoiding interactions in community spaces as well as external channels like social media.
+    Violating these terms may lead to a temporary or permanent ban.
+
+3. Temporary Ban
+    Community Impact: A serious violation of community standards, including sustained inappropriate behavior.
+
+    Consequence: A temporary ban from any sort of interaction or public communication with the community for a specified
+    period of time. No public or private interaction with the people involved, including unsolicited interaction with
+    those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban.
+
+4. Permanent Ban
+    Community Impact: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals.
+
+    Consequence: A permanent ban from any sort of public interaction within the community.
+
+Attribution
+-----------
+
+This Code of Conduct is adapted from the Contributor Covenant, version 2.0, available at https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by Mozilla’s code of conduct enforcement ladder.
+
+For answers to common questions about this code of conduct, see the FAQ at https://www.contributor-covenant.org/faq.
+Translations are available at https://www.contributor-covenant.org/translations.

testbed/deepset-ai__haystack/docs/README.md

@@ -0,0 +1,57 @@
+# :ledger: Looking for the docs?
+
+You can find Haystack's documentation at https://docs.haystack.deepset.ai/.
+
+# :computer: How to update docs?
+
+## Overview, Components, Pipeline Nodes, and Guides
+
+You can find these docs on the Haystack Docs page: https://docs.haystack.deepset.ai/docs/get_started. If you want to contribute, and we welcome every contribution, do the following:
+1. Make sure you're on the right version (check the version expanding list in the top left corner).
+2. Use the "Suggest Edits" link you can find in the top right corner of every page.
+3. Suggest a change right in the docs and click **Submit Suggested Edits**.
+4. Optionally, leave us a comment and submit your change.
+
+Once we take care of it, you'll get an email telling you the change's been merged, or not. If not, we'll give you the reason why.
+
+Make sure to check our [Contribution Guidelines](https://github.com/deepset-ai/haystack/blob/main/CONTRIBUTING.md).
+
+## Tutorials
+
+The Tutorials live in a separate repo: https://github.com/deepset-ai/haystack-tutorials. For instructions on how to contribute to tutorials, see [Contributing to Tutorials](https://github.com/deepset-ai/haystack-tutorials/blob/main/Contributing.md#contributing-to-haystack-tutorials).
+
+## API Reference
+
+We use Pydoc-Markdown to create Markdown files from the docstrings in our code. There is a Github Action that regenerates the API pages with each commit.
+
+If you want to generate a new Markdown file for a new Haystack module, create a `.yml` file in `docs/src/api/api` which configures how Pydoc-Markdown will generate the page and commit it to main.
+
+All the updates to doctrings get pushed to documentation when you commit to the main branch.
+
+### Configuration
+
+Pydoc will read the configuration from a `.yml` file which is located under `/haystack/docs/_src/api/pydoc`. Our files contain three main sections:
+
+- **loader**: A list of plugins that load API objects from python source files.
+    - **type**: Loader for python source files
+    - **search_path**: Location of source files
+    - **modules**: Module which are used for generating the markdown file
+    - **ignore_when_discovered**: Define which files should be ignored
+- **processor**: A list of plugins that process API objects to modify their docstrings (e.g. to adapt them from a documentation format to Markdown or to remove items that should not be rendered into the documentation).
+    - **type: filter**: Filter for specific modules
+    - **documented_only**: Only documented API objects
+    - **do_not_filter_modules**: Do not filter module objects
+    - **skip_empty_modules**: Skip modules without content
+- **renderer**: A plugin that produces the output files. We use a custom ReadmeRenderer based on the Markdown renderer. It makes sure the Markdown files comply with ReadMe requirements.
+    - **type**: Define the renderer which you want to use. We are using the ReadmeRenderer to make sure the files display properly in ReadMe.
+    - **excerpt**: Add a short description of the page. It shows up right below the page title.
+    - **category**: This is the ReadMe category ID to make sure the doc lands in the right section of Haystack docs.
+    - **title**: The title of the doc as it will appear on the website. Make sure you always add "API" at the end.
+    - **slug**: The page slug, each word should be separated with a dash.
+    - **order**: Pages are ordered alphabetically. This defines where in the TOC the page lands.
+    - markdown:
+        - **descriptive_class_title**: Remove the word "Object" from class titles.
+        - **descriptive_module_title**: Adding the word “Module” before the module name.
+        - **add_method_class_prefix**: Add the class name as a prefix to method names.
+        - **add_member_class_prefix**: Add the class name as a prefix to member names.
+        - **filename**: File name of the generated file, use underscores to separate each word.

testbed/deepset-ai__haystack/docs/pydoc/config/audio_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/audio]
+    modules: ["whisper_local", "whisper_remote"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Transcribes audio files.
+  category_slug: haystack-api
+  title: Audio
+  slug: audio-api
+  order: 3
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: audio_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/builders_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/builders]
+    modules: ["answer_builder", "prompt_builder", "chat_prompt_builder"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Extract the output of a Generator to an Answer format, and build prompts.
+  category_slug: haystack-api
+  title: Builders
+  slug: builders-api
+  order: 5
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: builders_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/caching_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/caching]
+    modules: ["cache_checker"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Checks if any document coming from the given URL is already present in the store.
+  category_slug: haystack-api
+  title: Caching
+  slug: caching-api
+  order: 7
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: cachings_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/classifiers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/classifiers]
+    modules: ["document_language_classifier", "zero_shot_document_classifier"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Classify documents based on the provided labels.
+  category_slug: haystack-api
+  title: Classifiers
+  slug: classifiers-api
+  order: 10
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: classifiers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/connectors.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/connectors]
+    modules: ["openapi_service"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Various connectors to integrate with external services.
+  category_slug: haystack-api
+  title: Connectors
+  slug: connectors-api
+  order: 15
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: connectors_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/converters_api.yml

@@ -0,0 +1,42 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/converters]
+    modules:
+      [
+        "azure",
+        "csv",
+        "docx",
+        "html",
+        "json",
+        "markdown",
+        "openapi_functions",
+        "output_adapter",
+        "pdfminer",
+        "pptx",
+        "pypdf",
+        "tika",
+        "txt",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Various converters to transform data from one format to another.
+  category_slug: haystack-api
+  title: Converters
+  slug: converters-api
+  order: 20
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: converters_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/data_classess_api.yml

@@ -0,0 +1,28 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/dataclasses]
+    modules:
+      ["answer", "byte_stream", "chat_message", "document", "streaming_chunk", "sparse_embedding"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Core classes that carry data through the system.
+  category_slug: haystack-api
+  title: Data Classes
+  slug: data-classes-api
+  order: 30
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: data_classess_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/document_stores_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/document_stores/in_memory]
+    modules: ["document_store"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Stores your texts and meta data and provides them to the Retriever at query time.
+  category_slug: haystack-api
+  title: Document Stores
+  slug: document-stores-api
+  order: 40
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: document_stores_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/document_writers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/writers]
+    modules: ["document_writer"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Writes Documents to a DocumentStore.
+  category_slug: haystack-api
+  title: Document Writers
+  slug: document-writers-api
+  order: 50
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: document_writers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/embedders_api.yml

@@ -0,0 +1,37 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/embedders]
+    modules:
+      [
+        "azure_document_embedder",
+        "azure_text_embedder",
+        "hugging_face_api_document_embedder",
+        "hugging_face_api_text_embedder",
+        "openai_document_embedder",
+        "openai_text_embedder",
+        "sentence_transformers_document_embedder",
+        "sentence_transformers_text_embedder",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Transforms queries into vectors to look for similar or relevant Documents.
+  category_slug: haystack-api
+  title: Embedders
+  slug: embedders-api
+  order: 60
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: embedders_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/evaluation_api.yml

@@ -0,0 +1,31 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/evaluation]
+    modules:
+      [
+        "base",
+        "eval_run_result",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Represents the results of evaluation.
+  category_slug: haystack-api
+  title: Evaluation
+  slug: evaluation-api
+  order: 61
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: evaluation_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/evaluators_api.yml

@@ -0,0 +1,38 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/evaluators]
+    modules:
+      [
+        "answer_exact_match",
+        "context_relevance",
+        "document_map",
+        "document_mrr",
+        "document_ndcg",
+        "document_recall",
+        "faithfulness",
+        "llm_evaluator",
+        "sas_evaluator",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Evaluate your pipelines or individual components.
+  category_slug: haystack-api
+  title: Evaluators
+  slug: evaluators-api
+  order: 63
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: evaluators_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/extractors_api.yml

@@ -0,0 +1,29 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/extractors]
+    modules: ["named_entity_extractor"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: filter
+    expression: "name not in ['_BackendEnumMeta', '_NerBackend', '_HfBackend', '_SpacyBackend']"
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Extracts predefined entities out of a piece of text.
+  category_slug: haystack-api
+  title: Extractors
+  slug: extractors-api
+  order: 65
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: extractors_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/fetchers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/fetchers]
+    modules: ["link_content"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Fetches content from a list of URLs and returns a list of extracted content streams.
+  category_slug: haystack-api
+  title: Fetchers
+  slug: fetchers-api
+  order: 80
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: fetchers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/generators_api.yml

@@ -0,0 +1,37 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/generators]
+    modules:
+      [
+        "azure",
+        "hugging_face_local",
+        "hugging_face_api",
+        "openai",
+        "chat/azure",
+        "chat/hugging_face_local",
+        "chat/hugging_face_api",
+        "chat/openai",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Enables text generation using LLMs.
+  category_slug: haystack-api
+  title: Generators
+  slug: generators-api
+  order: 70
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: generators_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/joiners_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/joiners]
+    modules: ["document_joiner", "branch", "answer_joiner", "string_joiner"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Components that join list of different objects
+  category_slug: haystack-api
+  title: Joiners
+  slug: joiners-api
+  order: 75
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: joiners_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/pipeline_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/core/pipeline]
+    modules: ["pipeline"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Arranges components and integrations in flow.
+  category_slug: haystack-api
+  title: Pipeline
+  slug: pipeline-api
+  order: 90
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: pipeline_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/preprocessors_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/preprocessors]
+    modules: ["document_cleaner", "document_splitter", "text_cleaner", "nltk_document_splitter"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Preprocess your Documents and texts. Clean, split, and more.
+  category_slug: haystack-api
+  title: PreProcessors
+  slug: preprocessors-api
+  order: 100
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: preprocessors_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/rankers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/rankers]
+    modules: ["lost_in_the_middle", "meta_field", "transformers_similarity", "sentence_transformers_diversity"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Reorders a set of Documents based on their relevance to the query.
+  category_slug: haystack-api
+  title: Rankers
+  slug: rankers-api
+  order: 110
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: rankers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/readers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/readers]
+    modules: ["extractive"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Takes a query and a set of Documents as input and returns ExtractedAnswers by selecting a text span within the Documents.
+  category_slug: haystack-api
+  title: Readers
+  slug: readers-api
+  order: 120
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: readers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/retrievers_api.yml

@@ -0,0 +1,33 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/retrievers]
+    modules:
+      [
+        "in_memory/bm25_retriever",
+        "in_memory/embedding_retriever",
+        "filter_retriever",
+        "sentence_window_retriever",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Sweeps through a Document Store and returns a set of candidate Documents that are relevant to the query.
+  category_slug: haystack-api
+  title: Retrievers
+  slug: retrievers-api
+  order: 130
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: retrievers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/routers_api.yml

@@ -0,0 +1,35 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/routers]
+    modules:
+      [
+        "conditional_router",
+        "file_type_router",
+        "metadata_router",
+        "text_language_router",
+        "transformers_text_router",
+        "zero_shot_text_router",
+      ]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Routers is a group of components that route queries or Documents to other components that can handle them best.
+  category_slug: haystack-api
+  title: Routers
+  slug: routers-api
+  order: 140
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: routers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/samplers_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/samplers]
+    modules: ["top_p"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Filters documents based on their similarity scores using top-p sampling.
+  category_slug: haystack-api
+  title: Samplers
+  slug: samplers-api
+  order: 150
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: samplers_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/utils_api.yml

@@ -0,0 +1,28 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/utils]
+    ignore_when_discovered: ["__init__", "hf"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: filter
+    expression: "name not in ['TokenSecret', 'EnvVarSecret','_get_default_device', '_split_device_string', 'convert']"
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Utility functions and classes used across the library.
+  category_slug: haystack-api
+  title: Utils
+  slug: utils-api
+  order: 153
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: utils_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/validators_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/validators]
+    modules: ["json_schema"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Validators validate LLM outputs
+  category_slug: haystack-api
+  title: Validators
+  slug: validators-api
+  order: 155
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: validators_api.md

testbed/deepset-ai__haystack/docs/pydoc/config/websearch_api.yml

@@ -0,0 +1,27 @@
+loaders:
+  - type: haystack_pydoc_tools.loaders.CustomPythonLoader
+    search_path: [../../../haystack/components/websearch]
+    modules: ["serper_dev", "searchapi"]
+    ignore_when_discovered: ["__init__"]
+processors:
+  - type: filter
+    expression:
+    documented_only: true
+    do_not_filter_modules: false
+    skip_empty_modules: true
+  - type: smart
+  - type: crossref
+renderer:
+  type: haystack_pydoc_tools.renderers.ReadmeCoreRenderer
+  excerpt: Web search engine for Haystack.
+  category_slug: haystack-api
+  title: Websearch
+  slug: websearch-api
+  order: 170
+  markdown:
+    descriptive_class_title: false
+    classdef_code_block: false
+    descriptive_module_title: true
+    add_method_class_prefix: true
+    add_member_class_prefix: false
+    filename: websearch_api.md

testbed/deepset-ai__haystack/examples/README.md

@@ -0,0 +1,5 @@
+# Examples have been moved!
+
+If you're searching for Haystack examples we moved them into a dedicated repository.
+
+You can find all the example cookbooks [👉 here 👈](https://github.com/deepset-ai/haystack-cookbook/).

testbed/deepset-ai__haystack/license-header.txt

@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: ${inceptionYear}-present ${copyrightOwner}
+
+SPDX-License-Identifier: Apache-2.0

testbed/deepset-ai__haystack/licenserc.toml

@@ -0,0 +1,23 @@
+headerPath = "license-header.txt"
+
+excludes = [
+    ".github",
+    "docker",
+    "docs",
+    "examples",
+    "proposals",
+    "releasenotes",
+    "test",
+    "CITATION.cff",
+    "*.ini",
+    "*.jinja2",
+    "*.md",
+    "*.toml",
+    "*.txt",
+    "*.yaml",
+    "*.wav",
+]
+
+[properties]
+inceptionYear = 2022
+copyrightOwner = "deepset GmbH <info@deepset.ai>"

testbed/deepset-ai__haystack/proposals/0000-template.md

@@ -0,0 +1,64 @@
+- Title: (the title in plain english)
+- Decision driver: (your name here)
+- Start Date: (today's date, in format YYYY-MM-DD)
+- Proposal PR: (fill in after opening the PR)
+- Github Issue or Discussion: (only if available, link the original request for this change)
+
+# Summary
+
+Explain the feature briefly.
+
+# Basic example
+
+When applicable, write a snippet of code showing how the new feature would
+be used.
+
+# Motivation
+
+Give us more background and explanation: Why do we need this feature? What use cases does it support? What's the expected
+outcome?
+
+Focus on explaining the motivation for this feature. We'd like to understand it, so that even if we don't accept this
+proposal, others can use the motivation to develop alternative solutions.
+
+# Detailed design
+
+This is the bulk of the proposal. Explain the design in enough detail for somebody
+familiar with Haystack to understand, and for somebody familiar with the
+implementation to implement. Get into specifics and corner-cases,
+and include examples of how the feature is used. Also, if there's any new terminology involved,
+define it here.
+
+# Drawbacks
+
+Look at the feature from the other side: what are the reasons why we should _not_ work on it? Consider the following:
+
+- What's the implementation cost, both in terms of code size and complexity?
+- Can the solution you're proposing be implemented as a separate package, outside of Haystack?
+- Does it teach people more about Haystack?
+- How does this feature integrate with other existing and planned features?
+- What's the cost of migrating existing Haystack pipelines (is it a breaking change?)?
+
+There are tradeoffs to choosing any path. Attempt to identify them here.
+
+# Alternatives
+
+What other designs have you considered? What's the impact of not adding this feature?
+
+# Adoption strategy
+
+If we implement this proposal, how will the existing Haystack users adopt it? Is
+this a breaking change? Can we write a migration script?
+
+# How we teach this
+
+Would implementing this feature mean the documentation must be re-organized
+or updated? Does it change how Haystack is taught to new developers at any level?
+
+How should this feature be taught to the existing Haystack users (for example with a page in the docs,
+a tutorial, ...).
+
+# Unresolved questions
+
+Optional, but suggested for first drafts. What parts of the design are still
+TBD?

testbed/deepset-ai__haystack/proposals/README.md

@@ -0,0 +1,120 @@
+# Haystack proposals design process
+
+Most of the changes to Haystack, including bug fixes and small improvements,
+are implemented through the normal Pull Request workflow, according to our
+[contribution guidelines](../CONTRIBUTING.md).
+
+Some changes, though, are "substantial", and these are the ones we want to put through a bit
+of a design process to make sure we're all on the same page before we invest the time
+into the actual implementation of a new feature or a deep refactoring.
+
+We've introduced the "Proposals design process" to provide a
+consistent and controlled path for such changes to Haystack.
+
+We will apply the same level of rigor to both core developers' and
+Community's proposals. The primary difference between them is in the design phase:
+core developers proposals tend to be submitted at the end of the design process
+whereas the Community ones tend to be submitted at the beginning, as a way
+to kickstart it.
+
+## When do I follow the process?
+
+Follow the process if you intend to make "substantial" changes to Haystack, `rest_api` or the process itself.  What is
+defined as a "substantial" change is evolving based on community norms and on what part of the project you are proposing
+to change, but it may include the following:
+
+- A new feature that creates new API surface areas.
+- A new component (Nodes, Pipelines, Document Stores).
+- Removing features that already shipped in the current minor version.
+- A deep refactoring that would require new tests or introduce new dependencies.
+- A change that's complex enough to require multiple steps to be delivered.
+
+Some changes don't require a proposal, for example:
+
+- Minor bug fixes.
+- Rephrasing, reorganizing, or otherwise "changing shape does not change meaning".
+- Addition and removal of warnings or other error messages.
+- Additions only likely to be noticed by other contributors, invisible to Haystack users.
+
+In any case, the core developers might politely ask you to submit a proposal before merging
+a new feature when they see fit.
+
+## Before creating a proposal
+
+Laying some groundwork ahead of the proposal can make the process smoother.
+
+Although there is no single way to prepare for submitting a proposal, it is generally a good idea
+to collect feedback from other project developers first, to make sure that the change is
+is actually needed. As we're an open source community where everyone can impact the project, we all
+need to make an effort to build consensus.
+
+When you're preparing for writing and submitting a proposal, talk the idea over on our official
+[Discord server](https://haystack.deepset.ai/community/join) and in a Github
+issue or discussion in the [Haystack repository](https://github.com/deepset-ai/haystack).
+
+## The process
+
+To get a major feature added to Haystack, you first merge the proposal into the Haystack repo as a Markdown file.
+At that point, the proposal can be implemented and eventually included into the codebase.
+
+There are several people involved in the process:
+- **Decision Driver**: the person creating the proposal. If the Decision Driver is not a core contributor themselves,
+  one will be assigned to the PR and will take care of facilitating the process.
+- **Input Givers**: anybody reviewing or commenting the PR.
+- **Approvers**: the core contributors approving the PR.
+
+During its lifecycle, a proposal can transition between the following states:
+- **Review**: proposal is getting feedback.
+- **Final Comment**: proposal received approval from 3 core contributors; this state must be kept for a grace period of
+  3 calendar days.
+- **Active**: proposal was approved and merged and can be implemented if not already.
+- **Stale**: proposal didn't get any update in the last 30 days and will be closed after a grace period of 10 days.
+- **Rejected**: proposal was actively rejected and the reasons explained.
+
+
+To create a proposal:
+
+1. Copy `0000-template.md` to `text/0000-my-feature.md`, where 'my-feature' is a descriptive name of the feature you're
+   proposing. Don't assign an identification number yet.
+2. Fill in the proposal. Pay attention to details. Proposals that present convincing motivation,
+   demonstrate an understanding of the feature impact, and honestly present the drawbacks and
+   alternatives tend to be received well.
+3. Submit a pull request. This ensures the document receives design feedback from a larger community,
+   and as the Decision Driver, you should be prepared to revise it in response.
+4. Rename the file using the PR number, for example from `text/0000-my-feature.md` to `text/4242-my-feature.md`. The
+   proposal is now in **Review** state.
+5. Reach an agreement with the Input Givers and integrate the feedback you got. Proposals that have broad support are
+   much more likely to make progress than those that don't receive any comments.
+6. Now it's time for the Approvers to decide whether the proposal is a candidate for inclusion in Haystack. Note that a
+   review from the core contributors may take a long time, and getting early feedback from members of the Community can
+   ease the process.
+7. When the proposal enters the **Final Comment** state (see above), the PR will be marked accordingly, entering a
+   grace period lasting 3 calendar days during which a proposal can be modified based on feedback from core developers
+   or the Community. Big changes may trigger a new final comment period.
+8. Approvers may reject a proposal once the public discussion and adding comments are over, adding the reason for
+   rejection. A core developer then closes the related PR. The proposal gets the **Rejected** state.
+9. When the final comment period ends, the PR is merged and the proposal becomes **Active**.
+
+## What happens next
+
+Once a proposal becomes active, the authors are free to implement it and submit the feature as one or more pull
+requests to the Haystack repo. Becoming 'active' is not a rubber stamp, and in particular still doesn't
+mean the feature will ultimately be merged; it does mean that the core team has agreed to it in
+principle and is open to merging it if the implementation reflects the contents of the proposal.
+
+The fact that a given proposal has been accepted and is 'active' doesn't imply it has a priority assigned or somebody's
+currently working on it.
+
+To change an active proposal, open follow-up PRs. Our goal is to write each proposal so that
+it reflects the final design of the feature, but the nature of the process means that we cannot
+expect every merged proposal to actually reflect what the end result will be at the time of the next release.
+That's why we try to keep each proposal document somewhat in sync with the feature as planned, tracking such
+changes through follow-up pull requests to the document.
+
+As the author of a proposal, you're not obligated to implement it. Of course, the author (like any other developer)
+is welcome to post an implementation for review after the proposal has been accepted.
+
+## Inspiration
+
+Haystack's proposals design process process owes its inspiration to the [React](https://github.com/reactjs/rfcs) and
+[Rust](https://github.com/rust-lang/rfcs) RFC processes. We're open to changing it if needed.

testbed/deepset-ai__haystack/proposals/text/2170-pydantic-dataclasses.md

@@ -0,0 +1,80 @@
+<!--
+NOTE: this document was imported from a different process and is not compliant with the proposal template. Do not
+use it as a reference for new proposals.
+-->
+- Start Date: 2021-10-14
+- Proposal PR: n/a
+- Github Issue: https://github.com/deepset-ai/haystack/pull/1598
+- Deciders: @tholor
+
+
+## Context and Problem Statement
+
+Originally we implemented Haystack's primitive based on Python's vanilla `dataclasses`. However, shortly after we realized this causes issues with FastAPI, which uses Pydantic's implementation. We need to decide which version (vanilla Python's or Pydantic's) to use in our codebase.
+
+## Decision Drivers
+
+* The Swagger autogenerated documentation for REST API in FastAPI was broken where the dataclasses include non-standard fields (`pd.dataframe` + `np.ndarray`)
+
+## Considered Options
+
+* Switch to Pydantic `dataclasses` in our codebase as well.
+* Staying with vanilla `dataclasses` and find a workaround for FastAPI to accept them in place of Pydantic's implementation.
+
+## Decision Outcome
+
+Chosen option: **1**, because our initial concerns about speed proved negligible and Pydantic's implementation provided some additional functionality for free (see below).
+
+### Positive Consequences
+
+* We can now inherit directly from the primitives in the REST API dataclasses, and overwrite the problematic fields with standard types.
+* We now get runtime type checks "for free", as this is a core feature of Pydantic's implementation.
+
+### Negative Consequences
+
+* Pydantic dataclasses are slower. See https://github.com/deepset-ai/haystack/pull/1598 for a rough performance assessment.
+* Pydantic dataclasses do not play nice with mypy and autocomplete tools unaided. In many cases a complex import statement, such as the following, is needed:
+
+```python
+if typing.TYPE_CHECKING:
+    from dataclasses import dataclass
+else:
+    from pydantic.dataclasses import dataclass
+```
+
+## Pros and Cons of the Options
+
+### Switch to Pydantic `dataclasses`
+
+* Good, because it solves the issue without having to find workarounds for FastAPI.
+* Good, because it adds type checks at runtime.
+* Bad, because mypy and autocomplete tools need assistance to parse its dataclasses properly. Example:
+
+```python
+if typing.TYPE_CHECKING:
+    from dataclasses import dataclass
+else:
+    from pydantic.dataclasses import dataclass
+```
+
+* Bad, because it introduces an additional dependency to Haystack (negligible)
+* Bad, because it adds some overhead on the creation of primitives (negligible)
+
+### Staying with vanilla `dataclasses`
+
+* Good, because it's Python's standard way to generate data classes
+* Good, because mypy can deal with them without plugins or other tricks.
+* Good, because it's faster than Pydantic's implementation.
+* Bad, because does not play well with FastAPI and Swagger (critical).
+* Bad, because it has no validation at runtime (negligible)
+
+## Links <!-- optional -->
+
+* https://pydantic-docs.helpmanual.io/usage/dataclasses/
+* https://github.com/deepset-ai/haystack/pull/1598
+* https://github.com/deepset-ai/haystack/issues/1593
+* https://github.com/deepset-ai/haystack/issues/1582
+* https://github.com/deepset-ai/haystack/pull/1398
+* https://github.com/deepset-ai/haystack/issues/1232
+
+<!-- markdownlint-disable-file MD013 -->

testbed/deepset-ai__haystack/proposals/text/3550-csv-converter.md

@@ -0,0 +1,86 @@
+- Start Date: 2022-11-28
+- Proposal PR: [#3638](https://github.com/deepset-ai/haystack/issues/3638)
+- Github Issue: [#3550](https://github.com/deepset-ai/haystack/issues/3550)
+
+# Summary
+
+Using Haystack for questions answering pipelines is prettier easy, but most of the time users have CSV files containing
+their knowledge base with questions and there associated answers.
+Unfortunately there is no easy way to dynamically update the knowledge base or import new data from CSV though rest API
+using YAML, as there are no CSV parser.
+
+Having a basic way to dynamically index a CSV file always requires development of a new nodes.
+
+# Basic example
+
+To define an FAQ query and **indexing** pipeline we would then simply do :
+```yaml
+# To allow your IDE to autocomplete and validate your YAML pipelines, name them as <name of your choice>.haystack-pipeline.yml
+
+version: ignore
+
+components:    # define all the building-blocks for Pipeline
+  - name: DocumentStore
+    type: ElasticsearchDocumentStore
+    params:
+      host: localhost
+      embedding_field: question_emb
+      embedding_dim: 384
+      excluded_meta_data:
+        - question_emb
+      similarity: cosine
+  - name: Retriever
+    type: EmbeddingRetriever
+    params:
+      document_store: DocumentStore    # params can reference other components defined in the YAML
+      embedding_model: sentence-transformers/all-MiniLM-L6-v2
+      scale_score: False
+  - name: CSVConverter
+    type: CsvTextConverter
+
+pipelines:
+  - name: indexing
+    nodes:
+      - name: CSVConverter
+        inputs: [File]
+      - name: Retriever
+        inputs: [ CSVConverter ]
+      - name: DocumentStore
+        inputs: [ Retriever ]
+```
+
+# Motivation
+
+Using YAML pipeline description it's not possible to describe a CSV FAQ indexing pipeline that takes CSV files as input
+containing questions and answers and index them. It's a basic usage that still requires coding.
+
+As we are presenting a tutorial `Utilizing Existing FAQs for Question Answering` it would be great to have this basic
+node so that anyone can quickly run an FAQ Question Answering pipeline using only a YAML description and import their
+CSV though REST API.
+
+# Detailed design
+
+I've added a new node: **`CsvTextConverter`** . It takes a file input, parse it as FAQ CSV file having `question` and `answer` column
+and outputs `Document`s.
+
+For now the node is very simple: can only handle a fixed CSV format and no other tabular data. It also
+can't produce documents that are not of type `text`. These shortcomings can be addressed in later enhancements.
+
+# Drawbacks
+
+We could consider that developing this custom node is easy and a good way to learn Haystack,
+but casual users shouldn't need to know this much before being able to index CSV files.
+
+# Alternatives
+
+Didn't consider any other design.
+
+# Adoption strategy
+
+It doesn't introduce any breaking change, any users having FAQs pipeline would be able to use the official nodes instead
+of their existing ones.
+
+# How we teach this
+
+This may require updating this tutorial [Utilizing Existing FAQs for Question Answering](https://haystack.deepset.ai/tutorials/04_faq_style_qa)
+and to document those 2 nodes.

testbed/deepset-ai__haystack/proposals/text/3558-embedding_retriever.md

@@ -0,0 +1,131 @@
+- Start Date: 2022-11-11
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3558
+- Github Issue:
+
+> ⚠️ Superseded by https://github.com/deepset-ai/haystack/blob/main/proposals/text/5390-embedders.md
+
+  # Summary
+
+- Current EmbeddingRetriever doesn't allow Haystack users to provide new embedding methods and is
+  currently constricted to farm, transformers, sentence transformers, OpenAI and Cohere based
+  embedding approaches. Any new encoding methods need to be explicitly added to Haystack
+  and registered with the EmbeddingRetriever.
+
+
+- We should allow users to easily plug-in new embedding methods to EmbeddingRetriever. For example, a Haystack user should be able to
+  add custom embeddings without having to commit additional code to Haystack repository.
+
+  # Basic example
+    EmbeddingRetriever is instantiated with:
+
+  ``` python
+	  retriever = EmbeddingRetriever(
+	      document_store=document_store,
+	      embedding_model="sentence-transformers/multi-qa-mpnet-base-dot-v1",
+	      model_format="sentence_transformers",
+	  )
+  ```
+- The current approach doesn't provide a pluggable abstraction point of composition but
+  rather attempts to satisfy various embedding methodologies by having a lot of
+  parameters which keep ever expanding.
+
+
+- The new approach allows creation of the underlying embedding mechanism (EmbeddingEncoder)
+  which is then in turn plugged into EmbeddingRetriever.  For example:
+
+  ``` python
+	  encoder = SomeNewFancyEmbeddingEncoder(api_key="asdfklklja",
+                                          query_model="text-search-query",
+                                          doc_model="text-search-doc")
+  ```
+
+- EmbeddingEncoder is then used for the creation of EmbeddingRetriever. EmbeddingRetriever
+  init method doesn't get polluted with additional parameters as all of the peculiarities
+  of a particular encoder methodology are contained on in its abstraction layer.
+
+  ``` python
+	  retriever = EmbeddingRetriever(
+	      document_store=document_store,
+	      encoder=encoder
+	  )
+  ```
+
+  # Motivation
+
+- Why are we doing this? What use cases does it support? What is the expected outcome?
+
+  We could certainly keep the current solution as is; it does implement a decent level
+  of composition/decoration to lower coupling between EmbeddingRetriever and the underlying
+  mechanism of embedding (sentence transformers, OpenAI, etc). However, the current mechanism
+  in place basically hard-codes available embedding implementations and prevents our users from
+  adding new embedding mechanism by themselves outside of Haystack repository. We also might
+  want to have a non-public dC embedding mechanism in the future. In the current design a non-public
+  dC embedding mechanism would be impractical. In addition, the more underlying implementations we
+  add we'll continue to "pollute" EmbeddingRetriever init method with more and more parameters.
+  This is certainly less than ideal long term.
+
+
+- EmbeddingEncoder classes should be subclasses of BaseComponent! As subclasses of BaseComponent,
+  we can use them outside the EmbeddingRetriever context in indexing pipelines, generating the
+  embeddings. We are currently employing a kludge of using Retrievers which is quite counter-intuitive
+  and confusing for our users.
+
+
+- EmbeddingEncoder classes might sound overly complicated, especially with a distinguishing mechanism
+  name pre-appended (i.e CohereEmbeddingEncoder). Therefore, we'll adopt <specific>Embedder
+  naming scheme, i.e. CohereEmbedder, SentenceTransformerEmbedder and so on.
+
+  # Detailed design
+
+- Our new EmbeddingRetriever would still wrap the underlying encoding mechanism in the form of
+  _BaseEmbedder. _BaseEmbedder still needs to implement methods:
+	- embed_queries
+	- embed_documents
+
+
+- The new design approach differs is in the creation of EmbeddingRetriever - rather than hiding the underlying encoding
+  mechanism one could simply create the EmbeddingRetriever with a specific encoder directly. For example:
+
+  ```
+	  retriever = EmbeddingRetriever(
+	      document_store=document_store,
+	      encoder=OpenAIEmbedder(api_key="asdfklklja", model="ada"),
+	      #additional EmbeddingRetriever-abstraction-level parameters
+	  )
+  ```
+
+- If the "two-step approach" of EmbeddingRetriever initialization is no longer the ideal solution (issues with current
+  schema generation and loading/saving via YAML pipelines) we might simply add the EmbeddingRetriever
+  class for every supported encoding approach. For example, we could have OpenAIEmbeddingRetriever, CohereEmbeddingRetriever,
+  SentenceTransformerEmbeddingRetriever and so on. Each of these retrievers will delegate the bulk of the work to an
+  existing EmbeddingRetriever with a per-class-specific Embedder set in the class constructor (for that custom
+  encoding part). We'll get the best of both worlds. Each <Specific>EmeddingRetriever will have only the relevant primitives
+  parameters for the **init()** constructor; the underlying EmbeddingRetriever attribute in <Specific>EmeddingRetriever
+  will handle most of the business logic of retrieving, yet each retriever will use an appropriate per-class-specific
+  Embedder for the custom encoding part.
+
+
+
+  # Drawbacks
+- The main shortcoming are:
+	- The "two-step approach" in EmbeddingRetriever initialization
+	- Likely be an issue for the current schema generation and loading/saving via YAML pipelines (see solution above)
+	- It is a API breaking change so it'll require code update for all EmbeddingRetriever usage both in our codebase and for Haystack users
+	- Can only be done in major release along with other breaking changes
+
+  # Alternatives
+
+  We could certainly keep everything as is :-)
+
+  # Adoption strategy
+- As it is a breaking change, we should implement it for the next major release.
+
+  # How do we teach this?
+- This change would require only a minor change in documentation.
+- The concept of embedding retriever remains, just the mechanics are slightly changed
+- All docs and tutorials need to be updated
+- Haystack users are informed about a possibility to create and use their own embedders for embedding retriever.
+- # Unresolved questions
+
+  Optional, but suggested for first drafts. What parts of the design are still
+  TBD?

testbed/deepset-ai__haystack/proposals/text/3665-prompt-node.md

@@ -0,0 +1,445 @@
+- Start Date: 2022-12-04
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3665
+- Github Issue: https://github.com/deepset-ai/haystack/issues/3306
+- Example Colab notebook: https://colab.research.google.com/drive/1bOIxb8cnpTrpMtTSBArY9FJlL59Ar4K_?usp=sharing
+
+ # Summary
+
+- The PromptNode class is the central abstraction in Haystack's large language model (LLM) support.
+  Such a component supports multiple NLP tasks out-of-the-box. PromptNode allows users to
+  perform multiple tasks, such as summarization, question answering, question generation etc. using a single,
+  unified model within the Haystack framework.
+
+
+- One of the benefits of PromptNode is that it allows users to define and add additional tasks
+  that are supported by the model. This can enable users to extend the capabilities of the model and
+  to use it for a wider range of NLP tasks within the Haystack ecosystem.
+
+
+  # Basic example
+
+  PromptNode is instantiated with the underlying LLM model and prompted by using natural language:
+
+  ``` python
+	  from haystack.nodes.llm import PromptNode
+      pn = PromptNode(model_name_or_path="google/flan-t5-base")
+      pn("What is the capital of Germany?")
+
+      ----------------------------------------------------------------------------
+      ['berlin']
+  ```
+
+  # Motivation
+
+
+- The use of large language models (LLMs) has become increasingly popular in natural language
+  processing (NLP) due to their ability to capture complex and nuanced patterns in language.
+  PromptNode allows users to leverage the power of LLMs in the Haystack ecosystem, and
+  to perform multiple NLP tasks using a single, unified model. This provides a flexible and efficient
+  tool for NLP in Haystack, and can enable users to improve the performance and reliability of their applications.
+
+
+- Modern LLM support hundreds if not thousands of tasks. Aside from PromptNode we'll define prompt templates for
+  dozen or so most popular NLP tasks and allow users to register prompt templates for additional tasks. The
+  extensible and modular approach would allow users to extend the capabilities of the model and to use
+  it for a wider range of NLP tasks within the Haystack ecosystem. Prompt engineers would define templates
+  for each NLP task and register them with the PromptNode. The burden of defining the best templates for each task
+  would be on the prompt engineers and not on the users.
+
+
+- The use of templates to define NLP tasks can make it easier for users to use PromptNode, as
+  they do not need to know the details of how the model works or how to define tasks for it. This can
+  reduce the learning curve and make it easier for users to get started with PromptNode and
+  to leverage the power of LLMs in Haystack.
+
+
+- The extensible and modular approach of PromptNode allows users to easily add support for
+  additional templates, even on-the-fly, which can enable them to extend the capabilities of the model and to use it for
+  a wider range of NLP tasks. This can provide users with more flexibility and control over the model,
+  and can enable them to tailor it to their specific needs and applications.
+
+  # Detailed design
+
+- The PromptNode class is the most important abstraction in Haystack's large language model (LLM) support.
+  In addition to PromptNode class, we'll also define a set of prompt templates for the most popular NLP tasks.
+
+
+- NLP prompt templates will be represented by `PromptTemplate` class.
+
+  ``` python
+      class PromptTemplate(BaseTemplate):
+
+          name: str
+          prompt_text: str
+          input_variables: List[str]
+
+  ````
+
+  PromptNode would, out-of-the-box, support 10-20 default NLP tasks defined by PromptTemplate instances. However, it would
+  allow registering additional templates with PromptNode.
+
+
+- The prompt templates for default tasks (question-answering,question-generation, summarization etc.) could be examined by the user
+  using `get_prompt_templates_names` class method of the PromptNode. For example:
+
+  ``` python
+	  from haystack.nodes.llm import PromptNode
+      PromptNode.get_prompt_templates_names()
+
+      ----------------------------------------------------------------------------
+      ['question-answering',
+       'question-generation',
+       'conditioned-question-generation',
+       'summarization',
+       'question-answering-check']
+  ```
+
+
+- PromptNode supports natural language prompting (using `prompt` method) by specifying prompt template method parameter. For example:
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      pn = PromptNode(model_name_or_path="google/flan-t5-base")
+	  pn.prompt("question-generation", documents=["Berlin is the capital of Germany."])
+
+      ----------------------------------------------------------------------------
+      ['What is the capital of Germany?']
+  ```
+
+- PromptNode supports selecting a particular default template for a certain task (e.g. question-generation) and then subsequently
+  using the selected template until user changes the current template. For example:
+
+  ``` python
+	  qa = pn.use_prompt_template("deepset/question-generation-v2")
+      qa(documents=["Berlin is the capital of Germany."])
+
+      ----------------------------------------------------------------------------
+      ['What is the capital of Germany?']
+  ```
+
+- The addition of new prompt templates is supported by the `add_prompt_template` method. For example:
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      PromptNode.add_prompt_template(PromptTemplate(name="sentiment-analysis",
+                              prompt_text="Please give a sentiment for this context. Answer with positive, "
+                              "negative or neutral. Context: $documents; Answer:",
+                              input_variables=["documents"]))
+      PromptNode.get_prompt_templates_names()
+
+      ----------------------------------------------------------------------------
+      ['question-answering',
+       'question-generation',
+       'conditioned-question-generation',
+       'summarization',
+       'question-answering-check',
+       'sentiment-analysis']
+  ```
+
+- Users can inspect registered prompt templates with two class methods: `get_prompt_templates_names` and `get_prompt_templates`. The first
+  method, as we have seen, simply lists the names of the supported templates while the second method returns the list of `PromptTemplate`
+  instances, in readable format, allowing users to inspect the actual prompt template used and the templates input parameters.
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      PromptNode.get_prompt_templates()
+
+      ----------------------------------------------------------------------------
+      [PromptTemplate(name="sentiment-analysis",
+                              prompt_text="Please give a sentiment for this context. Answer with positive, "
+                              "negative or neutral. Context: $documents; Answer:",
+                              input_variables=["documents"], ...]
+  ```
+
+
+
+- However, aside from existing templates, users should also be able to use "on-the-fly" templates without registering them first. For example:
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      pn = PromptNode(model_name_or_path="google/flan-t5-base")
+      prompt_template = PromptTemplate(name="sentiment-analysis",
+                          prompt_text="Please give a sentiment for this context. "
+                          "Answer with positive, negative or neutral. Context: $documents; Answer:",
+                          input_variables=["documents"])
+      pn.prompt(prompt_template, documents=["I really enjoyed the recent movie."])
+
+      ----------------------------------------------------------------------------
+      ['positive']
+  ```
+  This, "on-the-fly" approach might be handy if users want to simply try stuff out
+
+
+- Therefore, the most central API method of the PromptNode class would be the `prompt` method with the following signature:
+  ``` python
+    def prompt(self, prompt_template: Union[str, PromptTemplate] = None, *args, **kwargs) -> List[str]:
+  ```
+
+
+- PromptNode class `__init__` constructor, aside from the `model_name_or_path` parameter would also have a
+  `prompt_template` parameter which would serve as the current and default template of the PromptNode.
+
+- ``` python
+    def __init__(self, model_name_or_path: str = "google/flan-t5-base", prompt_template: Union[str, PromptTemplate] = None):
+  ```
+
+  If the `prompt_template` is not specified in the `PromptNode` init method then user is required to specify the
+  template in the prompt method:
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      pn = PromptNode(model_name_or_path="google/flan-t5-base")
+      pn.prompt("question-generation", documents=["Berlin is the capital of Germany."])
+
+      ----------------------------------------------------------------------------
+      ['What is the capital of Germany?']
+  ```
+
+  Otherwise, when the `PromptNode` is initialized with a prompt template user can invoke the `PromptNode` directly
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      pn = PromptNode(model_name_or_path="google/flan-t5-base", prompt_template="question-generation")
+      pn(documents=["Berlin is the capital of Germany."])
+
+      ----------------------------------------------------------------------------
+      ['What is the capital of Germany?']
+  ```
+
+- Template parameters verification
+
+  All template input parameters will be verified to match the template definition and the corresponding runtime
+  parameters for the input variables will be checked for type and value. For example:
+
+  ``` python
+      from haystack.nodes.llm import PromptNode
+      on = PromptNode(model_name_or_path="google/flan-t5-base")
+      on.prompt("question-generation", some_unknown_param=["Berlin is the capital of Germany."])
+
+      ----------------------------------------------------------------------------
+      ValueError                                Traceback (most recent call last)
+      <ipython-input-16-369cca52e960> in <module>
+            1 # tasks parameters are checked
+      ----> 2 sa(some_param=[Document("Berlin is the capital of Germany.")])
+
+      2 frames
+      /usr/local/lib/python3.8/dist-packages/haystack/nodes/llm/multi_task.py in __call__(self, *args, **kwargs)
+           34         if set(template_dict.keys()) != set(self.input_variables):
+           35             available_params = set(list(template_dict.keys()) + list(set(kwargs.keys())))
+      ---> 36             raise ValueError(f"Expected prompt params {self.input_variables} but got {list(available_params)}")
+           37
+           38         template_dict["prompt_template"] = self.prompt_text
+
+      ValueError: Expected prompt params ['documents'] but got ['some_unknown_param']
+  ```
+
+- Pipelines
+
+  Even though we can use PromptNode directly its real power lies in using pipelines and Haystack. For example, we
+  can retrieve documents from the document store using the query and then inject the retrieved documents into documents
+  as a parameter to the selected PromptNode template. For example:
+
+  ``` python
+      from haystack.pipelines import PromptNode
+      top_k = 3
+      query = "Who are the parents of Arya Stark?"
+      retriever = EmbeddingRetriever(...)
+      pn = PromptNode(model_name_or_path="google/flan-t5-base", prompt_template="question-answering")
+
+      pipe = Pipeline()
+      pipe.add_node(component=retriever, name="Retriever", inputs=["Query"])
+      pipe.add_node(component=pn, name="prompt_node", inputs=["Retriever"])
+
+      output = pipe.run(query=query,
+                        params={"Retriever": {"top_k": top_k}},
+                        questions=[query for n in range(0, top_k)],
+                        #documents parameter we need for this task will be automatically populated by the retriever
+                        )
+
+      output["results"]
+  ```
+
+ - However, we are still not utilizing the full power of Haystack pipelines. What if we could use more than
+   one PromptNode in the pipeline? Perhaps we could first retrieve documents from the retriever, pass it
+   to first PromptNode that will generate questions from these documents, and then add a
+   second PromptNode component that will answer those generated questions given the documents as the
+   context. Here is how we can do exactly that:
+
+    ``` python
+        top_k = 3
+        query = "Who are the parents of Arya Stark?"
+        retriever = EmbeddingRetriever(...)
+        model = PromptModel(model_name_or_path="google/flan-t5-small")
+
+        qg = PromptNode(prompt_template="question-generation", prompt_model=model, output_variable="questions")
+        qa = PromptNode(prompt_template="question-answering", prompt_model=model)
+
+        pipe = Pipeline()
+        pipe.add_node(component=retriever, name="Retriever", inputs=["Query"])
+        pipe.add_node(component=qg, name="qg", inputs=["Retriever"])
+        pipe.add_node(component=qa, name="qa", inputs=["qg"])
+
+        result = pipe.run(query=query)
+
+        print(result["results"])
+
+    ```
+
+    The above example shows how we can use PromptNode in a pipeline and how we can bind the results of one
+    PromptNode to the input of another PromptNode. The `output_variable` parameter used in the constructor of the
+    question answering node, and assigned value `questions` indicates that variable `questions` could be resolved by any
+    downstream pipeline node. In this particular case, the output of the question generation node will be passed to downstream
+    nodes, and answering node will use that `questions` variable to inject its stored value into the `questions` parameter of
+    the question answering template.
+
+    A careful reader of this proposal will also notice that we are using the same PromptModel instance for both PromptNodes.
+    This is done mainly for reuse as the PromptModel instance could be a locally run LLM and we don't want to load it
+    multiple times.
+
+    As LLMs are very resource intensive we can also envision a scenario where we would like to use a remote LLM service.
+    In such cases we can use multiple instances of a PromptNode in a pipeline directly thus bypassing PromptModel altogether.
+
+
+ - Pipeline YAML config file
+
+   Let's recreate the above pipeline using a YAML config file and a declarative way of defining a pipeline.
+
+    ```yaml
+
+      components:
+
+      # can go in pipeline
+      - name: prompt_node
+        params:
+          prompt_template: template
+          model_name_or_path: model
+          output_variable: "questions"
+        type: PromptNode
+
+      # can go in pipeline
+      - name: prompt_node_2
+        params:
+          prompt_template: "question-answering"
+          model_name_or_path: deepset/model-name
+        type: PromptNode
+
+      # not in pipeline - only needed if you're reusing the model across multiple PromptNode in a pipeline
+      # and hidden from users in the Python beginner world
+      - name: model
+        params:
+          model_name_or_path: google/flan-t5-xl
+        type: PromptModel
+
+      # not in pipeline
+      - name: template
+        params:
+          name: "question-generation-v2"
+          prompt_text: "Given the following $documents, please generate a question. Question:"
+          input_variables: documents
+        type: PromptTemplate
+
+      pipelines:
+        - name: question-generation-answering-pipeline
+          nodes:
+            - name: EmbeddingRetriever
+              inputs: [Query]
+            - name: prompt_node
+              inputs: [EmbeddingRetriever]
+            - name: prompt_node_2
+              inputs: [prompt_node]
+    ```
+    First of all, notice how we reuse the resource heavy PromptModel instance across multiple PromptNode instances. And
+    although we could have used already registered `question-generation` prompt template, we decided to define a new one
+    called `question-generation-v2` and as such set it as the default template for the first PromptNode. We also defined
+    the output of the first PromptNode as `questions` and used that variable in the second PromptNode.
+
+    In conclusion, we can see that the YAML config file is a mirror image of the previous code centric pipeline
+    example and also a very powerful way of defining a pipeline.
+
+
+
+  - Default tasks/prompts to be added to PromptNode
+
+    [Muffin]:
+      - Summarization
+      - Natural Language Inference
+      - Multiple-Choice QA
+      - Translation
+      - Sentiment Analysis
+      - Extractive QA
+      - Structured Data to Text
+      - Coreference Resolution
+      - Code Repair
+      - Code Error Generation
+      - Dialogue Context Generation
+      - Closed-Book QA
+      - Next Sentence Prediction
+      - Paraphrasing Identification
+      - Conversational Question Answering
+      - Topic Classification
+      - Mathematical QA
+      - Dialog Next Turn Prediction
+      - Grammatical Acceptability
+      - Punctuation fixing
+
+    [T0-SF]:
+      - Adversarial QA
+      - Question Generation
+      - Commonsense Reasoning
+      - Title Generation
+      - Dialogue Turn Prediction
+      - Predict Span Indices
+      - Context Generation
+
+    [NIV2]:
+      - Program Execution
+      - Text Matching
+      - Toxic Language Detection
+      - Cause Effect Classification
+      - Information Extraction
+      - Textual Entailment
+      - Wrong Candidate Generation
+      - Named Entity Recognition
+      - Commonsense Classification
+      - Fill-in-the-blank
+      - Text Completion
+      - Sentence Composition
+      - Question Understanding
+
+    [CoT Reasoning]:
+      - Explanation Generation
+      - Generate Question And Answer
+      - Grade School Math Word Problems
+      - Algebraic Question Answering
+      - Common Sense Reasoning Over Entities
+      - Common Sense Reasoning For QA
+      - Passage Based Question Answering
+      - Sense-Making And Explanation
+
+  # Drawbacks
+- One potential drawback of PromptNode is that it may require a significant amount of computational resources
+  to use. This may limit its use in applications or environments where there are constraints on the available hardware
+  or software resources.
+
+
+- Due to current pipeline design limitations PromptTemplate has to be a subclass of BaseComponent. This might slightly
+  confuse some users who are already familiar with Haystack components. We will mitigate this issue in subsequent releases
+  as we refactor the pipeline design. All in all, PromptTemplate will be a thin class with minimal inheritance signature from some base class.
+
+
+
+  # Alternatives
+
+- One alternative to PromptNode is to continue to use separate models for each NLP task in Haystack. This
+  can enable users to tailor the model to the specific requirements of each task, and to potentially improve the
+  performance of the model for that task by additional fine-tuning or model adaptation via GPL. However, using separate
+  models may require these complex and computationally intensive training and deployment processes, and may not be as
+  efficient or flexible as using a single, unified model.
+
+  # Adoption strategy
+- This is not a breaking change proposal and we should implement it immediately.
+
+  # How do we teach this?
+- This change would require change in documentation.
+- We can provide examples of how to use PromptNode in Haystack pipelines via tutorials.
+- Docs and tutorials need to be updated

testbed/deepset-ai__haystack/proposals/text/3695-demo-repository.md

@@ -0,0 +1,77 @@
+- Start Date: 2022-12-12
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3695
+- Github Issue: (if available, link the issue containing the original request for this change)
+
+# Summary
+
+A new git repository is created to host NLP applications showcasing Haystack's features.
+
+# Basic example
+
+A git repository was already created on Github as an example:
+
+https://github.com/deepset-ai/haystack-demos
+
+# Motivation
+
+NLP applications showcasing Haystack's capabilities can be an invaluable learning resource
+for its users, but at this moment we don't fully take advantage of the only one demo we have
+as a documentation source.
+
+This proposal aims at overcoming that limitation in two ways:
+- Define better requirements for a demo application so that users can learn from it.
+- Make it easier to add more demo applications showcasing Haystack.
+
+# Detailed design
+
+Every demo has a descriptive name that will be used as its identifier.
+
+Every demo lives in a dedicated folder named after its identifier at the root of the repo, and
+provides all the resources needed to understand the code, run the application locally or deploy it
+remotely on a server.
+
+Every demo provides a README.md file containing the following information:
+- A brief description of the application and what's its goal.
+- Explicit mention of which NLP use case is implemented: for example "QA", or "Document Retrieval".
+- Detailed instructions about how to run the application locally.
+- Any hardware requirement and the limitations when not provided (for example, a GPU device).
+- How to modify and test the code, and how to contribute changes.
+
+The code of a demo application should be tested whenever possible, and at least some of the
+tests should be able to run in the repo CI system. Every demo has a dedicated Workflow defined
+in a file named after its identifier. The workflow runs only when files in the demo folder are
+modified.
+
+In case the CI is needed for continuous deployment, or for building artifacts, a demo can have
+more than one workflow file defined, named after its identifier plus a descriptive suffix, for
+example: `my_demo_identifier.yml` for tests, `my_demo_identifier_docker.yml` for building a
+Docker image, `my_demo_identifier_deploy.yml` for continuous delivery.
+
+# Drawbacks
+
+- The code of the existing demo would be removed from Haystack and potentially become harder to
+  find for existing contributors.
+- The proposed design dictates a list of new requirements for a demo that will take time to
+  implement.
+
+# Alternatives
+
+- Leave things as they are
+- Implement the design proposal to a subfolder of Haystack's git repository
+
+# Adoption strategy
+
+Adoption will be mostly driven by communicating the changes to the community and monitoring the
+traffic in the new Github repository: interacting with the existing demo will not be affected
+but accessing the code would.
+
+# How we teach this
+
+- A link to the demo repository will be added to the web page of the [demo itself](https://haystack-demo.deepset.ai/).
+- Haystack's README and documentation will mention where to find the code for the demos.
+- [Haystack Home](https://haystack.deepset.ai) will host a whole section dedicated to Haystack demos
+  (detailing the aforementioned section is out of scope for this proposal).
+
+# Unresolved questions
+
+N/A.

testbed/deepset-ai__haystack/proposals/text/3784-shaper.md

@@ -0,0 +1,272 @@
+- Title: Shaper
+- Decision driver: Vladimir
+- Start Date: 2022-12-29
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3784/
+
+# Summary
+
+Input/Output Shaper (Shaper) is a new pipeline component that can invoke arbitrary, registered functions, on the
+invocation context (query, documents etc.) of a pipeline and pass the new/modified variables further down the pipeline.
+
+# Basic example
+
+In the following example, we'll use Shaper to add a new variable `questions` to the invocation context.
+`questions` is a copy of query variable. This functionality of Shaper is useful when we simply want to
+rename a variable in the invocation context e.g. in cases where the PromptNode template is expecting a variable
+'questions' rather than 'query'.
+
+
+```python
+
+    from haystack import Pipeline, Document
+
+    with open("tmp_config.yml", "w") as tmp_file:
+        tmp_file.write(
+            f"""
+            version: ignore
+            components:
+            - name: shaper
+              params:
+                inputs:
+                    query:
+                      output: questions
+              type: Shaper
+            pipelines:
+              - name: query
+                nodes:
+                  - name: shaper
+                    inputs:
+                      - Query
+        """
+        )
+    pipeline = Pipeline.load_from_yaml(path="tmp_config.yml")
+    result = pipeline.run(
+        query="What can you tell me about Berlin?",
+        documents=[Document("Berlin is an amazing city."), Document("I love Berlin.")],
+    )
+    assert result
+    # query has been renamed to questions
+    assert isinstance(result["meta"]["invocation_context"]["questions"], str)
+
+
+```
+
+# Motivation
+
+We need Shaper to support the use cases where we want to easily add new variables to the pipeline invocation context.
+These new variables hold values which are a result of some arbitrary function invocation on the existing variables
+in the invocation context.
+
+Shaper is especially useful when combined with PromptNode(s). Aside from simply renaming variables to match
+the templates of PromptNodes, we can also use Shaper to add new variables to the invocation context. Often
+these new variables are the result of some arbitrary function invocation on the existing variables in the
+invocation context.
+
+The original idea for Shaper is related to question answering use case using PromptNode. In QA, query string variable
+passed to a pipeline run method needs to be expanded to a list of strings with the list size matching the size of the
+documents list. Therefore, we can use the query as the question to pose to all the documents in the documents list.
+
+The expected outcome of using Shaper is that we can easily add new variables to the invocation context so they can
+match the prompt templates of PromptNodes. Multiple Shaper components can be used in a pipeline to modify the
+invocation context as needed.
+
+
+# Detailed design
+
+The Shaper component is most often defined in pipelines YAML file. The YAML component definition consists of the
+params block:
+
+```yaml
+            components:
+            - name: shaper
+              params:
+                inputs:
+                   query:
+                      func: expand
+                      output: questions
+                      params:
+                        expand_target: query
+                        size:
+                          func: len
+                          params:
+                            - documents
+                   documents:
+                      func: concat
+                      params:
+                        docs: documents
+                        delimiter: " "
+              type: Shaper
+            pipelines:
+              - name: query
+                nodes:
+                  - name: shaper
+                    inputs:
+                      - Query
+```
+
+The params block consists of the inputs list. Each item in the inputs list is a dictionary with the key being the
+invocation context variable that we want to modify.
+
+In the example above, we have two items in the inputs list. The first item is a dictionary with the key `query` and the
+second item is a dictionary with the key `documents`.
+
+For the query variable, we want to invoke the function `expand` and store the result in the variable `questions`.
+The `expand` function takes two keyword parameters: `expand_target` and `size`. The `expand_target` parameter is the
+name of the variable in the invocation context that we want to expand. The `size`parameter is a result of the `len`
+function invocation on the variable `documents`.
+
+For the documents variable, we want to invoke the function `concat` and store the result in the same variable.
+Therefore, after the invocation, the documents variable will hold a result of `concat` function invocation while
+we'll also have a new variable `questions` in the invocation context. The questions variable will hold a result of
+`expand` function invocation.
+
+The important thing to note here is that we can invoke functions with both keyword and positional parameters. Function
+`len` is an example of a function that takes non-keyword positional parameters. The `concat` and `expand` function
+take keyword parameters. These functions can also be invoked with positional parameters but that is not recommended.
+
+
+### Default parameters
+
+The Shaper component can also be configured with default parameters. Default parameters are used when we
+don't specify the parameters for a function invocation. The default parameters are specified in the function definition.
+
+For example, in the YAML snippet definition below, we have a function `expand` that takes two keyword parameters:
+`expand_target` and `size`. However, we haven't specified either of these parameters in the YAML config. This is
+possible because we assume that the first parameter is always the variable we want to invoke the function on. In this
+case, the variable `query`. The second parameter is the `size` of the list we want to expand the variable to. Here we
+have also defined a helper function in Shaper called `expand:size` that calculates the default value of
+this parameter - `len(documents)`.
+
+Therefore, the `expand` function, described below, will be invoked with the following parameters: `query`
+and `len(documents)`
+
+```yaml
+            components:
+            - name: shaper
+              params:
+                inputs:
+                    query:
+                      func: expand
+                      output: questions
+              type: Shaper
+            pipelines:
+              - name: query
+                nodes:
+                  - name: shaper
+                    inputs:
+                      - Query
+
+```
+
+We need the "default parameter" functionality to support YAML files definitions that are more concise and less
+error-prone.
+
+
+### Omitting output parameter
+
+The output parameter is optional. If it is omitted, the result of the function invocation will be stored in
+the corresponding input variable. In the example below, the output of expand function will be stored in the
+query variable.
+
+```yaml
+            components:
+            - name: shaper
+              params:
+                inputs:
+                    query:
+                      func: expand
+              type: Shaper
+            pipelines:
+              - name: query
+                nodes:
+                  - name: shaper
+                    inputs:
+                      - Query
+
+```
+
+### Order of function invocation
+
+The order of function invocation is important. The functions are invoked in the order they are defined in the YAML.
+In the example below, we have two input variables: `query` and `documents`. The `query` variable is expanded to a
+list of strings and stored in the variable `questions`. The `documents` variable is then contracted and the
+variable `questions` is immediately used as the `num_tokens` keyword parameter to the `concat` function.
+
+```yaml
+            components:
+            - name: shaper
+              params:
+                inputs:
+                    query:
+                      func: expand
+                      output: questions
+                      params:
+                        expand_target: query
+                        size:
+                          func: len
+                          params:
+                            - documents
+                    documents:
+                      func: concat
+                      output: documents
+                      params:
+                        docs: documents
+                        delimiter: " "
+                        num_tokens:
+                            func: len
+                            params:
+                                - questions
+              type: Shaper
+            pipelines:
+              - name: query
+                nodes:
+                  - name: shaper
+                    inputs:
+                      - Query
+```
+
+### Security
+
+The Shaper component prevents arbitrary code execution. There should be no dangerous `exec` or `eval` Python calls. Only
+the functions we have specified in the Shaper component are allowed to be invoked. The functions are specified in the
+constructor using immutable data structures.
+
+This security measure might be relaxed in the future to allow users to specify their own functions. However, this
+change will require a more thorough security review.
+
+# Drawbacks and other considerations
+
+Although a "normal use" of PromptNodes would not trigger a need for Shaper there are cases where its
+use is necessary. In cases where we can only use pipeline definitions to configure the pipeline (via YAML),
+we need to use it.
+
+
+- Implementation and maintenance cost should not be high.
+- Shaper is not really useful outside of Haystack pipeline.
+- Shaper could turn out to be useful in other use cases as well - i.e. declarative pre/post processing.
+- Shaper integrates well with PromptNodes and other components.
+- No braking changes to existing components.
+
+
+# Alternatives
+
+A better solution would likely be a more general run method for components. This would allow us to arbitrarily
+define the pipeline invocation context. However even in those cases we'll need to use Shaper to modify
+existing variables in invocation context as needed.
+
+# Adoption strategy
+
+Haystack users can start using Shaper in their pipelines immediately. There are no breaking changes to
+existing components or pipelines.
+
+
+# How we teach this
+
+We will need docs update to teach users how to use Shaper. The docs will need to explain the
+motivation using Shaper and PromptNode examples. We also need to show the usage via tutorials.
+
+
+# Unresolved questions
+
+Optional, but suggested for first drafts. What parts of the design are still
+TBD?

testbed/deepset-ai__haystack/proposals/text/3875-table-cell.md

@@ -0,0 +1,238 @@
+- Title: TableCell Dataclass
+- Decision driver: Sebastian Lee
+- Start Date: 2023-01-17
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3875
+- Github Issue: https://github.com/deepset-ai/haystack/issues/3616
+
+# Summary
+
+When returning answers for a TableQA pipeline we would like to return the column and row index as the answer location
+within the table since the table is either returned as a list of lists in Haystack.
+This would allow users to easily look up the answer in the returned table to fetch the text directly from the table,
+identify the row or column labels for that answer, or generally perform operations on the table near or around the
+answer cell.
+
+# Basic Example
+
+When applicable, write a snippet of code showing how the new feature would be used.
+```python
+import pandas as pd
+from haystack.nodes import TableReader
+from haystack import Document
+
+data = {
+    "actors": ["brad pitt", "leonardo di caprio", "george clooney"],
+    "age": ["58", "47", "60"],
+    "number of movies": ["87", "53", "69"],
+    "date of birth": ["18 december 1963", "11 november 1974", "6 may 1961"],
+}
+table_doc = Document(content=pd.DataFrame(data), content_type="table")
+reader = TableReader(model_name_or_path="google/tapas-base-finetuned-wtq", max_seq_len=128)
+prediction = reader.predict(query="Who was in the most number of movies?", documents=[table_doc])
+answer = prediction["answers"][0]
+
+# New feature
+# answer.context -> [["actor", "age", "number of movies"], ["Brad Pitt",...], [...]]
+# answer.offsets_in_context[0] -> (row=1, col=1)
+print(answer.context[answer.offsets_in_context[0].row][answer.offsets_in_context[0].col])
+```
+
+# Motivation
+
+## Why do we need this feature?
+To allow users to easily look up the answer cell in the returned table to fetch the answer text
+directly from the table, identify the row or column labels for that answer, or generally perform operations on the table
+near or around the answer cell.
+
+Currently, we return the location of the answer in the **linearized** version of the table, so we can use the
+`Span` dataclass. The `Span` dataclass is reproduced below:
+```python
+@dataclass
+class Span:
+    start: int
+    end: int
+    """
+    Defining a sequence of characters (Text span) or cells (Table span) via start and end index.
+    For extractive QA: Character where answer starts/ends
+    For TableQA: Cell where the answer starts/ends (counted from top left to bottom right of table)
+
+    :param start: Position where the span starts
+    :param end:  Position where the span ends
+    """
+```
+This is inconvenient for users because they would need to know how the table is linearized (column major or row major)
+so they could reconstruct the column and row indices of the answer before they could locate the answer cell in the table.
+
+## What use cases does it support?
+Some examples are already stated above but to recap, to easily perform operations on the table near or around the answer cell.
+
+## What's the expected outcome?
+The addition of a new dataclass called `TableCell` that would look like
+```python
+@dataclass
+class TableCell:
+    row: int
+    col: int
+    """
+    Defining a table cell via the row and column index.
+
+    :param row: Row index of the cell
+    :param col: Column index of the cell
+    """
+```
+
+# Detailed design
+
+**New terminology:** `TableCell`, the new name for the dataclass to
+store the column and row index of the answer cell.
+
+**Basic Example:** [Above Basic Example](#basic-example)
+
+## Code changes
+- Addition of `TableCell` dataclass to https://github.com/deepset-ai/haystack/blob/main/haystack/schema.py
+```python
+@dataclass
+class TableCell:
+    row: int
+    col: int
+    """
+    Defining a table cell via the row and column index.
+
+    :param row: Row index of the cell
+    :param col: Column index of the cell
+    """
+```
+
+- Updating code (e.g. schema objects, classes, functions) that use `Span` to also support `TableCell` where appropriate.
+This includes:
+- Updating the `Answer` dataclass to support `TableCell` as a valid type for `offsets_in_document` and `offsets_in_context`
+```python
+@dataclass
+ class Answer:
+     answer: str
+     type: Literal["generative", "extractive", "other"] = "extractive"
+     score: Optional[float] = None
+     context: Optional[Union[str, List[List]]] = None
+     offsets_in_document: Optional[List[Span], List[TableCell]] = None
+     offsets_in_context: Optional[List[Span], List[TableCell]] = None
+     document_id: Optional[str] = None
+     meta: Optional[Dict[str, Any]] = None
+```
+- Similar to how we can return a list of `Span`s, we would allow a list of `TableCell`s to be returned to handle the case
+ when multiple `TableCell`s are returned to form a final answer.
+- Updating any functions that accept table answers as input to use the new `col` and `row` variables instead of `start` and `end` variables.
+This type of check for table answers is most likely already done by checking if the `context` is of type `pd.DataFrame`.
+- `TableReader` and `RCIReader` to return `TableCell` objects instead of `Span`.
+
+Changes related to the Edge Case/Bug below
+- Update `Document.content` and `Answer.context` to use `List[List]` instead of `pd.DataFrame`.
+- Update `TableReader` nodes to convert table from `List[List]` into `pd.DataFrame` before inputting to the model.
+
+## Edge Case/Bug
+Internally, Haystack stores a table as a pandas DataFrame in the `Answer` dataclass, which does not treat the column
+labels as the first row in the table.
+However, in Haystack's rest-api the table is converted into a list of lists format where the column labels are
+stored as the first row, which can be seen [here](https://github.com/deepset-ai/haystack/pull/3872), which is consistent
+with the `Document.to_dict()` method seen [here](https://github.com/deepset-ai/haystack/blob/6af4f14fe0d375a1ae0ced18930a9239401231c7/haystack/schema.py#L164-L165).
+
+This means that the current `Span` and (new) `TableCell` dataclass point to the wrong location when the table is
+converted to a list of lists.
+
+For example, the following code
+```python
+import pandas as pd
+from haystack import Document
+
+data = {
+    "actors": ["brad pitt", "leonardo di caprio", "george clooney"],
+    "age": ["58", "47", "60"],
+    "number of movies": ["87", "53", "69"],
+    "date of birth": ["18 december 1963", "11 november 1974", "6 may 1961"],
+}
+table_doc = Document(content=pd.DataFrame(data), content_type="table")
+span = (0, 0)
+print(table_doc.content.iloc[span])  # prints "brad pitt"
+
+dict_table_doc = table_doc.to_dict()
+print(dict_table_doc["content"][span[0]][span[1]])  # prints "actors"
+```
+
+We have decided to store the table internally as a list of lists to avoid this issue. See discussion starting [here](https://github.com/deepset-ai/haystack/pull/3875#discussion_r1088766318).
+
+# Drawbacks
+
+Look at the feature from the other side: what are the reasons why we should _not_ work on it? Consider the following:
+
+- What's the implementation cost, both in terms of code size and complexity?
+
+I don't believe this will require too much code change since we already check for Table like answers by checking if the
+returned context is of type string or pandas Dataframe.
+
+- Can the solution you're proposing be implemented as a separate package, outside of Haystack?
+
+Technically yes, but since it affects core classes like `TableReader`, and `RCIReader` it makes sense to implement in
+Haystack.
+
+- Does it teach people more about Haystack?
+
+It would update already existing documentation and tutorials of Haystack.
+
+- How does this feature integrate with other existing and planned features?
+
+This feature directly integrates and impacts the TableQA feature of Haystack.
+
+- What's the cost of migrating existing Haystack pipelines (is it a breaking change?)?
+
+Yes there are breaking changes that would affect end users.
+1. The way to access the offsets in returned Answers would be different.
+Following the deprecation policy we will support both `Span` and `TableCell` (can be toggled between using a boolean flag)
+for 2 additional versions of Haystack.
+2. Tables in Haystack Documents and Answers will change from type pandas Dataframe to a list of lists.
+
+# Alternatives
+
+## What's the impact of not adding this feature?
+Requiring users to figure out how to interpret the linearized answer cell coordinates to reconstruct the row and column indices
+to be able to access the answer cell in the returned table.
+
+## Other designs
+1. Expand `Span` dataclass to have optional `col` and `row` fields. This would require a similar check as `TableCell`, but instead
+require checking for which of the elements are populated, which seems unnecessarily complex.
+```python
+@dataclass
+class Span:
+    start: int = None
+    end: int = None
+    col: int = None
+    row: int = None
+```
+2. Use the existing `Span` dataclass and put the row index and column index as the `start` and `end` respectively.
+This may be confusing to users since it is not obvious that `start` should refer to `row` and `end` should refer to `column`.
+```python
+answer_cell_offset = Span(start=row_idx, end=col_idx)
+```
+3. Provide a convenience function shown [here](https://github.com/deepset-ai/haystack/issues/3616#issuecomment-1361300067)
+to help users convert the linearized `Span` back to row and column indices. I believe this solution is non-ideal since it would
+require a user of the rest_api to access a python function to convert the linearized indices back into row and column indices.
+
+# Adoption strategy
+
+## How will the existing Haystack users adopt it?
+Haystack users would immediately experience this change once they update their installation of Haystack if they were using
+the TableQA reader. This would be a breaking change since it would change the `offsets_in_document` and
+`offsets_in_context` in the returned `Answer`. I'm not sure if there would be a straightforward way to write a migration
+script for this change.
+
+# How we teach this
+
+Would implementing this feature mean the documentation must be re-organized
+or updated? Does it change how Haystack is taught to new developers at any level?
+
+- The API docs for `TableCell` would need to be added.
+- The documentation page for [Table Question Answering](https://docs.haystack.deepset.ai/docs/table_qa) would need to be updated.
+- Update the (TableQa tutorial)[https://github.com/deepset-ai/haystack-tutorials/blob/main/tutorials/15_TableQA.ipynb]
+to reflect the `Span` is no longer linearzied.
+
+# Unresolved questions
+
+No more unresolved questions.

testbed/deepset-ai__haystack/proposals/text/3925-mrkl-agent.md

@@ -0,0 +1,380 @@
+- Title: MRKLAgent
+- Decision driver: @julian-risch (in close collaboration with @vblagoje )
+- Start Date: 2023-01-27
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/3925
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/3753
+
+# Summary
+The Agent class answers queries by choosing between different tools, which are implemented as pipelines or nodes.
+It uses a large language model (LLM) to generate a thought based on the query, choose a tool, and generate the input for the tool.
+Based on the result returned by an action/tool (used interchangeably), the Agent has two options.
+It can either stop if it knows the answer now or repeat the process of 1) thought, 2) action choice, 3) action input.
+
+The Agent can be used for questions containing multiple subquestions that can be answered step-by-step (Multihop QA).
+Combined with tools like the PythonRuntime or SerpAPIComponent we imagine for Haystack, the Agent can query the web and do calculations.
+
+We have a [notebook](https://colab.research.google.com/drive/1oJf4gxkokIazLN26NNt6XsewMvCmVrz8?usp=sharing) that demonstrates how to use an Agent with two tools: PythonRuntime and SerpAPIComponent. It requires API keys for OpenAI and SerpAPI.
+The notebook is based on the branch https://github.com/deepset-ai/haystack/compare/main...mrkl-pipeline (no pull request)
+
+# Basic example
+
+An example of an Agent could use two tools: a web search engine and a calculator.
+
+The query "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?" can be broken down into three steps:
+1) Searching the web for the name of Olivia Wilde's boyfriend
+2) Searching the web for the age of that boyfriend
+3) Calculating that age raised to the 0.23 power
+
+And the Agent would respond in the end with "Jason Sudeikis, Olivia Wilde's boyfriend, is 47 years old and his age raised to the 0.23 power is 2.4242784855673896." A detailed walk-through follows below.
+
+
+# Motivation
+
+With an Agent, users can combine multiple LLMs and tools, so that they can build a truly powerful app. They can use an LLM in a loop to answer more complex questions than with ExtractiveQA or GenerativeQA. With an Agent and a tool for web search, Haystack is not limited to extracting answers from a document store or generating answers based on model weights anymore but it can use the knowledge it retrieves on-the-fly from the web. Thereby, the model's knowledge does not get outdated.
+
+In future, we envision that an Agent could use tools not only for retrieving knowledge but also for interacting with the world. For example, it could periodically skim through newly opened issues in Haystack's GitHub repository. If there is a question that can be answered based on documentation then the Agent could retrieve relevant pages from the documentation, generate an answer and post it as a first response to the issue.
+
+# Detailed design
+
+**Glossary**
+- Thought: First part of a prompt generated by Agent that serves to breakdown the query into a plan, for example, what part of the question needs to be answered first.
+- Action (or tool): Actions/tools are Haystack pipelines or nodes that the Agent can use to answer a question. We use tool and action interchangeably in this proposal until we decided on the best naming. Choosing a tool in each iteration is the center part of a prompt generated by Agent.
+- Action input: Last part of a prompt generated by an Agent. It serves as the input to a tool that the Agent uses to answer a question.
+- Observation: The output generated by a tool and sent back to the Agent.
+
+The Agent consists of a PromptNode that generates thoughts, chooses actions, and generates action inputs.
+Just like Haystack pipelines, an Agent can be loaded from a YAML file. That YAML file must also contain the tools of the Agent defined as pipelines or nodes.
+Tools need to be added to an Agent so that it can use them, just like nodes need to be added to pipelines.
+When a tool is added to an Agent, a description of the tools needs to be added so that the LLM knows when it is useful.
+
+A key functionality of the Agent is that it can act iteratively and use any of the pre-defined tools as many times as it wants based on the input query and the results returned from the tools used earlier. In every iteration, it chooses one of the tools and generates the input for that tool dynamically.
+An example application of this is MultiHopQA, where multiple subquestions need to be answered step-by-step.
+For the example query "Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?", the MRKLPipeline needs to answer several subquestions. Here is an example of a full transcript of the prompt input and generated output:
+
+```
+Answer the following questions as best as you can. You have access to the following tools:
+
+Search: useful for when you need to answer questions about current events. You should ask targeted questions
+Calculator: useful for when you need to answer questions about math
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [Search, Calculator]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question
+
+Begin!
+Question: Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?
+Thought: I need to do some research to answer this question.
+Action: Search
+Action Input: Olivia Wilde's boyfriend
+Observation: First linked in November 2011, Wilde and Sudeikis got engaged in January 2013. They later became parents, welcoming son Otis in 2014 and daughter Daisy in 2016.
+Thought: I need to find out his age
+Action: Search
+Action Input: Jason Sudeikis age
+Observation: 47 years
+Thought: I need to raise it to the 0.23 power
+Action: Calculator
+Action Input: 47^0.23
+Observation: 2.4242784855673896
+Thought: I now know the final answer
+Final Answer: Jason Sudeikis, Olivia Wilde's boyfriend, is 47 years old and his age raised to the 0.23 power is 2.4242784855673896.
+```
+
+## Agent steps breakdown
+The above steps represent the entire action trace for the Agent. However, let's break it down into individual agent steps so we can understand how it makes decisions, chooses actions and action inputs.
+
+### Step 1:
+
+We start with a prompt where we instruct LLM on what we want. The first prompt we send to LLM is the following:
+```
+Answer the following questions as best as you can. You have access to the following tools:
+
+Search: useful for when you need to answer questions about current events. You should ask targeted questions
+Calculator: useful for when you need to answer questions about math
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [Search, Calculator]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final Answer
+Final Answer: the final Answer to the original input question
+
+Begin!
+Question: Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?
+Thought:
+```
+
+Notice how we finish the prompt with the `Thought:` token, priming the model to start its generation of an actual plan of what needs to be done in the first step.
+LLM would also generate `Action:` and `Action Input:` rows of this step which help us select an Action to execute and the input for that action.
+As we also instruct the model to stop generating a response with stop words being `Observation:` the model response for this step is:
+
+```
+I need to do some research to answer this question.
+Action: Search
+Action Input: Olivia Wilde's boyfriend
+```
+
+At this point, we invoke Search (along with the input) and receive the response from the Search tool: "First linked in November 2011, Wilde and Sudeikis got engaged in January 2013. They later became parents, welcoming son Otis in 2014 and daughter Daisy in 2016."
+
+We append the tool response under the `Observation:`
+
+LLM generation above and the response from the Search action (added under Observation) are appended to the initial prompt.
+
+### Step 2:
+
+We start this step with the following prompt:
+
+```
+Answer the following questions as best as you can. You have access to the following tools:
+
+Search: useful for when you need to answer questions about current events. You should ask targeted questions
+Calculator: useful for when you need to answer questions about math
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [Search, Calculator]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final Answer
+Final Answer: the final Answer to the original input question
+
+Begin!
+Question: Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?
+Thought: I need to do some research to answer this question.
+Action: Search
+Action Input: Olivia Wilde's boyfriend
+Observation: First linked in November 2011, Wilde and Sudeikis got engaged in January 2013. They later became parents, welcoming son Otis in 2014 and daughter Daisy in 2016.
+Thought:
+```
+
+Again, notice how we've added the response from LLM and the `Observation` from the tool to the prompt, and we finish the prompt with `Thought:` token, priming the model to start the response with the plan for this step. As in the previous step, the model generates an action plan and selects an action and its input. The LLM response is:
+
+```
+I need to find out his age
+Action: Search
+Action Input: Jason Sudeikis age
+```
+
+This LLM response above gives us enough information to invoke a Search tool again along with the appropriate input, and we receive the response from the Search: 47 years. We add this response to the prompt history as the `Observation:` keyword.
+
+### Step 3:
+
+For the sake of brevity, let's not list the entire prompt again. The critical part to remember is that we append the output of step 2 to the prompt history we are creating as we step through each agent step. These so-called reasoning traces help agents "understand" what needs to be done in each successive step.
+The last part of the prompt is the following:
+```
+Thought: I need to find out his age
+Action: Search
+Action Input: Jason Sudeikis age
+Observation: 47 years
+Thought:
+```
+
+The LLM-generated response is:
+
+```
+I need to raise it to the 0.23 power
+Action: Calculator
+Action Input: 47^0.23
+```
+
+In this step, we invoke a new tool - The calculator with specified input. The calculator response is 2.4242784855673896
+We added the calculator response to the prompt history under the Observation keyword.
+
+
+### Step 4:
+
+Again, we append a calculator response and prompt to the prompt history once again. Let's not list the entire prompt, but the last few lines:
+```
+I need to raise it to the 0.23 power
+Action: Calculator
+Action Input: 47^0.23
+Observation: 2.4242784855673896
+Thought:
+```
+
+The LLM-generated response is:
+```
+I now know the final answer
+Final Answer: Jason Sudeikis, Olivia Wilde's boyfriend, is 47 years old and his age raised to the 0.23 power is 2.4242784855673896.
+```
+
+Using simple string parsing, we can detect that the mode in this step responded with the "Final Answer:" keyword just as we instructed, thus breaking out of the loop and completing the agent's task with a response returned to the agent's client.
+In the rare case that "Final Answer:" is not generated even after many iterations, we can break out of the loop based on a maximum number of iterations allowed. Thereby, we can prevent an infinite loop.
+
+## Agent Creation
+
+The Agent can be either created programmatically or loaded from a YAML file.
+In the following example, one tool is a node for searching the web. The other tool is a pipeline for doing calculations in python.
+
+**Example programmatic creation:**
+```python
+search = SerpAPIComponent(api_key=os.environ.get("SERPAPI_API_KEY"), name="Serp", inputs=["Query"])
+
+prompt_model=PromptModel(model_name_or_path="text-davinci-003", api_key=os.environ.get("OPENAI_API_KEY"))
+
+calculator = Pipeline()
+calculator.add_node(PromptNode(
+    model_name_or_path=prompt_model,
+    default_prompt_template=PromptTemplate(prompt_text="Write a simple python function that calculates..."),
+    output_variable="python_runtime_input")  # input
+calculator.add_node(PythonRuntime())  # actual calculator
+
+prompt_node = PromptNode(
+    model_name_or_path=prompt_model,
+    stop_words=["Observation:"]
+)
+
+agent = Agent(prompt_node=prompt_node)
+# Nodes and pipelines can be added as tools to the agent. Just as nodes can be added to pipelines with add_node()
+agent.add_tool("Search", search, "useful for when you need to answer questions about current events. You should ask targeted questions")
+agent.add_tool("Calculator", calculator, "useful for when you need to answer questions about math")
+
+result = agent.run("What is 2 to the power of 3?")
+```
+
+**Example YAML file:**
+```yaml
+version: ignore
+
+components:
+  - name: AgentPromptNode
+    type: PromptNode
+    params:
+      model_name_or_path: DavinciModel
+      stop_words: ['Observation:']
+  - name: DavinciModel
+    type: PromptModel
+    params:
+      model_name_or_path: 'text-davinci-003'
+      api_key: 'XYZ'
+  - name: Serp
+    type: SerpAPIComponent
+    params:
+      api_key: 'XYZ'
+  - name: CalculatorInput
+    type: PromptNode
+    params:
+      model_name_or_path: DavinciModel
+      default_prompt_template: CalculatorTemplate
+      output_variable: python_runtime_input
+  - name: Calculator
+    type: PythonRuntime
+  - name: CalculatorTemplate
+    type: PromptTemplate
+    params:
+      name: calculator
+      prompt_text:  |
+          # Write a simple python function that calculates
+          # $query
+          # Do not print the result; invoke the function and assign the result to final_result variable
+          # Start with import statement
+
+pipelines:
+  - name: calculator_pipeline
+    nodes:
+      - name: CalculatorInput
+        inputs: [Query]
+      - name: Calculator
+        inputs: [CalculatorInput]
+
+agents:
+  - name: agent
+    params:
+      prompt_node: AgentPromptNode
+      tools:
+        - name: Search
+          pipeline_or_node: Serp
+          description: >
+            useful for when you need to answer questions about current events.
+            You should ask targeted questions
+        - name: Calculator
+          pipeline_or_node: calculator_pipeline
+          description: >
+            useful for when you need to answer questions about math
+```
+
+and loading from the YAML file into an Agent:
+
+```python
+agent = Agent.load_from_yaml(
+    "test.mrkl.haystack-pipeline.yml", agent_name="agent"
+)
+```
+
+Pipelines, agents, nodes, and tools all implement `run` and `run_batch` methods, which is the minimal contract.
+At the moment, tools are either pipelines or nodes but we can imagine more types of tools as long as they implement that minimal contract.
+
+# Drawbacks
+
+Although the scope of the initial Agent is limited, it can grow into a full-fledged framework consisting of
+various types of agents (conversation, Robotic Process Automation etc.). The field of agents is rapidly growing, and we should be aware that it can even outgrow Haystack in the future. Perhaps we can start with the Agent being part of Haystack and potentially create a new project in the future.
+
+One of the central building blocks of an Agent are the PromptNode and set "neural attachments" extending the agent's capabilities.
+Many tools like Search, Calculator, Notion and API connectors are somewhat different conceptually from the existing Haystack components.
+On the other hand, some of the existing Haystack components fit naturally into the framework of tools, for example, DocumentStore, Retriever, and Reader.
+
+There is a non-negligible potential for a growing implementation cost of such an agent framework that might
+stretch the resource away from the existing Haystack core. However, as LLM-based agents are an exciting and
+rapidly growing field, they may raise Haystack awareness significantly.
+
+# Alternatives
+
+We have considered an alternative design where the Agent is just another node or a pipeline.
+However, we decided to introduce it as a separate concept because of user-friendliness / clear code.
+While a Pipeline is a collection of Nodes, an Agent is a collection of Pipelines.
+Nodes in a pipeline have a pre-defined execution order, whereas the execution order of Pipelines in an Agent are chosen at runtime by a LLM.
+
+Regarding the name *Agent*, we considered several alternatives and prefer *Agent* for its simplicity.
+Alternative names:
+- MRKLAgent
+- LLMOrchestrator
+- LLMChain
+- Toolchain (fits nicely with tools and [toolchains](https://en.wikipedia.org/wiki/Toolchain) in software)
+- PipelineComposer / LLMComposer
+- PipelineComposition / LLMComposition
+- Interesting naming tidbits:
+  - MRKL [paper](https://arxiv.org/pdf/2205.00445.pdf) never uses word agent, only system
+  - ReAct [paper](https://arxiv.org/pdf/2210.03629.pdf) uses agent almost exclusively
+
+
+# Adoption strategy
+
+Introducing the Agent concept is a rather big change that would require a careful adoption strategy. We would need a lot more documentation explaining these new concepts, and each attaching tool would need additional documentation.
+
+However, the existing Haystack users, especially advanced users have already requested an agent framework to be added as part of the Haystack. We anticipate that advanced users will be the first to adopt the Agent.
+
+Using an Agent requires an OpenAI api key and some tools require additional api keys, for example SerpAPI but there are free trials.
+
+The debugging output of the Agent will help users to better understand how it works. In a debugger, the agent works as any other Haystack pipeline containing a prompt node.
+
+# How we teach this
+
+Yes, adding agents to Haystack would require a lot of documentation changes. Perhaps even a separate documentation for MRKL and other future agents somewhat detached from Haystack.
+
+We can teach existing Haystack users about agents and agent tools in a new section of the documentation. We can also organize Discord office hours, tutorials, and webinars to teach the new concepts.
+
+# Unresolved questions
+
+**Name of the parameter pipeline_or_node**
+* When we add a tool to the agent, we need to specify the name of the pipeline or node (component) to add.
+This parameter could be called `pipeline_or_node` or `pipeline_or_component_name` etc.
+
+**Umbrella Term for Pipeline and Agent**
+* We need a term that captures pipelines and agents for communication with users (NLP application, flow, system, service, engine ...).
+Let's have that conversation separately from this proposal.
+
+**Tools we imagine in the near future**
+* Tools will be discussed in a separate proposal.

testbed/deepset-ai__haystack/proposals/text/3959-json-converter.md

@@ -0,0 +1,142 @@
+- Title: Addition of a `JsonConverter` node
+- Decision driver: @bglearning
+- Start Date: 2023-01-26
+- Proposal PR: #3959
+
+# Summary
+
+Right now we don't have a node that can take json files as input to be fed into a pipeline.
+
+Proposal: Add a `JsonConverter` node that takes in a json file, parses it, and generates `Document`s.
+It would also support the `jsonl` format with one line corresponding to one document.
+
+# Basic example
+
+```python
+from haystack.nodes import JsonConverter
+
+converter = JsonConverter()
+
+# Receive back List[Document]
+docs = converter.convert("data_file.json")
+```
+
+With the `data_file.json` as a list of json representation of documents:
+
+```json
+[
+    {
+        "content": "...",
+        "content_type": "text", "meta": {...}
+    },
+    {
+        "content": [["h1", "h2"], ["val1", "val2"]],
+        "content_type": "table", "meta": {...}
+    }
+]
+```
+
+Alternatively, the data can also be `jsonl`.
+By default, the converter will try to auto-detect between `json` and `jsonl`.
+
+The main use case would be to be able to include this directly in the YAML specification
+
+```yaml
+...
+
+pipelines:
+  - name: indexing
+    nodes:
+      - name: JsonConverter
+        inputs: [File]
+      - name: Retriever
+        inputs: [JsonConverter]
+      - name: DocumentStore
+        inputs: [Retriever]
+```
+
+# Motivation
+
+Users may want to do some processing of the data themselves, persist it somehow, and only then pass it onto a haystack pipeline (for instance, by uploading into the REST API endpoint). Ideally this would happen without the need to create a custom endpoint.
+
+For many such processing, json is a convenient intermediate format as it allows for things like specifying the metadata.
+
+Specifically, one use-case that has come up for a team using haystack: they want to use a PDF parser (for tables) currently not in haystack. As such, they want to handle the parsing themselves outside of haystack, put the parsed result into a json file, and then pass it onto a haystack API endpoint.
+
+Having a `JsonConverter` node would allow users to setup a haystack pipeline to ingest such data without the user having to create a custom node for it.
+
+# Detailed design
+
+The converter would primarily be a wrapper around `Document.from_dict`.
+
+The schema accepted would be the a list of json dictionary of Documents.
+So, the following, with `content` being the only compulsory field.
+
+```
+[
+    {
+        "content": str or list[list],
+        "content_type": str,
+        "meta": dict,
+        "id_hash_keys": list,
+        "score": float,
+        "embedding": array
+    },
+    ...
+]
+```
+
+```python
+class JsonConverter(BaseConverter):
+    def __init__(self, ...):
+        ...
+
+    def convert(
+        self,
+        file_path: Path,
+        meta: Optional[Dict[str, str]] = None,
+        encoding: Optional[str] = "UTF-8",
+        id_hash_keys: Optional[List[str]] = None,
+        ...
+    ) -> List[Document]:
+        if id_hash_keys is None:
+            id_hash_keys = self.id_hash_keys
+
+        documents = []
+        with open(file_path, encoding=encoding, errors="ignore") as f:
+            data = json.load(f)
+            for doc_dict in data:
+                doc_dict = dict(doc_dict)
+                doc_dict['id_hash_keys'] = id_hash_keys
+                doc_dict['meta'] = doc_dict.get('meta', dict())
+
+                if meta:
+                    doc_dict['meta'].update(meta)
+
+                documents.append(Document.from_dict(doc_dict))
+
+        return documents
+```
+
+# Drawbacks
+
+- It would add another node that needs to be maintained and documented.
+
+# Alternatives
+
+- This node could be created as a custom node for the particular application where it is required. But could be better to have it out-of-the-box.
+- Design Alternative: Also, provide options to map custom fields to `Document` fields (E.g. {"review": "content"}) which could make this node a bit more flexible and might mean the user doesn't have to do some pre-formatting beforehand. But this can be a future development.
+
+# Adoption strategy
+
+It doesn't introduce a breaking change and wouldn't require changes in existing pipelines.
+
+# How we teach this
+
+It would be good to have this be part of the Guide (perhaps under File Converters).
+
+Could also be mentioned in one of the tutorials. For instance, in the preprocessing tutorial where we say "Haystack expects data to be provided as a list documents in the following dictionary format".
+
+# Unresolved questions
+
+- Should the `content_type` allowed be restricted (e.g. only "text" and "table"). And relatedly, should the name be more specific? E.g. `JsonTableTextConverter` rather than `JsonConverter`. Currently leaning towards no restriction and the `JsonConverter` name.