From 9eefa575050f0be9f2aa3110c630573c465e0031 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Thu, 4 Apr 2024 23:27:08 -0400
Subject: [PATCH 01/26] keyword retriever

---
 .../retrievers/keyword_retriever.py           | 136 ++++++++++++++++++
 .../pgvector/document_store.py                |  78 ++++++++--
 2 files changed, 204 insertions(+), 10 deletions(-)
 create mode 100644 integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py

diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
new file mode 100644
index 000000000..856395b6e
--- /dev/null
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
@@ -0,0 +1,136 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Dict, List, Optional
+
+from haystack import component, default_from_dict, default_to_dict
+from haystack.dataclasses import Document
+from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
+
+
+@component
+class PgvectorKeywordRetriever:
+    """
+    Retrieves documents from the `PgvectorDocumentStore`, based on their sparse vectors.
+
+    Example usage:
+    ```python
+    from haystack.document_stores import DuplicatePolicy
+    from haystack import Document, Pipeline
+    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+
+    from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
+    from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever
+
+    # Set an environment variable `PG_CONN_STR` with the connection string to your PostgreSQL database.
+    # e.g., "postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"
+
+    document_store = PgvectorDocumentStore(
+    embedding_dimension=768,
+    vector_function="cosine_similarity",
+    recreate_table=True,
+    )
+
+    documents = [Document(content="There are over 7,000 languages spoken around the world today."),
+        Document(content="Elephants have been observed to behave in a way that indicates..."),
+        Document(content="In certain places, you can witness the phenomenon of bioluminescent waves.")]
+
+    document_embedder = SentenceTransformersDocumentEmbedder()
+    document_embedder.warm_up()
+    documents_with_embeddings = document_embedder.run(documents)
+
+    document_store.write_documents(documents_with_embeddings.get("documents"), policy=DuplicatePolicy.OVERWRITE)
+
+    query_pipeline = Pipeline()
+    query_pipeline.add_component("retriever", PgvectorKeywordRetriever(document_store=document_store))
+    query_pipeline.connect("query", "retriever.query")
+
+    query = "How many languages are there?"
+
+    res = query_pipeline.run({"retriever": {"text": query}})
+
+    assert res['retriever']['documents'][0].content == "There are over 7,000 languages spoken around the world today."
+    """
+
+    def __init__(
+        self,
+        *,
+        document_store: PgvectorDocumentStore,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        language: str = "english",
+    ):
+        """
+        :param document_store: An instance of `PgvectorDocumentStore}.
+        :param filters: Filters applied to the retrieved Documents.
+        :param top_k: Maximum number of Documents to return.
+
+        :raises ValueError: If `document_store` is not an instance of `PgvectorDocumentStore` or if `vector_function`
+            is not one of the valid options.
+        """
+        if not isinstance(document_store, PgvectorDocumentStore):
+            msg = "document_store must be an instance of PgvectorDocumentStore"
+            raise ValueError(msg)
+
+        self.document_store = document_store
+        self.filters = filters or {}
+        self.top_k = top_k
+        self.language = language
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            filters=self.filters,
+            top_k=self.top_k,
+            document_store=self.document_store.to_dict(),
+            language=self.language,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "PgvectorKeywordRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+        :returns:
+            Deserialized component.
+        """
+        doc_store_params = data["init_parameters"]["document_store"]
+        data["init_parameters"]["document_store"] = PgvectorDocumentStore.from_dict(doc_store_params)
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document])
+    def run(
+        self,
+        user_query: str,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+        language: Optional[str] = "english",
+    ):
+        """
+        Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
+
+        :param user_input: The user's query.
+        :param filters: Filters applied to the retrieved Documents.
+        :param top_k: Maximum number of Documents to return.
+
+        :returns: List of Documents similar to `user_query`.
+        """
+        filters = filters or self.filters
+        top_k = top_k or self.top_k
+        language = language or self.language
+
+        docs = self.document_store._keyword_retrieval(
+            user_query=user_query,
+            filters=filters,
+            top_k=top_k,
+            language=language,
+        )
+        return {"documents": docs}
diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index da08a5f19..6f2c8ca2f 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -80,9 +80,11 @@ def __init__(
         vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] = "cosine_similarity",
         recreate_table: bool = False,
         search_strategy: Literal["exact_nearest_neighbor", "hnsw"] = "exact_nearest_neighbor",
+        hybrid_search: bool = False,
         hnsw_recreate_index_if_exists: bool = False,
         hnsw_index_creation_kwargs: Optional[Dict[str, int]] = None,
         hnsw_ef_search: Optional[int] = None,
+        language: Optional[str] = "english",
     ):
         """
         Creates a new PgvectorDocumentStore instance.
@@ -117,6 +119,7 @@ def __init__(
         :param hnsw_ef_search: The `ef_search` parameter to use at query time. Only used if search_strategy is set to
             `"hnsw"`. You can find more information about this parameter in the
             [pgvector documentation](https://github.com/pgvector/pgvector?tab=readme-ov-file#hnsw)
+        :param language: The language to use for the full-text/hybrid search.
         """
 
         self.connection_string = connection_string
@@ -128,9 +131,11 @@ def __init__(
         self.vector_function = vector_function
         self.recreate_table = recreate_table
         self.search_strategy = search_strategy
+        self.hybrid_search = hybrid_search
         self.hnsw_recreate_index_if_exists = hnsw_recreate_index_if_exists
         self.hnsw_index_creation_kwargs = hnsw_index_creation_kwargs or {}
         self.hnsw_ef_search = hnsw_ef_search
+        self.language = language
 
         connection = connect(self.connection_string.resolve_value())
         connection.autocommit = True
@@ -168,6 +173,7 @@ def to_dict(self) -> Dict[str, Any]:
             hnsw_recreate_index_if_exists=self.hnsw_recreate_index_if_exists,
             hnsw_index_creation_kwargs=self.hnsw_index_creation_kwargs,
             hnsw_ef_search=self.hnsw_ef_search,
+            language=self.language,
         )
 
     @classmethod
@@ -220,6 +226,7 @@ def _create_table_if_not_exists(self):
         )
 
         self._execute_sql(create_sql, error_msg="Could not create table in PgvectorDocumentStore")
+        self._create_keyword_index()
 
     def delete_table(self):
         """
@@ -231,6 +238,17 @@ def delete_table(self):
 
         self._execute_sql(delete_sql, error_msg=f"Could not delete table {self.table_name} in PgvectorDocumentStore")
 
+    def _create_keyword_index(self):
+        """
+        Internal method to create the keyword index.
+        """
+
+        sql_create_index = SQL("CREATE INDEX ON {table_name} USING GIN (to_tsvector({language}, content))").format(
+            table_name=Identifier(self.table_name), language=SQLLiteral(self.language)
+        )
+
+        self._execute_sql(sql_create_index, error_msg="Could not create keyword index on table")
+
     def _handle_hnsw(self):
         """
         Internal method to handle the HNSW index creation.
@@ -415,16 +433,6 @@ def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str,
             db_document["dataframe"] = Jsonb(db_document["dataframe"]) if db_document["dataframe"] else None
             db_document["meta"] = Jsonb(db_document["meta"])
 
-            if "sparse_embedding" in db_document:
-                sparse_embedding = db_document.pop("sparse_embedding", None)
-                if sparse_embedding:
-                    logger.warning(
-                        "Document %s has the `sparse_embedding` field set,"
-                        "but storing sparse embeddings in Pgvector is not currently supported."
-                        "The `sparse_embedding` field will be ignored.",
-                        db_document["id"],
-                    )
-
             db_documents.append(db_document)
 
         return db_documents
@@ -475,6 +483,56 @@ def delete_documents(self, document_ids: List[str]) -> None:
 
         self._execute_sql(delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore")
 
+    def _keyword_retrieval(
+        self,
+        user_query: str,
+        top_k: int = 10,
+        filters: Optional[Dict[str, Any]] = None,
+        language: Optional[str] = "english",
+    ) -> List[Document]:
+        """
+        Retrieves documents that are most similar to the query using a full-text search.
+
+        This method is not meant to be part of the public interface of
+        `PgvectorDocumentStore` and it should not be called directly.
+        `PgvectorKeywordRetriever` uses this method directly and is the public interface for it.
+        :returns: List of Documents that are most similar to `user_query`
+        """
+
+        if not user_query:
+            msg = "user_query must be a non-empty string"
+            raise ValueError(msg)
+
+        sql_select = SQL(
+            """SELECT *, RANK() OVER (ORDER BY
+            ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
+            FROM {table_name}, plainto_tsquery({language}, {query}) query
+            WHERE to_tsvector({language}, content) @@ query"""
+        ).format(table_name=Identifier(self.table_name), language=language, query=user_query)
+
+        sql_where_clause = SQL("")
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+
+        sql_sort = SQL(" ORDER BY rank {sort_order} LIMIT {top_k}").format(
+            top_k=SQLLiteral(top_k),
+            sort_order=SQL("DESC"),
+        )
+
+        sql_query = sql_select + sql_where_clause + sql_sort
+
+        result = self._execute_sql(
+            sql_query,
+            params,
+            error_msg="Could not retrieve documents from PgvectorDocumentStore.",
+            cursor=self._dict_cursor,
+        )
+
+        records = result.fetchall()
+        docs = self._from_pg_to_haystack_documents(records)
+        return docs
+
     def _embedding_retrieval(
         self,
         query_embedding: List[float],

From de9b258b31c0ab83b2c6d6d93dc443a1fe3ef1a1 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Thu, 4 Apr 2024 23:34:21 -0400
Subject: [PATCH 02/26] add lang to init for tests

---
 integrations/pgvector/tests/test_document_store.py | 1 +
 integrations/pgvector/tests/test_retriever.py      | 1 +
 2 files changed, 2 insertions(+)

diff --git a/integrations/pgvector/tests/test_document_store.py b/integrations/pgvector/tests/test_document_store.py
index bf5ccd5d4..6fd7e0dc0 100644
--- a/integrations/pgvector/tests/test_document_store.py
+++ b/integrations/pgvector/tests/test_document_store.py
@@ -89,6 +89,7 @@ def test_to_dict(monkeypatch):
             "recreate_table": True,
             "search_strategy": "hnsw",
             "hnsw_recreate_index_if_exists": True,
+            "language": "english",
             "hnsw_index_creation_kwargs": {"m": 32, "ef_construction": 128},
             "hnsw_ef_search": 50,
         },
diff --git a/integrations/pgvector/tests/test_retriever.py b/integrations/pgvector/tests/test_retriever.py
index 61381c24e..8a14cff73 100644
--- a/integrations/pgvector/tests/test_retriever.py
+++ b/integrations/pgvector/tests/test_retriever.py
@@ -46,6 +46,7 @@ def test_to_dict(self, mock_store):
                         "recreate_table": True,
                         "search_strategy": "exact_nearest_neighbor",
                         "hnsw_recreate_index_if_exists": False,
+                        "language": "english",
                         "hnsw_index_creation_kwargs": {},
                         "hnsw_ef_search": None,
                     },

From 65aa8afd7b85f65450de5b67f71279bd12fcfc5d Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Sun, 7 Apr 2024 22:33:35 -0400
Subject: [PATCH 03/26] make suggested edits/test

---
 .../retrievers/keyword_retriever.py           |  6 ---
 .../pgvector/document_store.py                | 36 ++++++---------
 .../pgvector/tests/test_keyword_retrieval.py  | 46 +++++++++++++++++++
 3 files changed, 61 insertions(+), 27 deletions(-)
 create mode 100644 integrations/pgvector/tests/test_keyword_retrieval.py

diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
index 856395b6e..ce0e8601a 100644
--- a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
@@ -58,7 +58,6 @@ def __init__(
         document_store: PgvectorDocumentStore,
         filters: Optional[Dict[str, Any]] = None,
         top_k: int = 10,
-        language: str = "english",
     ):
         """
         :param document_store: An instance of `PgvectorDocumentStore}.
@@ -75,7 +74,6 @@ def __init__(
         self.document_store = document_store
         self.filters = filters or {}
         self.top_k = top_k
-        self.language = language
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -89,7 +87,6 @@ def to_dict(self) -> Dict[str, Any]:
             filters=self.filters,
             top_k=self.top_k,
             document_store=self.document_store.to_dict(),
-            language=self.language,
         )
 
     @classmethod
@@ -112,7 +109,6 @@ def run(
         user_query: str,
         filters: Optional[Dict[str, Any]] = None,
         top_k: Optional[int] = None,
-        language: Optional[str] = "english",
     ):
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
@@ -125,12 +121,10 @@ def run(
         """
         filters = filters or self.filters
         top_k = top_k or self.top_k
-        language = language or self.language
 
         docs = self.document_store._keyword_retrieval(
             user_query=user_query,
             filters=filters,
             top_k=top_k,
-            language=language,
         )
         return {"documents": docs}
diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 6f2c8ca2f..8c6c20f66 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -80,11 +80,10 @@ def __init__(
         vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] = "cosine_similarity",
         recreate_table: bool = False,
         search_strategy: Literal["exact_nearest_neighbor", "hnsw"] = "exact_nearest_neighbor",
-        hybrid_search: bool = False,
         hnsw_recreate_index_if_exists: bool = False,
         hnsw_index_creation_kwargs: Optional[Dict[str, int]] = None,
         hnsw_ef_search: Optional[int] = None,
-        language: Optional[str] = "english",
+        language: str = "english",
     ):
         """
         Creates a new PgvectorDocumentStore instance.
@@ -131,7 +130,6 @@ def __init__(
         self.vector_function = vector_function
         self.recreate_table = recreate_table
         self.search_strategy = search_strategy
-        self.hybrid_search = hybrid_search
         self.hnsw_recreate_index_if_exists = hnsw_recreate_index_if_exists
         self.hnsw_index_creation_kwargs = hnsw_index_creation_kwargs or {}
         self.hnsw_ef_search = hnsw_ef_search
@@ -151,6 +149,7 @@ def __init__(
         if recreate_table:
             self.delete_table()
         self._create_table_if_not_exists()
+        self._create_keyword_index()
 
         if search_strategy == "hnsw":
             self._handle_hnsw()
@@ -226,7 +225,6 @@ def _create_table_if_not_exists(self):
         )
 
         self._execute_sql(create_sql, error_msg="Could not create table in PgvectorDocumentStore")
-        self._create_keyword_index()
 
     def delete_table(self):
         """
@@ -433,6 +431,16 @@ def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str,
             db_document["dataframe"] = Jsonb(db_document["dataframe"]) if db_document["dataframe"] else None
             db_document["meta"] = Jsonb(db_document["meta"])
 
+            if "sparse_embedding" in db_document:
+                sparse_embedding = db_document.pop("sparse_embedding", None)
+                if sparse_embedding:
+                    logger.warning(
+                        "Document %s has the `sparse_embedding` field set,"
+                        "but storing sparse embeddings in Pgvector is not currently supported."
+                        "The `sparse_embedding` field will be ignored.",
+                        db_document["id"],
+                    )
+
             db_documents.append(db_document)
 
         return db_documents
@@ -488,7 +496,6 @@ def _keyword_retrieval(
         user_query: str,
         top_k: int = 10,
         filters: Optional[Dict[str, Any]] = None,
-        language: Optional[str] = "english",
     ) -> List[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search.
@@ -507,24 +514,11 @@ def _keyword_retrieval(
             """SELECT *, RANK() OVER (ORDER BY
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
             FROM {table_name}, plainto_tsquery({language}, {query}) query
-            WHERE to_tsvector({language}, content) @@ query"""
-        ).format(table_name=Identifier(self.table_name), language=language, query=user_query)
-
-        sql_where_clause = SQL("")
-        params = ()
-        if filters:
-            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
-
-        sql_sort = SQL(" ORDER BY rank {sort_order} LIMIT {top_k}").format(
-            top_k=SQLLiteral(top_k),
-            sort_order=SQL("DESC"),
-        )
-
-        sql_query = sql_select + sql_where_clause + sql_sort
+            WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
+        ).format(table_name=Identifier(self.table_name), language=self.language, query=user_query)
 
         result = self._execute_sql(
-            sql_query,
-            params,
+            sql_select,
             error_msg="Could not retrieve documents from PgvectorDocumentStore.",
             cursor=self._dict_cursor,
         )
diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
new file mode 100644
index 000000000..0099f03c2
--- /dev/null
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -0,0 +1,46 @@
+from typing import List
+
+import pytest
+from haystack.dataclasses.document import Document
+from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
+
+
+@pytest.mark.integration
+class TestKeywordRetrieval:
+    @pytest.fixture
+    def document_store_w_hnsw_index(self, request):
+        connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
+        table_name = f"haystack_nn_{request.node.name}"
+        embedding_dimension = 768
+        vector_function = "cosine_similarity"
+        recreate_table = True
+        search_strategy = "exact_nearest_neighbor"
+
+        store = PgvectorDocumentStore(
+            connection_string=connection_string,
+            table_name=table_name,
+            embedding_dimension=embedding_dimension,
+            vector_function=vector_function,
+            recreate_table=recreate_table,
+            search_strategy=search_strategy,
+        )
+        yield store
+
+        store.delete_table()
+
+    @pytest.mark.parametrize("document_store", ["document_store"], indirect=True)
+    def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
+        # Mock query and expected documents
+        query = "The quick brown fox jumps over the lazy dog"
+        docs = [
+            Document(content="The quick brown fox chased the dog", meta={"id": "1"}, embedding=[0.1] * 768),
+            Document(content="The fox was brown", meta={"id": "2"}, embedding=[0.1] * 768),
+            Document(content="The lazy dog", meta={"id": "3"}, embedding=[0.1] * 768),
+        ]
+
+        document_store.write_documents(docs)
+
+        results = document_store._keyword_retrieval(user_query=query, top_k=2)
+
+        assert len(results) == 2
+        assert results[0].content == docs[0].content

From fdb5d5b5be4a82f640c4c3b058c3c2cf0882244c Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Sun, 7 Apr 2024 22:59:21 -0400
Subject: [PATCH 04/26] fixes to test / lint

---
 .../document_stores/pgvector/document_store.py   | 16 +++++++++++-----
 .../pgvector/tests/test_keyword_retrieval.py     |  6 ++----
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 8c6c20f66..5c5e90ecd 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -149,7 +149,6 @@ def __init__(
         if recreate_table:
             self.delete_table()
         self._create_table_if_not_exists()
-        self._create_keyword_index()
 
         if search_strategy == "hnsw":
             self._handle_hnsw()
@@ -238,8 +237,15 @@ def delete_table(self):
 
     def _create_keyword_index(self):
         """
-        Internal method to create the keyword index.
+        Internal method to create the keyword index if not exists.
         """
+        sql_check_index = SQL("SELECT * FROM pg_indexes WHERE tablename = {table_name};").format(
+            table_name=Identifier(self.table_name)
+        )
+        result = self._execute_sql(sql_check_index, error_msg="Could not create keyword index on table")
+
+        if result.fetchone():
+            return
 
         sql_create_index = SQL("CREATE INDEX ON {table_name} USING GIN (to_tsvector({language}, content))").format(
             table_name=Identifier(self.table_name), language=SQLLiteral(self.language)
@@ -495,7 +501,7 @@ def _keyword_retrieval(
         self,
         user_query: str,
         top_k: int = 10,
-        filters: Optional[Dict[str, Any]] = None,
+        # filters: Optional[Dict[str, Any]] = None,
     ) -> List[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search.
@@ -505,7 +511,7 @@ def _keyword_retrieval(
         `PgvectorKeywordRetriever` uses this method directly and is the public interface for it.
         :returns: List of Documents that are most similar to `user_query`
         """
-
+        self._create_keyword_index()
         if not user_query:
             msg = "user_query must be a non-empty string"
             raise ValueError(msg)
@@ -515,7 +521,7 @@ def _keyword_retrieval(
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
             FROM {table_name}, plainto_tsquery({language}, {query}) query
             WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
-        ).format(table_name=Identifier(self.table_name), language=self.language, query=user_query)
+        ).format(table_name=Identifier(self.table_name), language=self.language, query=user_query, top_k=top_k)
 
         result = self._execute_sql(
             sql_select,
diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index 0099f03c2..1df450a08 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -1,5 +1,3 @@
-from typing import List
-
 import pytest
 from haystack.dataclasses.document import Document
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
@@ -8,7 +6,7 @@
 @pytest.mark.integration
 class TestKeywordRetrieval:
     @pytest.fixture
-    def document_store_w_hnsw_index(self, request):
+    def document_store_keyword(self, request):
         connection_string = "postgresql://postgres:postgres@localhost:5432/postgres"
         table_name = f"haystack_nn_{request.node.name}"
         embedding_dimension = 768
@@ -28,7 +26,7 @@ def document_store_w_hnsw_index(self, request):
 
         store.delete_table()
 
-    @pytest.mark.parametrize("document_store", ["document_store"], indirect=True)
+    @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
     def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
         # Mock query and expected documents
         query = "The quick brown fox jumps over the lazy dog"

From 32e53fe5f8aa83a487bacb805f9cbdf6645e7592 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 19:27:39 -0400
Subject: [PATCH 05/26] index check query change

---
 .../pgvector/document_store.py                | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 5c5e90ecd..f50c490a2 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -239,19 +239,20 @@ def _create_keyword_index(self):
         """
         Internal method to create the keyword index if not exists.
         """
-        sql_check_index = SQL("SELECT * FROM pg_indexes WHERE tablename = {table_name};").format(
-            table_name=Identifier(self.table_name)
+        index_exists = bool(
+            self._execute_sql(
+                "SELECT * FROM pg_indexes WHERE tablename = %s",
+                (self.table_name),
+                "Could not check if keyword index exists",
+            ).fetchone()
         )
-        result = self._execute_sql(sql_check_index, error_msg="Could not create keyword index on table")
-
-        if result.fetchone():
-            return
 
-        sql_create_index = SQL("CREATE INDEX ON {table_name} USING GIN (to_tsvector({language}, content))").format(
-            table_name=Identifier(self.table_name), language=SQLLiteral(self.language)
+        sql_create_index = SQL('CREATE INDEX ON "{table_name}" USING GIN (to_tsvector({language}, content))').format(
+            table_name=SQLLiteral(self.table_name), language=SQLLiteral(self.language)
         )
 
-        self._execute_sql(sql_create_index, error_msg="Could not create keyword index on table")
+        if not index_exists:
+            self._execute_sql(sql_create_index, error_msg="Could not create keyword index on table")
 
     def _handle_hnsw(self):
         """

From 3b123dcd93b2579cb5238db4ac0a7573c4c91213 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 19:35:37 -0400
Subject: [PATCH 06/26] SQLLiteral fix

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index f50c490a2..e4d57e1d4 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -522,7 +522,7 @@ def _keyword_retrieval(
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
             FROM {table_name}, plainto_tsquery({language}, {query}) query
             WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
-        ).format(table_name=Identifier(self.table_name), language=self.language, query=user_query, top_k=top_k)
+        ).format(table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k)
 
         result = self._execute_sql(
             sql_select,

From eed3730f67160dad9a9831f3ff9435c3874eac4f Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 19:54:19 -0400
Subject: [PATCH 07/26] table name quotes

---
 .../document_stores/pgvector/document_store.py              | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index e4d57e1d4..9862739c5 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -520,9 +520,11 @@ def _keyword_retrieval(
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
-            FROM {table_name}, plainto_tsquery({language}, {query}) query
+            FROM "{table_name}", plainto_tsquery({language}, {query}) query
             WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
-        ).format(table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k)
+        ).format(
+            table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k
+        )
 
         result = self._execute_sql(
             sql_select,

From ffdff8af19ebb04b4ee7aab5eae80300df43f939 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 20:06:19 -0400
Subject: [PATCH 08/26] table name quotes

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 9862739c5..2d6a6ede2 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -242,7 +242,7 @@ def _create_keyword_index(self):
         index_exists = bool(
             self._execute_sql(
                 "SELECT * FROM pg_indexes WHERE tablename = %s",
-                (self.table_name),
+                (self.table_name,),
                 "Could not check if keyword index exists",
             ).fetchone()
         )

From 654959ecefa669caa9afbda0a4c68f89844731a3 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 20:09:27 -0400
Subject: [PATCH 09/26] table name quotes

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 2d6a6ede2..b4249ca03 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -520,7 +520,7 @@ def _keyword_retrieval(
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
-            FROM "{table_name}", plainto_tsquery({language}, {query}) query
+            FROM {table_name}, plainto_tsquery({language}, {query}) query
             WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
         ).format(
             table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k

From d90893dc22db59d056826f9dc7ee87986ded395c Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 21:21:46 -0400
Subject: [PATCH 10/26] test query edit

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index 1df450a08..36b4a0beb 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -29,7 +29,7 @@ def document_store_keyword(self, request):
     @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
     def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
         # Mock query and expected documents
-        query = "The quick brown fox jumps over the lazy dog"
+        query = "fox"
         docs = [
             Document(content="The quick brown fox chased the dog", meta={"id": "1"}, embedding=[0.1] * 768),
             Document(content="The fox was brown", meta={"id": "2"}, embedding=[0.1] * 768),

From 8d3836d91485a58f3cb318337d2f43501c6638bd Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 9 Apr 2024 21:27:44 -0400
Subject: [PATCH 11/26] remove meta

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index 36b4a0beb..abb8e7fe9 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -31,9 +31,9 @@ def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
         # Mock query and expected documents
         query = "fox"
         docs = [
-            Document(content="The quick brown fox chased the dog", meta={"id": "1"}, embedding=[0.1] * 768),
-            Document(content="The fox was brown", meta={"id": "2"}, embedding=[0.1] * 768),
-            Document(content="The lazy dog", meta={"id": "3"}, embedding=[0.1] * 768),
+            Document(content="The quick brown fox chased the dog", embedding=[0.1] * 768),
+            Document(content="The fox was brown", embedding=[0.1] * 768),
+            Document(content="The lazy dog", embedding=[0.1] * 768),
         ]
 
         document_store.write_documents(docs)

From 65202208105a9f086c67f507cb3efe1e8ee9530d Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Mon, 22 Apr 2024 08:18:15 -0400
Subject: [PATCH 12/26] move keyword index to init

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index b4249ca03..3f21768b9 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -149,6 +149,7 @@ def __init__(
         if recreate_table:
             self.delete_table()
         self._create_table_if_not_exists()
+        self._create_keyword_index()
 
         if search_strategy == "hnsw":
             self._handle_hnsw()
@@ -512,7 +513,6 @@ def _keyword_retrieval(
         `PgvectorKeywordRetriever` uses this method directly and is the public interface for it.
         :returns: List of Documents that are most similar to `user_query`
         """
-        self._create_keyword_index()
         if not user_query:
             msg = "user_query must be a non-empty string"
             raise ValueError(msg)

From 941866029b6b033d4ae252100e276633dfac7115 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Mon, 22 Apr 2024 19:28:34 -0400
Subject: [PATCH 13/26] move keyword index to init

---
 .../components/retrievers/keyword_retriever.py      |  2 +-
 .../document_stores/pgvector/document_store.py      | 13 ++++++++++---
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
index ce0e8601a..752caa7bf 100644
--- a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
@@ -111,7 +111,7 @@ def run(
         top_k: Optional[int] = None,
     ):
         """
-        Retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
+        Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 
         :param user_input: The user's query.
         :param filters: Filters applied to the retrieved Documents.
diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 3f21768b9..469f2b24e 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -503,7 +503,7 @@ def _keyword_retrieval(
         self,
         user_query: str,
         top_k: int = 10,
-        # filters: Optional[Dict[str, Any]] = None,
+        filters: Optional[Dict[str, Any]] = None,
     ) -> List[Document]:
         """
         Retrieves documents that are most similar to the query using a full-text search.
@@ -517,17 +517,24 @@ def _keyword_retrieval(
             msg = "user_query must be a non-empty string"
             raise ValueError(msg)
 
+        params = ()
+        sql_where_clause = SQL("")
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY
             ts_rank_cd(to_tsvector({language}, content), query) DESC) AS rank
             FROM {table_name}, plainto_tsquery({language}, {query}) query
-            WHERE to_tsvector({language}, content) @@ query LIMIT {top_k}"""
+            WHERE to_tsvector({language}, content) @@ query {where_clause} LIMIT {top_k}"""
         ).format(
-            table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k
+            table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k,
+            where_clause=sql_where_clause
         )
 
         result = self._execute_sql(
             sql_select,
+            params,
             error_msg="Could not retrieve documents from PgvectorDocumentStore.",
             cursor=self._dict_cursor,
         )

From 9f583eaed00045594c9f464286dc4557a1f9dfd0 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Mon, 22 Apr 2024 19:30:07 -0400
Subject: [PATCH 14/26] move keyword index to init

---
 .../document_stores/pgvector/document_store.py             | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 469f2b24e..c38320874 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -528,8 +528,11 @@ def _keyword_retrieval(
             FROM {table_name}, plainto_tsquery({language}, {query}) query
             WHERE to_tsvector({language}, content) @@ query {where_clause} LIMIT {top_k}"""
         ).format(
-            table_name=Identifier(self.table_name), language=self.language, query=SQLLiteral(user_query), top_k=top_k,
-            where_clause=sql_where_clause
+            table_name=Identifier(self.table_name),
+            language=self.language,
+            query=SQLLiteral(user_query),
+            top_k=top_k,
+            where_clause=sql_where_clause,
         )
 
         result = self._execute_sql(

From 2bb3b5920b4f225e3067d419fdf7e3479b68c68d Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 23 Apr 2024 19:56:54 -0400
Subject: [PATCH 15/26] keyword with filters test

---
 .../pgvector/tests/test_keyword_retrieval.py  | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index abb8e7fe9..7a50a47b7 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -1,6 +1,7 @@
 import pytest
 from haystack.dataclasses.document import Document
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
+from numpy.random import rand
 
 
 @pytest.mark.integration
@@ -42,3 +43,21 @@ def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
 
         assert len(results) == 2
         assert results[0].content == docs[0].content
+
+
+    @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
+    def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentStore):
+        docs = [Document(content=f"Document {i}", embedding=rand(768).tolist()) for i in range(10)]
+
+        for i in range(10):
+            docs[i].meta["meta_field"] = "custom_value" if i % 2 == 0 else "other_value"
+
+        document_store.write_documents(docs)
+
+        query = "value"
+        filters = {"field": "meta.meta_field", "operator": "==", "value": "custom_value"}
+
+        results = document_store._keyword_retrieval(user_query=query, top_k=3, filters=filters)
+        assert len(results) == 3
+        for result in results:
+            assert result.meta["meta_field"] == "custom_value"

From b44112e48fc5a65badc1ca853d162fb15c2f21d3 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 23 Apr 2024 19:58:06 -0400
Subject: [PATCH 16/26] keyword with filters test

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index 7a50a47b7..5690ab7d9 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -44,7 +44,6 @@ def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
         assert len(results) == 2
         assert results[0].content == docs[0].content
 
-
     @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
     def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentStore):
         docs = [Document(content=f"Document {i}", embedding=rand(768).tolist()) for i in range(10)]

From dcfa0ba591f5e480c57d7e4a251119a5ae5493c1 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 23 Apr 2024 20:11:20 -0400
Subject: [PATCH 17/26] keyword with filters test

---
 .../document_stores/pgvector/document_store.py                   | 1 +
 1 file changed, 1 insertion(+)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index c38320874..daa139c91 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -521,6 +521,7 @@ def _keyword_retrieval(
         sql_where_clause = SQL("")
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            sql_where_clause.replace("WHERE", "AND")
 
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY

From 7a03aa79d93e65c1750921c833517ebe107be358 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 23 Apr 2024 20:20:51 -0400
Subject: [PATCH 18/26] keyword with filters test

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index daa139c91..02e346f69 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -521,7 +521,7 @@ def _keyword_retrieval(
         sql_where_clause = SQL("")
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
-            sql_where_clause.replace("WHERE", "AND")
+            sql_where_clause = SQL(str(sql_where_clause).replace("WHERE", "AND"))
 
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY

From 00122c6ac2bae85911c46031889859b963a8e4ac Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Tue, 23 Apr 2024 20:37:55 -0400
Subject: [PATCH 19/26] keyword with filters test

---
 .../document_stores/pgvector/document_store.py                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 02e346f69..5a70a3b48 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -521,7 +521,7 @@ def _keyword_retrieval(
         sql_where_clause = SQL("")
         if filters:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
-            sql_where_clause = SQL(str(sql_where_clause).replace("WHERE", "AND"))
+            sql_where_clause = str(sql_where_clause).replace("WHERE", "AND")
 
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY

From 59d81c57d7749bf866ed2afb2a20bf8ff1e0e948 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Thu, 25 Apr 2024 17:53:55 -0400
Subject: [PATCH 20/26] keyword with filters test

---
 .../document_stores/pgvector/document_store.py    |  5 ++---
 .../document_stores/pgvector/filters.py           | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 5a70a3b48..67256af96 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -20,7 +20,7 @@
 
 from pgvector.psycopg import register_vector
 
-from .filters import _convert_filters_to_where_clause_and_params
+from .filters import _convert_filters_to_and_clause_and_params, _convert_filters_to_where_clause_and_params
 
 logger = logging.getLogger(__name__)
 
@@ -520,8 +520,7 @@ def _keyword_retrieval(
         params = ()
         sql_where_clause = SQL("")
         if filters:
-            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
-            sql_where_clause = str(sql_where_clause).replace("WHERE", "AND")
+            sql_where_clause, params = _convert_filters_to_and_clause_and_params(filters)
 
         sql_select = SQL(
             """SELECT *, RANK() OVER (ORDER BY
diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/filters.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/filters.py
index daa90f502..3e771b13e 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/filters.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/filters.py
@@ -37,6 +37,21 @@ def _convert_filters_to_where_clause_and_params(filters: Dict[str, Any]) -> tupl
     return where_clause, params
 
 
+def _convert_filters_to_and_clause_and_params(filters: Dict[str, Any]) -> tuple[SQL, tuple]:
+    """
+    Convert Haystack filters to a WHERE clause and a tuple of params to query PostgreSQL.
+    """
+    if "field" in filters:
+        query, values = _parse_comparison_condition(filters)
+    else:
+        query, values = _parse_logical_condition(filters)
+
+    where_clause = SQL(" AND ") + SQL(query)
+    params = tuple(value for value in values if value != NO_VALUE)
+
+    return where_clause, params
+
+
 def _parse_logical_condition(condition: Dict[str, Any]) -> tuple[str, List[Any]]:
     if "operator" not in condition:
         msg = f"'operator' key missing in {condition}"

From 31662df29bb0ac6494e40baaeaecf02545cb22ef Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Fri, 26 Apr 2024 19:11:42 -0400
Subject: [PATCH 21/26] keyword with filters test

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index 5690ab7d9..c13918a20 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -46,14 +46,14 @@ def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
 
     @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
     def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentStore):
-        docs = [Document(content=f"Document {i}", embedding=rand(768).tolist()) for i in range(10)]
+        docs = [Document(content=f"Document {i} testing", embedding=rand(768).tolist()) for i in range(10)]
 
         for i in range(10):
             docs[i].meta["meta_field"] = "custom_value" if i % 2 == 0 else "other_value"
 
         document_store.write_documents(docs)
 
-        query = "value"
+        query = "Document"
         filters = {"field": "meta.meta_field", "operator": "==", "value": "custom_value"}
 
         results = document_store._keyword_retrieval(user_query=query, top_k=3, filters=filters)

From fb576f548ca96bc83b1b3c9dbd3c54141040df67 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Fri, 26 Apr 2024 19:32:08 -0400
Subject: [PATCH 22/26] keyword with filters test

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index c13918a20..de626ea55 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -58,5 +58,6 @@ def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentSt
 
         results = document_store._keyword_retrieval(user_query=query, top_k=3, filters=filters)
         assert len(results) == 3
-        for result in results:
-            assert result.meta["meta_field"] == "custom_value"
+        assert "meta_field" in results[0].meta
+        # for result in results:
+        #     assert result.meta["meta_field"] == "custom_value"

From f3ba516824354c3ab4cad3862e3fc6866baa40da Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Fri, 26 Apr 2024 19:43:35 -0400
Subject: [PATCH 23/26] keyword with filters test

---
 .../pgvector/tests/test_keyword_retrieval.py        | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index de626ea55..aa0baba8a 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -46,10 +46,15 @@ def test_keyword_retrieval(self, document_store: PgvectorDocumentStore):
 
     @pytest.mark.parametrize("document_store", ["document_store_keyword"], indirect=True)
     def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentStore):
-        docs = [Document(content=f"Document {i} testing", embedding=rand(768).tolist()) for i in range(10)]
-
-        for i in range(10):
-            docs[i].meta["meta_field"] = "custom_value" if i % 2 == 0 else "other_value"
+        docs = [
+            Document(
+                content="The quick brown fox chased the dog",
+                embedding=([0.1] * 768),
+                meta={"meta_field": "custom_value"},
+            ),
+            Document(content="The fox was brown", embedding=([0.1] * 768), meta={"meta_field": "custom_value"}),
+            Document(content="The lazy dog", embedding=([0.1] * 768), meta={"meta_field": "custom_value"}),
+        ]
 
         document_store.write_documents(docs)
 

From 1f692d9fc51df01899d731b1e59ad0d7af3a5129 Mon Sep 17 00:00:00 2001
From: jlonge4 <josh.longenecker1@gmail.com>
Date: Fri, 26 Apr 2024 19:46:55 -0400
Subject: [PATCH 24/26] keyword with filters test

---
 integrations/pgvector/tests/test_keyword_retrieval.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/integrations/pgvector/tests/test_keyword_retrieval.py b/integrations/pgvector/tests/test_keyword_retrieval.py
index aa0baba8a..2c64242c9 100644
--- a/integrations/pgvector/tests/test_keyword_retrieval.py
+++ b/integrations/pgvector/tests/test_keyword_retrieval.py
@@ -1,7 +1,6 @@
 import pytest
 from haystack.dataclasses.document import Document
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
-from numpy.random import rand
 
 
 @pytest.mark.integration
@@ -58,7 +57,7 @@ def test_keyword_retrieval_with_filters(self, document_store: PgvectorDocumentSt
 
         document_store.write_documents(docs)
 
-        query = "Document"
+        query = "fox"
         filters = {"field": "meta.meta_field", "operator": "==", "value": "custom_value"}
 
         results = document_store._keyword_retrieval(user_query=query, top_k=3, filters=filters)

From 6cebc36e3c50be1abc9e58fe48028c76358d36c8 Mon Sep 17 00:00:00 2001
From: anakin87 <stefanofiorucci@gmail.com>
Date: Wed, 8 May 2024 09:59:38 +0200
Subject: [PATCH 25/26] more tests

---
 integrations/pgvector/pyproject.toml          |   5 +
 .../retrievers/pgvector/__init__.py           |   3 +-
 .../pgvector/embedding_retriever.py           |   2 +-
 .../{ => pgvector}/keyword_retriever.py       |  47 ++++----
 .../pgvector/document_store.py                |  18 ++--
 integrations/pgvector/tests/conftest.py       |   4 +-
 .../{test_retriever.py => test_retrievers.py} | 100 +++++++++++++++++-
 7 files changed, 140 insertions(+), 39 deletions(-)
 rename integrations/pgvector/src/haystack_integrations/components/retrievers/{ => pgvector}/keyword_retriever.py (75%)
 rename integrations/pgvector/tests/{test_retriever.py => test_retrievers.py} (54%)

diff --git a/integrations/pgvector/pyproject.toml b/integrations/pgvector/pyproject.toml
index 39e2183cb..b440cf28e 100644
--- a/integrations/pgvector/pyproject.toml
+++ b/integrations/pgvector/pyproject.toml
@@ -174,6 +174,11 @@ exclude_lines = [
   "if TYPE_CHECKING:",
 ]
 
+[tool.pytest.ini_options]
+markers = [
+  "integration: integration tests"
+]
+
 
 [[tool.mypy.overrides]]
 module = [
diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/__init__.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/__init__.py
index ec0cf0dc4..ea9fa8fe7 100644
--- a/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/__init__.py
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/__init__.py
@@ -2,5 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 from .embedding_retriever import PgvectorEmbeddingRetriever
+from .keyword_retriever import PgvectorKeywordRetriever
 
-__all__ = ["PgvectorEmbeddingRetriever"]
+__all__ = ["PgvectorEmbeddingRetriever", "PgvectorKeywordRetriever"]
diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py
index 6085545cb..be894dcf7 100644
--- a/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/embedding_retriever.py
@@ -64,7 +64,7 @@ def __init__(
         vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
     ):
         """
-        :param document_store: An instance of `PgvectorDocumentStore}.
+        :param document_store: An instance of `PgvectorDocumentStore`.
         :param filters: Filters applied to the retrieved Documents.
         :param top_k: Maximum number of Documents to return.
         :param vector_function: The similarity function to use when searching for similar embeddings.
diff --git a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py
similarity index 75%
rename from integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
rename to integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py
index fb5da8ba6..c09ac9bb5 100644
--- a/integrations/pgvector/src/haystack_integrations/components/retrievers/keyword_retriever.py
+++ b/integrations/pgvector/src/haystack_integrations/components/retrievers/pgvector/keyword_retriever.py
@@ -11,43 +11,36 @@
 @component
 class PgvectorKeywordRetriever:
     """
-    Retrieves documents from the `PgvectorDocumentStore`, based on their sparse vectors.
+    Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 
-    Example usage:
+    To rank the documents, the `ts_rank_cd` function of PostgreSQL is used.
+    It considers how often the query terms appear in the document, how close together the terms are in the document,
+    and how important is the part of the document where they occur.
+    For more details, see
+    [Postgres documentation](https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-RANKING).
+
+    Usage example:
     ```python
     from haystack.document_stores import DuplicatePolicy
-    from haystack import Document, Pipeline
-    from haystack.components.embedders import SentenceTransformersTextEmbedder, SentenceTransformersDocumentEmbedder
+    from haystack import Document
 
     from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
-    from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever
+    from haystack_integrations.components.retrievers.pgvector import PgvectorKeywordRetriever
 
     # Set an environment variable `PG_CONN_STR` with the connection string to your PostgreSQL database.
     # e.g., "postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"
 
-    document_store = PgvectorDocumentStore(
-    embedding_dimension=768,
-    vector_function="cosine_similarity",
-    recreate_table=True,
-    )
+    document_store = PgvectorDocumentStore(language="english", recreate_table=True)
 
     documents = [Document(content="There are over 7,000 languages spoken around the world today."),
         Document(content="Elephants have been observed to behave in a way that indicates..."),
         Document(content="In certain places, you can witness the phenomenon of bioluminescent waves.")]
 
-    document_embedder = SentenceTransformersDocumentEmbedder()
-    document_embedder.warm_up()
-    documents_with_embeddings = document_embedder.run(documents)
-
     document_store.write_documents(documents_with_embeddings.get("documents"), policy=DuplicatePolicy.OVERWRITE)
 
-    query_pipeline = Pipeline()
-    query_pipeline.add_component("retriever", PgvectorKeywordRetriever(document_store=document_store))
-    query_pipeline.connect("query", "retriever.query")
-
-    query = "How many languages are there?"
+    retriever = PgvectorKeywordRetriever(document_store=document_store)
 
-    res = query_pipeline.run({"retriever": {"text": query}})
+    result = retriever.run(query="languages")
 
     assert res['retriever']['documents'][0].content == "There are over 7,000 languages spoken around the world today."
     """
@@ -60,12 +53,11 @@ def __init__(
         top_k: int = 10,
     ):
         """
-        :param document_store: An instance of `PgvectorDocumentStore}.
+        :param document_store: An instance of `PgvectorDocumentStore`.
         :param filters: Filters applied to the retrieved Documents.
         :param top_k: Maximum number of Documents to return.
 
-        :raises ValueError: If `document_store` is not an instance of `PgvectorDocumentStore` or if `vector_function`
-            is not one of the valid options.
+        :raises ValueError: If `document_store` is not an instance of `PgvectorDocumentStore`.
         """
         if not isinstance(document_store, PgvectorDocumentStore):
             msg = "document_store must be an instance of PgvectorDocumentStore"
@@ -106,24 +98,25 @@ def from_dict(cls, data: Dict[str, Any]) -> "PgvectorKeywordRetriever":
     @component.output_types(documents=List[Document])
     def run(
         self,
-        user_query: str,
+        query: str,
         filters: Optional[Dict[str, Any]] = None,
         top_k: Optional[int] = None,
     ):
         """
         Retrieve documents from the `PgvectorDocumentStore`, based on keywords.
 
-        :param user_input: The user's query.
+        :param query: String to search in `Document`s' content.
         :param filters: Filters applied to the retrieved Documents.
         :param top_k: Maximum number of Documents to return.
 
-        :returns: List of Documents similar to `user_query`.
+        :returns: A dictionary with the following keys:
+            - `documents`: List of `Document`s that match the query.
         """
         filters = filters or self.filters
         top_k = top_k or self.top_k
 
         docs = self.document_store._keyword_retrieval(
-            query=user_query,
+            query=query,
             filters=filters,
             top_k=top_k,
         )
diff --git a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
index 8330cc487..bb663f936 100644
--- a/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
+++ b/integrations/pgvector/src/haystack_integrations/document_stores/pgvector/document_store.py
@@ -84,6 +84,7 @@ def __init__(
         *,
         connection_string: Secret = Secret.from_env_var("PG_CONN_STR"),
         table_name: str = "haystack_documents",
+        language: str = "english",
         embedding_dimension: int = 768,
         vector_function: Literal["cosine_similarity", "inner_product", "l2_distance"] = "cosine_similarity",
         recreate_table: bool = False,
@@ -91,7 +92,6 @@ def __init__(
         hnsw_recreate_index_if_exists: bool = False,
         hnsw_index_creation_kwargs: Optional[Dict[str, int]] = None,
         hnsw_ef_search: Optional[int] = None,
-        language: str = "english",
     ):
         """
         Creates a new PgvectorDocumentStore instance.
@@ -101,6 +101,10 @@ def __init__(
         :param connection_string: The connection string to use to connect to the PostgreSQL database, defined as an
             environment variable, e.g.: `PG_CONN_STR="postgresql://USER:PASSWORD@HOST:PORT/DB_NAME"`
         :param table_name: The name of the table to use to store Haystack documents.
+        :param language: The language to be used to parse query and document content in keyword retrieval.
+            To see the list of available languages, you can run the following SQL query in your PostgreSQL database:
+            `SELECT cfgname FROM pg_ts_config;`.
+            More information can be found in this [StackOverflow answer](https://stackoverflow.com/a/39752553).
         :param embedding_dimension: The dimension of the embedding.
         :param vector_function: The similarity function to use when searching for similar embeddings.
             `"cosine_similarity"` and `"inner_product"` are similarity functions and
@@ -125,8 +129,7 @@ def __init__(
             [pgvector documentation](https://github.com/pgvector/pgvector?tab=readme-ov-file#hnsw)
         :param hnsw_ef_search: The `ef_search` parameter to use at query time. Only used if search_strategy is set to
             `"hnsw"`. You can find more information about this parameter in the
-            [pgvector documentation](https://github.com/pgvector/pgvector?tab=readme-ov-file#hnsw)
-        :param language: The language to use for the full-text/hybrid search.
+            [pgvector documentation](https://github.com/pgvector/pgvector?tab=readme-ov-file#hnsw).
         """
 
         self.connection_string = connection_string
@@ -157,7 +160,7 @@ def __init__(
         if recreate_table:
             self.delete_table()
         self._create_table_if_not_exists()
-        self._create_keyword_index()
+        self._create_keyword_index_if_not_exists()
 
         if search_strategy == "hnsw":
             self._handle_hnsw()
@@ -244,7 +247,7 @@ def delete_table(self):
 
         self._execute_sql(delete_sql, error_msg=f"Could not delete table {self.table_name} in PgvectorDocumentStore")
 
-    def _create_keyword_index(self):
+    def _create_keyword_index_if_not_exists(self):
         """
         Internal method to create the keyword index if not exists.
         """
@@ -544,9 +547,9 @@ def _keyword_retrieval(
                 filters=filters, operator="AND"
             )
 
-        sql_top_k = SQL(" ORDER BY score DESC LIMIT {top_k}").format(top_k=SQLLiteral(top_k))
+        sql_sort = SQL(" ORDER BY score DESC LIMIT {top_k}").format(top_k=SQLLiteral(top_k))
 
-        sql_query = sql_select + sql_where_clause + sql_top_k
+        sql_query = sql_select + sql_where_clause + sql_sort
 
         result = self._execute_sql(
             sql_query,
@@ -573,6 +576,7 @@ def _embedding_retrieval(
         This method is not meant to be part of the public interface of
         `PgvectorDocumentStore` and it should not be called directly.
         `PgvectorEmbeddingRetriever` uses this method directly and is the public interface for it.
+
         :returns: List of Documents that are most similar to `query_embedding`
         """
 
diff --git a/integrations/pgvector/tests/conftest.py b/integrations/pgvector/tests/conftest.py
index 94b35a04d..6547db9eb 100644
--- a/integrations/pgvector/tests/conftest.py
+++ b/integrations/pgvector/tests/conftest.py
@@ -36,10 +36,12 @@ def patches_for_unit_tests():
     ) as mock_delete, patch(
         "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore._create_table_if_not_exists"
     ) as mock_create, patch(
+        "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore._create_keyword_index_if_not_exists"
+    ) as mock_create_kw_index, patch(
         "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore._handle_hnsw"
     ) as mock_hnsw:
 
-        yield mock_connect, mock_register, mock_delete, mock_create, mock_hnsw
+        yield mock_connect, mock_register, mock_delete, mock_create, mock_create_kw_index, mock_hnsw
 
 
 @pytest.fixture
diff --git a/integrations/pgvector/tests/test_retriever.py b/integrations/pgvector/tests/test_retrievers.py
similarity index 54%
rename from integrations/pgvector/tests/test_retriever.py
rename to integrations/pgvector/tests/test_retrievers.py
index 8a14cff73..ef6f918ed 100644
--- a/integrations/pgvector/tests/test_retriever.py
+++ b/integrations/pgvector/tests/test_retrievers.py
@@ -6,11 +6,11 @@
 import pytest
 from haystack.dataclasses import Document
 from haystack.utils.auth import EnvVarSecret
-from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever
+from haystack_integrations.components.retrievers.pgvector import PgvectorEmbeddingRetriever, PgvectorKeywordRetriever
 from haystack_integrations.document_stores.pgvector import PgvectorDocumentStore
 
 
-class TestRetriever:
+class TestEmbeddingRetriever:
     def test_init_default(self, mock_store):
         retriever = PgvectorEmbeddingRetriever(document_store=mock_store)
         assert retriever.document_store == mock_store
@@ -115,3 +115,99 @@ def test_run(self):
         )
 
         assert res == {"documents": [doc]}
+
+
+class TestKeywordRetriever:
+    def test_init_default(self, mock_store):
+        retriever = PgvectorKeywordRetriever(document_store=mock_store)
+        assert retriever.document_store == mock_store
+        assert retriever.filters == {}
+        assert retriever.top_k == 10
+
+    def test_init(self, mock_store):
+        retriever = PgvectorKeywordRetriever(document_store=mock_store, filters={"field": "value"}, top_k=5)
+        assert retriever.document_store == mock_store
+        assert retriever.filters == {"field": "value"}
+        assert retriever.top_k == 5
+
+    def test_to_dict(self, mock_store):
+        retriever = PgvectorKeywordRetriever(document_store=mock_store, filters={"field": "value"}, top_k=5)
+        res = retriever.to_dict()
+        t = "haystack_integrations.components.retrievers.pgvector.keyword_retriever.PgvectorKeywordRetriever"
+        assert res == {
+            "type": t,
+            "init_parameters": {
+                "document_store": {
+                    "type": "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore",
+                    "init_parameters": {
+                        "connection_string": {"env_vars": ["PG_CONN_STR"], "strict": True, "type": "env_var"},
+                        "table_name": "haystack",
+                        "embedding_dimension": 768,
+                        "vector_function": "cosine_similarity",
+                        "recreate_table": True,
+                        "search_strategy": "exact_nearest_neighbor",
+                        "hnsw_recreate_index_if_exists": False,
+                        "language": "english",
+                        "hnsw_index_creation_kwargs": {},
+                        "hnsw_ef_search": None,
+                    },
+                },
+                "filters": {"field": "value"},
+                "top_k": 5,
+            },
+        }
+
+    @pytest.mark.usefixtures("patches_for_unit_tests")
+    def test_from_dict(self, monkeypatch):
+        monkeypatch.setenv("PG_CONN_STR", "some-connection-string")
+        t = "haystack_integrations.components.retrievers.pgvector.keyword_retriever.PgvectorKeywordRetriever"
+        data = {
+            "type": t,
+            "init_parameters": {
+                "document_store": {
+                    "type": "haystack_integrations.document_stores.pgvector.document_store.PgvectorDocumentStore",
+                    "init_parameters": {
+                        "connection_string": {"env_vars": ["PG_CONN_STR"], "strict": True, "type": "env_var"},
+                        "table_name": "haystack_test_to_dict",
+                        "embedding_dimension": 768,
+                        "vector_function": "cosine_similarity",
+                        "recreate_table": True,
+                        "search_strategy": "exact_nearest_neighbor",
+                        "hnsw_recreate_index_if_exists": False,
+                        "hnsw_index_creation_kwargs": {},
+                        "hnsw_ef_search": None,
+                    },
+                },
+                "filters": {"field": "value"},
+                "top_k": 5,
+            },
+        }
+
+        retriever = PgvectorKeywordRetriever.from_dict(data)
+        document_store = retriever.document_store
+
+        assert isinstance(document_store, PgvectorDocumentStore)
+        assert isinstance(document_store.connection_string, EnvVarSecret)
+        assert document_store.table_name == "haystack_test_to_dict"
+        assert document_store.embedding_dimension == 768
+        assert document_store.vector_function == "cosine_similarity"
+        assert document_store.recreate_table
+        assert document_store.search_strategy == "exact_nearest_neighbor"
+        assert not document_store.hnsw_recreate_index_if_exists
+        assert document_store.hnsw_index_creation_kwargs == {}
+        assert document_store.hnsw_ef_search is None
+
+        assert retriever.filters == {"field": "value"}
+        assert retriever.top_k == 5
+
+    def test_run(self):
+        mock_store = Mock(spec=PgvectorDocumentStore)
+        doc = Document(content="Test doc", embedding=[0.1, 0.2])
+        mock_store._keyword_retrieval.return_value = [doc]
+
+        retriever = PgvectorKeywordRetriever(document_store=mock_store)
+        res = retriever.run(query="test query")
+
+        mock_store._keyword_retrieval.assert_called_once_with(query="test query", filters={}, top_k=10)
+
+        assert res == {"documents": [doc]}

From 4cfed5289e5ed4edd12e3e37a6f78c896b19b195 Mon Sep 17 00:00:00 2001
From: anakin87 <stefanofiorucci@gmail.com>
Date: Wed, 8 May 2024 10:04:30 +0200
Subject: [PATCH 26/26] rename example

---
 .../pgvector/examples/{example.py => embedding_retrieval.py}      | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename integrations/pgvector/examples/{example.py => embedding_retrieval.py} (100%)

diff --git a/integrations/pgvector/examples/example.py b/integrations/pgvector/examples/embedding_retrieval.py
similarity index 100%
rename from integrations/pgvector/examples/example.py
rename to integrations/pgvector/examples/embedding_retrieval.py