pgvector-haystack 3.0.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

haystack_integrations/components/retrievers/pgvector/embedding_retriever.py

@@ -151,7 +151,8 @@ class PgvectorEmbeddingRetriever:
         :param top_k: Maximum number of Documents to return.
         :param vector_function: The similarity function to use when searching for similar embeddings.
 
-        :returns: List of Documents similar to `query_embedding`.
+        :returns: A dictionary with the following keys:
+            - `documents`: List of `Document`s that are similar to `query_embedding`.
         """
         filters = apply_filter_policy(self.filter_policy, self.filters, filters)
         top_k = top_k or self.top_k
@@ -164,3 +165,36 @@ class PgvectorEmbeddingRetriever:
             vector_function=vector_function,
         )
         return {"documents": docs}
+
+    @component.output_types(documents=List[Document])
+    async def run_async(
+        self,
+        query_embedding: List[float],
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+    ):
+        """
+        Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on their embeddings.
+
+        :param query_embedding: Embedding of the query.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
+        :param top_k: Maximum number of Documents to return.
+        :param vector_function: The similarity function to use when searching for similar embeddings.
+
+        :returns: A dictionary with the following keys:
+            - `documents`: List of `Document`s that are similar to `query_embedding`.
+        """
+        filters = apply_filter_policy(self.filter_policy, self.filters, filters)
+        top_k = top_k or self.top_k
+        vector_function = vector_function or self.vector_function
+
+        docs = await self.document_store._embedding_retrieval_async(
+            query_embedding=query_embedding,
+            filters=filters,
+            top_k=top_k,
+            vector_function=vector_function,
+        )
+        return {"documents": docs}

haystack_integrations/components/retrievers/pgvector/keyword_retriever.py

@@ -136,3 +136,33 @@ class PgvectorKeywordRetriever:
             top_k=top_k,
         )
         return {"documents": docs}
+
+    @component.output_types(documents=List[Document])
+    async def run_async(
+        self,
+        query: str,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+    ):
+        """
+        Asynchronously retrieve documents from the `PgvectorDocumentStore`, based on keywords.
+
+        :param query: String to search in `Document`s' content.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
+        :param top_k: Maximum number of Documents to return.
+
+        :returns: A dictionary with the following keys:
+            - `documents`: List of `Document`s that match the query.
+        """
+        filters = apply_filter_policy(self.filter_policy, self.filters, filters)
+
+        top_k = top_k or self.top_k
+
+        docs = await self.document_store._keyword_retrieval_async(
+            query=query,
+            filters=filters,
+            top_k=top_k,
+        )
+        return {"documents": docs}

haystack_integrations/document_stores/pgvector/converters.py

@@ -0,0 +1,65 @@
+from typing import Any, Dict, List
+
+from haystack import logging
+from haystack.dataclasses import ByteStream, Document
+from psycopg.types.json import Jsonb
+
+logger = logging.getLogger(__name__)
+
+
+def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str, Any]]:
+    """
+    Internal method to convert a list of Haystack Documents to a list of dictionaries that can be used to insert
+    documents into the PgvectorDocumentStore.
+    """
+
+    db_documents = []
+    for document in documents:
+        db_document = {k: v for k, v in document.to_dict(flatten=False).items() if k not in ["score", "blob"]}
+
+        blob = document.blob
+        db_document["blob_data"] = blob.data if blob else None
+        db_document["blob_meta"] = Jsonb(blob.meta) if blob and blob.meta else None
+        db_document["blob_mime_type"] = blob.mime_type if blob and blob.mime_type 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 {doc_id} has the `sparse_embedding` field set,"
+                    "but storing sparse embeddings in Pgvector is not currently supported."
+                    "The `sparse_embedding` field will be ignored.",
+                    doc_id=db_document["id"],
+                )
+
+        db_documents.append(db_document)
+
+    return db_documents
+
+
+def _from_pg_to_haystack_documents(documents: List[Dict[str, Any]]) -> List[Document]:
+    """
+    Internal method to convert a list of dictionaries from pgvector to a list of Haystack Documents.
+    """
+
+    haystack_documents = []
+    for document in documents:
+        haystack_dict = dict(document)
+        blob_data = haystack_dict.pop("blob_data")
+        blob_meta = haystack_dict.pop("blob_meta")
+        blob_mime_type = haystack_dict.pop("blob_mime_type")
+
+        # convert the embedding to a list of floats
+        if document.get("embedding") is not None:
+            haystack_dict["embedding"] = document["embedding"].tolist()
+
+        haystack_document = Document.from_dict(haystack_dict)
+
+        if blob_data:
+            blob = ByteStream(data=blob_data, meta=blob_meta, mime_type=blob_mime_type)
+            haystack_document.blob = blob
+
+        haystack_documents.append(haystack_document)
+
+    return haystack_documents

haystack_integrations/document_stores/pgvector/document_store.py

@@ -4,26 +4,27 @@
 from typing import Any, Dict, List, Literal, Optional
 
 from haystack import default_from_dict, default_to_dict, logging
-from haystack.dataclasses.document import ByteStream, Document
+from haystack.dataclasses.document import Document
 from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.utils.auth import Secret, deserialize_secrets_inplace
-from psycopg import Error, IntegrityError, connect
+from psycopg import AsyncConnection, Connection, Error, IntegrityError
 from psycopg.abc import Query
+from psycopg.connection_async import AsyncCursor
 from psycopg.cursor import Cursor
 from psycopg.rows import dict_row
 from psycopg.sql import SQL, Identifier
 from psycopg.sql import Literal as SQLLiteral
-from psycopg.types.json import Jsonb
 
-from pgvector.psycopg import register_vector
+from pgvector.psycopg import register_vector, register_vector_async
 
-from .filters import _convert_filters_to_where_clause_and_params
+from .converters import _from_haystack_to_pg_documents, _from_pg_to_haystack_documents
+from .filters import _convert_filters_to_where_clause_and_params, _validate_filters
 
 logger = logging.getLogger(__name__)
 
 CREATE_TABLE_STATEMENT = """
-CREATE TABLE IF NOT EXISTS {schema_name}.{table_name} (
+CREATE TABLE {schema_name}.{table_name} (
 id VARCHAR(128) PRIMARY KEY,
 embedding VECTOR({embedding_dimension}),
 content TEXT,
@@ -156,90 +157,15 @@ class PgvectorDocumentStore:
         self.hnsw_ef_search = hnsw_ef_search
         self.keyword_index_name = keyword_index_name
         self.language = language
+
         self._connection = None
+        self._async_connection = None
         self._cursor = None
+        self._async_cursor = None
         self._dict_cursor = None
+        self._async_dict_cursor = None
         self._table_initialized = False
 
-    @property
-    def cursor(self):
-        if self._cursor is None or not self._connection_is_valid(self._connection):
-            self._create_connection()
-
-        return self._cursor
-
-    @property
-    def dict_cursor(self):
-        if self._dict_cursor is None or not self._connection_is_valid(self._connection):
-            self._create_connection()
-
-        return self._dict_cursor
-
-    @property
-    def connection(self):
-        if self._connection is None or not self._connection_is_valid(self._connection):
-            self._create_connection()
-
-        return self._connection
-
-    def _create_connection(self):
-        """
-        Internal method to create a connection to the PostgreSQL database.
-        """
-
-        # close the connection if it already exists
-        if self._connection:
-            try:
-                self._connection.close()
-            except Error as e:
-                logger.debug("Failed to close connection: {e}", e=str(e))
-
-        conn_str = self.connection_string.resolve_value() or ""
-        connection = connect(conn_str)
-        connection.autocommit = True
-        if self.create_extension:
-            connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
-        register_vector(connection)  # Note: this must be called before creating the cursors.
-
-        self._connection = connection
-        self._cursor = self._connection.cursor()
-        self._dict_cursor = self._connection.cursor(row_factory=dict_row)
-
-        if not self._table_initialized:
-            self._initialize_table()
-
-        return self._connection
-
-    def _initialize_table(self):
-        """
-        Internal method to initialize the table.
-        """
-        if self.recreate_table:
-            self.delete_table()
-
-        self._create_table_if_not_exists()
-        self._create_keyword_index_if_not_exists()
-
-        if self.search_strategy == "hnsw":
-            self._handle_hnsw()
-
-        self._table_initialized = True
-
-    @staticmethod
-    def _connection_is_valid(connection):
-        """
-        Internal method to check if the connection is still valid.
-        """
-
-        # implementation inspired to psycopg pool
-        # https://github.com/psycopg/psycopg/blob/d38cf7798b0c602ff43dac9f20bbab96237a9c38/psycopg_pool/psycopg_pool/pool.py#L528
-
-        try:
-            connection.execute("")
-        except Error:
-            return False
-        return True
-
     def to_dict(self) -> Dict[str, Any]:
         """
         Serializes the component to a dictionary.
@@ -278,6 +204,32 @@ class PgvectorDocumentStore:
         deserialize_secrets_inplace(data["init_parameters"], ["connection_string"])
         return default_from_dict(cls, data)
 
+    @staticmethod
+    def _connection_is_valid(connection):
+        """
+        Internal method to check if the connection is still valid.
+        """
+
+        # implementation inspired to psycopg pool
+        # https://github.com/psycopg/psycopg/blob/d38cf7798b0c602ff43dac9f20bbab96237a9c38/psycopg_pool/psycopg_pool/pool.py#L528
+
+        try:
+            connection.execute("")
+        except Error:
+            return False
+        return True
+
+    @staticmethod
+    async def _connection_is_valid_async(connection):
+        """
+        Internal method to check if the async connection is still valid.
+        """
+        try:
+            await connection.execute("")
+        except Error:
+            return False
+        return True
+
     def _execute_sql(
         self, sql_query: Query, params: Optional[tuple] = None, error_msg: str = "", cursor: Optional[Cursor] = None
     ):
@@ -287,11 +239,18 @@ class PgvectorDocumentStore:
         :param sql_query: The SQL query to execute.
         :param params: The parameters to pass to the SQL query.
         :param error_msg: The error message to use if an exception is raised.
-        :param cursor: The cursor to use to execute the SQL query. Defaults to self.cursor.
+        :param cursor: The cursor to use to execute the SQL query. Defaults to self._cursor.
         """
 
         params = params or ()
-        cursor = cursor or self.cursor
+        cursor = cursor or self._cursor
+
+        if cursor is None or self._connection is None:
+            message = (
+                "The cursor or the connection is not initialized. "
+                "Make sure to call _ensure_db_setup() before calling this method."
+            )
+            raise ValueError(message)
 
         sql_query_str = sql_query.as_string(cursor) if not isinstance(sql_query, str) else sql_query
         logger.debug("SQL query: {query}\nParameters: {parameters}", query=sql_query_str, parameters=params)
@@ -299,24 +258,215 @@ class PgvectorDocumentStore:
         try:
             result = cursor.execute(sql_query, params)
         except Error as e:
-            self.connection.rollback()
+            self._connection.rollback()
             detailed_error_msg = f"{error_msg}.\nYou can find the SQL query and the parameters in the debug logs."
             raise DocumentStoreError(detailed_error_msg) from e
 
         return result
 
-    def _create_table_if_not_exists(self):
+    async def _execute_sql_async(
+        self,
+        sql_query: Query,
+        params: Optional[tuple] = None,
+        error_msg: str = "",
+        cursor: Optional[AsyncCursor] = None,
+    ):
         """
-        Creates the table to store Haystack documents if it doesn't exist yet.
+        Internal method to asynchronously execute SQL statements and handle exceptions.
+
+        :param sql_query: The SQL query to execute.
+        :param params: The parameters to pass to the SQL query.
+        :param error_msg: The error message to use if an exception is raised.
+        :param cursor: The cursor to use to execute the SQL query. Defaults to self._async_cursor.
         """
 
-        create_sql = SQL(CREATE_TABLE_STATEMENT).format(
+        params = params or ()
+        cursor = cursor or self._async_cursor
+
+        if cursor is None or self._async_connection is None:
+            message = (
+                "The cursor or the connection is not initialized. "
+                "Make sure to call _ensure_db_setup_async() before calling this method."
+            )
+            raise ValueError(message)
+
+        sql_query_str = sql_query.as_string(cursor) if not isinstance(sql_query, str) else sql_query
+        logger.debug("SQL query: {query}\nParameters: {parameters}", query=sql_query_str, parameters=params)
+
+        try:
+            result = await cursor.execute(sql_query, params)
+        except Error as e:
+            await self._async_connection.rollback()
+            detailed_error_msg = f"{error_msg}.\nYou can find the SQL query and the parameters in the debug logs."
+            raise DocumentStoreError(detailed_error_msg) from e
+
+        return result
+
+    def _ensure_db_setup(self):
+        """
+        Ensures that the connection to the PostgreSQL database exists and is valid.
+        If not, connection and cursors are created.
+        If the table is not initialized, it will be set up.
+        """
+        if self._connection and self._cursor and self._dict_cursor and self._connection_is_valid(self._connection):
+            return
+
+        # close the connection if it already exists
+        if self._connection:
+            try:
+                self._connection.close()
+            except Error as e:
+                logger.debug("Failed to close connection: {e}", e=str(e))
+
+        conn_str = self.connection_string.resolve_value() or ""
+        connection = Connection.connect(conn_str)
+        connection.autocommit = True
+        if self.create_extension:
+            connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
+        register_vector(connection)  # Note: this must be called before creating the cursors.
+
+        self._connection = connection
+        self._cursor = self._connection.cursor()
+        self._dict_cursor = self._connection.cursor(row_factory=dict_row)
+
+        if not self._table_initialized:
+            self._initialize_table()
+
+    async def _ensure_db_setup_async(self):
+        """
+        Async internal method.
+        Ensures that the connection to the PostgreSQL database exists and is valid.
+        If not, connection and cursors are created.
+        If the table is not initialized, it will be set up.
+        """
+
+        if (
+            self._async_connection
+            and self._async_cursor
+            and self._async_dict_cursor
+            and await self._connection_is_valid_async(self._async_connection)
+        ):
+            return
+
+        # close the connection if it already exists
+        if self._async_connection:
+            await self._async_connection.close()
+
+        conn_str = self.connection_string.resolve_value() or ""
+        async_connection = await AsyncConnection.connect(conn_str)
+        await async_connection.set_autocommit(True)
+        if self.create_extension:
+            await async_connection.execute("CREATE EXTENSION IF NOT EXISTS vector")
+        await register_vector_async(async_connection)  # Note: this must be called before creating the cursors.
+
+        self._async_connection = async_connection
+        self._async_cursor = self._async_connection.cursor()
+        self._async_dict_cursor = self._async_connection.cursor(row_factory=dict_row)
+
+        if not self._table_initialized:
+            await self._initialize_table_async()
+
+    def _build_table_creation_queries(self):
+        """
+        Internal method to build the SQL queries for table creation.
+        """
+
+        sql_table_exists = SQL("SELECT 1 FROM pg_tables WHERE schemaname = %s AND tablename = %s")
+        sql_create_table = SQL(CREATE_TABLE_STATEMENT).format(
             schema_name=Identifier(self.schema_name),
             table_name=Identifier(self.table_name),
             embedding_dimension=SQLLiteral(self.embedding_dimension),
         )
 
-        self._execute_sql(create_sql, error_msg="Could not create table in PgvectorDocumentStore")
+        sql_keyword_index_exists = SQL(
+            "SELECT 1 FROM pg_indexes WHERE schemaname = %s AND tablename = %s AND indexname = %s"
+        )
+        sql_create_keyword_index = SQL(
+            "CREATE INDEX {index_name} ON {schema_name}.{table_name} USING GIN (to_tsvector({language}, content))"
+        ).format(
+            schema_name=Identifier(self.schema_name),
+            index_name=Identifier(self.keyword_index_name),
+            table_name=Identifier(self.table_name),
+            language=SQLLiteral(self.language),
+        )
+
+        return sql_table_exists, sql_create_table, sql_keyword_index_exists, sql_create_keyword_index
+
+    def _initialize_table(self):
+        """
+        Internal method to initialize the table.
+        """
+        if self.recreate_table:
+            self.delete_table()
+
+        sql_table_exists, sql_create_table, sql_keyword_index_exists, sql_create_keyword_index = (
+            self._build_table_creation_queries()
+        )
+
+        table_exists = bool(
+            self._execute_sql(
+                sql_table_exists, (self.schema_name, self.table_name), "Could not check if table exists"
+            ).fetchone()
+        )
+        if not table_exists:
+            self._execute_sql(sql_create_table, error_msg="Could not create table")
+
+        index_exists = bool(
+            self._execute_sql(
+                sql_keyword_index_exists,
+                (self.schema_name, self.table_name, self.keyword_index_name),
+                "Could not check if keyword index exists",
+            ).fetchone()
+        )
+        if not index_exists:
+            self._execute_sql(sql_create_keyword_index, error_msg="Could not create keyword index on table")
+
+        if self.search_strategy == "hnsw":
+            self._handle_hnsw()
+
+        self._table_initialized = True
+
+    async def _initialize_table_async(self):
+        """
+        Internal async method to initialize the table.
+        """
+        if self.recreate_table:
+            await self.delete_table_async()
+
+        sql_table_exists, sql_create_table, sql_keyword_index_exists, sql_create_keyword_index = (
+            self._build_table_creation_queries()
+        )
+
+        table_exists = bool(
+            await (
+                await self._execute_sql_async(
+                    sql_table_exists,
+                    (self.schema_name, self.table_name),
+                    "Could not check if table exists",
+                    self._async_cursor,
+                )
+            ).fetchone()
+        )
+        if not table_exists:
+            await self._execute_sql_async(sql_create_table, error_msg="Could not create table")
+
+        index_exists = bool(
+            await (
+                await self._execute_sql_async(
+                    sql_keyword_index_exists,
+                    (self.schema_name, self.table_name, self.keyword_index_name),
+                    "Could not check if keyword index exists",
+                    self._async_cursor,
+                )
+            ).fetchone()
+        )
+        if not index_exists:
+            await self._execute_sql_async(sql_create_keyword_index, error_msg="Could not create keyword index on table")
+
+        if self.search_strategy == "hnsw":
+            await self._handle_hnsw_async()
+
+        self._table_initialized = True
 
     def delete_table(self):
         """
@@ -334,29 +484,58 @@ class PgvectorDocumentStore:
             error_msg=f"Could not delete table {self.schema_name}.{self.table_name} in PgvectorDocumentStore",
         )
 
-    def _create_keyword_index_if_not_exists(self):
+    async def delete_table_async(self):
         """
-        Internal method to create the keyword index if not exists.
+        Async method to delete the table used to store Haystack documents.
         """
-        index_exists = bool(
-            self._execute_sql(
-                "SELECT 1 FROM pg_indexes WHERE schemaname = %s AND tablename = %s AND indexname = %s",
-                (self.schema_name, self.table_name, self.keyword_index_name),
-                "Could not check if keyword index exists",
-            ).fetchone()
+        delete_sql = SQL("DROP TABLE IF EXISTS {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
         )
 
-        sql_create_index = SQL(
-            "CREATE INDEX {index_name} ON {schema_name}.{table_name} USING GIN (to_tsvector({language}, content))"
+        await self._execute_sql_async(
+            delete_sql,
+            error_msg=f"Could not delete table {self.schema_name}.{self.table_name} in PgvectorDocumentStore",
+        )
+
+    def _build_hnsw_queries(self):
+        """Common method to build all HNSW-related SQL queries"""
+
+        sql_set_hnsw_ef_search = (
+            SQL("SET hnsw.ef_search = {hnsw_ef_search}").format(hnsw_ef_search=SQLLiteral(self.hnsw_ef_search))
+            if self.hnsw_ef_search
+            else None
+        )
+
+        sql_hnsw_index_exists = SQL(
+            "SELECT 1 FROM pg_indexes WHERE schemaname = %s AND tablename = %s AND indexname = %s"
+        )
+
+        sql_drop_hnsw_index = SQL("DROP INDEX IF EXISTS {schema_name}.{index_name}").format(
+            schema_name=Identifier(self.schema_name),
+            index_name=Identifier(self.hnsw_index_name),
+        )
+
+        pg_ops = VECTOR_FUNCTION_TO_POSTGRESQL_OPS[self.vector_function]
+
+        sql_create_hnsw_index = SQL(
+            "CREATE INDEX {index_name} ON {schema_name}.{table_name} USING hnsw (embedding {ops})"
         ).format(
             schema_name=Identifier(self.schema_name),
-            index_name=Identifier(self.keyword_index_name),
+            index_name=Identifier(self.hnsw_index_name),
             table_name=Identifier(self.table_name),
-            language=SQLLiteral(self.language),
+            ops=SQL(pg_ops),
         )
 
-        if not index_exists:
-            self._execute_sql(sql_create_index, error_msg="Could not create keyword index on table")
+        # Add creation kwargs if any valid ones exist
+        valid_kwargs = {
+            k: v for k, v in self.hnsw_index_creation_kwargs.items() if k in HNSW_INDEX_CREATION_VALID_KWARGS
+        }
+        if valid_kwargs:
+            kwargs_str = ", ".join(f"{k} = {v}" for k, v in valid_kwargs.items())
+            sql_create_hnsw_index += SQL(" WITH ({})").format(SQL(kwargs_str))
+
+        return sql_set_hnsw_ef_search, sql_hnsw_index_exists, sql_drop_hnsw_index, sql_create_hnsw_index
 
     def _handle_hnsw(self):
         """
@@ -364,15 +543,16 @@ class PgvectorDocumentStore:
         It also sets the `hnsw.ef_search` parameter for queries if it is specified.
         """
 
+        sql_set_hnsw_ef_search, sql_hnsw_index_exists, sql_drop_hnsw_index, sql_create_hnsw_index = (
+            self._build_hnsw_queries()
+        )
+
         if self.hnsw_ef_search:
-            sql_set_hnsw_ef_search = SQL("SET hnsw.ef_search = {hnsw_ef_search}").format(
-                hnsw_ef_search=SQLLiteral(self.hnsw_ef_search)
-            )
             self._execute_sql(sql_set_hnsw_ef_search, error_msg="Could not set hnsw.ef_search")
 
         index_exists = bool(
             self._execute_sql(
-                "SELECT 1 FROM pg_indexes WHERE schemaname = %s AND tablename = %s AND indexname = %s",
+                sql_hnsw_index_exists,
                 (self.schema_name, self.table_name, self.hnsw_index_name),
                 "Could not check if HNSW index exists",
             ).fetchone()
@@ -386,59 +566,81 @@ class PgvectorDocumentStore:
             )
             return
 
-        sql_drop_index = SQL("DROP INDEX IF EXISTS {schema_name}.{index_name}").format(
-            schema_name=Identifier(self.schema_name), index_name=Identifier(self.hnsw_index_name)
-        )
-        self._execute_sql(sql_drop_index, error_msg="Could not drop HNSW index")
+        self._execute_sql(sql_drop_hnsw_index, error_msg="Could not drop HNSW index")
 
-        self._create_hnsw_index()
+        self._execute_sql(sql_create_hnsw_index, error_msg="Could not create HNSW index")
 
-    def _create_hnsw_index(self):
+    async def _handle_hnsw_async(self):
         """
-        Internal method to create the HNSW index.
+        Internal async method to handle the HNSW index creation.
         """
 
-        pg_ops = VECTOR_FUNCTION_TO_POSTGRESQL_OPS[self.vector_function]
-        actual_hnsw_index_creation_kwargs = {
-            key: value
-            for key, value in self.hnsw_index_creation_kwargs.items()
-            if key in HNSW_INDEX_CREATION_VALID_KWARGS
-        }
+        sql_set_hnsw_ef_search, sql_hnsw_index_exists, sql_drop_hnsw_index, sql_create_hnsw_index = (
+            self._build_hnsw_queries()
+        )
 
-        sql_create_index = SQL(
-            "CREATE INDEX {index_name} ON {schema_name}.{table_name} USING hnsw (embedding {ops}) "
-        ).format(
-            schema_name=Identifier(self.schema_name),
-            index_name=Identifier(self.hnsw_index_name),
-            table_name=Identifier(self.table_name),
-            ops=SQL(pg_ops),
+        if self.hnsw_ef_search:
+            await self._execute_sql_async(sql_set_hnsw_ef_search, error_msg="Could not set hnsw.ef_search")
+
+        index_exists = bool(
+            await (
+                await self._execute_sql_async(
+                    sql_hnsw_index_exists,
+                    (self.schema_name, self.table_name, self.hnsw_index_name),
+                    "Could not check if HNSW index exists",
+                    self._async_cursor,
+                )
+            ).fetchone()
         )
 
-        if actual_hnsw_index_creation_kwargs:
-            actual_hnsw_index_creation_kwargs_str = ", ".join(
-                f"{key} = {value}" for key, value in actual_hnsw_index_creation_kwargs.items()
-            )
-            sql_add_creation_kwargs = SQL("WITH ({creation_kwargs_str})").format(
-                creation_kwargs_str=SQL(actual_hnsw_index_creation_kwargs_str)
+        if index_exists and not self.hnsw_recreate_index_if_exists:
+            logger.warning(
+                "HNSW index already exists and won't be recreated. "
+                "If you want to recreate it, pass 'hnsw_recreate_index_if_exists=True' to the "
+                "Document Store constructor"
             )
-            sql_create_index += sql_add_creation_kwargs
+            return
+
+        await self._execute_sql_async(sql_drop_hnsw_index, error_msg="Could not drop HNSW index")
 
-        self._execute_sql(sql_create_index, error_msg="Could not create HNSW index")
+        await self._execute_sql_async(sql_create_hnsw_index, error_msg="Could not create HNSW index")
 
     def count_documents(self) -> int:
         """
         Returns how many documents are present in the document store.
-        """
 
+        :returns:
+            Number of documents in the document store.
+        """
         sql_count = SQL("SELECT COUNT(*) FROM {schema_name}.{table_name}").format(
             schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
         )
 
+        self._ensure_db_setup()
         count = self._execute_sql(sql_count, error_msg="Could not count documents in PgvectorDocumentStore").fetchone()[
             0
         ]
         return count
 
+    async def count_documents_async(self) -> int:
+        """
+        Returns how many documents are present in the document store.
+
+        :returns:
+            Number of documents in the document store.
+        """
+        sql_count = SQL("SELECT COUNT(*) FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
+        )
+
+        await self._ensure_db_setup_async()
+
+        result = await (
+            await self._execute_sql_async(sql_count, error_msg="Could not count documents in PgvectorDocumentStore")
+        ).fetchone()
+
+        return result[0]
+
     def filter_documents(self, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
         """
         Returns the documents that match the filters provided.
@@ -448,15 +650,10 @@ class PgvectorDocumentStore:
 
         :param filters: The filters to apply to the document list.
         :raises TypeError: If `filters` is not a dictionary.
+        :raises ValueError: If `filters` syntax is invalid.
         :returns: A list of Documents that match the given filters.
         """
-        if filters:
-            if not isinstance(filters, dict):
-                msg = "Filters must be a dictionary"
-                raise TypeError(msg)
-            if "operator" not in filters and "conditions" not in filters:
-                msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
-                raise ValueError(msg)
+        _validate_filters(filters)
 
         sql_filter = SQL("SELECT * FROM {schema_name}.{table_name}").format(
             schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
@@ -467,28 +664,83 @@ class PgvectorDocumentStore:
             sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
             sql_filter += sql_where_clause
 
+        self._ensure_db_setup()
         result = self._execute_sql(
             sql_filter,
             params,
             error_msg="Could not filter documents from PgvectorDocumentStore.",
-            cursor=self.dict_cursor,
+            cursor=self._dict_cursor,
         )
 
         records = result.fetchall()
-        docs = self._from_pg_to_haystack_documents(records)
+        docs = _from_pg_to_haystack_documents(records)
         return docs
 
+    async def filter_documents_async(self, filters: Optional[Dict[str, Any]] = None) -> List[Document]:
+        """
+        Asynchronously returns the documents that match the filters provided.
+
+        For a detailed specification of the filters,
+        refer to the [documentation](https://docs.haystack.deepset.ai/v2.0/docs/metadata-filtering)
+
+        :param filters: The filters to apply to the document list.
+
+        :raises TypeError: If `filters` is not a dictionary.
+        :raises ValueError: If `filters` syntax is invalid.
+        :returns: A list of Documents that match the given filters.
+        """
+        _validate_filters(filters)
+
+        sql_filter = SQL("SELECT * FROM {schema_name}.{table_name}").format(
+            schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
+        )
+
+        params = ()
+        if filters:
+            sql_where_clause, params = _convert_filters_to_where_clause_and_params(filters)
+            sql_filter += sql_where_clause
+
+        await self._ensure_db_setup_async()
+        result = await self._execute_sql_async(
+            sql_filter,
+            params,
+            error_msg="Could not filter documents from PgvectorDocumentStore.",
+            cursor=self._async_dict_cursor,
+        )
+
+        records = await result.fetchall()
+        docs = _from_pg_to_haystack_documents(records)
+        return docs
+
+    def _build_insert_statement(self, policy: DuplicatePolicy):
+        """
+        Builds the SQL insert statement to write documents.
+        """
+        sql_insert = SQL(INSERT_STATEMENT).format(
+            schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
+        )
+
+        if policy == DuplicatePolicy.OVERWRITE:
+            sql_insert += SQL(UPDATE_STATEMENT)
+        elif policy == DuplicatePolicy.SKIP:
+            sql_insert += SQL("ON CONFLICT DO NOTHING")
+
+        sql_insert += SQL(" RETURNING id")
+
+        return sql_insert
+
     def write_documents(self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE) -> int:
         """
         Writes documents to the document store.
 
         :param documents: A list of Documents to write to the document store.
         :param policy: The duplicate policy to use when writing documents.
+        :raises ValueError: If `documents` contains objects that are not of type `Document`.
         :raises DuplicateDocumentError: If a document with the same id already exists in the document store
              and the policy is set to `DuplicatePolicy.FAIL` (or not specified).
+        :raises DocumentStoreError: If the write operation fails for any other reason.
         :returns: The number of documents written to the document store.
         """
-
         if len(documents) > 0:
             if not isinstance(documents[0], Document):
                 msg = "param 'documents' must contain a list of objects of type Document"
@@ -497,29 +749,24 @@ class PgvectorDocumentStore:
         if policy == DuplicatePolicy.NONE:
             policy = DuplicatePolicy.FAIL
 
-        db_documents = self._from_haystack_to_pg_documents(documents)
+        db_documents = _from_haystack_to_pg_documents(documents)
 
-        sql_insert = SQL(INSERT_STATEMENT).format(
-            schema_name=Identifier(self.schema_name), table_name=Identifier(self.table_name)
-        )
-
-        if policy == DuplicatePolicy.OVERWRITE:
-            sql_insert += SQL(UPDATE_STATEMENT)
-        elif policy == DuplicatePolicy.SKIP:
-            sql_insert += SQL("ON CONFLICT DO NOTHING")
+        sql_insert = self._build_insert_statement(policy)
 
-        sql_insert += SQL(" RETURNING id")
+        self._ensure_db_setup()
+        assert self._cursor is not None  # verified in _ensure_db_setup() but mypy doesn't know that
+        assert self._connection is not None  # verified in _ensure_db_setup() but mypy doesn't know that
 
-        sql_query_str = sql_insert.as_string(self.cursor) if not isinstance(sql_insert, str) else sql_insert
+        sql_query_str = sql_insert.as_string(self._cursor) if not isinstance(sql_insert, str) else sql_insert
         logger.debug("SQL query: {query}\nParameters: {parameters}", query=sql_query_str, parameters=db_documents)
 
         try:
-            self.cursor.executemany(sql_insert, db_documents, returning=True)
+            self._cursor.executemany(sql_insert, db_documents, returning=True)
         except IntegrityError as ie:
-            self.connection.rollback()
+            self._connection.rollback()
             raise DuplicateDocumentError from ie
         except Error as e:
-            self.connection.rollback()
+            self._connection.rollback()
             error_msg = (
                 "Could not write documents to PgvectorDocumentStore. \n"
                 "You can find the SQL query and the parameters in the debug logs."
@@ -530,70 +777,64 @@ class PgvectorDocumentStore:
         # https://www.psycopg.org/psycopg3/docs/api/cursors.html#psycopg.Cursor.executemany
         written_docs = 0
         while True:
-            if self.cursor.fetchone():
+            if self._cursor.fetchone():
                 written_docs += 1
-            if not self.cursor.nextset():
+            if not self._cursor.nextset():
                 break
 
         return written_docs
 
-    @staticmethod
-    def _from_haystack_to_pg_documents(documents: List[Document]) -> List[Dict[str, Any]]:
-        """
-        Internal method to convert a list of Haystack Documents to a list of dictionaries that can be used to insert
-        documents into the PgvectorDocumentStore.
+    async def write_documents_async(
+        self, documents: List[Document], policy: DuplicatePolicy = DuplicatePolicy.NONE
+    ) -> int:
         """
+        Asynchronously writes documents to the document store.
 
-        db_documents = []
-        for document in documents:
-            db_document = {k: v for k, v in document.to_dict(flatten=False).items() if k not in ["score", "blob"]}
-
-            blob = document.blob
-            db_document["blob_data"] = blob.data if blob else None
-            db_document["blob_meta"] = Jsonb(blob.meta) if blob and blob.meta else None
-            db_document["blob_mime_type"] = blob.mime_type if blob and blob.mime_type else None
-            db_document["meta"] = Jsonb(db_document["meta"])
+        :param documents: A list of Documents to write to the document store.
+        :param policy: The duplicate policy to use when writing documents.
+        :raises ValueError: If `documents` contains objects that are not of type `Document`.
+        :raises DuplicateDocumentError: If a document with the same id already exists in the document store
+             and the policy is set to `DuplicatePolicy.FAIL` (or not specified).
+        :raises DocumentStoreError: If the write operation fails for any other reason.
+        :returns: The number of documents written to the document store.
+        """
+        if len(documents) > 0:
+            if not isinstance(documents[0], Document):
+                msg = "param 'documents' must contain a list of objects of type Document"
+                raise ValueError(msg)
 
-            if "sparse_embedding" in db_document:
-                sparse_embedding = db_document.pop("sparse_embedding", None)
-                if sparse_embedding:
-                    logger.warning(
-                        "Document {doc_id} has the `sparse_embedding` field set,"
-                        "but storing sparse embeddings in Pgvector is not currently supported."
-                        "The `sparse_embedding` field will be ignored.",
-                        doc_id=db_document["id"],
-                    )
+        if policy == DuplicatePolicy.NONE:
+            policy = DuplicatePolicy.FAIL
 
-            db_documents.append(db_document)
+        db_documents = _from_haystack_to_pg_documents(documents)
 
-        return db_documents
+        sql_insert = self._build_insert_statement(policy)
 
-    @staticmethod
-    def _from_pg_to_haystack_documents(documents: List[Dict[str, Any]]) -> List[Document]:
-        """
-        Internal method to convert a list of dictionaries from pgvector to a list of Haystack Documents.
-        """
+        await self._ensure_db_setup_async()
+        assert self._async_cursor is not None  # verified in _ensure_db_setup_async() but mypy doesn't know that
+        assert self._async_connection is not None  # verified in _ensure_db_setup_async() but mypy doesn't know that
 
-        haystack_documents = []
-        for document in documents:
-            haystack_dict = dict(document)
-            blob_data = haystack_dict.pop("blob_data")
-            blob_meta = haystack_dict.pop("blob_meta")
-            blob_mime_type = haystack_dict.pop("blob_mime_type")
-
-            # convert the embedding to a list of floats
-            if document.get("embedding") is not None:
-                haystack_dict["embedding"] = document["embedding"].tolist()
-
-            haystack_document = Document.from_dict(haystack_dict)
+        sql_query_str = sql_insert.as_string(self._async_cursor) if not isinstance(sql_insert, str) else sql_insert
+        logger.debug("SQL query: {query}\nParameters: {parameters}", query=sql_query_str, parameters=db_documents)
 
-            if blob_data:
-                blob = ByteStream(data=blob_data, meta=blob_meta, mime_type=blob_mime_type)
-                haystack_document.blob = blob
+        try:
+            await self._async_cursor.executemany(sql_insert, db_documents, returning=True)
+        except IntegrityError as ie:
+            await self._async_connection.rollback()
+            raise DuplicateDocumentError from ie
+        except Error as e:
+            await self._async_connection.rollback()
+            error_msg = (
+                "Could not write documents to PgvectorDocumentStore. \n"
+                "You can find the SQL query and the parameters in the debug logs."
+            )
+            raise DocumentStoreError(error_msg) from e
 
-            haystack_documents.append(haystack_document)
+        written_docs = 0
+        async for _ in self._async_cursor:
+            written_docs += 1
 
-        return haystack_documents
+        return written_docs
 
     def delete_documents(self, document_ids: List[str]) -> None:
         """
@@ -601,7 +842,6 @@ class PgvectorDocumentStore:
 
         :param document_ids: the document ids to delete
         """
-
         if not document_ids:
             return
 
@@ -613,28 +853,33 @@ class PgvectorDocumentStore:
             document_ids_str=SQL(document_ids_str),
         )
 
+        self._ensure_db_setup()
         self._execute_sql(delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore")
 
-    def _keyword_retrieval(
-        self,
-        query: str,
-        *,
-        filters: Optional[Dict[str, Any]] = None,
-        top_k: int = 10,
-    ) -> List[Document]:
+    async def delete_documents_async(self, document_ids: List[str]) -> None:
         """
-        Retrieves documents that are most similar to the query using a full-text search.
+        Asynchronously deletes documents that match the provided `document_ids` from the document store.
 
-        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 `query`
+        :param document_ids: the document ids to delete
         """
-        if not query:
-            msg = "query must be a non-empty string"
-            raise ValueError(msg)
+        if not document_ids:
+            return
+
+        document_ids_str = ", ".join(f"'{document_id}'" for document_id in document_ids)
 
+        delete_sql = SQL("DELETE FROM {schema_name}.{table_name} WHERE id IN ({document_ids_str})").format(
+            schema_name=Identifier(self.schema_name),
+            table_name=Identifier(self.table_name),
+            document_ids_str=SQL(document_ids_str),
+        )
+
+        await self._ensure_db_setup_async()
+        await self._execute_sql_async(delete_sql, error_msg="Could not delete documents from PgvectorDocumentStore")
+
+    def _build_keyword_retrieval_query(self, query: str, top_k: int, filters: Optional[Dict[str, Any]] = None):
+        """
+        Builds the SQL query and the where parameters for keyword retrieval.
+        """
         sql_select = SQL(KEYWORD_QUERY).format(
             schema_name=Identifier(self.schema_name),
             table_name=Identifier(self.table_name),
@@ -653,33 +898,79 @@ class PgvectorDocumentStore:
 
         sql_query = sql_select + sql_where_clause + sql_sort
 
+        return sql_query, where_params
+
+    def _keyword_retrieval(
+        self,
+        query: str,
+        *,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+    ) -> 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 `query`
+        """
+        if not query:
+            msg = "query must be a non-empty string"
+            raise ValueError(msg)
+
+        sql_query, where_params = self._build_keyword_retrieval_query(query=query, top_k=top_k, filters=filters)
+
+        self._ensure_db_setup()
         result = self._execute_sql(
             sql_query,
             (query, *where_params),
             error_msg="Could not retrieve documents from PgvectorDocumentStore.",
-            cursor=self.dict_cursor,
+            cursor=self._dict_cursor,
         )
 
         records = result.fetchall()
-        docs = self._from_pg_to_haystack_documents(records)
+        docs = _from_pg_to_haystack_documents(records)
         return docs
 
-    def _embedding_retrieval(
+    async def _keyword_retrieval_async(
         self,
-        query_embedding: List[float],
+        query: str,
         *,
         filters: Optional[Dict[str, Any]] = None,
         top_k: int = 10,
-        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
     ) -> List[Document]:
         """
-        Retrieves documents that are most similar to the query embedding using a vector similarity metric.
+        Retrieves documents that are most similar to the query using a full-text search asynchronously.
+        """
+        if not query:
+            msg = "query must be a non-empty string"
+            raise ValueError(msg)
 
-        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.
+        sql_query, where_params = self._build_keyword_retrieval_query(query=query, top_k=top_k, filters=filters)
 
-        :returns: List of Documents that are most similar to `query_embedding`
+        await self._ensure_db_setup_async()
+        result = await self._execute_sql_async(
+            sql_query,
+            (query, *where_params),
+            error_msg="Could not retrieve documents from PgvectorDocumentStore.",
+            cursor=self._async_dict_cursor,
+        )
+
+        records = await result.fetchall()
+        docs = _from_pg_to_haystack_documents(records)
+        return docs
+
+    def _check_and_build_embedding_retrieval_query(
+        self,
+        query_embedding: List[float],
+        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]],
+        top_k: int,
+        filters: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Performs checks and builds the SQL query and the where parameters for embedding retrieval.
         """
 
         if not query_embedding:
@@ -732,13 +1023,66 @@ class PgvectorDocumentStore:
 
         sql_query = sql_select + sql_where_clause + sql_sort
 
+        return sql_query, params
+
+    def _embedding_retrieval(
+        self,
+        query_embedding: List[float],
+        *,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+    ) -> List[Document]:
+        """
+        Retrieves documents that are most similar to the query embedding using a vector similarity metric.
+
+        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`
+        """
+
+        sql_query, params = self._check_and_build_embedding_retrieval_query(
+            query_embedding=query_embedding, vector_function=vector_function, top_k=top_k, filters=filters
+        )
+        self._ensure_db_setup()
         result = self._execute_sql(
             sql_query,
             params,
             error_msg="Could not retrieve documents from PgvectorDocumentStore.",
-            cursor=self.dict_cursor,
+            cursor=self._dict_cursor,
         )
 
         records = result.fetchall()
-        docs = self._from_pg_to_haystack_documents(records)
+        docs = _from_pg_to_haystack_documents(records)
+        return docs
+
+    async def _embedding_retrieval_async(
+        self,
+        query_embedding: List[float],
+        *,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        vector_function: Optional[Literal["cosine_similarity", "inner_product", "l2_distance"]] = None,
+    ) -> List[Document]:
+        """
+        Asynchronously retrieves documents that are most similar to the query embedding using a
+        vector similarity metric.
+        """
+
+        sql_query, params = self._check_and_build_embedding_retrieval_query(
+            query_embedding=query_embedding, vector_function=vector_function, top_k=top_k, filters=filters
+        )
+
+        await self._ensure_db_setup_async()
+        result = await self._execute_sql_async(
+            sql_query,
+            params,
+            error_msg="Could not retrieve documents from PgvectorDocumentStore.",
+            cursor=self._async_dict_cursor,
+        )
+
+        records = await result.fetchall()
+        docs = _from_pg_to_haystack_documents(records)
         return docs

haystack_integrations/document_stores/pgvector/filters.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 from datetime import datetime
 from itertools import chain
-from typing import Any, Dict, List, Literal, Tuple
+from typing import Any, Dict, List, Literal, Optional, Tuple
 
 from haystack.errors import FilterError
 from psycopg.sql import SQL
@@ -21,6 +21,19 @@ PYTHON_TYPES_TO_PG_TYPES = {
 NO_VALUE = "no_value"
 
 
+def _validate_filters(filters: Optional[Dict[str, Any]] = None):
+    """
+    Validates the filters provided.
+    """
+    if filters:
+        if not isinstance(filters, dict):
+            msg = "Filters must be a dictionary"
+            raise TypeError(msg)
+        if "operator" not in filters and "conditions" not in filters:
+            msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
+            raise ValueError(msg)
+
+
 def _convert_filters_to_where_clause_and_params(
     filters: Dict[str, Any], operator: Literal["WHERE", "AND"] = "WHERE"
 ) -> Tuple[SQL, Tuple]:

{pgvector_haystack-3.0.0.dist-info → pgvector_haystack-3.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvector-haystack
-Version: 3.0.0
+Version: 3.1.0
 Summary: An integration of pgvector (vector search extension for Postgres) with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/pgvector/README.md
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9

pgvector_haystack-3.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+haystack_integrations/components/retrievers/pgvector/__init__.py,sha256=n4q4pUApJ9DZakJ_JL-egwOzlefdnI_ZxjU1Lu44Sqo,296
+haystack_integrations/components/retrievers/pgvector/embedding_retriever.py,sha256=uK-ak1ZASjprix-5wgKoqP8rLnQfpQzExw_6X8fXUxg,9131
+haystack_integrations/components/retrievers/pgvector/keyword_retriever.py,sha256=5NECAn5qlLqcFTvRf_c-x1crdqdgTCeLHsmCxtD3pHk,6784
+haystack_integrations/document_stores/pgvector/__init__.py,sha256=Ge-7ggarfr3x8UqNdFHUuFGiu52u49sOVe3l16WEwZU,197
+haystack_integrations/document_stores/pgvector/converters.py,sha256=ECNF04RcStH_xpjtY125xB00co0wN8OWNI1fFiv0fUA,2448
+haystack_integrations/document_stores/pgvector/document_store.py,sha256=2Mphtj5K7yRVroEy_esvkxhzTN90glgl_WeAyWIrI5Q,44981
+haystack_integrations/document_stores/pgvector/filters.py,sha256=1xfU-DJcqFUFQtBezZCA8UsYFN0D9znXtsick1KANoU,8998
+pgvector_haystack-3.1.0.dist-info/METADATA,sha256=fhF5qTdD0UkVTtLRjgwVJui26CzrqASA6UNdhiwEhMY,2235
+pgvector_haystack-3.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pgvector_haystack-3.1.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+pgvector_haystack-3.1.0.dist-info/RECORD,,

pgvector_haystack-3.0.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-haystack_integrations/components/retrievers/pgvector/__init__.py,sha256=n4q4pUApJ9DZakJ_JL-egwOzlefdnI_ZxjU1Lu44Sqo,296
-haystack_integrations/components/retrievers/pgvector/embedding_retriever.py,sha256=IEIdgKy_IWgmL5Qy_Hqkwa2mq2JxnQ_JOdjm38JPxmE,7530
-haystack_integrations/components/retrievers/pgvector/keyword_retriever.py,sha256=SYHqjTkDczobYZ2qq0z8yS9p_g8aINnzwA5AN_nKdHI,5632
-haystack_integrations/document_stores/pgvector/__init__.py,sha256=Ge-7ggarfr3x8UqNdFHUuFGiu52u49sOVe3l16WEwZU,197
-haystack_integrations/document_stores/pgvector/document_store.py,sha256=bs1MCwiQgoTw8Wrad8DaRRgIQokk8_t1fLmzxdufWS4,31267
-haystack_integrations/document_stores/pgvector/filters.py,sha256=M-_wmM1iKS1QdKhnRk27N8t2W1st2YZWAwVSFUyyTtk,8508
-pgvector_haystack-3.0.0.dist-info/METADATA,sha256=1rd0uO91j_NxG5hmxXIhn7RFPYJsDgO9w7XBqKMMw-Q,2184
-pgvector_haystack-3.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pgvector_haystack-3.0.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-pgvector_haystack-3.0.0.dist-info/RECORD,,