Add files using upload-large-folder tool

SPFsmartGATE/LIVE/TMP/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 -->

SPFsmartGATE/LIVE/TMP/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.

SPFsmartGATE/LIVE/TMP/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?

SPFsmartGATE/LIVE/TMP/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

SPFsmartGATE/LIVE/TMP/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.

SPFsmartGATE/LIVE/TMP/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?

SPFsmartGATE/LIVE/TMP/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.

SPFsmartGATE/LIVE/TMP/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.

SPFsmartGATE/LIVE/TMP/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.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/4084-agent-demo.md

@@ -0,0 +1,262 @@
+- Title: Agent tools
+- Decision driver: Vladimir Blagojevic (with Julian Risch)
+- Start Date: 2023-02-06
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/4084
+
+
+# Summary
+
+Agent system consists of an extendable set of modules (aka experts/tools) and a "router" dispatching natural
+language input to a module that can best respond to the given input. These modules can be:
+
+• Neural, including the general-purpose LLMs as well as other smaller, specialized LMs.
+
+• Symbolic, for example a math calculator, a currency converter, or an API call to a search engine.
+
+
+Current Haystack pipeline design approach fits nicely with these extension modules/tools. They can be tested in
+isolation and subsequently integrated into the agent. The agent can register these tools, understand their objectives
+and route the user input to the appropriate tool. The tools can be either Haystack pipelines or components.
+
+
+A demo idea for the new Agent is to demonstrate Question Answering on Technical Documentation (using the example of
+Haystack). It should be useful and impressive, and it determines what tools we will implement first.
+
+**Example Questions:**
+- "Why am I seeing duplicate answers being returned?" based on indexed FAQ documentation
+- "Which organizations use Haystack?" based on web search and Wikipedia returning answers via SearchEngine
+- "How can I choose the model for PromptNode?" based on retrieving documents via WebRetriever
+- "How can I make overwrite_with_env_variables work in RayPipeline" based on an open issue found with GitHub API or web search
+
+If an answer cannot be found in indexed files, the Agent will use self reflection to rephrase the question and/or search the
+web. It will give updates while searching, for example print thoughts: “Found nothing in indexed documentation. Will continue
+with web search.” If still nothing can be found, the Agent will generate a link to a pre-filled and pre-tagged issue template
+like this that the user can choose to create. Tools required for the demo: SearchEngine, GitHubAPI, Self Reflection Module, WebRetriever.
+
+We also need to demonstrate how the Agent uses a combination of multiple tools to answer a question instead of just trying
+them sequentially.
+
+**Example Question:**
+- "Is there an open issue about any of the nodes in a standard QA pipeline not working?"
+
+Here the LLM might first use documentation to find out more about what nodes are part of standard QA pipelines and then
+searches on GitHub for open issues that mention retriever or reader.
+
+We propose the following tools to be developed for the MVP version of our agent (#3925):
+
+- SearchEngine
+- Self reflection module (query rephrasing)
+- WebRetriever
+- Top-p (nucleus) sampling
+- Agent memory
+- deepset Cloud API
+
+# Basic example
+
+No code examples are provided, but a high-level overview of how the feature would be used.
+
+There is also a [colab notebook](https://colab.research.google.com/drive/1oJf4gxkokIazLN26NNt6XsewMvCmVrz8?usp=sharing)
+demonstrating how to use an agent with tools and a [branch](https://github.com/deepset-ai/haystack/compare/main...mrkl-pipeline)
+for demo purposes (no pull request).
+
+# Motivation
+
+Agent tools are the main and essential building block of the agent system. They are the modules extending the
+agent's capabilities. Agent, when it relies only on itself, is not as powerful as when it can leverage the
+external modules (tools) that are highly specialized in their respective domains. Agent can't do, for example, lookup of
+restaurants in our neighbourhood, but it can use SearchEngine to do that. When it comes to complex math calculations, LLM
+would be a poor choice, but a math calculator would be a good fit, and so on.
+
+Combining the power of LLMs with the power of external tools is the key ingredient to the success of the agent framework.
+
+
+# Detailed design
+
+In the following sections, we list essential agent tools required for agent MVP. We start with the general design
+principles and then describe each tool in detail.
+
+Each tool is defined as a Python class that inherits from the BaseComponent class. The base class acts as a wrapper
+around the actual tool implementation.
+
+The main Agent modules/tools are:
+
+## SearchEngine
+
+SearchEngine is a symbolic API module allowing programmatic interaction with Google and other search engines. We'll have
+multiple providers of SearchEngine including https://serper.dev, https://www.searchapi.io/ and https://serpapi.com as initial providers.
+
+SearchEngine will return a list of results (e.g. List[Document]), the content of each document being a "snippet" of the
+single search result, while all other attributes of the search results (e.g. title, url link, etc.) will
+be metadata of the document.
+
+### SearchEngine scoping
+
+A great feature of SearchEngine is that it can be scoped to a particular domain. Therefore, in our demo, if so desired,
+we can search through Haystack documentation on docs.haystack.com, github.com/deepset-ai/haystack and so on.
+
+## Self reflection module
+
+SRM is a neural module that aims to improve the agent's overall robustness. Agents can sometimes be very fragile
+in their execution steps. As a core component, the motivation for the self-reflection module (SRM) is to improve the
+robustness of the agent's execution. Agents can be fragile in their execution steps due to the non-deterministic nature
+of LLM inferencing and their sensitivity to the chosen prompts.
+
+SRM relies on instruction following LLM and operates in two lock-step sequences. Given any other agent module/tool,
+its description, and its input and output - SRM does the following:
+
+1. It checks if the module description (objective), the input, and the output are aligned/congruent.
+2. If they are not aligned, it rephrases the input (while retaining semantic meaning) and attempts to elicit an aligned
+output.
+
+SRM can improve the robustness of any module. For example, SearchEngine can sometimes be very sensitive to query wording.
+If we are searching for "Olivia Wilde's boyfriend", the results might not be as precise as if we search for "Who is
+Olivia Wilde's current boyfriend?". SRM can rephrase the query to the latter form if the former form doesn't return
+an aligned answer.
+
+It is still an open question of how to implement SRM. We can make it an internal component or another pipeline. The
+former approach is more efficient and has tight coupling, and the latter is more flexible. We'll carefully weigh
+the pros and cons of each approach and decide on the best approach.
+
+One idea how to integrate SRM into an existing Agent and its tools is that every tool can set a parameter indicating
+how often SRM should run for this tool (default value 0). If it is 0, SRM will not be used at all for that tool,
+otherwise it will check at least once for alignment/congruency and optionally rephrase. This will repeat but not
+more often than the parameter allows.
+
+One possible implementation of SRM could be https://arxiv.org/abs/2203.11171
+
+The main motivation for addition of SRM (and self-consistency ideas in general) is the finding from
+https://arxiv.org/abs/2210.03629 Google Brain researchers discovered that "Wrong reasoning trace (including failing
+to recover from repetitive steps)" accounts for 47% of agent errors.
+
+## WebRetriever
+
+WebRetriever is a symbolic module that allows users to query the web for relevant documents. It is a wrapper around
+SearchEngine that produces a list of Haystack Documents.
+
+WebRetriever will operate in two modes:
+
+- snippet mode: WebRetriever will return a list of Documents, each Document being a snippet of the search result
+- document mode: WebRetriever will return a list of Documents, each Document being a full HTML stripped document of the search result
+
+In document mode, given a user query passed via the run method, SearchEngine first fetches the top_k relevant URL hits, which are
+downloaded and processed. The processing involves stripping irrelevant HTML tags and producing clean raw text. WebRetriever
+then splits raw text into paragraph-long Documents of the desired size.
+
+In the future, we'll develop WebRetriever variants with DocumentStore that caches documents with some expiration
+setting. The enhanced WebRetreiever versions will allow us to avoid downloading the same documents from the web
+multiple times.
+
+However, for the first version of the agent, we'll strive to keep WebRetriever as simple as possible.
+
+## Top-p (nucleus) sampling
+
+Although very useful, top-k ranking is sometimes inferior to top-p ranking. Instead of filtering only from the most
+likely k hits, in top-p sampling we choose the smallest possible set of documents whose cumulative probability of
+relevance exceeds the probability p (usually close to 1). The relevance could be calculated via sbert.net CrossEncoder using
+query and the document content.
+
+In web search, this is a very useful feature as it allows us to avoid query irrelevant documents and be super precise
+in our search results. We'll implement top-p sampling as a separate module that WebRetriever can use. Other components
+in Haystack can use it as well.
+
+The main motivation for addition of top-p sampling is the finding from https://arxiv.org/abs/2210.03629 Google Brain
+researchers found that "Search result error" is the main cause in 23% of the cases of agent failure. Top-p sampling
+can help us minimize this point of failure.
+
+Note that one can still use top-k filtering via Ranker and top-p filtering via TopPSampler in combination.
+
+## Agent memory
+
+Although we currently support only so-called ReAct agents, it is not hard to envision a future where we'll have
+additional agent types including conversational agents.
+
+Due to LLMs one-shot-forget nature of inferencing, conversational agents might need to remember the context of the
+conversation. To support conversational agents, we'll need Agent memory component. The memory component will initially contain
+two submodules: entity extraction and summarization
+
+Entity extraction is a neural module extracting entities from the provided conversation transcript (raw text).
+The entities are best thought of as an outcome of Named-entity recognition task; for example, people, places, organizations etc.
+
+Entity summarization is a neural module that summarizes the entities extracted by the entity extraction module.
+
+Entity extraction and summarization are run in the background as the conversation progresses. The
+frequency of extraction and summarization updates will be configurable.
+
+The extracted entities along with relevant summaries will be stored in the Agent memory. Agent memory implementation
+details are out of scope of this proposal; they could be various short or long term memory storage options.
+
+For the first version of the agent, we'll strive to keep the memory component as simple as possible; we'll
+only implement entity extraction and summarization while we'll use runtime memory for storing entities.
+
+### Future improvements:
+
+As we have limited token payload for model inferencing, we'll need to implement a mechanism for decaying memory.
+
+If we have many entities in the memory, we'll also need to implement a mechanism for entities selection.
+We'll likely need no summaries for well-known entities like "Elon Musk" or "New York".
+
+Information related to the entities could become stale over time (e.g."I'm currently in New York") and we'll
+need to implement a mechanism for updating the entities.
+
+The mechanism for decaying memory, prioritizing and updating entities is out of scope of this proposal.
+
+
+## deepset Cloud API
+The Agent should be able to use pipelines deployed on deepset Cloud as a tool.
+To this end, the text question needs to be send via REST API to
+the [search endpoint](https://docs.cloud.deepset.ai/reference/search_api_v1_workspaces__workspace_name__pipelines__pipeline_name__search_post) of a given pipeline deployed on deepset Cloud.
+
+In the demo, the Agent will use this tool for question answering on indexed documents of the Haystack documentation,
+such as documentation web pages or tutorials.
+
+
+# Drawbacks
+
+One of the main reasons why we should not work on implementing this proposal is that it is a rather large
+undertaking requiring substantial resources. This naturally carries significant risks. We should carefully weigh
+the pros and cons of tools we want to implement and prioritize them. The current priority criteria is that the tool
+should be useful for the agents MVP, the majority of early adopters and that it should be relatively easy to
+implement. We can always add more tools in the future.
+
+Another priority guidance is the demo we intend to build. We want to build a demo that showcases the agent's
+capabilities in a use case that is relevant to the majority of early adopters (current Haystack users).
+
+
+# Alternatives
+
+We also considered the following demo alternatives:
+
+- Medical QA: We can build a demo that answers medical questions. This is a very interesting use case but also
+fraught with risks. A question one might ask in such a demo is “Which antibiotic should I use for urinary tract infections?”.
+A factoid-based QA system might (reasonably) return the answer “trimethoprim 200mg”. However, a “correct” answer is not
+sufficient to translate into clinical use. There were other recent demos but they were not very successful.
+See https://twitter.com/GlassHealthHQ/status/1620092094034620421 for more details.
+
+- Public Healthcare QA: a bit less risky proposal than the medical QA. We can build a demo that answers questions about
+healthy diet, cooking recipes, vitamines etc. This demo would use almost exactly the same tools as the main demo proposal
+and we can potentially switch to this demo if needed.
+
+- Financial Domain (earnings transcript): we can build a demo that answers questions about earnings transcripts. However,
+we were not sure if this is a good use case for the agent as it is not very relevant to the majority of early adopters.
+
+
+# Adoption strategy
+
+An adoption strategy for this proposal is not needed as much and the objective is to demo the capabilities of the agent
+and inspire early adopters to use the agent and the main tools we are going to implement.
+
+
+# Demo
+
+See the Summary section for the demo description.
+
+# How we teach this
+
+We intend to use the demo to teach users about the agent's capabilities. We'll subsequently add more documentation about
+core components used in the demo and the agent in general. This demo would be mainly used to promote Haystack Agents and
+to generate interest in the agent.
+
+# Unresolved questions
+
+Optional, but suggested for first drafts. What parts of the design are still
+TBD?

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/4172-shaper-in-prompt-template.md

@@ -0,0 +1,185 @@
+- Title: Shapers in Prompt Templates
+- Decision driver: tstadel
+- Start Date: 2023-02-15
+- Proposal PR: (fill in after opening the PR)
+- Github Issues or Discussion:
+  - spike: https://github.com/deepset-ai/haystack/pull/4061
+  - solved issues:
+    - https://github.com/deepset-ai/haystack/issues/3877
+    - https://github.com/deepset-ai/haystack/issues/4053
+    - https://github.com/deepset-ai/haystack/issues/4047
+
+# Summary
+
+In order to make prompt templates more flexible and powerful while at the same time making PromptNode as easy to use as any other node in Haystack, we want to introduce two modifications to PromptTemplate:
+- output: support Shapers in PromptTemplates to enable the user to define how the output to the prompt template should be shaped
+- input: extend the prompt syntax to support the usage of functions that can be applied to input variables
+
+With these modifications prompt templates will be able to define, and abstract away from PromptNode, everything that is necessary to create a Haystack node that is specialized for a certain use-case (e.g. generative QA). Additionally, PromptTemplates will be fully serializable, enabling everyone to share their prompt templates with the community.
+
+# Basic example
+
+A generative QA pipeline would be as easy as this:
+
+    ```python
+    from haystack import Pipeline
+    from haystack.document_store import InMemoryDocumentStore
+    from haystack.nodes import PromptNode, EmbeddingRetriever
+
+    document_store = InMemoryDocumentStore()
+    retriever = EmbeddingRetriever(document_store=document_store, ...)
+    pn = PromptNode(default_prompt_template="question-answering-with-references")
+
+    p = Pipeline()
+    p.add_node(component=retriever, name="Retriever", inputs=["Query"])
+    p.add_node(component=pn, name="Prompt", inputs=["Retriever"])
+    ```
+
+As a result we get a pipeline that uses PromptNode as a drop-in replacement for Generators:
+
+    ```python
+    p.run(
+        query="What is the most popular drink?"
+    )
+    ```
+
+    ```python
+    {'answers': [<Answer {'answer': 'Potable water is the most popular drink, followed by tea and beer as stated in Document[5].', 'type': 'generative', 'score': None, 'context': None, 'offsets_in_document': None, 'offsets_in_context': None, 'document_ids': ['fcd62336fb380a69c2d655f8cd072995'], 'meta': {}}>],
+    'invocation_context': {'query': 'What is the most popular drink?',
+    'documents': [<Document: {'content': 'Beer is the oldest[1][2][3] and most widely consumed[4] type of alcoholic drink in the world, and the third most popular drink overall after potable water and tea.[5] It is produced by the brewing and fermentation of starches, mainly derived from cereal grains—most commonly from malted barley, though wheat, maize (corn), rice, and oats are also used. During the brewing process, fermentation of the starch sugars in the wort produces ethanol and carbonation in the resulting beer.[6] Most modern beer is brewed with hops, which add bitterness and other flavours and act as a natural preservative and stabilizing agent. Other flavouring agents such as gruit, herbs, or fruits may be included or used instead of hops. In commercial brewing, the natural carbonation effect is often removed during processing and replaced with forced carbonation.[7]', 'content_type': 'text', 'score': None, 'meta': {}, 'id_hash_keys': ['content'], 'embedding': None, 'id': 'fcd62336fb380a69c2d655f8cd072995'}>],
+    'answers': [<Answer {'answer': 'Potable water is the most popular drink, followed by tea and beer as stated in Document[5].', 'type': 'generative', 'score': None, 'context': None, 'offsets_in_document': None, 'offsets_in_context': None, 'document_ids': ['fcd62336fb380a69c2d655f8cd072995'], 'meta': {}}>]},
+     '_debug': {'PromptNode': {'runtime': {'prompts_used': ['Create a concise and informative answer (no more than 50 words) for a given question based solely on the given documents. You must only use information from the given documents. Use an unbiased and journalistic tone. Do not repeat text. Cite the documents using Document[number] notation. If multiple documents contain the answer, cite those documents like ‘as stated in Document[number,number,etc]’. If the documents do not contain the answer to the question, say that ‘answering is not possible given the available information.’\nDocument[1]: Beer is the oldest(1)(2)(3) and most widely consumed(4) type of alcoholic drink in the world, and the third most popular drink overall after potable water and tea.(5) It is produced by the brewing and fermentation of starches, mainly derived from cereal grains—most commonly from malted barley, though wheat, maize (corn), rice, and oats are also used. During the brewing process, fermentation of the starch sugars in the wort produces ethanol and carbonation in the resulting beer.(6) Most modern beer is brewed with hops, which add bitterness and other flavours and act as a natural preservative and stabilizing agent. Other flavouring agents such as gruit, herbs, or fruits may be included or used instead of hops. In commercial brewing, the natural carbonation effect is often removed during processing and replaced with forced carbonation.(7); \n Question: What is the most popular drink?; Answer: ']}}},
+     'root_node': 'Query',
+     'params': {},
+     'query': 'What is the most popular drink?',
+     'documents': [<Document: {'content': 'Beer is the oldest[1][2][3] and most widely consumed[4] type of alcoholic drink in the world, and the third most popular drink overall after potable water and tea.[5] It is produced by the brewing and fermentation of starches, mainly derived from cereal grains—most commonly from malted barley, though wheat, maize (corn), rice, and oats are also used. During the brewing process, fermentation of the starch sugars in the wort produces ethanol and carbonation in the resulting beer.[6] Most modern beer is brewed with hops, which add bitterness and other flavours and act as a natural preservative and stabilizing agent. Other flavouring agents such as gruit, herbs, or fruits may be included or used instead of hops. In commercial brewing, the natural carbonation effect is often removed during processing and replaced with forced carbonation.[7]', 'content_type': 'text', 'score': None, 'meta': {}, 'id_hash_keys': ['content'], 'embedding': None, 'id': 'fcd62336fb380a69c2d655f8cd072995'}>],
+     'node_id': 'PromptNode'}
+    ```
+
+The corresponding prompt template would look like this (provided `join_documents` and `strings_to_answers` Shaper functions are extended a bit):
+
+    ```python
+    PromptTemplate(
+            name="question-answering-with-references",
+            prompt_text="Create a concise and informative answer (no more than 50 words) for a given question "
+            "based solely on the given documents. You must only use information from the given documents. "
+            "Use an unbiased and journalistic tone. Do not repeat text. Cite the documents using Document[number] notation. "
+            "If multiple documents contain the answer, cite those documents like ‘as stated in Document[number,number,etc]’. "
+            "If the documents do not contain the answer to the question, say that ‘answering is not possible given the available information.’\n"
+            "{join(documents, '\n', '\nDocument[$idx]: $content', {'\n': ' ', '[': '(', ']': ')'})} \n Question: {query}; Answer: ",
+            output_shapers=[
+                Shaper(
+                    func="strings_to_answers",
+                    inputs={"strings": "results", "documents": "documents"},
+                    outputs=["answers"],
+                )
+            ],
+            output_variable="answers",
+        )
+    ```
+
+We make sure that we have proper default values for the input shaping function and it is easy to understand. `{join(documents)}` should be usable in most cases. When you want to have more control over document rendering something like `join(documents, DELIMITER, PATTERN, CHAR_REPLACEMENT)` with
+
+    ```python
+    DELIMITER = "\n"
+    PATTERN = "$content" # parsable by StringTemplate using data from document.content, document.meta and the index of the document
+    CHAR_REPLACEMENT = {"[": "(", "}": ")"} # just an example what could be passed here
+    ```
+
+would do.
+
+Note that the number of how many prompts are created depends on which shaping functions are used. If you use `join(documents)` you will have only one prompt. If you omit the `join` and use `to_list(query)` instead, you will have multiple prompts (one prompt per document).
+
+# Motivation
+
+Currently using PromptNode is a bit cumbersome as:
+- for using it in popular use-cases like question-answering, it requires to add the Shapers to the pipeline manually which creates a lot of boilerplate code and is not very intuitive
+- to customize a prompt within a pipeline, you may need to change four different things: the prompt node, the prompt template, the input shapers and the output shapers. This is not ideal as it requires to write a lot of boilerplate code and makes it hard to iterate quickly on prompts.
+- if you wanted to share your prompt template with the community, you would need to share the whole pipeline (as you do need shapers), which is not ideal as it may contain other nodes that are not relevant.
+
+
+# Detailed design
+
+## General changes
+PromptTemplate gets one new attribute: `output_shapers`. These are lists of Shaper objects that are applied to the output of the prompt.
+PromptTemplate's syntax is extended to allow for the usage of shaping functions on input variables. These shaping functions are predefined.
+
+## Basic flow:
+PromptNode calls `PromptTemplate.prepare` before executing the prompt. `PromptTemplate.prepare` applies the shaping functions (if present) to the arguments of the `invocation_context`.
+PromptNode invokes the prompt on the prepared `invocation_context`.
+PromptNode calls `PromptTemplate.post_process` after executing the prompt. `PromptTemplate.post_process` makes all `output_shapers` run on the `invocation_context`.
+
+## Shaping functions
+The PromptTemplate syntax is extended to allow for the usage of shaping functions on input variables. These shaping functions should be easy to understand and use.
+We only support positional args for shaping functions. This is because we want to keep the syntax simple and we don't want to overcomplicate the parsing logic. As args any python primitive is allowed (e.g. strings, ints, floats, lists, dicts, None).
+Parsing is done by using regular expressions. If we however notice that this is not enough, we can switch to a more complex parsing library like `jinja2`.
+Here is a basic (and incomplete) example how the parsing logic could look like:
+
+    ```python
+
+        # template allowing basic list comprehensions to create the wanted string
+        template = """
+        Create a concise and informative answer (no more than 50 words) for a given question
+        based solely on the given documents. You must only use information from the given documents.
+        Use an unbiased and journalistic tone. Do not repeat text. Cite the documents using Document[number] notation.
+        If multiple documents contain the answer, cite those documents like ‘as stated in Document[number,number,etc]’.
+        If the documents do not contain the answer to the question, say that ‘answering is not possible given the available information.
+        {join(documents, new_line)} \n Question: {query}; Answer:
+        """
+
+        for group in re.findall(r'\{(.*?)\}', template):
+            if "(" in group and ")" in group:
+                function_to_call = group[:group.index("(")].strip()
+                variables_for_function = [var.strip() for var in group[group.index("(")+1:group.index(")")].split(",")]
+                print(f"Found function '{function_to_call}' with vars '{variables_for_function}'")
+            else:
+                print("Found single variable:", group)
+
+        # Returns
+        # >>> Found function 'join' with vars '['documents', 'new_line']'
+        # >>> Found single variable: query
+    ```
+
+## Prompt engineering with Haystack Pipelines
+Additionally we want to support changing the prompt via a param of `Pipeline.run`. This is useful for example if you want to fine-tune your prompt and iterate quickly on it without having to change the pipeline. The `prompt` param is a string in `Pipeline.run` which will be delegated to the `PromptNode` and then used by `PromptTemplate`. This is similar to how `Pipeline.run` works with the `query` param. Note that the `prompt` param does not affect `output_shapers`.
+
+## Misc
+Note, that `Shapers` are still usable in Pipelines as before.
+
+# 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? A good day
+- Can the solution you're proposing be implemented as a separate package, outside of Haystack? No
+- Does it teach people more about Haystack? No, but it makes it easier to use especially for beginners.
+- How does this feature integrate with other existing and planned features? It doesn't change any existing features and should nicely integrate with agents.
+- What's the cost of migrating existing Haystack pipelines (is it a breaking change?)? None
+
+It also fosters a bit the nesting of components in Haystack. Although the whole PromptNode ecosystem already does this (e.g. via PromptModel, PromptTemplate being used by PromptNode), it's still a bit of a new concept. However, I think it's a good one and it's not too hard to understand.
+
+We still don't have access to PromptNode, PromptModel or the invocation layer inside of PromptTemplates. If we want PromptTemplate to access fundamental parts of them (e.g. the tokenizer), we would need to pass them to the PromptTemplate. This would make the whole system more complex, but it would be possible.
+
+# Alternatives
+
+Sub-classing specialized PromptNodes like QuestionAnsweringPromptNode, which would have the shapers already defined. This would make it easier to use, but it would be harder to iterate quickly on prompts, be less flexible and sharing is difficult. The same is true for sub-classing PromptTemplate like QuestionAnsweringPromptTemplate. Both sub-classing approaches would make it easier to use, but it would be harder to iterate quickly on prompts, be less flexible and sharing is difficult.
+
+Having `input_shapers` in the same way as `output_shapers` in the PromptTemplate. This would make it harder for users to get started as they would need to understand Shapers and which functions are relevant for input shaping.
+# Adoption strategy
+
+As the syntax for input variables in `PromptTemplate` changes we can do the following:
+- raise an error if the old syntax is used and tell the user to use the new syntax
+- support the old syntax for a while and raise a deprecation warning
+
+# How we teach this
+
+We should show how:
+- predefined PromptTemplates can be used
+- predefined PromptTemplates can be customized
+- custom PromptTemplates can be created
+
+# Unresolved questions
+
+How does `OpenAIAnswerGenerator` make use of input shaping functions and output shapers?
+- output shapers: it doesn't use them
+- input shaping functions: it uses them if they are present. If not it uses its own default functions.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/4284-drop-basecomponent.md

@@ -0,0 +1,950 @@
+- Title: Drop `BaseComponent` and reimplement `Pipeline`.
+- Decision driver: @ZanSara
+- Start Date: 27/02/2023
+- Proposal PR: #4284
+- Github Issue or Discussion: #2807
+
+# Summary
+
+Haystack Pipelines are very powerful objects, but they still have a number of unnecessary limitations, by design and by implementation.
+
+This proposal aims to address most of the implementation issues, some fundamental assumptions like the need for DAGs and the `BaseComponent` class, and proposes a solution for the question of `DocumentStore`'s status with respect to the `Pipeline`.
+
+
+# Motivation
+
+Pipelines are the fundamental component of Haystack and one of its most powerful concepts. At its core, a Pipeline is a DAG (Directed Acyclic Graph) of objects called Nodes, or Components, each of whom executes a specific transformation on the data flowing along the pipeline. In this way, users can combine powerful libraries, NLP models, and simple Python snippets to connect a herd of tools into a one single, coherent object that can fulfill an infinite variety of tasks.
+
+However, as it currently stands, the `Pipeline` object is also imposing a number of limitations on its use, most of which are likely to be unnecessary. Some of these include:
+
+- DAGs. DAGs are safe, but loops could enable many more usecases, like `Agents`.
+
+- `Pipeline` can select among branches, but cannot run such branches in parallel, except for some specific and inconsistent corner cases. For further reference and discussions on the topic, see:
+    - https://github.com/deepset-ai/haystack/pull/2593
+    - https://github.com/deepset-ai/haystack/pull/2981#issuecomment-1207850632
+    - https://github.com/deepset-ai/haystack/issues/2999#issuecomment-1210382151
+
+- `Pipeline`s are forced to have one single input and one single output node, and the input node has to be called either `Query` or `Indexing`, which softly forbids any other type of pipeline.
+
+- The fixed set of allowed inputs (`query`, `file_paths`, `labels`, `documents`, `meta`, `params` and `debug`) blocks several usecases, like summarization pipelines, translation pipelines, even some sort of generative pipelines.
+
+- `Pipeline`s are often required to have a `DocumentStore` _somewhere_ (see below), even in situation where it wouldn't be needed.
+  - For example, `Pipeline` has a `get_document_store()` method which iterates over all nodes looking for a `Retriever`.
+
+- The redundant concept of `run()` and `run_batch()`: nodes should take care of this distinction internally if it's important, otherwise run in batches by default.
+
+- The distinction between a `Pipeline` and its YAML representation is confusing: YAMLs can contain several pipelines, but `Pipeline.save_to_yaml()` can only save a single pipeline.
+
+In addition, there are a number of known bugs that makes the current Pipeline implementation hard to work with. Some of these include:
+
+- Branching and merging logic is known to be buggy even where it's supported.
+- Nodes can't be added twice to the same pipeline in different locations, limiting their reusability.
+- Pipeline YAML validation needs to happen with a YAML schema because `Pipeline`s can only be loaded along with all their nodes, which is a very heavy operation. Shallow or lazy loading of nodes doesn't exist.
+- Being forced to use a schema for YAML validation makes impossible to validate the graph in advance.
+
+On top of these issues, there is the tangential issue of `DocumentStore`s and their uncertain relationship with `Pipeline`s. This problem has to be taken into account during a redesign of `Pipeline` and, if necessary, `DocumentStore`s should also be partially impacted. Some of these issues include:
+
+- `DocumentStore`s are nodes in theory, but in practice they can be added to `Pipeline`s only to receive documents to be stored. On the other hand, `DocumentStore`'s most prominent usecase is as a _source_ of documents, and currently they are not suited for this task without going through an intermediary, most often a `Retriever` class.
+  - The relationship between `DocumentStore` and `Retriever` should be left as a topic for a separate proposal but kept in mind, because `Retriever`s currently act as the main interface for `DocumentStore`s into `Pipeline`s.
+
+This proposal tries to address all the above point by taking a radical stance with:
+
+- A full reimplementation of the `Pipeline` class that does not limit itself to DAGs, can run branches in parallel, can skip branches and can process loops safely.
+
+- Dropping the concept of `BaseComponent` and introducing the much lighter concept of `Node` in its place.
+
+- Define a clear contract between `Pipeline` and the `Node`s.
+
+- Define a clear place for `DocumentStore`s with respect to `Pipeline`s that doesn't forcefully involve `Retriever`s.
+
+- Redesign the YAML representation of `Pipeline`s.
+
+# Basic example
+
+A simple example of how the new Pipeline could look like is shown here. This example does not address `DocumentStore`s or YAML serialization, but rather focuses on the shift between `BaseComponent` and `Node`s.
+
+For the detailed explanation behind the design choices and all open questions, see the "Detailed Design" section and the draft implementation here: https://github.com/ZanSara/haystack-2.0-draft
+
+## Simple example
+
+This is a very simplified example that performs some mathematical operations. See below for more realistic examples.
+
+```python
+from typing import Dict, Any, List, Tuple
+from haystack.pipeline import Pipeline
+from haystack.nodes import node
+
+# A Haystack Node. See below for details about this contract.
+# Crucial components are the @node decorator and the `run()` method
+@node
+class AddValue:
+    def __init__(self, add: int = 1, input_name: str = "value", output_name: str = "value"):
+        self.add = add
+        self.init_parameters = {"add": add}
+        self.inputs = [input_name]
+        self.outputs = [output_name]
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Any],
+        stores: Dict[str, Any],
+    ):
+        my_parameters = parameters.get(name, {})
+        add = my_parameters.get("add", self.add)
+
+        for _, value in data:
+            value += add
+
+        return ({self.outputs[0]: value}, parameters)
+
+
+@node
+class Double:
+    def __init__(self, input_edge: str = "value"):
+        self.init_parameters = {"input_edge": input_edge}
+        self.inputs = [input_edge]
+        self.outputs = [input_edge]
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Any],
+        stores: Dict[str, Any],
+    ):
+        for _, value in data:
+            value *= 2
+
+        return ({self.outputs[0]: value}, parameters)
+
+
+pipeline = Pipeline()
+
+# Nodes can be initialized as standalone objects.
+# These instances can be added to the Pipeline in several places.
+addition = AddValue(add=1)
+
+# Nodes are added with a name and an node. Note the lack of references to any other node.
+pipeline.add_node("first_addition", addition, parameters={"add": 3})  # Nodes can store default parameters per node.
+pipeline.add_node("second_addition", addition)  # Note that instances can be reused
+pipeline.add_node("double", Double())
+
+# Nodes are the connected as input node: [list of output nodes]
+pipeline.connect(connect_from="first_addition", connect_to="double")
+pipeline.connect(connect_from="double", connect_to="second_addition")
+
+pipeline.draw("pipeline.png")
+
+# Pipeline.run() accepts 'data' and 'parameters' only. Such dictionaries can contain
+# anything, depending on what the first node(s) of the pipeline requires.
+# Pipeline does not validate the input: the first node(s) should do so.
+results = pipeline.run(
+    data={"value": 1},
+    parameters = {"second_addition": {"add": 10}}   # Parameters can be passed at this stage as well
+)
+assert results == {"value": 18}
+```
+
+The result of `Pipeline.draw()`:
+
+![image](images/4284-drop-basecomponent/pipeline.png)
+
+
+## Query Pipeline
+
+This query pipeline includes real Reader and Retriever nodes. A new set of primitives and a new DocumentStore has been used for this example: please refer to the draft implementation for details on those: https://github.com/ZanSara/haystack-2.0-draft
+
+
+<details>
+<summary>RetrieveByBM25</summary>
+
+```python
+from typing import Dict, Any, List, Tuple
+
+import logging
+
+from haystack.data import TextQuery
+from haystack.nodes import node
+
+
+@node
+class RetrieveByBM25:
+    """
+    Simple dummy BM25 Retriever that works with MemoryStore.
+    Supports batch processing.
+    """
+    def __init__(self,
+            input_name: str = "query",
+            output_name: str = "documents_by_query",
+            default_store: str = "documents",
+            default_top_k: int = 10
+        ):
+        self.default_store = default_store
+        self.default_top_k = default_top_k
+
+        # Pipelne's contract:
+        self.init_parameters = {
+            "input_name": input_name,
+            "output_name": output_name,
+            "default_store": default_store,
+            "default_top_k": default_top_k
+        }
+        self.inputs = [input_name]
+        self.outputs = [output_name]
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Any],
+        stores: Dict[str, Any],
+    ):
+        my_parameters = parameters.get(name, {})
+        store_name = my_parameters.get("store", self.default_store)
+        top_k = my_parameters.get("top_k", self.default_top_k)
+
+        # This can be done safely, because Nodes expect the Pipeline to respect their contract.
+        # Errors here are Pipeline's responsibility, so Nodes should not care.
+        queries = data[0][1]
+
+        # Batch support is not the pipeline's business, but the node's
+        if isinstance(queries, TextQuery):
+            queries = [queries]
+        elif queries and not (
+            isinstance(queries, list) and
+            all(isinstance(query, TextQuery) for query in queries)
+        ):
+            raise ValueError(f"'{data[0][0]}' can only contain TextQuery objects. '{data[0][0]}' contains: {queries}")
+
+        if not store_name in stores.keys():
+            raise ValueError(f"No store called '{store_name}'.")
+
+        results = stores[store_name].get_relevant_documents(queries=queries, top_k=top_k)
+
+        return ({self.outputs[0]: results}, parameters)
+```
+
+</details>
+
+
+<details>
+<summary>ReadByTransformers</summary>
+
+```python
+from typing import Dict, Any, List, Tuple
+
+from haystack.data import TextAnswer, Span
+from haystack import node
+
+
+@node
+class ReadByTransformers:
+    """
+    Simple dummy Transformers Reader.
+    Supports batch processing.
+    """
+    def __init__(self,
+        model_name_or_path: str,
+        default_top_k: int = 5,
+        default_no_answer: bool = True,
+        default_max_seq_len: int = 256,
+        default_doc_stride: int = 128,
+        default_batch_size: int = 16,
+        default_context_window_size: int = 70,
+        input_name: str = "documents_by_query",
+        output_name: str = "answers_by_query",
+    ):
+        self.model_name_or_path = model_name_or_path
+        self.default_top_k = default_top_k
+        self.default_no_answer = default_no_answer
+        self.default_max_seq_len = default_max_seq_len
+        self.default_doc_stride = default_doc_stride
+        self.default_batch_size = default_batch_size
+        self.default_context_window_size = default_context_window_size
+        self.model = None
+
+        self.init_parameters = {
+            "input_name": input_name,
+            "output_name": output_name,
+            "model_name_or_path": model_name_or_path,
+            "default_top_k": default_top_k,
+            "default_no_answer": default_no_answer,
+            "default_max_seq_len": default_max_seq_len,
+            "default_doc_stride": default_doc_stride,
+            "default_batch_size": default_batch_size,
+            "default_context_window_size": default_context_window_size,
+        }
+        self.inputs = [input_name]
+        self.outputs = [output_name]
+
+    def warm_up(self):
+        try:
+            from transformers import pipeline
+        except Exception as e:
+            raise ImportError("Can't import 'transformers': this node won't work.") from e
+
+        if not self.model:
+            self.model = pipeline(
+                "question-answering",
+                model=self.model_name_or_path,
+            )
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Any],
+        stores: Dict[str, Any],
+    ):
+        my_parameters = parameters.get(name, {})
+        top_k = my_parameters.get("top_k", self.default_top_k)
+        no_answer = my_parameters.get("no_answer", self.default_no_answer)
+        max_seq_len = my_parameters.get("max_seq_len", self.default_max_seq_len)
+        doc_stride = my_parameters.get("doc_stride", self.default_doc_stride)
+        batch_size = my_parameters.get("batch_size", self.default_batch_size)
+        context_window_size = my_parameters.get("context_window_size", self.default_context_window_size)
+
+        documents_for_queries = data[0][1]
+
+        inputs = []
+        for query, documents in documents_for_queries.items():
+            inputs.extend([
+                self.model.create_sample(question=query.content, context=doc.content)  # type: ignore
+                for doc in documents
+            ])
+
+        # Inference
+        predictions = self.model(   # type: ignore
+            inputs,
+            top_k=top_k,
+            handle_impossible_answer=no_answer,
+            max_seq_len=max_seq_len,
+            doc_stride=doc_stride,
+            batch_size=batch_size,
+        )
+
+        # Builds the TextAnswer object
+        answers_for_queries = {query: [] for query in documents_for_queries.keys()}
+        for query, documents in documents_for_queries.items():
+            documents = list(documents) # FIXME consume here the iterator for now
+            docs_len = len(documents)
+            relevant_predictions = predictions[:docs_len]
+            predictions = predictions[docs_len:]
+
+            for document, prediction in zip(documents, relevant_predictions):
+                if prediction.get("answer", None):
+                    context_start = max(0, prediction["start"] - context_window_size)
+                    context_end = min(len(document.content), prediction["end"] + context_window_size)
+                    answers_for_queries[query].append(
+                        TextAnswer(
+                            content=prediction["answer"],
+                            score=prediction["score"],
+                            context=document.content[context_start:context_end],
+                            offset_in_document=Span(start=prediction["start"], end=prediction["end"]),
+                            offset_in_context=Span(start=prediction["start"] - context_start, end=prediction["end"] - context_start),
+                            document_id=document.id,
+                            meta=document.meta,
+                        )
+                    )
+                elif no_answer:
+                    answers_for_queries[query].append(
+                        TextAnswer(
+                            content="",
+                            score=prediction["score"],
+                            meta=document.meta,
+                        )
+                    )
+            answers_for_queries[query] = sorted(answers_for_queries[query], reverse=True)[:top_k]
+        return ({self.outputs[0]: answers_for_queries}, parameters)
+```
+
+</details>
+
+```python
+import json
+from pathlib import Path
+
+from haystack.pipeline import Pipeline
+from haystack.stores import MemoryDocumentStore
+from haystack.data import TextQuery, TextDocument
+from haystack.nodes import RetrieveByBM25, ReadByTransformers
+
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+
+
+def test_pipeline():
+    document_store = MemoryDocumentStore()
+    document_store.write_documents([
+        TextDocument(content="My name is Anna and I live in Paris."),
+        TextDocument(content="My name is Serena and I live in Rome."),
+        TextDocument(content="My name is Julia and I live in Berlin."),
+    ])
+    pipeline = Pipeline()
+    pipeline.connect_store("my_documents", document_store)
+    pipeline.add_node("retriever", RetrieveByBM25(default_store="my_documents"))
+    pipeline.add_node("reader", ReadByTransformers(model_name_or_path="distilbert-base-uncased-distilled-squad"))
+
+    pipeline.connect(connect_from="retriever", connect_to="reader")
+    pipeline.draw("query_pipeline.png")
+
+    results = pipeline.run({"query": TextQuery(content="Who lives in Berlin?")})
+
+    print(results)
+
+
+if __name__ == "__main__":
+    test_pipeline()
+```
+Pipeline diagram:
+
+![image](images/4284-drop-basecomponent/query_pipeline.png)
+
+Output:
+```
+{
+    "answers_by_query": {
+        "TextQuery('Who lives in Berlin?')": [
+            "TextAnswer(id='bfe8d4e1fd43db24a61847a4efea7e4b', content='Julia', content_type='text', meta={}, id_hash_keys=['content'], score=0.9149983525276184, context='My name is Julia and I live in Berlin.', offset_in_document=Span(start=11, end=16), offset_in_context=Span(start=11, end=16), document_id='6afac5b39e0ddd125a7513b13fefe27d')"
+        ]
+    }
+}
+```
+
+**IMPORTANT NOTE:** This is an example meant to showcase the concept. However, it has a major flaw: it is coupling queries and documents tightly.
+
+This does not surface as an issue in this simple example, but it limits severely the reusability of Retrievers and Readers because they do not simply output documents anymore, they output a complex structure that is only accessible by them. We should do our best to decouple values as much as possible, so that other nodes can access only the specific output required for them to operate.
+
+In this specific example, we might imagine a multi-modal Retriever connected to several single-modality Readers. To make that work, we would need a DocumentClassifier, an intermediate node to route the documents by type to each Reader: in the current design, that won't be easy. If instead queries and documents were send out in two separate lists, the task for DocumentClassifier would be far easier.
+
+This is a bright example of how good and careful design of nodes is going to be vital for the health of the framework, and will force us to be way more strict around best practices and standards.
+
+# Detailed design
+
+This section focuses on the concept rather than the implementation strategy. For a discussion on the implementation, see the draft here: https://github.com/ZanSara/haystack-2.0-draft
+
+## The Pipeline API
+
+These are the core features that drove the design of the revised Pipeline API:
+
+- An execution graph that is more flexible than a DAG.
+- A clear place for `DocumentStore`s
+
+Therefore, the revised Pipeline object has the following API:
+
+- Core functions:
+    - `__init__(metadata=None)`: Creates an empty Pipeline. Note the `metadata` field, which can be used to carry metadata info. Such metadata might come useful in `Application`s (see below) to distinguish `Pipeline`s, tag them, describe them, etc.
+    - `run(data, parameters, debug)`: the core of the class. Relies on `networkx` for most of the heavy-lifting. Check out the implementation (https://github.com/ZanSara/haystack-2.0-draft/blob/main/new-haystack/haystack/pipeline/pipeline.py) for details: the code is heavily commented on the main loop and on the handling of non-trivial execution paths like branch selection, parallel branch execution, loops handling, multiple input/output and so on. For the effects of `debug`, see the dedicated section below.
+    - `draw(path)`: as in the old Pipeline object. Based on `pygraphviz` (which requires `graphviz`), but we might need to look for pure Python alternatives based on Matplotlib to reduce our dependencies.
+- Graph building:
+    - `add_node(name, node, parameters)`: adds a disconnected node to the graph. It expects Haystack nodes in the `node` parameter and will fail if they aren't respecting the contract. See below for a more detailed discussion of the Nodes' contract.
+    - `get_node(name)`: returns the node's information stored in the graph
+    - `connect(input_node, output_node)`: connects nodes together. It will fail if the nodes inputs and outputs do not match: see the Nodes' contract to understand how Nodes can declare their I/O.
+- Docstore management:
+    - `add_store(name, store)`: adds a DocumentStore to the stores that are passed down to the nodes through the `stores` variable.
+    - `list_stores()`: returns all connected stores.
+    - `get_store(name)`: returns a specific document store by name.
+
+Example pipeline topologies supported by the new implementation (images taken from the test suite):
+
+<details>
+<summary>Merging pipeline</summary>
+
+![image](images/4284-drop-basecomponent/merging_pipeline.png)
+
+In this pipeline, several nodes send their input into a single output node. Note that this pipeline has several starting nodes, something that is currently not supported by Haystack's `Pipeline`.
+
+</details>
+
+<details>
+<summary>Branching pipeline with branch skipping</summary>
+
+![image](images/4284-drop-basecomponent/decision_pipeline.png)
+
+In this pipeline, only one edge will run depending on the decision taken by the `remainder` node. Note that this pipeline has several terminal nodes, something that is currently not supported by Haystack's `Pipeline`.
+
+</details>
+
+<details>
+<summary>Branching pipeline with parallel branch execution</summary>
+
+![image](images/4284-drop-basecomponent/parallel_branches_pipeline.png)
+
+In this pipeline, all the edges that leave `enumerate` are run by `Pipeline`. Note that this usecase is currently not supported by Haystack's `Pipeline`.
+
+</details>
+
+<details>
+<summary>Branching pipeline with branch skipping and merge</summary>
+
+![image](images/4284-drop-basecomponent/decision_and_merge_pipeline.png)
+
+In this pipeline, the merge node can understand that some of its upstream nodes will never run (`remainder` selects only one output edge) and waits only for the inputs that it can receive, so one from `remainder`, plus `no-op`.
+
+</details>
+
+<details>
+<summary>Looping pipeline</summary>
+
+![image](images/4284-drop-basecomponent/looping_pipeline.png)
+
+This is a pipeline with a loop and a counter that statefully counts how many times it has been called.
+
+Note that the new `Pipeline` can set a maximum number of allowed visits to nodes, so that loops are eventually stopped if they get stuck.
+
+</details>
+
+<details>
+<summary>Looping pipeline with merge</summary>
+
+![image](images/4284-drop-basecomponent/looping_and_merge_pipeline.png)
+
+This is a pipeline with a loop and a counter that statefully counts how many times it has been called. There is also a merge node at the bottom, which shows how Pipeline can wait for the entire loop to exit before running `sum`.
+
+</details>
+
+<details>
+<summary>Arbitrarily complex pipeline</summary>
+
+![image](images/4284-drop-basecomponent/complex_pipeline.png)
+
+This is an example of how complex Pipelines the new objects can support. This pipeline combines all cases above:
+- Multiple inputs
+- Multiple outputs
+- Decision nodes and branches skipped due to a selection
+- Distribution nodes and branches executed in parallel
+- Merge nodes where it's unclear how many edges will actually carry values
+- Merge nodes with repeated inputs (`sum` takes three `value` edges) or distinct inputs (`diff` takes `value` and `sum`)
+- Loops along a branch
+</details>
+
+NOTE: the draft implementation supports all of these topologies already. You can find the code for each of these pipelines under https://github.com/ZanSara/new-haystack-pipeline-draft/tree/main/new-haystack/tests/integration
+
+## The Node contract
+
+A Haystack node is any class that abides the following contract:
+
+```python
+# This decorator does very little, but is necessary for Pipelines to recognize
+# this class as a Haystack node. Check its implementation for details.
+@node
+class MyNode:
+
+    def __init__(self, model_name: str: "deepset-ai/a-model-name"):
+        """
+        Haystack nodes should have an `__init__` method where they define:
+
+        - `self.inputs = [<input_name(s)>]`:
+            A list with all the edges they can possibly receive input from
+
+        - `self.outputs = [<output_name(s)>]`:
+            A list with the edges they might possibly produce as output
+
+        - `self.init_parameters = {<init parameters>}`:
+            Any state they wish to be persisted in their YAML serialization.
+            These values will be given to the `__init__` method of a new instance
+            when the pipeline is deserialized.
+
+        The `__init__` must be extremely lightweight, because it's a frequent
+        operation during the construction and validation of the pipeline. If a node
+        has some heavy state to initialize (models, backends, etc...) refer to the
+        `warm_up()` method.
+        """
+        # Lightweight state can be initialized here, for example storing the model name
+        # to be loaded later. See self.warm_up()
+        self.model = None
+        self.model_name = model_name
+        self.how_many_times_have_I_been_called = 0
+
+        # Contract - all three are mandatory.
+        self.init_parameters = {"model_name": model_name}
+        self.inputs = ["input_name"]
+        self.outputs = ["output_name"]
+
+    def warm_up(self):
+        """
+        Optional method.
+
+        This method is called by Pipeline before the graph execution.
+        Make sure to avoid double-initializations, because Pipeline will not keep
+        track of which nodes it called `warm_up` on.
+        """
+        if not self.model:
+            self.model = AutoModel.load_from_pretrained(self.model_name)
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Any],
+        stores: Dict[str, Any],
+    ):
+        """
+        Mandatory method.
+
+        This is the method where the main functionality of the node should be carried out.
+        It's called by `Pipeline.run()`, which passes the following parameters to it:
+
+        - `name: str`: the name of the node. Allows the node to find its own parameters in the `parameters` dictionary (see below).
+
+        - `data: List[Tuple[str, Any]]`: the input data.
+            Pipeline guarantees that the following assert always passes: `assert self.inputs == [name for name, value in data]`,
+            which means that:
+            - `data` is of the same length as `self.inputs`.
+            - `data` contains one tuple for each string stored in `self.inputs`.
+            - no guarantee is given on the values of these tuples: notably, if there was a decision node upstream, some values might be `None`.
+            For example, if a node declares `self.inputs = ["value", "value"]` (think of a Sum node), `data` might look like:
+            - `[("value", 1), ("value", 10)]`
+            - `[("value", None), ("value", 10)]`
+            - `[("value", None), ("value", None)]`, or even
+            - `[("value", 1), ("value", ["something", "unexpected"])]`
+            but it will never look like:
+            - `[("value", 1), ("value", 10), ("value", 100)]`,
+            - `[("value": 15)]` or
+            - `[("value": 15), ("unexpected", 10)]`.
+
+        - `parameters: Dict[str, Dict[str, Any]]`: a dictionary of dictionaries with all the parameters for all nodes.
+            Note that all nodes have access to all parameters for all other nodes: this might come handy to nodes like `Agent`s, that
+            want to influence the behavior of nodes downstream.
+            Nodes can access their own parameters using `name`, but they must not assume their name is present in the dictionary.
+            Therefore the best way to get the parameters is with `my_parameters = parameters.get(name, {})`
+
+        - `stores`: a dictionary of all the (Document)Stores connected to this pipeline.
+
+        Pipeline expect the output of this function to be a tuple in the following format:
+
+        `( {edge: value for edge in <subset of self.outputs>}, {the parameters dictionary})
+
+        Which means that:
+        - Nodes are not forced to produce output on all the expected outputs: for example nodes taking a decision, like classifiers,
+            can produce output on a subset of the expected output edges and Pipeline will figure out the rest.
+        - Nodes must not add any key in the data dictionary that is not present in `self.outputs`,
+        - Nodes can alter the content of `parameters` and their changes will be propagated downstream.
+        """
+        self.how_many_times_have_I_been_called += 1
+
+        value = data[0][1]
+        print(f"Hello I'm {name}! This instance have been called {self.how_many_times_have_I_been_called} times and this is the value I received: {value}")
+
+        return ({self.outputs[0]: value}, parameters)
+```
+
+This contract is stored in the docstring of `@node` and acts as the single source of truth.
+
+Note how there are a few fundamental shifts from the old concept of pipelines and nodes:
+
+- There's no base class for nodes anymore. A node is whatever object is decorated with `@node`.
+
+- Pipelines can now be validated by instantiating them, and instantiation is going to be very fast, because the nodes are supposed to defer heavy operations to the `warm_up()` method. This does not prevent us from having shallow validation with a schema, but gives us more room for other validation strategies too.
+
+- Edges are designed to carry one value, be it a primitive like an `int` or a complex dictionary or an object. We have no more "fat edges" by default that carry complex output: we can now safely output several values on several edges and, if need be, connect multiple edges between the same two nodes.
+    - For example, if `node_a` outputs `value_1` and `value_2`, both these edges can be given to a `sum` node.
+
+- There's no more naming ambiguity between nodes and components.
+
+### Nodes discovery logic
+
+When pipelines are loaded from YAML, Pipeline needs to find the classes definition somewhere in the imported modules. Currently, at initialization `Pipeline` looks for classes which is decorated with the `@node` decorator under `haystack`, however such search can be extended (or narrowed) by setting the `search_nodes_in` init parameter of `Pipeline`. Note that it will try to import any module that is not imported yet.
+
+Search might fail in narrow corner cases: for example, inner classes are not discovered (often the case in tests). For these scenarios, `Pipeline` also accepts an `extra_nodes` init parameter that allows users to explicitly provide a dictionary of nodes to merge with the other discovered nodes.
+
+Name collisions are handled by prefixing the node name with the name of the module it was imported from.
+
+## Validation
+
+Pipeline performs validation on the edge name level: when calling `Pipeline.connect()`, it uses the values of the nodes' `self.inputs` and `self.outputs` to make sure that the connection is possible.
+
+Nodes are required, by contract, to explicitly define their inputs and outputs, and these values are used by the `connect` method to validate the connection, and by the `run` method to route values.
+
+For example, let's imagine we have two nodes with the following I/O declared:
+
+```python
+@node
+class NodeA:
+
+    def __init__(self):
+        self.inputs = ["input"]
+        self.outputs = ["intermediate_value"]
+
+    def run(self):
+        pass
+
+@node
+class NodeB:
+
+    def __init__(self):
+        self.inputs = ["intermediate_value"]
+        self.outputs = ["output"]
+
+    def run(self):
+        pass
+```
+
+This is the behavior of `Pipeline.connect()`:
+
+```python
+pipeline.connect('node_a', 'node_b')
+# Succeeds: no output
+
+pipeline.connect('node_a', 'node_a')
+# Traceback (most recent call last):
+#   File "/home/sara/work/haystack-2/example.py", line 29, in <module>
+#     pipeline.connect('node_a', 'node_a')
+#   File "/home/sara/work/haystack-2/new-haystack/haystack/pipeline/pipeline.py", line 224, in connect
+#     raise PipelineConnectError(
+# haystack.pipeline._utils.PipelineConnectError: Cannot connect 'node_a' with 'node_a' with an edge named 'intermediate_value': their declared inputs and outputs do not match.
+# Upstream node 'node_a' declared these outputs:
+#  - intermediate_value (free)
+# Downstream node 'node_a' declared these inputs:
+#  - input (free)
+
+pipeline.connect('node_b', 'node_a')
+# Traceback (most recent call last):
+#   File "/home/sara/work/haystack-2/example.py", line 29, in <module>
+#     pipeline.connect('node_b', 'node_a')
+#   File "/home/sara/work/haystack-2/new-haystack/haystack/pipeline/pipeline.py", line 224, in connect
+#     raise PipelineConnectError(
+# haystack.pipeline._utils.PipelineConnectError: Cannot connect 'node_b' with 'node_a' with an edge named 'output': their declared inputs and outputs do not match.
+# Upstream node 'node_b' declared these outputs:
+#  - output (free)
+# Downstream node 'node_a' declared these inputs:
+#  - input (free)
+```
+
+This type of error reporting was found especially useful for nodes that declare a variable number and name of inputs and outputs depending on their initialization parameters (think of language classifiers, for example).
+
+One shortcoming is that currently Pipeline "trusts" the nodes to respect their own declarations. So if a node states that it will output `intermediate_value`, but outputs something else once run, `Pipeline` will fail. We accept this failure as a "contract breach": the node should fix its behavior and `Pipeline` should not try to prevent such scenarios.
+
+Note: the draft implementation does not validate the type of the values, but only their names. So two nodes might agree to pass a variable called `documents` to each other, but one might output a `Set` when the receiver expects a `List`, and that will cause a crash. However, such check will be added.
+
+Other features planned for addition are:
+- automatically connect nodes if matching edges are found, even if the match is partial
+- double check for unconnected nodes and edges
+
+### Parameters hierarchy
+
+Parameters can be passed to nodes at several stages, and they have different priorities. Here they're listed from least priority to top priority.
+
+1. **Node's default `__init__` parameters**: nodes's `__init__` can provide defaults. Those are used only if no other parameters are passed at any stage.
+2. **Node's `__init__` parameters**: at initialization, nodes might be given values for their parameters. These are stored within the node instance and, if the instance is reused in the pipeline several times, they will be the same on all of them
+3. **Pipeline's `add_node()`**: When added to the pipeline, users can specify some parameters that have to be given only to that node specifically. They will override the node instance's parameters, but they will be applied only in that specific location of the pipeline and not be applied to other instances of the same node anywhere else in the graph.
+4. **Pipeline's `run()`**: `run()` also accepts a dictionary of parameters that will override all conflicting parameters set at any level below, quite like Pipeline does today.
+
+Example:
+
+```python
+
+class Node:
+    def __init__(self, value_1: int = 1, value_2: int = 1, value_3: int = 1, value_4: int = 1):
+        ...
+
+node = Node(value_2=2, value_3=2, value_4=2)
+pipeline = Pipeline()
+pipeline.add_node("node", node, parameters={"value_3": 3, "value_4": 3})
+...
+pipeline.run(data={...}, parameters={"node": {"value_4": 4}})
+
+# Node will receive {"value_1": 1, "value_2": 2, "value_3": 3,"value_4": 4}
+```
+
+### Debug mode
+
+The strategy towards debugging:
+
+- Pipelines are aware of debug mode, Nodes aren't.
+- Pipeline will produce debug output entirely through machine-readable logs.
+
+This implies that nodes don't have any **standardized** way to tell whether they're being debugged (while nothing prevents them from accepting a `debug` parameter if need be), and that they don't have any **standardized** way to output debug info except from logs (while nothing prevents them from supporting a `debug` edge if need be).
+
+We took this decision to encourage nodes to implement the same behavior regardless of debug mode, and to incentivize the use of machine-readable logs.
+
+### Evaluation
+
+Evaluation of Pipelines is a topic too wide for the scope of this proposal, so it has been left out on purpose. We will open a separate proposal after this one has been approved.
+
+### Pipeline Serialization
+
+_(Disclaimer: no draft implementation available yet)_
+
+We decide to remove the possibility of serializing single `Pipeline`s and to defer such task to a dedicated marshalling utility. This decision was made to remove the current ambiguity of `Pipeline` YAMLs being able to store several `Pipeline`s, while `Pipeline.save_to_yaml()` can only save one.
+
+In code, saving and loading pipelines will look like this:
+
+```python
+from haystack.pipelines import Pipeline, save_pipelines, load_pipelines
+
+query_pipeline = Pipeline()
+indexing_pipeline = Pipeline()
+# .. assemble the pipelines ...
+
+# Save the pipelines
+save_pipelines(
+    pipelines={
+        "query": query_pipeline,
+        "indexing": indexing_pipeline,
+    },
+    path="my_pipelines.json",
+    writer=json.dumps
+)
+
+# Load the pipelines
+new_pipelines = load_pipelines(
+    path="my_pipelines.json",
+    reader=json.loads
+)
+
+assert new_pipelines["query"] == query_pipeline
+assert new_pipelines["indexing"] == indexing_pipeline
+```
+
+Note how the save/load functions accept a writer/reader function: this choice frees us from committing strongly to a specific template language, and although a default will be set (be it YAML, TOML, HCL or anything else) the decision can be overridden by passing another explicit reader/writer function to the `save_pipelines`/`load_pipelines` functions.
+
+This is how the resulting file will look like, assuming a JSON writer was chosen.
+
+`my_pipeline.json`
+
+```json
+{
+    # A list of "dependencies" for the application.
+    # Used to ensure all external nodes are present when loading.
+    "dependencies" : [
+        "haystack == 2.0.0",
+        "my_custom_node_module == 0.0.1",
+    ],
+
+    # Stores are defined here, outside single pipeline graphs.
+    # All pipelines have access to all these docstores.
+    "stores": {
+        # Nodes will be able to access them by the name defined here,
+        # in this case `my_first_store` (see the retrievers below).
+        "my_first_store": {
+            # class_name is mandatory
+            "class_name": "InMemoryDocumentStore",
+            # Then come all the additional parameters for the store
+            "use_bm25": true
+        },
+        "my_second_store": {
+            "class_name": "InMemoryDocumentStore",
+            "use_bm25": false
+        }
+    },
+
+    # Nodes are defined here, outside single pipeline graphs as well.
+    # All pipelines can use these nodes. Instances are re-used across
+    # Pipelines if they happen to share a node.
+    "nodes": {
+        # In order to reuse an instance across multiple nodes, instead
+        # of a `class_name` there should be a pointer to another node.
+        "my_sparse_retriever": {
+            # class_name is mandatory, unless it's a pointer to another node.
+            "class_name": "BM25Retriever",
+            # Then come all the additional init parameters for the node
+            "store_name": "my_first_store",
+            "top_k": 5
+        },
+        "my_dense_retriever": {
+            "class_name": "EmbeddingRetriever",
+            "model_name": "deepset-ai/a-model-name",
+            "store_name": "my_second_store",
+            "top_k": 5
+        },
+        "my_ranker": {
+            "class_name": "Ranker",
+            "inputs": ["documents", "documents"],
+            "outputs": ["documents"],
+        },
+        "my_reader": {
+            "class_name": "Reader",
+            "model_name": "deepset-ai/another-model-name",
+            "top_k": 3
+        }
+    },
+
+    # Pipelines are defined here. They can reference all nodes above.
+    # All pipelines will get access to all docstores
+    "pipelines": {
+        "sparse_question_answering": {
+            # Mandatory list of edges. Same syntax as for `Pipeline.connect()`
+            "edges": [
+                ("my_sparse_retriever", ["reader"])
+            ],
+            # To pass some parameters at the `Pipeline.add_node()` stage, add them here.
+            "parameters": {
+                "my_sparse_retriever": {
+                    "top_k": 10
+                }
+            },
+            # Metadata can be very valuable for dC and to organize larger Applications
+            "metadata": {
+                "type": "question_answering",
+                "description": "A test pipeline to evaluate Sparse QA.",
+                "author": "ZanSara"
+            },
+            # Other `Pipeline.__init__()` parameters
+            "max_allowed_loops": 10,
+        },
+        "dense_question_answering": {
+            "edges": [
+                ("my_dense_retriever", ["reader"])
+            ],
+            "metadata": {
+                "type": "question_answering",
+                "description": "A test pipeline to evaluate Sparse QA.",
+                "author": "an_intern"
+            }
+        },
+        "hybrid_question_answering": {
+            "edges": [
+                ("my_sparse_retriever", ["ranker"]),
+                ("my_dense_retriever", ["ranker"]),
+                ("ranker", ["reader"]),
+            ],
+            "metadata": {
+                "type": "question_answering",
+                "description": "A test pipeline to evaluate Hybrid QA.",
+                "author": "the_boss"
+            }
+        }
+    }
+}
+```
+
+# Open questions
+
+None left.
+
+# Drawbacks
+
+There are a number of drawbacks about the proposed approach:
+
+- Migration is going to be far from straightforward for us. Although many nodes can probably work with minor adaptations into the new system, it would be beneficial for most of them to be reduced to their `run()` method, especially indexing nodes. This means that nodes need, at least, to be migrated one by one to the new system and code copied over.
+
+- Migration is going to be far from straightforward for the users: see "Adoption strategy".
+
+- This system allows for pipelines with more complex topologies, which brings the risk of more corner cases. `Pipeline.run()` must be made very solid in order to avoid this scenario.
+
+- Nodes might break more easily while running due to unexpected inputs. While well designed nodes should internally check and deal with such situations, we might face larger amount of bugs due to our failure at noticing the lack of checks at review time.
+
+- The entire system work on the assumption that nodes are well behaving and "polite" to other nodes, for example not touching their parameters unless necessary, etc. Malicious or otherwise "rude" nodes can wreak havoc in `Pipeline`s by messing with other node's parameters.
+
+## Known limitations
+
+- **Reusability of nodes across Pipelines in REST API.** Currently, REST API are designed in such a way that a separate worker is spawned for each pipeline deployed. That makes sharing node instances across them a non-starter. However, we believe this specific limitation can be addressed by a different approach to the problem, like splitting pipelines in a way that shared nodes are stored in a dedicated sub-pipeline and so on. We postpone addressing this problem when it arises, as we don't consider it blocking and workarounds can be found.
+
+# Adoption strategy
+
+Old and new `Pipeline` and nodes are going to be fully incompatible. We must provide a migration script that can convert their existing pipeline YAMLs into the new ones.
+
+This proposal is best thought as part of the design of Haystack 2.0.
+
+## Rollout process
+
+These changes are going to be release with Haystack 1.x in a hidden internal package called `haystack.v2.pipelines`, and won't be promoted straight away.
+
+We will progressively add nodes to this `haystack.v2` package and build a folder structure under it (`haystack.v2.nodes`, `haystack.v2.stores`, ...) version after version, until we believe the content of the package is usable. Documentation will be built in parallel and we will progressively start pushing users towards the 2.0 API.
+Power users like dC and other Haystack experts will be able to test out these changes from the start and provide feedback while still in Haystack 1.x.
+
+Once we're confident that the v2 version covers all of Haystack v1.x usecases, Haystack 2.0 will be released and the packages are going to be switched: the content of `haystack` will be moved into `haystack.v1` and deprecated, and the content of `haystack.v2` will me moved under `haystack`. A few 2.x versions later, `haystack.v1` will then be dropped.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/4370-documentstores-and-retrievers.md

@@ -0,0 +1,239 @@
+- Title: `DocumentStores` and `Retrievers`
+- Decision driver: @ZanSara
+- Start Date: 2023-03-09
+- Proposal PR: 4370
+- Github Issue or Discussion: (only if available, link the original request for this change)
+
+# Summary
+
+Haystack's Document Stores are a very central component in Haystack and, as the name suggest, they were initially designed around the concept of `Document`.
+
+As the framework grew, so did the number of Document Stores and their API, until the point where keeping them aligned aligned on the same feature set started to become a serious challenge.
+
+In this proposal we outline a reviewed design of the same concept.
+
+Note: these stores are designed to work **only** alongside Haystack 2.0 Pipelines (see https://github.com/deepset-ai/haystack/pull/4284)
+
+# Motivation
+
+Current `DocumentStore` face several issues mostly due to their organic growth. Some of them are:
+
+- `DocumentStore`s perform the bulk of retrieval, but they need to be tightly coupled to a `Retriever` object to work. We believe this coupling can be broken by a clear API boundary between `DocumentStores`, `Retriever`s and `Embedder`s. In this PR we focus on decoupling them.
+
+- `DocumentStore`s tend to bring in complex dependencies, so less used stores should be easy to decouple into external packages at need.
+
+# Basic example
+
+Stores will have to follow a contract rather than subclassing a base class. We define a contract for `DocumentStore` that defines a very simple CRUD API for Documents. Then, we provide one implementation for each underlying technology (`MemoryDocumentStore`, `ElasticsearchDocumentStore`, `FaissDocumentStore`) that respects such contract.
+
+Once stores are defined, we will create one `Retriever` for each `DocumentStore`. Such retrievers are going to be highly specialized nodes that expect one specific document store and can handle all its specific requirements without being bound to a generic interface.
+
+For example, this is how embedding-based retrieval would look like:
+
+```python
+from haystack import Pipeline
+from haystack.nodes import (
+    TxtConverter,
+    PreProcessor,
+    DocumentWriter,
+    DocumentEmbedder,
+    StringEmbedder,
+    MemoryRetriever,
+    Reader,
+)
+from haystack.document_stores import MemoryDocumentStore
+
+docstore = MemoryDocumentStore()
+
+indexing_pipe = Pipeline()
+indexing_pipe.add_store("document_store", docstore)
+indexing_pipe.add_node("txt_converter", TxtConverter())
+indexing_pipe.add_node("preprocessor", PreProcessor())
+indexing_pipe.add_node("embedder", DocumentEmbedder(model_name="deepset/model-name"))
+indexing_pipe.add_node("writer", DocumentWriter(store="document_store"))
+indexing_pipe.connect("txt_converter", "preprocessor")
+indexing_pipe.connect("preprocessor", "embedder")
+indexing_pipe.connect("embedder", "writer")
+
+indexing_pipe.run(...)
+
+query_pipe = Pipeline()
+query_pipe.add_store("document_store", docstore)
+query_pipe.add_node("embedder", StringEmbedder(model_name="deepset/model-name"))
+query_pipe.add_node("retriever", MemoryRetriever(store="document_store", retrieval_method="embedding"))
+query_pipe.add_node("reader", Reader(model_name="deepset/model-name"))
+query_pipe.connect("embedder", "retriever")
+query_pipe.connect("retriever", "reader")
+
+results = query_pipe.run(...)
+```
+
+Note a few key differences with the existing Haystack process:
+
+- During indexing we do not use any `Retriever`, but rather a `DocumentEmbedder`. This class accepts a model name and simply adds embeddings to the `Document`s it receives.
+
+- We used an explicit `DocumentWriter` node instead of adding the `DocumentStore` at the end of the pipeline. That node will be generic for any document store, because the `DocumentStore` contract declares a `write_documents` method (see "Detailed Design").
+
+- During query, the first step is not a `Retriever` anymore, but a `StringEmbedder`. Such node will convert the query into its embedding representation and forward it over to a `Retriever` that expects it. In this case, an imaginary `MemoryRetriever` can be configured to expect an embedding by setting the `retrieval_method` flag to `embedding`.
+
+
+# Detailed design
+
+## `DocumentStore` contract
+
+Here is a summary of the basic contract that all `DocumentStore`s are expected to follow.
+
+```python
+class MyDocumentStore:
+
+    def count_documents(self, **kwargs) -> int:
+        ...
+
+    def filter_documents(self, filters: Dict[str, Any], **kwargs) -> List[Document]:
+        ...
+
+    def write_documents(self, documents: List[Document], **kwargs) -> None:
+        ...
+
+    def delete_documents(self, ids: List[str], **kwargs) -> None:
+        ...
+```
+
+The contract is quite narrow to encourage the use of specialized nodes. `DocumentStore`s' primary focus should be storing documents: the fact that most vector stores also support retrieval should be outside of this abstraction and made available through methods that do not belong to the contract. This allows `Retriever`s to carry out their tasks while avoiding clutter on `DocumentStore`s that do not support some features.
+
+Note also how the concept of `index` is not present anymore, as it it mostly ES-specific.
+
+For example, a `MemoryDocumentStore` could offer the following API:
+
+```python
+class MemoryDocumentStore:
+
+    def filter_documents(self, filters: Dict[str, Any], **kwargs) -> List[Document]:
+        ...
+
+    def write_documents(self, documents: List[Document], **kwargs) -> None:
+        ...
+
+    def delete_documents(self, ids: List[str], **kwargs) -> None:
+        ...
+
+    def bm25_retrieval(
+        self,
+        queries: List[str],   # Note: takes strings!
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10
+    ) -> List[List[Document]]:
+        ...
+
+    def vector_similarity_retrieval(
+        self,
+        queries: List[np.array],   # Note: takes embeddings!
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10
+    ) -> List[List[Document]]:
+        ...
+
+    def knn_retrieval(
+        self,
+        queries: List[np.array],   # Note: takes embeddings!
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10
+    ) -> List[List[Document]]:
+        ...
+```
+
+In this way, a `DocumentWriter` could easily use the `write_documents` method defined in the contract on all document stores, while `MemoryRetriever` can leverage the fact that it only supports `MemoryDocumentStore`, so it can assume all its custom methods like `bm25_retrieval`, `vector_similarity_retrieval`, etc... are present.
+
+Here is, for comparison, an example implementation of a `DocumentWriter`, a document-store agnostic node.
+
+```python
+@node
+class DocumentWriter:
+
+    def __init__(self, inputs=['documents'], stores=["documents"]):
+        self.store_names = stores
+        self.inputs = inputs
+        self.outputs = []
+        self.init_parameters = {"inputs": inputs, "stores": stores}
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        writer_parameters = parameters.get(name, {})
+        stores = writer_parameters.pop("stores", {})
+
+        all_documents = []
+        for _, documents in data:
+            all_documents += documents
+
+        for store_name in self.store_names:
+            stores[store_name].write_documents(documents=all_documents, **writer_parameters)
+
+        return ({}, parameters)
+```
+This class does not check which document store it is using, because it can safely assume they are going to have a `write_documents` method.
+
+Here instead we can see an example implementation of a `MemoryRetriever`, a document-store aware node.
+
+```python
+@node
+class MemoryRetriever:
+
+    def __init__(self, inputs=['query'], output="documents", stores=["documents"]):
+        self.store_names = stores
+        self.inputs = inputs
+        self.outputs = [output]
+        self.init_parameters = {"inputs": inputs, "output": output "stores": stores}
+
+    def run(
+        self,
+        name: str,
+        data: List[Tuple[str, Any]],
+        parameters: Dict[str, Dict[str, Any]]
+    ) -> Dict[str, Any]:
+
+        retriever_parameters = parameters.get(name, {})
+        stores = retriever_parameters.pop("stores", {})
+        retrieval_method = retriever_parameters.pop("retrieval_method", "bm25")
+
+        for store_name in self.store_names:
+            if not isinstance(stores[store_name], MemoryStore):
+                raise ValueError("MemoryRetriever only works with MemoryDocumentStore.")
+
+            if retrieval_method == "bm25":
+                documents = stores[store_name].bm25_retrieval(queries=queries, **retriever_parameters)
+            elif retrieval_method == "embedding":
+                documents = stores[store_name].vector_similarity_retrieval(queries=queries, **retriever_parameters)
+            ...
+
+        return ({self.outputs[0]: documents}, parameters)
+```
+
+Note how `MemoryRetriever` is making use of methods that are not specified in the contract and therefore has to check that the document store it has been connected to is a proper one.
+
+# Drawbacks
+
+### Migration effort
+
+We will need to migrate all `DocumentStore`s and heavily cut their API. Although it is going to be a massive undertaking, this process will allow us to drop less used `DocumentStore` backends and focus on the most important ones. It will also highly reduce the code we have to maintain.
+
+We will also need to re-implement the ehtire Retrieval stack. We believe a lot of code could be reused, but we will focus on leveraging each document store facilities a lot more, and that will require almost complete rewriters. The upside is that the resulting code should be several times shorter, so the maintenance burden should be limited.
+
+# Alternatives
+
+We could force support for the old Docstores into the new Pipelines, but I see no value in such effort given that with the same investment we can get a massively smaller codebase.
+
+# Adoption strategy
+
+This proposal is part of the Haystack 2.0 rollout strategy. See https://github.com/deepset-ai/haystack/pull/4284.
+
+# How we teach this
+
+Documentation is going to be crucial, as much as tutorials and demos. We plan to start working on those as soon as basic nodes (one reader and one retriever) are added to Haystack v2 and `MemoryDocumentStore` receives its first implementation.
+
+# Open questions
+
+- We should enable validation of `DocumentStore`s for nodes that are document-store aware. It could be done by an additional `validation` method with relative ease, but it's currently not mentioned in the node/pipeline contract.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5289-recentness-ranker.md

@@ -0,0 +1,185 @@
+- Title: Addition of a RecentnessRanker node
+- Decision driver: @elundaeva
+- Start Date: 2023-07-05
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/5289
+- Github Issue or Discussion: some links available in the "Detailed design" section below
+
+# Summary
+
+This ranker allows to have retrieved documents sorted not only by relevance (default) but also with recency factored in.
+
+# Basic example
+
+The RecentnessRanker would be instantiated as follows:
+
+  ``` python
+
+	  ranker = RecentnessRanker(
+	      date_identifier="date",
+	      weight="0.5",
+          top_k=3,
+	      method="reciprocal_rank_fusion",
+	  )
+  ```
+
+And here is an example of how the node would work in the context of a generative QA pipeline:
+
+  ``` yaml
+
+version: '1.18.0'
+name: 'Example pipeline'
+
+components:
+- name: DocumentStore
+  type: DeepsetCloudDocumentStore
+- name: EmbeddingRetriever
+  type: EmbeddingRetriever
+  params:
+    document_store: DocumentStore
+    embedding_model: [embedding model here]
+    model_format: sentence_transformers
+    top_k: 30
+- name: BM25Retriever
+  type: BM25Retriever
+  params:
+    document_store: DocumentStore
+    top_k: 30
+- name: JoinDocuments
+  type: JoinDocuments
+  params:
+    top_k_join: 30
+    join_mode: reciprocal_rank_fusion
+- name: Ranker
+  type: SentenceTransformersRanker
+  params:
+    model_name_or_path: [cross-encoder model here]
+    top_k: 15
+- name: RecentnessRanker
+  type: RecentnessRanker
+  params:
+    date_identifier: release_date
+    top_k: 3
+    method: score
+- name: qa_template
+  type: PromptTemplate
+  params:
+    output_parser:
+        type: AnswerParser
+    prompt: "prompt text here"
+- name: PromptNode
+  type: PromptNode
+  params:
+    default_prompt_template: qa_template
+    max_length: 300
+    model_kwargs:
+      temperature: 0
+    model_name_or_path: gpt-3.5-turbo
+- name: FileTypeClassifier
+  type: FileTypeClassifier
+- name: TextConverter
+  type: TextConverter
+- name: PDFConverter
+  type: PDFToTextConverter
+- name: Preprocessor
+  params:
+    language: en
+    split_by: word
+    split_length: 200
+    split_overlap: 10
+    split_respect_sentence_boundary: true
+  type: PreProcessor
+
+pipelines:
+- name: query
+  nodes:
+    - name: EmbeddingRetriever
+      inputs: [Query]
+    - name: BM25Retriever
+      inputs: [Query]
+    - name: JoinDocuments
+      inputs: [EmbeddingRetriever, BM25Retriever]
+    - name: Ranker
+      inputs: [JoinDocuments]
+    - name: RecentnessRanker
+      inputs: [Ranker]
+    - name: PromptNode
+      inputs: [RecentnessRanker]
+
+- name: indexing
+  nodes:
+  - inputs:
+    - File
+    name: FileTypeClassifier
+  - inputs:
+    - FileTypeClassifier.output_1
+    name: TextConverter
+  - inputs:
+    - FileTypeClassifier.output_2
+    name: PDFConverter
+  - inputs:
+    - TextConverter
+    - PDFConverter
+    name: Preprocessor
+  - inputs:
+    - Preprocessor
+    name: EmbeddingRetriever
+  - inputs:
+    - EmbeddingRetriever
+    name: DocumentStore
+
+  ```
+
+# Motivation
+
+Initially this ranker was implemented by Timo for a customer case where the date of the document mattered for retrieval. The reason we would like to add it to Haystack is because we see wider use for this node in future customer and community cases. One example where document recency matters is in a QA solution based on technical documentation with release notes of a software product - the older release notes should naturally have less priority in the responses than the most recent ones. And another example is news content - news articles retrieval can definitely benefit from recency being factored into the relevance calculation.
+
+# Detailed design
+
+You can see the code for this proposal here: https://github.com/deepset-ai/haystack/pull/5301/files.
+
+As a general description, the ranker has the following parameters (date_identifier and method are required, the rest are optional):
+- date_identifier (string pointing to the date field in the metadata)
+- weight (the options are:
+          - 0.5 default, relevance and recency will have the same impact in the calculation;
+          - 0 only relevance will be considered for the calculation, so the RecentnessRanker is effectively disabled;
+          - 1 only recency will be considered for the calculation)
+- top_k (number of documents to return, works the same way as top-k in other rankers as well as retrievers)
+- method (the options are:
+          - "reciprocal_rank_fusion" which does not require any relevance score from the previous node;
+          - "score" requires a 0-1 relevance score provided from the previous node in the pipeline.
+          More information on method compatibility with different retrievers is in the Drawbacks section below)
+
+The RecentnessRanker works by:
+1. Adjusting the relevance score based on the chosen weight.
+  For the "reciprocal_rank_fusion" the calculation is rrf * (1 - weight). The rrf is calculated as 1 / (k + rank) where k=61 (see reasoning below).
+  And the "score" method performs the calculation as relevance score * (1 - weight).
+2. Adding to the relevance score the recentness score by:
+  For the "reciprocal_rank_fusion" - performing the rrf * weight calculation on the documents dictionary sorted by date where rrf is 1 / (k + rank), k=61.
+  For the "score" method - performing the recentness score * weight calculation where recentness score is (amount of documents - rank) / amount of documents.
+3. Returning top-k documents in the documents dictionary sorted by final score (relevance score + recentness score both adjusted by weight).
+
+k is set to 61 in reciprocal rank fusion based on a University of Waterloo paper (co-authored with Google) called "Reciprocal Rank Fusion outperforms Condorcet and individual Rank Learning Methods" [https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf] where k=60 was suggested, and 1 was added as python lists are 0-based and the paper used 1-based ranking.
+
+# Drawbacks
+
+Since this is a relatively small change without any effect on existing nodes, I do not see major reasons not to add this ranker. The only important limitation to using this node is the need to have a metadata field with document date already present.
+
+For the "score" method, you would also need to double-check that the previous node outputs a score within [0,1] range (e.g. CohereRanker, SentenceTransformersRanker, EmbeddingRetriever). With the "reciprocal_rank_fusion" method, you do not need to have the relevance score pre-calculated, so using this method allows to combine RecentnessRanker with other retrieval nodes, like BM25 retriever.
+
+# Alternatives
+
+Without adding this feature it will not be possible to handle customer and community cases where recency of documents matters for the response, see examples in the Motivation section.
+
+# Adoption strategy
+
+This is not a breaking change and there does not seem to be any need for a migration script. Existing Haystack users can just start using this node on as-needed basis in combination with existing retrieval options (sparse/dense/hybrid).
+
+# How we teach this
+
+A small change like this might not require creating a whole new tutorial (although it is of course up to you), although it can be interesting to discuss this ranker with example usage in blog post format like we have for metadata filtering (https://www.deepset.ai/blog/metadata-filtering-in-haystack).
+
+As for documentation needs, it would be good to add some info on how to use this recentness ranker - it can be added to the same page where the other existing rankers are explained. If you need help writing the documentation and/or the blog post/tutorial, please do not hesitate to reach out to me.
+
+# Unresolved questions
+
+Since it has already been implemented and is functional, there are not many known unresolved design questions. We just need to make sure that if/when the custom node is deprecated and we transition to using this node in Haystack, there are no disruptions to production pipelines that have been using this node and they get adjusted accordingly.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5390-embedders.md

@@ -0,0 +1,249 @@
+- Title: Embedders
+- Decision driver: @anakin87
+- Start Date: 2023-07-19
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/5390
+
+# Summary
+
+As decided in the previous proposals ([Embedding Retriever](3558-embedding_retriever.md) and [DocumentStores and Retrievers](4370-documentstores-and-retrievers.md)), in Haystack V2 we want to introduce a new component: the Embedder.
+
+**Separation of concerns**
+- DocumentStores: store the Documents, their metadata and representations (vectors); they offer a CRUD API.
+- Retrievers: retrieve Documents from the DocumentStores; they are specific and aware of the used Store (e.g., MemoryRetriever for the MemoryDocumentStore). They will be commonly used in query pipelines (not in indexing pipelines).
+- **Embedders**: encode a list of data points (strings, images, etc.) into a list of vectors (i.e., the embeddings) using a model. They are used both in indexing pipelines (to encode the Documents) and query pipelines (to encode the query).
+
+*In the current implementation, the Embedder is part of Retriever, which is unintuitive and comes with several disadvantages (explained in the previous proposals).*
+
+**This proposal aims to define the Embedder design.**
+
+# Basic example
+
+*This code snippet is merely an example and may not be completely up-to-date.*
+
+
+```python
+from haystack import Pipeline
+from haystack.components import (
+    TxtConverter,
+    PreProcessor,
+    DocumentWriter,
+    OpenAITextEmbedder,
+    OpenAIDocumentEmbedder,
+    MemoryRetriever,
+    Reader,
+)
+from haystack.document_stores import MemoryDocumentStore
+docstore = MemoryDocumentStore()
+
+indexing_pipe = Pipeline()
+indexing_pipe.add_store("document_store", docstore)
+indexing_pipe.add_node("txt_converter", TxtConverter())
+indexing_pipe.add_node("preprocessor", PreProcessor())
+indexing_pipe.add_node("embedder", OpenAIDocumentEmbedder(model_name="text-embedding-ada-002"))
+indexing_pipe.add_node("writer", DocumentWriter(store="document_store"))
+indexing_pipe.connect("txt_converter", "preprocessor")
+indexing_pipe.connect("preprocessor", "embedder")
+indexing_pipe.connect("embedder", "writer")
+
+indexing_pipe.run(...)
+
+query_pipe = Pipeline()
+query_pipe.add_store("document_store", docstore)
+query_pipe.add_node("embedder", OpenAITextEmbedder(model_name="text-embedding-ada-002"))
+query_pipe.add_node("retriever", MemoryRetriever(store="document_store", retrieval_method="embedding"))
+query_pipe.add_node("reader", Reader(model_name="deepset/model-name"))
+query_pipe.connect("embedder", "retriever")
+query_pipe.connect("retriever", "reader")
+
+results = query_pipe.run(...)
+```
+
+- The `OpenAITextEmbedder` uses OpenAI models to convert a list of strings into a list of vectors. It is used in the query pipeline to embed the query.
+- The `OpenAIDocumentEmbedder` uses OpenAI models to enrich a list of Documents with the corresponding vectors (stored in the `embedding` field). It is used in the indexing pipeline to embed the Documents.
+- The Retriever is no longer needed in the indexing pipeline.
+
+# Motivation
+
+The motivations behind this change were already provided in the previous proposals ([Embedding Retriever](3558-embedding_retriever.md) and [DocumentStores and Retrievers](4370-document_stores_and_retrievers.md)). Here is a summary:
+- Retrievers shouldn't be responsible for embedding Documents.
+- Currently, Retrievers have many parameters just to support and configure different underlying Encoders(≈Embedders).
+- Adding support for new embedding providers or strategies is difficult. It requires changing the Retriever code.
+
+# Detailed design
+
+## Handle queries and Documents
+This is the most critical aspect of the design.
+
+- When embedding queries, the Embedder component receives a list of strings in input that are transformed into a list of vectors returned as output.
+- When embedding documents, the Embedder component receives a list of `Document` objects in input; for each item in the list, the corresponding vectors are computed and stored in the `embedding` field of the item itself. The list is then returned as the component output.
+- When working with documents, there's the possibility to compute embeddings also for document's metadata. In this case, the Embedder will be responsible for performing any text-manipulation work needed in preparation of the actual embedding process.
+
+**Below, I will focus on the public API. The internal implementation is discussed in [Implementation details](#implementation-details).**
+
+```python
+@component
+class HFTextEmbedder:
+    ...
+
+    @component.output_types(result=List[np.ndarray])
+    def run(self, strings: List[str]):
+        ...
+        return {"result": list_of_computed_embeddings}
+
+
+@component
+class HFDocumentEmbedder:
+    ...
+
+    @component.output_types(result=List[Document])
+    def run(self, documents: List[Document]):
+        ...
+        return {"result": list_of_documents_with_embeddings}
+```
+
+## Different providers/strategies
+
+- We can define different embedder components depending on the models or services providing the actual embeddings: `OpenAIEmbedder`, `CohereEmbedder`, `HuggingFaceEmbedder`, `SentenceTransformersEmbedder`, etc.
+- Additionally, we could define different classes depending on the embedding strategy if necessary.
+While this is not a prominent use case, there are scenarios where [new strategies](https://github.com/deepset-ai/haystack/issues/5242) are introduced, requiring different libraries (`InstructorEmbedder`) or involving a different string preparation (`E5Embedder`). Supporting these scenarios with minimal effort would be nice.
+
+## Different models in the same embedding/retrieval task
+
+As you can observe from the [current implementation](https://github.com/deepset-ai/haystack/blob/main/haystack/nodes/retriever/dense.py), some embedding/retrieval tasks require the usage of different models.
+
+This is not the most popular approach today, compared to what we call Embedding Retrieval (based on a single model). But it still has some relevant applications.
+
+Some examples:
+- In Dense Passage Retrieval, you need a model to encode queries and another model to encode Documents
+- in the TableTextRetriever, we use 3 different models: one for queries, one for textual passages and one for tables
+- in Multimodal Retrieval, we can specify different models to encode queries and Documents
+
+Since the Embedder will not be included in the Retriever, it makes sense to have different Embedders, each one using a single model.
+
+```python
+dpr_query_embedder = SentenceTransformersTextEmbedder(model_name="facebook/dpr-question_encoder-single-nq-base")
+dpr_doc_embedder = SentenceTransformersDocumentEmbedder(model_name="facebook/dpr-ctx_encoder-single-nq-base")
+```
+
+## Implementation details
+
+*You can skip this section if you are primarily interested in user experience.*
+
+There have been much discussion on how to effectively implement this proposal.
+The most important aspects to consider:
+- we want different Embedders for queries and Documents as they require a different treatment
+- if the same model is internally used for different Embedders, we want to reuse the same instance in order to save memory
+
+On top of the embedder components we already discussed, we introduce one additional abstraction:
+an `EmbeddingBackend`, which is NOT a component, responsible for performing the actual embedding computation, implemented as a singleton class in order to reuse instances. It will live in a different package and will be hidden from the public API.
+```python
+@singleton  # implementation is out of scope
+class HFEmbeddingBackend:
+    """
+    NOT A COMPONENT!
+    """
+    def __init__(self, model_name: str, ... init params ...):
+        """
+        init takes the minimum parameters needed at init time, not
+        the params needed at inference, so they're easier to reuse.
+        """
+        self.model = ...
+
+    def embed(self, data: str, ... inference params ... ) -> np.ndarray:
+        # compute embedding
+        return embedding
+
+
+class OpenAIEmbeddingBackend:
+    ... same as above ...
+```
+
+Implemented as singletons, when instantiating an EmbeddingBackend class, if another identical one exists, the existing one will be returned without allocating additional resources for a new one. This makes model reusability transparent, saving lots of memory without any user intervention.
+
+This is how an EmbeddingBackend would be used by a text embedder component:
+**Part of the public API**.
+```python
+@component
+class HFTextEmbedder:
+
+    def __init__(self, model_name: str, ... init params ...):
+        self.model_name = model_name
+        self.model_params = ... params ...
+
+    def warm_up(self):
+        self.embedding_backend = HFEmbeddingBackend(self.model_name, **self.model_params)
+
+    @component.output_types(result=List[np.ndarray])
+    def run(self, strings: List[str]):
+        return {"result": self.embedding_backend.embed(data)}
+```
+
+Another example, using an embedder component expecting Documents:
+**Part of the public API**.
+
+```python
+@component
+class HFDocumentEmbedder:
+
+    def __init__(self, model_name: str, ... init params ...):
+        self.model_name = model_name
+        self.model_params = ... params ...
+
+    def warm_up(self):
+        self.embedding_backend = HFEmbeddingBackend(self.model_name, **self.model_params)
+
+    @component.output_types(result=List[Document])
+    def run(self, documents: List[Document]):
+        text_strings = [document.content for document in data]
+        embeddings = self.embedding_backend.embed(text_strings)
+        documents_with_embeddings = [Document.from_dict(**doc.to_dict, "embedding": emb) for doc, emb in zip(documents, embeddings)]
+        return {"result": documents_with_embeddings}
+```
+
+# Drawbacks
+
+## Migration
+The drawbacks of separating Retrievers and Embedders were already discussed in [this proposal](https://github.com/deepset-ai/haystack/blob/main/proposals/text/4370-documentstores-and-retrievers.md) and mainly consist of **migration effort**.
+
+For example, if a user has indexed documents in the store and wants to update the embeddings using a different model instead, with the current Haystack implementation the user would run `document_store.update_embeddings(retriever)`.
+
+With the new Embedder design, I can imagine something similar (based on the MemoryDocumentStore v2 implementation):
+```python
+# get all the documents
+docs = memory_document_store.filter_documents()
+
+# compute the embedding with the new model
+new_embedder = HFDocumentEmbedder(model_name="new-model")
+docs_with_embeddings = new_embedder.run(documents=docs)
+
+# overwrite the documents
+memory_document_store.write_documents(documents=docs_with_embeddings, policy=DuplicatePolicy.OVERWRITE)
+```
+## Other aspects
+Regarding the design proposed in this document, there are some potential drawbacks to consider:
+  - Proliferation of classes (though they will be small and easy to maintain).
+  - Users need to know which models are appropriate for which task (e.g. embedding queries rather than embedding documents, see [Different models in the same embedding/retrieval task](#different-models-in-the-same-embeddingretrieval-task)). On the other hand, this approach is more explicit and will help making users aware of problems and tradeoffs related to the topic.
+
+# Alternatives
+
+Several alternatives to this design were considered. The main challenge was handling the differences between queries and Documents.
+Some ideas:
+- Have a single Embedder component for text (HFTextEmbedder instead of HFEmbeddingBackend, HFTextEmbedder and HFDocumentEmbedder) and adapt Documents before and after that, using other Components. --> Many components.
+- Make Embedders only work on Documents and represent the query as a Document. --> Unintuitive and require changes in the Retriever.
+- Create another primitive like Data (content + embedding) and use it for both queries and Documents. --> More conversion components like DataToDocument.
+- Have the DocumentEmbedder take a TextEmbedder as an input parameter. --> Fewer classes but serialization issues.
+
+# Adoption strategy
+
+This change will constitute a part of Haystack v2.
+
+# How we teach this
+
+Documentation and tutorials will be of fundamental importance.
+
+# Unresolved questions
+
+- Migration and refactoring of existing Encoders hidden in Retrievers.
+I prepared a table. Should it be shared here?
+- The migration and refactoring of TableTextRetriever require input and ownership from people involved in TableQA.
+- How to approach MultiModal Embedding? How many classes? Take into consideration that a query could also be an Image or a Table.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5540-llm-support-2.0.md

@@ -0,0 +1,253 @@
+- Title: LLM SUpport in Haystack 2.0
+- Decision driver: @ZanSara
+- Start Date: 2023-08-10
+- Proposal PR: #5540
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/5330
+
+# Summary
+
+In this proposal we outline our migration strategy of the `PromptNode` stack of functionality into Haystack 2.0 components.
+
+This proposal, however, does not discuss Agents or Agent-related features and functionality, which are going to be addressed into a separate proposal.
+
+# Motivation
+
+This proposal is part of a larger effort of migrating existing Haystack 1.x components into their 2.0 counterpart.
+
+# Basic example
+
+In Haystack 2.0 components should be smaller than their 1.x counterpart. Therefore, we plan to split the functionality of `PromptNode` into a few smaller components.
+
+As this proposal concerns LLM support, not specifically Agents, the main usecase in question is RAG (Retrieval-Augmented Generation).
+
+## Example: RAG Pipeline
+
+Using the components discussed in the Detailed Design section, a Haystack 2.0 RAG pipeline may look like this:
+
+```mermaid
+graph TD;
+
+IN{IN} -- "questions (List[str])" --> Retriever
+IN{IN} -- "questions (List[str])" --> PromptBuilder
+Retriever -- "documents (List[List[Doc]])"  --> PromptBuilder
+PromptBuilder -- "prompts (List[str])" --> GPT4Generator
+GPT4Generator -- "replies (List[List[str]])" --> RepliesToAnswersConverter
+RepliesToAnswersConverter -- "answers (List[List[Answer]])" --> OUT{OUT}
+```
+
+While the code for such pipeline may look like:
+
+```python
+from haystack.preview.components import MemoryRetriever, PromptBuilder, ChatGPTGenerator, RepliesToAnswersConverter
+from haystack.preview.document_stores import MemoryDocumentStore
+from haystack.preview.pipeline import Pipeline
+
+pipe = Pipeline()
+pipe.add_store("store", MemoryDocumentStore())
+pipe.add_component("retriever", MemoryRetriever(), store="store")
+pipe.add_component("prompt_builder", PromptBuilder("deepset/question-answering"))
+pipe.add_component("llm", GPT4Generator(api_key="..."))
+pipe.add_component("replies_converter", RepliesToAnswersConverter())
+
+pipe.connect("retriever", "prompt_builder")
+pipe.connect("prompt_builder", "llm")
+pipe.connect("llm", "replies_converter")
+
+questions = ["Why?", "Why not?"]
+results = pipe.run({
+	"retriever": {"queries": questions},
+	"prompt_builder": {"questions": questions},
+})
+
+assert results == {
+	"replies_converter": {
+    "answers": [[Answer("Because of this.")], [Answer("Because of that.")]]
+  }
+}
+```
+
+# Detailed design
+
+Haystack’s `PromptNode` is a very complex component that includes under its name several functionalities: loading prompt templates through the `PromptTemplate` class, rendering such prompt template with the variables from the invocation context, choosing which LLM backend to use, sending the prompt to the LLM using the correct invocation layer, interpreting the results, parsing them into objects, and putting them back in the pipeline in a way other components can understand.
+
+in Haystack 2.0 we unpack these functionalities into a few separate components, to clarify what is happening, how it works, and provide additional flexibility.
+
+The main functionalities we identified are the following:
+
+1. Fetching the prompt from different sources
+2. Rendering the prompt using variables
+3. Invoke the LLM
+4. Parse the output
+5. History/Memory management
+
+We leave the discussion about History/Memory to a separate proposal, as it concerns mostly Agents, and focus on the other points.
+
+## LLM invocation
+
+In Haystack 1.x, `PromptNode` uses `InvocationLayer` to query different LLMs under a unified API. In that design, users do not need to know which invocation layer is used for the model they select, as `PromptNode` takes responsibility of selecting it.
+
+Such invocation layers can be ported to 2.0 as standalone components. In this way we will have one component for each LLM backed that we support.
+
+Each component should be named after the class of models it supports, plus a `Generator` suffix. For example we should have `GPT4Generator`, `HuggingFaceLocalGenerator`, `CohereGenerator`, etc.
+
+Note that having separate components for each LLM makes easy to deprecate them when we realize they are dropping out of favor or become severely outdated. It also makes very easy for external contributors to make their own external components to support rarer LLMs, without having to add them to Haystack’s core.
+
+All these LLM clients will have a near-identical I/O:
+
+```python
+@component
+class ChatGPTGenerator:
+
+    @component.output_types(replies=List[List[str]])
+    def run(self, prompts: List[str], ... chatgpt specific params...):
+        ...
+        return {'replies': [...]}
+```
+
+Note how the component takes a list of prompts and LLM parameters only, but no variables nor templates, and returns only strings. This is because input rendering and output parsing are delegated to separate components, which description follows.
+
+Note: whether LLM components accept multiple prompts or a single one depends only on whether we want the LLM to support batching of prompts. Therefore it's an implementation decision that will be evaluated once we know the internals of the component. We strive to keep the interfaces as similar as possible to ease switching the various LLMs, but we won't force identical interfaces over them where it doesn't make sense with respect to their internal implementation.
+
+### Chat API
+
+Most LLMs support Chat interfaces, where they expect not a single prompt, but a list of messages in a format such as:
+
+```
+[
+    {"role": "system", "content": "\nYou are a helpful assistant speaking like a pirate. argh!"},
+    {"role": "user", "content": "What is the sun?"},
+]
+```
+
+In this proposal we're not taking this way of querying the LLMs into account, we will just focus on simple completion. We're going to address the Chat completion topic in a dedicated proposal.
+
+### Returning metadata
+
+In the example above we made the LLM return only a list of replies, as strings. However, in order to be able to parse the output into meaningful objects (see “Output parsing”) we may need additional metadata from these clients.
+
+1. Do we already have any such situation?
+2. Can we foresee any other?
+
+If the answer to any of the above is yes, a simple, maybe temporary solution would be to add a second output, called for example `'replies_meta'` . Any component that need such meta to parse the output would then request this second output along with the first and zip the two lists together to reconstruct the original output of the LLM.
+
+### Returning streams
+
+Most LLMs like ChatGPT have the option to stream the tokens as their generated. As we're already supporting this use case in version 1.x we want to support it in 2.x too.
+
+Currently we're supporting it by accepting a callback during `PromptNode` initialization that will be called every time a new chunk of the streamed response is received.
+
+In version 2.x we're going to do the same and have all generator components accept an optional callback during initialization.
+
+### How many clients we will have?
+
+Basing on the list of current invocation layers in Haystack 1.x, the list might look like:
+
+1. `ClaudeGenerator`
+2. `ChatGPTGenerator`, supporting GPT4 as well
+    - it may have an alias `GPT4Generator` to help users
+3. `CohereGenerator`
+4. `HuggingFaceInferenceGenerator`
+5. `HuggingFaceLocalGenerator`
+6. `GPT3Generator`
+7. `SagemakerGenerator`
+
+Plus one more for any other inference hosting/library that may appear in the future.
+
+## Prompt Builder
+
+In Haystack 1.x, prompts fetching and rendering is carried out by `PromptTemplate`. In 2.0, we rather make a separate `PromptBuilder` component to handle this process.
+
+The goal of `PromptBuilder` is to transform prompt templates, which are strings with variables (for example f-strings, Jinja-like templates), and fill up those variables with values that come from other components in the pipeline or from the pipeline inputs. The output of tis component is one (or more) prompts, where prompts means strings that the LLM can directly use.
+
+`PromptBuilder` is not tokenizer aware: the prompt will be checked for length by the LLM component before inference. If the need arise, we may later extend the component.
+
+Draft I/O for `PromptBuilder`:
+
+```python
+@component
+class PromptBuilder:
+
+    def __init__(self, template: Union[str, Path]):
+        self.template = # Download the template
+        template_variables = # extracts the variables from the template text
+		component.set_input_parameters(**{var: Any for var in template_variables})
+
+  	@component.output_types(prompts=List[str])
+    def run(self, **kwargs):
+        # Render the template using the variables
+        return {"prompts": prompts}
+```
+
+### Template variables
+
+Due to the dynamic nature of prompt templates, the `PromptBuilder.run()`  method takes `kwargs`, which contains all the variables that will be filled in the template. However, for this component to work with Canals, we need to know in advance which values this dict will contain: therefore, we need the users to specify in the `__init__` of the component the template to use.
+
+Such template names **cannot be changed at runtime**.
+
+The design above derives from one Canals limitation: component’s sockets need to be all known the latest at `__init__` time, in order for the connections to be made and validated. Therefore, we need to know all the prompt variables before building the pipelines, because the prompt variables are inputs of the `run()` method.
+
+However, earlier iterations of Canals did support so-called “true variadic” components: components that do not need to know what they will be connected to, and build the input sockets at need. Such components of course lack input validation, but enable usecases like the above.
+
+If we decide that Canals should support again such components, we would be able to rewrite `PromptBuilder` to take a prompt as its input parameter and just accept any other incoming input, on the assumption that users knows that they’re doing.
+
+For example:
+
+```python
+@component
+class PromptBuilder:
+
+	@variadic_input
+  	@component.output_types(prompts=List[str])
+    def run(self, template: Union[str, Path], **kwargs):
+	    # ... loads the template ...
+        # ... render the prompts ...
+        return {"prompts": prompts}
+```
+
+### Why a separate `PromptBuilder` component at all?
+
+`PromptNode` used to take the prompt template and the variables to render it directly, and then forward the result to the LLM.
+
+The key advantage of `PromptBuilder` is ability to use any tool from the ever growing list of LLM prompting template libs. If someone has invested a lot in guidance and considers using a framework like Haystack or LangChain this will be one of the biggest selling points: an ability to use `PromptBuilder` for a specific prompt tooling lib.
+
+On top of that, it also allows users to skip the template rendering step altogether and send prompts directly to the LLM, which may be beneficial in some context (for example, if users just want to chat with the LLM without RAG).
+
+The drawback is that `PromptBuilder` is an additional component, so we must evaluate if this additional flexibility is worth the additional complexity. However, at this point in time we are convinced that the benefits are worth the cost.
+
+## Output parsing
+
+LLMs clients output strings, but many components expect other object types, and LLMs may produce output in a parsable format that can be directly converted into objects. Output parsers transform these strings into objects of the user’s choosing.
+
+In Haystack 1.x, this task was assigned to the subclasses of `BaseOutputParser`. In 2.0 we’re going to have a very similar situation, with the difference that such classes are components.
+
+The most straightforward component in this category is `RepliesToAnswersConverter`. It takes the string replies of an LLM and produce `Answer` objects.  One additional output parser could be `RepliesToAnswersWithReferencesConverter`, which also connects answers to the documents used to produce them. As the need for additional output parsers arises, we will progressively add more.
+
+Draft I/O for `RepliesToAnswersConverter` (note: this may end up being almost the entire component’s implementation):
+
+```python
+@component
+class RepliesToAnswersConverter:
+
+    @component.output_types(answers=List[List[Answer]])
+    def run(self, replies: List[List[str]]):
+        return {"answers": Answer(answer=answer) for answers in replies for answer in answers}
+```
+
+# Drawbacks
+
+Possible drawbacks of this design:
+
+1. Users now need to use three components instead of a single, large one.
+2. We lose the capability to change the prompt for the LLM at runtime.
+
+# Alternatives
+
+1. Porting the existing `PromptNode` to Haystack 2.0: would be a massive effort and make the new version inherit some design decision that, with time, proved unnecessary and/or clumsy to use, like the “hiding” of invocation layer that makes it quite hard for external contributors to add support for other LLMs to `PromptNode`, or it’s imperfect layer selection algorithm.
+
+# Adoption strategy
+
+Follows the same strategy outlines for all other Proposal relative to the Haystack 2.0 migration
+
+# How we teach this
+
+We need brand new tutorials and examples of pipelines using these components.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5738-document-2.0.md

@@ -0,0 +1,108 @@
+- Title: Document class for Haystack 2.0
+- Decision driver: ZanSara
+- Start Date: 2023-09-07
+- Proposal PR: 5738
+
+# Summary
+
+With Haystack 2.0 we want to provide a lot more flexibility to Pipelines and Components. In a lot of situations,
+we found that the Document class inherited from Haystack 1.x was not up to the task: therefore we chose to expand its
+API to work best in this new paradigm.
+
+# Basic example
+
+Documents 2.0 have two fundamental differences with Documents 1.x:
+
+- They have more than one content field. Documents 1.x only have a `content: Any` field that needs to match with the
+    `content_type` field in meaning. Documents 2.0 instead support `text`, `array`, `dataframe` and `blob`, each typed
+    correctly.
+
+- The `content_type` field is gone: In Haystack 1.x we used the `content_type` field to interpret the data contained
+    in the `content` field: with the new design, this won't be necessary any longer. Haystack 2.0, however, have
+    a `mime_type` field that helps interpret the content of the `blob` field if necessary.
+
+# Motivation
+
+During the development of Haystack 2.0 components, we often found ourselves hold back by the design limitations of
+the Document class. Unlike in Haystack 1.x, Documents now carry more information across the pipeline: for example,
+they might contain the file they originated from, they might support more datatypes, etc.
+
+Therefore we decided to extend the Document class to support a wider array of data.
+
+# Detailed design
+
+The design of this class was inspired by the [DocArray API](https://docarray.jina.ai/fundamentals/document/).
+
+Here is the high-level API of the new Document class:
+
+```python
+@dataclass(frozen=True)
+class Document:
+    id: str = field(default_factory=str)
+    text: Optional[str] = field(default=None)
+    array: Optional[numpy.ndarray] = field(default=None)
+    dataframe: Optional[pandas.DataFrame] = field(default=None)
+    blob: Optional[bytes] = field(default=None)
+    mime_type: str = field(default="text/plain")
+    metadata: Dict[str, Any] = field(default_factory=dict, hash=False)
+    id_hash_keys: List[str] = field(default_factory=lambda: ["text", "array", "dataframe", "blob"], hash=False)
+    score: Optional[float] = field(default=None, compare=True)
+    embedding: Optional[numpy.ndarray] = field(default=None, repr=False)
+
+    def to_dict(self):
+        """
+        Saves the Document into a dictionary.
+        """
+
+    def to_json(self, json_encoder: Optional[Type[DocumentEncoder]] = None, **json_kwargs):
+        """
+        Saves the Document into a JSON string that can be later loaded back. Drops all binary data from the blob field.
+        """
+
+    @classmethod
+    def from_dict(cls, dictionary):
+        """
+        Creates a new Document object from a dictionary of its fields.
+        """
+
+    @classmethod
+    def from_json(cls, data, json_decoder: Optional[Type[DocumentDecoder]] = None, **json_kwargs):
+        """
+        Creates a new Document object from a JSON string.
+        """
+
+    def flatten(self) -> Dict[str, Any]:
+        """
+        Returns a dictionary with all the document fields and metadata on the same level.
+        Helpful for filtering in document stores.
+        """
+
+```
+
+As you can notice, the main difference is the management of the content fields: we now have:
+
+- `text`: for text data
+- `array`: for array-like data, for example images, audio, video
+- `dataframe`: for tabular data
+- `blob`: for binary data.
+
+In order to help interpret the content of these field, there's a `mime_type` field that components can use to figure out
+how to use the content fields they need.
+
+There are additional information that we may want to add, for example `path`. For now such info can be
+kept into the metadata: if we realize we access it extremely often while processing Documents we should consider
+bringing those fields out of `metadata` as top-level properties of the dataclass.
+
+
+# Drawbacks
+
+As the Document class becomes a bit more complex, components need to be adapted to it. This may cause some issues
+to DocumentStores, because now they not only need to be able to store text but binary blobs as well.
+
+We can imagine that some very simple DocumentStore will refuse to store the binary blobs. Fully-featured,
+production-ready document stores instead should be able to find a way to store such blobs.
+
+
+# Unresolved questions
+
+Are the 4 content fields appropriate? Are there other content types we can consider adding?

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5794-evaluation-haystack-2.md

@@ -0,0 +1,227 @@
+- Title: Evaluation in Haystack 2.0
+- Decision driver: (Silvano Cerza, Julian Risch)
+- Start Date: 2023-08-23
+- Proposal PR: [#5794](https://github.com/deepset-ai/haystack/pull/5794/)
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/5628
+
+# Summary
+
+Given the below requirements we redefine how evaluation and metrics are handled in Haystack 2.x.
+
+Our goal is to lower the barrier of entry for new comers but also making it more flexible and extensible for more advanced and expert users.
+All this while making it more modular and easier to test and maintain.
+
+The requirements are:
+
+- compare the performance of different pipelines on level of pipeline outputs (user perspective, integrated eval)
+  - while running the full pipeline we can store intermediate results and calculate metrics for each component that returns answers or documents
+- find out which component is the performance bottleneck in one pipeline by evaluating subpipelines (isolated evaluation)
+- as above, get evaluation metrics for every component in a pipeline that returns answer or documents (ranker, retriever, reader, PromptNode)
+- compare the performance of two components, for example two Readers, without the need to create a full retriever-reader pipeline
+- export evaluation results to a file (similar to Haystack 1.x but faster) and evaluation report
+- choose evaluation metrics from a list of metrics (e.g. F1, BLEU, ROUGE, Semantic Answer Similarity) based on the output type of a component
+- evaluate pipelines that return ExtractiveAnswers
+- evaluate pipelines that return GenerativeAnswers
+- evaluate hallucinations (check generated answers are backed up by retrieved documents)
+- evaluate pipelines with PromptNodes and arbitrary PromptTemplates (for example with Semantic Answer Similarity or BLEU, ROUGE (metrics from machine translation and summarization) if I provide labels)
+- load evaluation data for example from BEIR
+
+# Basic example
+
+```python
+pipe = Pipeline()
+...
+inputs = [{"component_name": {"query": "some question"}, ...}, ...]
+expected_output = [{"another_component_name": {"answer": "42"}, ...}, ...]
+result = eval(pipe, inputs=inputs, expected_output=expected_output)
+metrics = result.calculate_metrics(Metric.SAS)
+metrics.save("path/to/file.csv")
+```
+
+A more thorough example of a real use case can be found in the `0000-evaluation-haystack-2.py` file. It creates a small RAG Pipeline and shows how one would run evaluation on it.
+
+# Motivation
+
+Since the new version 2.x of Haystack is going toward a completely different approach to run `Pipeline`s and `component`s we also need to rework how we evaluate them.
+
+The current implementation in version 1.x is convoluted and mixes evaluation and metrics at different steps during the process. This makes it harder to reason about it and maintain. This is noticeable also by the fact that only a limited amount of nodes can be evaluated. Also it's currently not easy to calculate custom metrics.
+
+The goal of this new approach is to make it easier for users to evaluate and calculate metrics for their `Pipeline`s and `component`s. Evaluation is not an easy task to reason about and understand. Making it simpler will also make it less intimidating to less experienced users, pushing more people to approach this important part of Haystack.
+
+It must be flexible by making it possible to evaluate any type of `component`. This is also an hard requirement since we want to make it easier for users to define new `component`s. Limiting the types of `component`s that can be evaluated would also limit the usage of custom or novelty ones, thus limiting the user creativity.
+
+Extensibility is part of the goal too. We want to make is possible for user to calculate some of most common metrics, but also use custom logic to calculate any other one. As of now it's not possible to calculate custom metrics without knowing the nitty gritty of the Haystack internals.
+
+All these goals merge also into another goal, maintainability. By making evaluation and metrics calculation more modular and easy to use we're also going to make it more maintainable and testable.
+
+# Detailed design
+
+### The `eval` function
+
+We'll implement an `eval` function that will be able to evaluate all `Pipeline`s and `Component`s.
+A minimal implementation could look like this:
+
+```python
+def eval(runnable: Union[Pipeline, Component], inputs: List[Dict[str, Any]], expected_outputs: List[Dict[str, Any]]) -> EvaluationResult:
+    outputs = []
+    for input_ in inputs:
+      output = runnable.run(input_)
+      outputs.append(output)
+    return EvaluationResult(runnable, inputs, outputs, expected_outputs)
+```
+
+This is obviously an overtly simplistic example but the core concept remains.
+`inputs` must be a list of data that will be passed to either the `Pipeline` or the `Component`.
+`expected_outputs` could be a list with the same length of `inputs` or an empty list for blind evaluation.
+
+Blind in this context means running an evaluation without providing a list of expected output. This could be done for several reasons, like if we don't know what to expect as output, or to compare output of different components.
+
+`EvaluationResult` could either be a `Dict` or its own class, this is open to discussion. Either way it must be easy to save to disk. When saving the results to disk we can also include the `Pipeline` or `Component` in a serialized form.
+
+When evaluating a `Pipeline` we could also override its private `_run_component` function to evaluate every node it will run. This will 100% work for our implementation of `Pipeline`. If a user tries to evaluate a `Pipeline` that reimplements its own `run` method it might not be able to evaluate each `Component`. I believe this a worthy risky tradeoff.
+
+Overriding `_run_component` would also give us the chance to simulate optimal component outputs. `eval` could also accept an optional `simulated_output` dictionary containing the outputs of one or more `Component` that are in the `Pipeline`. It would look similar to this:
+
+```python
+simulated_output = {
+  "component_name": {"answer": "120"},
+  "another_component_name": {"metadata": {"id": 1}}
+}
+```
+
+Another alternative would be to use the `expected_output` also to simulate outputs of intermediate components.
+
+#### Tracking progress
+
+To track progress we can also go on another direction. We could return partials results while iterating our inputs:
+
+```
+def eval(runnable, inputs, expected_outputs):
+    result = EvaluationResult(runnable, inputs, {}, expected_outputs)
+    for input_ in inputs:
+      output = runnable.run(input_)
+      result.append_output(output)
+      yield result
+```
+
+Or return some progress percentage and only in the end the final result.
+
+```
+def eval(runnable, inputs, expected_outputs):
+    outputs = []
+    total = len(inputs)
+    for i, input_ in enumerate(inputs):
+      output = runnable.run(input_)
+      outputs.append(output)
+      yield 100 * (i / total), None
+
+    yield 100, EvaluationResult(runnable, inputs, outputs, expected_outputs)
+```
+
+### `EvaluationResult`
+
+`EvaluationResult` won't contain partial metrics anymore as it does in v1.x but it will keep track of all the information used by `eval()`.
+This way we'll be able to save all the necessary information to a single file. That information will probably be:
+
+- Serialized Pipeline or Component
+- Inputs
+- Expected outputs
+- Actual outputs
+
+This data should be serializable to string so that it can be saved to file and loaded back whenever necessary.
+We shouldn't expect all input and output data to implement serialization methods like `to_dict` and `from_dict` like `Pipeline` and `component`s do, so we probably should find an alternative to handle serialization of types that don't. An unsafe option would be the use of `pickle`, but that's dangerous as it could lead to malicious code being executed.
+
+Given the above information we should be able to implement a single method to calculate predeterminated metrics or even custom ones.
+Known metrics could be defined as an enum to ease discoverability and documentation.
+
+```python
+class Metric(Enum):
+    RECALL = "Recall"
+    MRR = "Mean Reciprocal Rank"
+    MAP = "Mean Average Precision"
+    EM = "Exact Match"
+    F1 = "F1"
+    SAS = "SemanticAnswerSimilarity"
+```
+
+The method to calculate metrics could look similar to this:
+
+```python
+MetricsResult = Dict[str, Dict[str, float]]
+MetricCalculator = Callable[..., MetricResult]
+
+def calculate_metrics(self: EvaluationResult, metric: Union[Metric, MetricCalculator], **kwargs) -> MetricsResult:
+    # Verify if we're calculating a known metric
+    if metric == Metric.RECALL:
+      return self._calculate_recall(**kwargs)
+    elif metric == Metric.MRR:
+      return self._calculate_mrr(**kwargs)
+    # Other metrics...
+
+    # If it's not a known metric it must be a custom one
+    return metric(self, **kwargs)
+```
+
+This gives the users the flexibility to easily calculate metrics that we support but also use custom logic to calculate any kind of metric given the available data.
+Since users will need to save their calculated metrics to file we could create a simple `MetricResult` class that simply wraps the generated metrics dictionary, something similar:
+
+```python
+class MetricResult(dict):
+    def save(self, file: Union[str, Path]):
+        # Dump info to file here
+```
+
+### Ease input specification
+
+When declaring the input of a `Pipeline` we must specify both a `component` name and its input names. This can be annoying so we could simplify this by making certain assumptions.
+
+An approach to this problem could be letting the user skip the `component` name specification when declaring the `Pipeline` input. This could work up until the point the user changes their `Pipeline` to have multiple inputs with the same name.
+
+So given a `Pipeline` that has single input `component` name `foo` that takes a `query` as its input we can let the user specify the `eval` input like so:
+
+```python
+eval(pipe, {"query": "This is the query"})
+```
+
+If the user adds a new `component` name `bar` that also takes a `query` as input we'll make evaluation fail preventively since we cannot be sure whether both `component`s must take `query` as input and force explicit specification:
+
+```python
+eval(pipe, {"foo": {"query": "This is the query"}, "bar": {"query": "This is the query"}})
+```
+
+# Drawbacks
+
+The major drawback found from the feedback gathered is always the same, and it's also common to `Pipeline.run()`. It's frustrating and annoying having to update the evaluation input and/or output data if I make changes to my `Pipeline`.
+
+Given that new `Pipeline` can have multiple inputs to different `component`s we must specify which component will take which input. As an example given a `Pipeline` with two input components called `foo` and `bar` that takes a `input_query` value we'll have to specify input as follow:
+
+```python
+input = {
+  "foo": {"input_query": "This my input query"},
+  "bar": {"input_query": "This my input query"}
+}
+```
+
+I believe this a worthy tradeoff as it gives huge amount of customization that wasn't possible in Haystack 1.x.
+
+We could ease inputs specification in some cases as specified in the above section but that would make evaluation prone to errors. I believe that to be a dangerous approach as it could mean making evaluation "easier to use" at the cost of making it also more error prone if not done properly and with the correct safe guards.
+
+The same thing can be said for the `Pipeline` output. There will be multiple outputs most of the times since we're going to evaluate individual nodes and the whole `Pipeline` input with a single evaluation run. So the user must specify from which `component` the output should be expected from.
+
+Expected output specification suffers from the same issue of inputs specification. So making assumption to try and match expected output with the actual `Pipeline` output is still error prone but probably can be handled for really simple `Pipeline`s with only a single output `component`.
+
+Evaluation should be an advanced topic for users that know what they're actually doing. This might seem contradictory to what has been said above regarding approachability of the feature but I believe this to be an easy to use but and hard to master feature.
+
+# Adoption strategy
+
+This is obviously a breaking change as it's meant for Haystack 2.x.
+
+# How we teach this
+
+Much like the current situation we'll write tutorials, examples and documentation to go along with this new feature. We can also leverage future ready-made `Pipeline`s to show how to evaluate them.
+
+We're also going to have new community spotlights in Discord to show how to approach evaluation in Haystack 2.x.
+
+# Unresolved questions
+
+Evaluation of pipelines containing Agents or other loops is out of scope for this proposal (except for integrated pipeline evaluation).

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/5794-evaluation-haystack-2.py

@@ -0,0 +1,141 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+# mypy: ignore-errors
+# pylint: skip-file
+###
+### This is an example script of how to use the eval function to evaluate a RAG Pipeline.
+### For more information see the relative proposal.
+###
+
+import os
+
+from haystack import Pipeline
+from haystack.components.builders.prompt_builder import PromptBuilder
+from haystack.components.generators.openai.gpt35 import GPT35Generator
+from haystack.components.retrievers.memory import MemoryBM25Retriever
+from haystack.dataclasses.document import Document
+from haystack.document_stores.memory import MemoryDocumentStore
+
+docstore = MemoryDocumentStore()
+
+# Write some fake documents
+docstore.write_documents(
+    [
+        Document(content="This is not the answer you are looking for.", meta={"name": "Obi-Wan Kenobi"}),
+        Document(content="This is the way.", meta={"name": "Mandalorian"}),
+        Document(content="The answer to life, the universe and everything is 42.", meta={"name": "Deep Thought"}),
+        Document(content="When you play the game of thrones, you win or you die.", meta={"name": "Cersei Lannister"}),
+        Document(content="Winter is coming.", meta={"name": "Ned Stark"}),
+    ]
+)
+
+# Create our retriever, we set top_k to 3 to get only the best 3 documents otherwise by default we get 10
+retriever = MemoryBM25Retriever(document_store=docstore, top_k=3)
+
+# Create our prompt template
+template = """Given the context please answer the question.
+Context:
+{# We're receiving a list of lists, so we handle it like this #}
+{% for list in documents %}
+    {% for doc in list %}
+        {{- doc -}};
+    {% endfor %}
+{% endfor %}
+Question: {{ question }};
+Answer:
+"""
+prompt_builder = PromptBuilder(template)
+
+# We're using OpenAI gpt-3.5
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+generator = GPT35Generator(api_key=OPENAI_API_KEY)
+
+# Build the pipeline
+pipe = Pipeline()
+
+pipe.add_component("docs_retriever", retriever)
+pipe.add_component("builder", prompt_builder)
+pipe.add_component("gpt35", generator)
+
+pipe.connect("docs_retriever.documents", "builder.documents")
+pipe.connect("builder.prompt", "gpt35.prompt")
+
+# Run the pipeline
+query = "What is the answer to life, the universe and everything?"
+result = pipe.run({"docs_retriever": {"queries": [query]}, "builder": {"question": query}})
+
+print(result["gpt35"]["replies"])
+
+
+# These are the input that will be passed to the Pipeline when running eval, much like we've done a couple of lines above
+inputs = [
+    {"docs_retriever": {"queries": ["What is the answer?"]}, "builder": {"question": "What is the answer?"}},
+    {
+        "docs_retriever": {"queries": ["Take a deep breath and think. What is the answer?"]},
+        "builder": {"question": "Take a deep breath and think. What is the answer?"},
+    },
+    {
+        "docs_retriever": {"queries": ["What is the answer to life, the universe and everything?"]},
+        "builder": {"question": "What is the answer to life, the universe and everything?"},
+    },
+]
+
+# These are the expected output that will be compared to the actual output of the Pipeline.
+# We have a dictionary for each input so that len(inputs) == len(expected_output).
+# This gives the possibility to have different expected output for each different input.
+# NOTE: I omitted the gpt35 metadata output because it's too long.
+expected_output = [
+    {
+        # This is the output that we expect from the docs_retriever component
+        "docs_retriever": {
+            "documents": [
+                [
+                    Document(
+                        content="The answer to life, the universe and everything is 42.", meta={"name": "Deep Thought"}
+                    ),
+                    Document(content="This is not the answer you are looking for.", meta={"name": "Obi-Wan Kenobi"}),
+                    Document(content="This is the way.", meta={"name": "Mandalorian"}),
+                ]
+            ]
+        },
+        # This is the output that we expect from the builder component
+        "builder": {"prompt": "I should write the actual template here but I'm lazy so I won't."},
+        # This is the output that we expect from the gpt35 component
+        "gpt35": {"replies": ["The answer to life, the universe and everything is 42."], "metadata": {}},
+    },
+    {
+        "docs_retriever": {
+            "documents": [
+                [
+                    Document(
+                        content="The answer to life, the universe and everything is 42.", meta={"name": "Deep Thought"}
+                    ),
+                    Document(content="This is not the answer you are looking for.", meta={"name": "Obi-Wan Kenobi"}),
+                    Document(content="This is the way.", meta={"name": "Mandalorian"}),
+                ]
+            ]
+        },
+        "builder": {"prompt": "I should write the actual template here but I'm lazy so I won't."},
+        "gpt35": {"replies": ["The answer to life, the universe and everything is 42."], "metadata": {}},
+    },
+    {
+        "docs_retriever": {
+            "documents": [
+                [
+                    Document(
+                        content="The answer to life, the universe and everything is 42.", meta={"name": "Deep Thought"}
+                    ),
+                    Document(content="This is not the answer you are looking for.", meta={"name": "Obi-Wan Kenobi"}),
+                    Document(content="This is the way.", meta={"name": "Mandalorian"}),
+                ]
+            ]
+        },
+        "builder": {"prompt": "I should write the actual template here but I'm lazy so I won't."},
+        "gpt35": {"replies": ["The answer to life, the universe and everything is 42."], "metadata": {}},
+    },
+]
+
+eval_result = eval(pipe, inputs=inputs, expected_output=expected_output)
+metrics = result.calculate_metrics(Metric.SAS)  # noqa
+metrics.save("path/to/file.csv")

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/6001-document-store-filter-rework.md

@@ -0,0 +1,183 @@
+- Title: Document Stores filter specification for Haystack 2.x
+- Decision driver: Silvano Cerza
+- Start Date: 2023-10-08
+- Proposal PR: [#6001](https://github.com/deepset-ai/haystack/pull/6001)
+
+# Summary
+
+This proposal introduces a new fully detailed and extensible specification for filtering Document Stores in Haystack 2.x.
+This comes from my personal experience and struggles trying to implement filters conversion for `ElasticsearchDocumentStore`.
+
+# Basic example
+
+```
+{
+  "conditions": [
+    { "field": "age", "operator": ">=", "value": 18 },
+    {
+      "operator": "OR",
+      "conditions": [
+        { "field": "country", "operator": "==", "value": "USA" },
+        { "field": "country", "operator": "==", "value": "Canada" }
+      ]
+    }
+  ]
+}
+```
+
+The above snippet would be equivalent to the following Python code:
+
+```python
+age >= 18 and (country == "USA" or country == "Canada)
+```
+
+# Motivation
+
+Filtering in Haystack 1.x has no detailed clear specification, we only have an [high level overview][filters-high-level-doc] in the documentation that also mixes REST APIs documentation in. It's also inherited from MongoDB and is a subset of the Mongo Query Language.
+
+Converting from the current filters to another query language is quite hard as there are tons of corner cases. Handling nested filters is usually really error prone as the operators can be keys, this requires ton of nested and/or recursive logic to figure out whether the current key is a field or an operator. There's also quite some backtracking involved as the field could be two or three levels above its comparison operator and/or value.
+
+As a practical example the below two filters are equivalent. Given that they're structured differently and `$and` is implicit in the second one:
+
+```
+{"number": {"$and": [{"$lte": 2}, {"$gte": 0}]}}
+
+{"number": {"$lte": 2, "$gte": 0}}
+```
+
+With the newly proposed approach both filters would be equivalent to:
+
+```
+{
+    "operator": "AND",
+    "conditions": [
+        { "field": "number", "operator": "<=", "value": 2 },
+        { "field": "number", "operator": ">=", "value": 0 },
+    ]
+}
+```
+
+As you can see all the required information is one the same level and clearly recognisable. This makes it much easier both to read by a human and convert with code.
+
+In Python code:
+
+```python
+number <= 2 AND number >= 0
+```
+
+# Detailed design
+
+Filters top level must be a dictionary.
+
+There are two types of dictionaries:
+
+- Comparison
+- Logic
+
+Top level can be either be a Comparison or Logic dictionary.
+
+Comparison dictionaries must contain the keys:
+
+- `field`
+- `operator`
+- `value`
+
+Logic dictionaries must contain the keys:
+
+- `operator`
+- `conditions`
+
+`conditions` key must be a list of dictionaries, either Comparison or Logic.
+
+`operator` values in Comparison dictionaries must be:
+
+- `==`
+- `!=`
+- `>`
+- `>=`
+- `<`
+- `<=`
+- `in`
+- `not in`
+
+`operator` values in Logic dictionaries must be:
+
+- `NOT`
+- `OR`
+- `AND`
+
+---
+
+As an example this:
+
+```
+{
+    "$and": {
+        "type": {"$eq": "article"},
+        "$or": {"genre": {"$in": ["economy", "politics"]}, "publisher": {"$eq": "nytimes"}},
+        "date": {"$gte": "2015-01-01", "$lt": "2021-01-01"},
+        "rating": {"$gte": 3},
+    }
+}
+```
+
+would convert to:
+
+```
+{
+    "operator": "AND",
+    "conditions": [
+        { "field": "type", "operator": "==", "value": "article" },
+        {
+            "operator": "OR",
+            "conditions": [
+                { "field": "genre", "operator": "in", "value": ["economy", "politics"] },
+                { "field": "publisher", "operator": "==", "value": "nytimes" },
+            ]
+        },
+        { "field": "date", "operator": ">=", "value": "2015-01-01" },
+        { "field": "date", "operator": "<", "value": "2021-01-01" },
+        { "field": "rating", "operator": ">=", "value": 3 },
+    ]
+}
+```
+
+In Python code:
+
+```python
+type == "article" and (
+    genre in ["economy", "politics"] or publisher == "nytimes"
+) and date >= "2015-01-01" and date < "2021-01-01" and rating >= 3
+```
+
+Dates have been kept as strings but ideally in the new implementation they would be converted to `datetime` instances so the Document Store will be able to convert it to whatever format it needs to actually compare them. As different Document Stores might have different ways of storing the same value it's important that they handle the conversion from Python type to stored type.
+
+Another thing that in my opinion should be changed is the that filtering metadata fields must be explicitly specified for filtering. In the example above all `field`s would be prefixed with `metadata.` to get in return the expected `Document`s. e.g. `date` -> `metadata.date`
+This connects to `Document` implementation and is not the focus of this proposal, but it should be taken into account.
+
+# Drawbacks
+
+The only drawback would be that we need to adapt the existing Document Stores already created for Haystack 2.x to support this filtering system. `MemoryDocumentStore`, `ElasticsearchDocumentStore`, `ChromaDocumentStore` and `MarqoDocumentStore` are the currently existing Document Stores.
+
+# Alternatives
+
+An alternative would be keeping the current strategy of declaring filters.
+This wouldn't require any change but supporting a new filtering language after the release of Haystack 2.x would be more difficult than doing it now.
+
+# Adoption strategy
+
+We're going to release this new strategy of filters declaration for Haystack 2.x. At the same time we'll deprecate the current strategy but we'll keep supporting it for a while.
+
+Since we're going to provide an utility function to convert from old style to new style it will be easy for Document Stores to support both.
+
+# How we teach this
+
+We're going to provide documentation and specifications on how the filters should be declared, this proposal is a good starting point as it already defines the specs.
+
+We're also going to provide utility functions to migrate filters from old style to new style.
+
+# Unresolved questions
+
+This is the full design and there are no unresolved questions.
+
+[filters-high-level-doc]: https://docs.haystack.deepset.ai/docs/metadata-filtering

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/6141-meta-field-ranker.md

@@ -0,0 +1,68 @@
+- Title: Meta Field Ranker
+- Decision driver: @domenicocinque
+- Start Date: 2023-10-20
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/6141
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/6054
+
+# Summary
+
+This ranker should allow to sort the documents based on a meta field of choice.
+
+# Basic example
+
+The ranker could be instantiated as follows:
+
+``` python
+ranker = MetaFieldRanker(
+    meta_field="rating",
+    weight="0.5",
+    ascending=False,
+    top_k=3,
+)
+```
+In the context of a simple pipeline with a retriever and a MetaFieldRanker in which
+the documents are provided with a meta field "rating". The documents are first retrieved by the retriever and
+then sorted by the MetaFieldRanker.
+
+``` python
+pipeline = Pipeline()
+pipeline.add_component(component=InMemoryBM25Retriever(document_store=document_store, top_k=20)
+, name="Retriever")
+pipeline.add_component(component=MetaFieldRanker(meta_field="rating"), name="Ranker")
+pipeline.connect("Retriever.documents", "MetaFieldRanker.documents")
+```
+
+# Motivation
+
+I found the need for this feature while working on system that retrieves books based on their description and the
+similarity to the query. After retrieving the documents it makes sense to expose them to the user in order of popularity.
+This is just one example of a use case for this feature, but I think it could be useful in many other contexts.
+
+# Detailed design
+
+The actual implementation of the ranker is very similar to the already present RecentnessRanker. The main difference
+is to remove the date parsing logic.
+
+# Drawbacks
+
+The main drawback is that it would be very similar to the already present RecentnessRanker. However, this could be
+solved by making the RecentnessRanker a subclass of the MetaFieldRanker and adding the date parsing logic to it.
+Apart from that, it is a very simple component that should not have any other drawbacks.
+
+# Alternatives
+
+The alternative is to make the user implement its own ranking logic.
+
+# Adoption strategy
+
+MetaFieldRanker is a Haystack 2.0 component. As it is not a breaking change, it should be easy to adopt in combination with the other components.
+
+# How we teach this
+
+It would be sufficient to integrate a small comparison with the RecentnessRanker in the documentation.
+
+
+# Unresolved questions
+
+The main issue is the implementation strategy. Especially if we want to include the `ranking_mode` parameter in the
+MetaFieldRanker, it would make sense to have the RecentnessRanker as a subclass of the MetaFieldRanker.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/6784-integrations-for-eval-framworks.md

@@ -0,0 +1,151 @@
+- Title: Integration of LLM Evaluation Frameworks
+- Decision driver: Madeesh Kannan, Julian Risch
+- Start Date: 2024-01-19
+- Proposal PR: https://github.com/deepset-ai/haystack/pull/6784
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/6672
+
+# Summary
+
+- Create integrations for three different LLM evaluation frameworks in https://github.com/deepset-ai/haystack-core-integrations
+- The LLM evaluation frameworks in question are: [Uptrain](https://docs.uptrain.ai/getting-started/introduction), [RAGAS](https://docs.ragas.io/en/stable/index.html) and [DeepEval](https://docs.confident-ai.com/docs/getting-started).
+- The integrations introduce the following components in this order: `UptrainEvaluator`, `RagasEvaluator`, `DeepEvalEvaluator`.
+- Users can run a Haystack pipeline and evaluate the result with model-based metrics implemented by the evaluation frameworks.
+- Calculation of metrics is done by the frameworks through running prompts with OpenAI (Uptrain) or using langchain to make the OpenAI call (RAGAS, DeepEval).
+
+# Basic example
+
+With the integration, users can use Haystack’s pipeline concept for the evaluation too. They need to provide the outputs of the RAG pipeline as inputs to the Evaluator component in an evaluation pipeline:
+
+```python
+p = Pipeline()
+p.add_component(instance=DeepEvalEvaluator(metric="Hallucination", params={"threshold": 0.3)}, name="evaluator"))
+# p.add_component(instance=RagasEvaluator()...
+
+questions = [...]
+contexts = [...]
+answers = [...]
+
+p.run({"evaluator": {"questions": questions, "context": contexts, "answer": answers})
+# {"evaluator": DeepEvalResult(metric='hallucination', score=0.817)}
+```
+
+# Motivation
+
+Users of Haystack that deploy RAG pipelines currently do not have an avenue of evaluating the outputs of the same. Traditional methods of evaluation that involves the creation of labelled datasets is often out of reach for open-source practitioners due resource- and time-constraints. Furthermore, this approach is not necessarily scalable and applicable to LLMs due to the generative property of RAG-based information retrieval.
+
+This is given rise to model-based evaluation approaches, i.e., the method of training language models to act as classifiers and scorers. A very popular implementation of this approach revolves around designing prompt-based natural language metrics that are used in conjunction with an instruction-trained LLM. The LLM then acts as the judge, evaluating the outputs based on the criteria defined in the metrics. This approach is eminently more scalable and low-friction for the end-user.
+
+Other LLM application frameworks such as LlamaIndex already provide support for this approach to evaluation, and it is in Haystack's interests to do the same. This will also help establish a baseline against which our future efforts in this area can be compared.
+
+# Detailed design
+
+As with evaluation in Haystack 1.x, we reaffirm the core idea of implementing different pipelines for different concerns. We consider evaluation a separate process and consequently separate the execution of RAG and the metric calculation into two different pipelines. This allows for greater flexibility - for instance, the evaluation pipeline could contain an additional component that routes the inputs to different evaluator components based on certain criteria, etc. Another example would be the ability to convert the inputs from/to different formats before passing them to the evaluator.
+
+A further advantage of this approach is that any tool we develop in the future to facilitate introspection and observability of pipelines can transparently be appled to evaluation as well.
+
+The implementation of the three evaluator components should follow the general guidelines for custom component development. There are two approaches we could take:
+
+- **Metric wrapping**: Make each metric an individual component.
+
+  Advantages:
+
+  - Inputs and outputs are explicitly defined for each metric, which makes the API more explicit.
+  - We can control which metrics to include.
+  - We can use the execution graph for control flow.
+
+  Disadvantages:
+
+  - Duplication between frameworks.
+  - Maintenance burden.
+  - Less freedom for the user.
+
+- **Framework wrapping**: Make each evaluation framework an individual component.
+
+  Advantages:
+
+  - Straightforward implementation.
+  - Easier to reason about.
+  - Low maintenance burden.
+  - More freedom for the user.
+
+  Disadvantages:
+
+  - API has to accommodate all possible inputs for all supported metrics.
+  - Less flexibility.
+
+Given the above comparison, **we will be implementing the second approach, i.e., framework as the component**. The disadvantages mentioned above can be mitigated by leaning into Haystack 2.x's I/O system.
+
+## API overview
+
+- We implement three components: `DeepEvalEvaluator`, `RagasEvaluator`, `UpTrainEvaluator`.
+- Their constructors take a two parameters: `Literal["MetricName"]` and `Optional[Dict[str, Any]]` for the metric name and optional parameters for the same.
+  - We use JSON-serializable types here to ensure serde support.
+- The component initializes the internal framework-specific metric representation.
+- Depending on the metric, the component also calls `set_input_types` to register the appropriate input sockets for the given metric, e.g: `question`, `contexts`, `answer` for groundness, etc.
+  - This approach lets the user modulate the inputs individually, which wouldn't be possible if we use a generic representation for all metrics/frameworks.
+- Outputs can be implemented in one of two ways:
+
+  - `set_output_types` is also called to enumerate the outputs of the metric
+  - The output is a `dataclass` specific to the evaluation framework.
+
+  As opposed to their inputs, the outputs of metrics are not likely to require sophisticated routing for their usage further downstream. So, each evaluator will implement a dataclass that encapsulates the results of the evaluation.
+
+### Illustrative example
+
+```python
+from deepeval import BaseMetric, FaithfulnessMetric
+
+@component
+class DeepEvalEvaluator:
+	self._metric: BaseMetric
+
+	def __init__(self, metric: str, params: Optional[Dict[str, Any]]):
+		params = {} if params is None
+		if metric == "Faithfulness":
+			self._metric = FaithfulnessMetric(**params)
+			self.set_input_types(questions=List[str], answers=List[str], contexts=Listt[List[str]])
+		elif metric == "ContextRecall":
+			...
+
+	def run(self, **kwargs):
+		# Logic to unwrap the inputs based on the metric and
+        # execute the backend code.
+        ...
+
+```
+
+# Drawbacks
+
+- **Lack of support for custom components**: The aforementioned API inherently restricts the user to the pre-defined metrics provided by the frameworks. On the other hand, we'd like to keep these integrations limited in their scope. Since we also plan on providing custom metric support in the future, this becomes a moot point.
+- **No support for batching across metrics**: Batching here refers to calculating multiple metrics on the inputs with a single API call. With the exception of UpTrain, the frameworks in question do not support this either. UpTrain's implementation is not publicly available, so we cannot determine if this type of batching happens on their server.
+- **Additional dependencies**: RAGAS and DeepEval depend on langchain, whereas UpTrain uses both its own client and OpenAI's.
+  - https://github.com/confident-ai/deepeval/blob/main/pyproject.toml
+  - https://github.com/explodinggradients/ragas/blob/main/pyproject.toml
+  - https://github.com/uptrain-ai/uptrain/blob/main/pyproject.toml
+
+# Alternatives
+
+- Eschewing the pipeline paradigm and using a separate evaluation API.
+  - Similar to how it was done in Haystack 1.x.
+- Implement them as components but run them individually.
+  - This would also be possible with the proposed API.
+
+# Adoption strategy
+
+This is a new feature with no breaking changes. Existing users can simply try out the evaluation with existing pipelines after installing additional dependencies and providing an OpenAI API key.
+
+# How we teach this
+
+We provide a new section in the documentation about evaluation. This proposal specifically deals with model-based evaluation, so it would be prudent to have a separate subsection for it.
+
+We should impress upon them the idea that evaluation is "just" another pipeline with different steps. A tutorial would also be helpful to guide them through the same. Apart from that, we should include pointers to the API docs of the different evaluation frameworks, etc.
+
+We clarify in the documentation how users can decide which Evaluation framework is best for them with a simple overview. They should not need to research the different frameworks before running their first evaluation.
+
+# Unresolved questions & future work
+
+- We see the integrated evaluation frameworks as a baseline. To what extent and when Haystack will have its own model-based metrics is out-of-scope for this proposal.
+- We envision an `Evaluator` component in Haystack's core with customizable model and prompt.
+- Terminology around existing `calculate_metrics`/`eval` functions and the `EvaluationResult` class need to be discussed (c.f https://github.com/deepset-ai/haystack/pull/6505).
+- Alternative take on the evaluation API - https://github.com/deepset-ai/haystack/pull/5794/
+  - The ideas proposed in the above should compatible with those of this proposal.

SPFsmartGATE/LIVE/TMP/haystack/proposals/text/7462-rag-evaluation.md

@@ -0,0 +1,223 @@
+- Title: Proposal for presentation of evaluation results
+- Decision driver: David S. Batista
+- Start Date: 2024-04-03
+- Proposal PR: #7462
+- Github Issue or Discussion: https://github.com/deepset-ai/haystack/issues/7398
+
+# Summary
+
+Add a new component to Haystack allowing users interact with the results of evaluating the performance of a RAG model.
+
+
+# Motivation
+
+RAG models are one of them most popular use cases for Haystack. We are adding support for evaluations metrics, but there is no way to present the results of the evaluation.
+
+
+# Detailed design
+
+The output results of an evaluation pipeline composed of `evaluator` components are passed to a `EvaluationResults`
+(this is a placeholder name) which stores them internally and acts as an interface to access and present the results.
+
+The examples below are just for illustrative purposes and are subject to change.
+
+Example of the data structure that the `EvaluationResults` class will receive for initialization:
+
+```python
+
+data = {
+    "inputs": {
+        "query_id": ["53c3b3e6", "225f87f7"],
+        "question": ["What is the capital of France?", "What is the capital of Spain?"],
+        "contexts": ["wiki_France", "wiki_Spain"],
+        "answer": ["Paris", "Madrid"],
+        "predicted_answer": ["Paris", "Madrid"]
+    },
+    "metrics":
+        [
+            {"name": "reciprocal_rank", "scores": [0.378064, 0.534964, 0.216058, 0.778642]},
+            {"name": "single_hit", "scores": [1, 1, 0, 1]},
+            {"name": "multi_hit", "scores": [0.706125, 0.454976, 0.445512, 0.250522]},
+            {"name": "context_relevance", "scores": [0.805466, 0.410251, 0.750070, 0.361332]},
+            {"name": "faithfulness", "scores": [0.135581, 0.695974, 0.749861, 0.041999]},
+            {"name": "semantic_answer_similarity", "scores": [0.971241, 0.159320, 0.019722, 1]}
+         ],
+    },
+
+```
+
+The `EvaluationResults` class provides the following methods to different types of users:
+
+Basic users:
+- `individual_aggregate_score_report()`
+- `comparative_aggregate_score_report()`
+
+Intermediate users:
+- `individual_detailed_score_report()`
+- `comparative_detailed_score_report()`
+
+Advanced users:
+- `find_thresholds()`
+- `find_inputs_below_threshold()`
+
+
+### Methods description
+An evaluation report that provides a summary of the performance of the model across all queries, showing the
+aggregated scores for all available metrics.
+
+```python
+def individual_aggregate_score_report():
+```
+
+Example output
+
+```bash
+{'Reciprocal Rank': 0.448,
+ 'Single Hit': 0.5,
+ 'Multi Hit': 0.540,
+ 'Context Relevance': 0.537,
+ 'Faithfulness': 0.452,
+ 'Semantic Answer Similarity': 0.478
+ }
+ ```
+
+A detailed evaluation report that provides the scores of all available metrics for all queries or a subset of queries.
+
+```python
+def individual_detailed_score_report(queries: Union[List[str], str] = "all"):
+```
+
+Example output
+
+```bash
+| question | context | answer | predicted_answer | reciprocal_rank | single_hit | multi_hit | context_relevance | faithfulness | semantic_answer_similarity |
+|----------|---------|--------|------------------|-----------------|------------|-----------|-------------------|-------------|----------------------------|
+| What is the capital of France? | wiki_France | Paris | Paris | 0.378064 | 1 | 0.706125 | 0.805466 | 0.135581 | 0.971241 |
+| What is the capital of Spain? | wiki_Spain | Madrid | Madrid | 0.534964 | 1 | 0.454976 | 0.410251 | 0.695974 | 0.159320 |
+```
+
+### Comparative Evaluation Report
+
+A comparative summary that compares the performance of the model with another model based on the aggregated scores
+for all available metrics.
+
+```python
+def comparative_aggregate_score_report(self, other: "EvaluationResults"):
+```
+
+```bash
+{
+    "model_1": {
+        'Reciprocal Rank': 0.448,
+        'Single Hit': 0.5,
+        'Multi Hit': 0.540,
+        'Context Relevance': 0.537,
+        'Faithfulness': 0.452,
+        'Semantic Answer Similarity': 0.478
+    },
+    "model_2": {
+        'Reciprocal Rank': 0.448,
+        'Single Hit': 0.5,
+        'Multi Hit': 0.540,
+        'Context Relevance': 0.537,
+        'Faithfulness': 0.452,
+        'Semantic Answer Similarity': 0.478
+    }
+}
+
+```
+
+A detailed comparative summary that compares the performance of the model with another model based on the scores of all
+available metrics for all queries.
+
+
+```python
+def comparative_detailed_score_report(self, other: "EvaluationResults"):
+```
+
+```bash
+| question | context | answer | predicted_answer_model_1 | predicted_answer_model_2 | reciprocal_rank_model_1 | reciprocal_rank_model_2 | single_hit_model_1 | single_hit_model_2 | multi_hit_model_1 | multi_hit_model_2 | context_relevance_model_1 | context_relevance_model_2 | faithfulness_model_1 | faithfulness_model_2 | semantic_answer_similarity_model_1 | semantic_answer_similarity_model_2 |
+|----------|---------|--------|--------------------------|--------------------------|-------------------------|-------------------------|--------------------|--------------------|-------------------|-------------------|---------------------------|---------------------------|----------------------|----------------------|------------------------------------|------------------------------------|
+| What is the capital of France? | wiki_France | Paris | Paris | Paris | 0.378064 | 0.378064 | 1 | 1 | 0.706125 | 0.706125 | 0.805466 | 0.805466 | 0.135581 | 0.135581 | 0.971241 | 0.971241 |
+| What is the capital of Spain? | wiki_Spain | Madrid | Madrid | Madrid | 0.534964 | 0.534964 | 1 | 1 | 0.454976 | 0.454976 | 0.410251 | 0.410251 | 0.695974 | 0.695974 | 0.159320 | 0.159320 |
+````
+
+
+Have a method to find interesting scores thresholds, typically used for error analysis, for all metrics available.
+Some potentially interesting thresholds to find are: the 25th percentile, the 75th percentile, the mean , the median.
+
+```python
+def find_thresholds(self, metrics: List[str]) -> Dict[str, float]:
+```
+
+```bash
+data  = {
+    "thresholds": ["25th percentile", "75th percentile", "median", "average"],
+    "reciprocal_rank": [0.378064, 0.534964, 0.216058, 0.778642],
+    "context_relevance": [0.805466, 0.410251, 0.750070, 0.361332],
+    "faithfulness": [0.135581, 0.695974, 0.749861, 0.041999],
+    "semantic_answer_similarity": [0.971241, 0.159320, 0.019722, 1],
+}
+````
+
+Then have another method that  
+
+```python
+def find_inputs_below_threshold(self, metric: str, threshold: float):
+    """Get the all the queries with a score below a certain threshold for a given metric"""  
+```
+
+# Drawbacks
+
+- Having the output in a format table may not be flexible enough, and maybe too verbose for datasets with a large number of queries.
+- Maybe the option to export to a .csv file would be better than having the output in a table format.
+- Maybe a JSON format would be better with the option for advanced users to do further analysis and visualization.
+
+
+# Adoption strategy
+
+- Doesn't introduce any breaking change, it is a new feature that can be adopted by users as they see fit for their use cases.
+
+# How we teach this
+
+- A tutorial would be the best approach to teach users how to use this feature.
+- Adding a new entry to the documentation.
+
+# User stories
+
+### 1. I would like to get a single summary score for my RAG pipeline so I can compare several pipeline configurations.
+
+Run `individual_aggregate_score_report()` and get the following output:
+
+```bash
+{'Reciprocal Rank': 0.448,
+ 'Single Hit': 0.5,
+ 'Multi Hit': 0.540,
+ 'Context Relevance': 0.537,
+ 'Faithfulness': 0.452,
+ 'Semantic Answer Similarity': 0.478
+ }
+ ```
+
+### 2. I am not sure what evaluation metrics work best for my RAG pipeline, specially when using the more novel LLM-based
+
+Use `context relevance` or `faithfulness`
+
+### 3. My RAG pipeline has a low aggregate score, so I would like to see examples of specific inputs where the score was low to be able to diagnose what the issue could be.
+
+Let's say it's a low score in `reciprocal_rank` and one already has an idea of what "low" is a query/question, then simply run:
+
+    find_inputs_below_threshold("reciprocal_rank", <threshold>)
+
+If the low score is in `reciprocal_rank` one can first get thresholds for this metric using:
+
+    `find_thresholds(["reciprocal_rank"])`
+
+this will give:
+
+- 25th percentile: (Q1) the value below which 25% of the data falls.
+- median percentile: (Q2) the value below which 50% of the data falls.
+- 75th percentile: (Q3) the value below which 75% of the data falls.
+
+this can help to decide what is considered a low score, and then get, for instance, queries with a score below
+the Q2 threshold using `find_inputs_below_threshold("context_relevance", threshold)`

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-TEI-embedders-8c76593bc25a7219.yaml

@@ -0,0 +1,28 @@
+---
+features:
+  - |
+    Add HuggingFace TEI Embedders - `HuggingFaceTEITextEmbedder` and `HuggingFaceTEIDocumentEmbedder`.
+
+    An example using `HuggingFaceTEITextEmbedder` to embed a string:
+    ```python
+    from haystack.components.embedders import HuggingFaceTEITextEmbedder
+    text_to_embed = "I love pizza!"
+    text_embedder = HuggingFaceTEITextEmbedder(
+        model="BAAI/bge-small-en-v1.5", url="<your-tei-endpoint-url>", token="<your-token>"
+    )
+    print(text_embedder.run(text_to_embed))
+    # {'embedding': [0.017020374536514282, -0.023255806416273117, ...],
+    ```
+
+    An example using `HuggingFaceTEIDocumentEmbedder` to create Document embeddings:
+    ```python
+    from haystack.dataclasses import Document
+    from haystack.components.embedders import HuggingFaceTEIDocumentEmbedder
+    doc = Document(content="I love pizza!")
+    document_embedder = HuggingFaceTEIDocumentEmbedder(
+        model="BAAI/bge-small-en-v1.5", url="<your-tei-endpoint-url>", token="<your-token>"
+    )
+    result = document_embedder.run([doc])
+    print(result["documents"][0].embedding)
+    # [0.017020374536514282, -0.023255806416273117, ...]
+    ```

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-answerbuilder-2.0-5dd255eeba68041f.yaml

@@ -0,0 +1,4 @@
+---
+preview:
+  - |
+    Add the `AnswerBuilder` component for Haystack 2.0 that creates Answer objects from the string output of Generators.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-apple-silicon-gpu-acceleration-38bf69781a933b95.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    Added support for Apple Silicon GPU acceleration through "mps pytorch", enabling better performance on Apple M1 hardware.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-apply_filter_policy-function-ae3152e6afe0ca57.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    Added the apply_filter_policy function to standardize the application of filter policies across all document store-specific retrievers, allowing for consistent handling of initial and runtime filters based on the chosen policy (replace or merge).

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-azure-kwargs-6a5ab1358ef7f44c.yaml

@@ -0,0 +1,6 @@
+---
+enhancements:
+  - |
+    Expose default_headers to pass custom headers to Azure API including APIM subscription key.
+  - |
+    Add optional azure_kwargs dictionary parameter to pass in parameters undefined in Haystack but supported by AzureOpenAI.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-azure_ocr_doc_converter-935130b3b243d236.yaml

@@ -0,0 +1,4 @@
+---
+preview:
+  - |
+    Add AzureOCRDocumentConverter to convert files of different types using Azure's Document Intelligence Service.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-batch_size_faiss_init-5e97c1fb9409f873.yaml

@@ -0,0 +1,5 @@
+---
+enhancements:
+  - |
+  Add batch_size to the __init__ method of FAISS Document Store. This works as the default value for all methods of
+  FAISS Document Store that support batch_size.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-blob-type-2a9476a39841f54d.yaml

@@ -0,0 +1,5 @@
+---
+preview:
+  - |
+    Add ByteStream type to send binary raw data across components
+    in a pipeline.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-branch-joiner-037298459ca74077.yaml

@@ -0,0 +1,14 @@
+---
+highlights: >
+    The `Multiplexer` component proved to be hard to explain and to understand. After reviewing its use cases, the documentation
+    was rewritten and the component was renamed to `BranchJoiner` to better explain its functionalities.
+upgrade:
+  - |
+    `BranchJoiner` has the very same interface as `Multiplexer`. To upgrade your code, just rename any occurrence
+    of `Multiplexer` to `BranchJoiner` and ajdust the imports accordingly.
+features:
+  - |
+    Add `BranchJoiner` to eventually replace `Multiplexer`
+deprecations:
+  - |
+    `Mulitplexer` is now deprecated.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-calculate-metrics-metricsresults-03bf27ce8b16cff5.yaml

@@ -0,0 +1,6 @@
+---
+features:
+  - |
+    Adds `calculate_metrics()` function to EvaluationResult for computation of evaluation metrics.
+    Adds `Metric` class to store list of available metrics.
+    Adds `MetricsResult` class to store the metric values computed during the evaluation.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-custom-filters-to-conditional-router-631eba8bab3c2ae7.yaml

@@ -0,0 +1,6 @@
+---
+features:
+  - |
+    Added custom filters support to ConditionalRouter. Users can now pass in
+    one or more custom Jinja2 filter callables and be able to access those
+    filters when defining condition expressions in routes.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-default-value-to-input-socket-2e62116fc4be5214.yaml

@@ -0,0 +1,5 @@
+---
+enhancements:
+  - |
+    Add a field called `default_value` to the `InputSocket` dataclass.
+    Derive `is_mandatory` value from the presence of `default_value`.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-document-writer-number-of-documents-written-2c57f3a5d6ae2131.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    Document writer returns the number of documents written.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-dynamic-prompt-builder-e61c4b11405b8d80.yaml

@@ -0,0 +1,5 @@
+---
+preview:
+  - |
+    Add `DynamicPromptBuilder` to dynamically generate prompts from either a list of ChatMessage instances or a string
+    template, leveraging Jinja2 templating for flexible and efficient prompt construction.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-exact-match-a7df21717238b771.yaml

@@ -0,0 +1,8 @@
+---
+features:
+  - |
+    Adds support for the Exact Match metric to `EvaluationResult.calculate_metrics(...)`:
+    ```python
+    from haystack.evaluation.metrics import Metric
+    exact_match_metric = eval_result.calculate_metrics(Metric.EM, output_key="answers")
+    ```

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-f1-d54cc900bec753f7.yaml

@@ -0,0 +1,8 @@
+---
+features:
+  - |
+    Adds support for the F1 metric to `EvaluationResult.calculate_metrics(...)`:
+    ```python
+    from haystack.evaluation.metrics import Metric
+    f1_metric = eval_result.calculate_metrics(Metric.F1, output_key="answers")
+    ```

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-huggingface-tgi-generator-9d7eed86f5246ea9.yaml

@@ -0,0 +1,5 @@
+---
+preview:
+  - |
+    Adds `HuggingFaceTGIGenerator` for text generation. This components support remote inferencing for
+    Hugging Face LLMs via text-generation-inference (TGI) protocol.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-indexing-ready-made-pipeline-85c1da2f8f910f9d.yaml

@@ -0,0 +1,4 @@
+---
+features:
+  - |
+    Add a indexing `build_indexing_pipeline` utility function

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-keep-id-to-document-cleaner-2a9854b5f195bb78.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    The `DocumentCleaner` class has the optional attribute `keep_id` that if set to True it keeps the document ids unchanged after cleanup.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-link-content-fetcher-145915976f38e1e0.yaml

@@ -0,0 +1,5 @@
+---
+preview:
+  - |
+    Introduced the LinkContentFetcher in Haystack 2.0. This component fetches content from specified
+    URLs and converts them into ByteStream objects for further processing in Haystack pipelines.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-lost-in-the-middle-ranker-6ad7dda754fad5a9.yaml

@@ -0,0 +1,18 @@
+---
+prelude: >
+    We're excited to introduce a new ranker to Haystack - LostInTheMiddleRanker.
+    It reorders documents based on the "Lost in the Middle" order, a strategy that
+    places the most relevant paragraphs at the beginning or end of the context,
+    while less relevant paragraphs are positioned in the middle. This ranker,
+    based on the research paper "Lost in the Middle: How Language Models Use Long
+    Contexts" by Liu et al., can be leveraged in Retrieval-Augmented Generation
+    (RAG) pipelines.
+features:
+  - |
+    The LostInTheMiddleRanker can be used like other rankers in Haystack. After
+    initializing LostInTheMiddleRanker with the desired parameters, it can be
+    used to rank/reorder a list of documents based on the "Lost in the Middle"
+    order - the most relevant documents are located at the top and bottom of
+    the returned list, while the least relevant documents are found in the
+    middle. We advise that you use this ranker in combination with other rankers,
+    and to place it towards the end of the pipeline.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-lost-in-the-middle-ranker-976f2e9bf83c3c68.yaml

@@ -0,0 +1,8 @@
+---
+
+features:
+  - |
+    Add LostInTheMiddleRanker.
+    It reorders documents based on the "Lost in the Middle" order, a strategy that
+    places the most relevant paragraphs at the beginning or end of the context,
+    while less relevant paragraphs are positioned in the middle.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-markdown-file-type-router-support-39a607faa5c1436f.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    Adds markdown mimetype support to the file type router i.e. `FileTypeRouter` class.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-metadata-HTMLToDocument-42dbd074a46c979e.yaml

@@ -0,0 +1,4 @@
+---
+preview:
+  - |
+    Adds support for adding additional metadata and utilizing metadata received from ByteStream sources when creating documents using HTMLToDocument.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-metadata_router-2.0-63829ac5a0528e9d.yaml

@@ -0,0 +1,4 @@
+---
+preview:
+  - |
+    Add `MetadataRouter`, a component that routes documents to different edges based on the content of their fields

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-min-top-k-top-p-sampler-dc65f97d420e70b0.yaml

@@ -0,0 +1,4 @@
+---
+enhancements:
+  - |
+    The parameter min_top_k is added to the TopPSampler which sets the minimum number of documents to be returned when the top-p sampling algorithm results in fewer documents being selected. The documents with the next highest scores are added to the selection. This is useful when we want to guarantee a set number of documents will always be passed on, but allow the Top-P algorithm to still determine if more documents should be sent based on document score.

SPFsmartGATE/LIVE/TMP/haystack/releasenotes/notes/add-mrr-metric-362527e55e21c24c.yaml

@@ -0,0 +1,5 @@
+---
+features:
+  - |
+    Add support for Mean Reciprocal Rank (MRR) Metric to `StatisticalEvaluator`.
+    MRR measures the mean reciprocal rank of times a label is present in at least one or more predictions.