langchain-postgres 0.0.14rc1__py3-none-any.whl → 0.0.16__py3-none-any.whl

langchain_postgres/__init__.py

@@ -1,8 +1,8 @@
 from importlib import metadata
 
 from langchain_postgres.chat_message_histories import PostgresChatMessageHistory
-from langchain_postgres.v2.engine import Column, PGEngine, ColumnDict
 from langchain_postgres.translator import PGVectorTranslator
+from langchain_postgres.v2.engine import Column, ColumnDict, PGEngine
 from langchain_postgres.v2.vectorstores import PGVectorStore
 from langchain_postgres.vectorstores import PGVector
 

langchain_postgres/chat_message_histories.py

@@ -2,6 +2,7 @@
 
 This client provides support for both sync and async via psycopg 3.
 """
+
 from __future__ import annotations
 
 import json

langchain_postgres/utils/pgvector_migrator.py

@@ -68,7 +68,7 @@ async def __aextract_pgvector_collection(
                 if not rows:
                     break
                 yield [row._mapping for row in rows]
-    except ValueError as e:
+    except ValueError:
         raise ValueError(f"Collection, {collection_name} does not exist.")
     except SQLAlchemyError as e:
         raise ProgrammingError(

langchain_postgres/v2/async_vectorstore.py

@@ -14,6 +14,7 @@ from sqlalchemy import RowMapping, text
 from sqlalchemy.ext.asyncio import AsyncEngine
 
 from .engine import PGEngine
+from .hybrid_search_config import HybridSearchConfig
 from .indexes import (
     DEFAULT_DISTANCE_STRATEGY,
     DEFAULT_INDEX_NAME_SUFFIX,
@@ -77,6 +78,7 @@ class AsyncPGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ):
         """AsyncPGVectorStore constructor.
         Args:
@@ -95,6 +97,7 @@ class AsyncPGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
 
         Raises:
@@ -119,6 +122,7 @@ class AsyncPGVectorStore(VectorStore):
         self.fetch_k = fetch_k
         self.lambda_mult = lambda_mult
         self.index_query_options = index_query_options
+        self.hybrid_search_config = hybrid_search_config
 
     @classmethod
     async def create(
@@ -139,6 +143,7 @@ class AsyncPGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> AsyncPGVectorStore:
         """Create an AsyncPGVectorStore instance.
 
@@ -158,6 +163,7 @@ class AsyncPGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Returns:
             AsyncPGVectorStore
@@ -193,9 +199,18 @@ class AsyncPGVectorStore(VectorStore):
             raise ValueError(
                 f"Content column, {content_column}, is type, {content_type}. It must be a type of character string."
             )
+        if hybrid_search_config:
+            tsv_column_name = (
+                hybrid_search_config.tsv_column
+                if hybrid_search_config.tsv_column
+                else content_column + "_tsv"
+            )
+            if tsv_column_name not in columns or columns[tsv_column_name] != "tsvector":
+                # mark tsv_column as empty because there is no TSV column in table
+                hybrid_search_config.tsv_column = ""
         if embedding_column not in columns:
             raise ValueError(f"Embedding column, {embedding_column}, does not exist.")
-        if columns[embedding_column] != "USER-DEFINED":
+        if columns[embedding_column] not in ["USER-DEFINED", "vector"]:
             raise ValueError(
                 f"Embedding column, {embedding_column}, is not type Vector."
             )
@@ -236,6 +251,7 @@ class AsyncPGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
 
     @property
@@ -273,17 +289,30 @@ class AsyncPGVectorStore(VectorStore):
                 if len(self.metadata_columns) > 0
                 else ""
             )
-            insert_stmt = f'INSERT INTO "{self.schema_name}"."{self.table_name}"("{self.id_column}", "{self.content_column}", "{self.embedding_column}"{metadata_col_names}'
+            hybrid_search_column = (
+                f', "{self.hybrid_search_config.tsv_column}"'
+                if self.hybrid_search_config and self.hybrid_search_config.tsv_column
+                else ""
+            )
+            insert_stmt = f'INSERT INTO "{self.schema_name}"."{self.table_name}"("{self.id_column}", "{self.content_column}", "{self.embedding_column}"{hybrid_search_column}{metadata_col_names}'
             values = {
-                "id": id,
+                "langchain_id": id,
                 "content": content,
                 "embedding": str([float(dimension) for dimension in embedding]),
             }
-            values_stmt = "VALUES (:id, :content, :embedding"
+            values_stmt = "VALUES (:langchain_id, :content, :embedding"
 
             if not embedding and can_inline_embed:
-                values_stmt = f"VALUES (:id, :content, {self.embedding_service.embed_query_inline(content)}"  # type: ignore
+                values_stmt = f"VALUES (:langchain_id, :content, {self.embedding_service.embed_query_inline(content)}"  # type: ignore
 
+            if self.hybrid_search_config and self.hybrid_search_config.tsv_column:
+                lang = (
+                    f"'{self.hybrid_search_config.tsv_lang}',"
+                    if self.hybrid_search_config.tsv_lang
+                    else ""
+                )
+                values_stmt += f", to_tsvector({lang} :tsv_content)"
+                values["tsv_content"] = content
             # Add metadata
             extra = copy.deepcopy(metadata)
             for metadata_column in self.metadata_columns:
@@ -308,6 +337,9 @@ class AsyncPGVectorStore(VectorStore):
 
             upsert_stmt = f' ON CONFLICT ("{self.id_column}") DO UPDATE SET "{self.content_column}" = EXCLUDED."{self.content_column}", "{self.embedding_column}" = EXCLUDED."{self.embedding_column}"'
 
+            if self.hybrid_search_config and self.hybrid_search_config.tsv_column:
+                upsert_stmt += f', "{self.hybrid_search_config.tsv_column}" = EXCLUDED."{self.hybrid_search_config.tsv_column}"'
+
             if self.metadata_json_column:
                 upsert_stmt += f', "{self.metadata_json_column}" = EXCLUDED."{self.metadata_json_column}"'
 
@@ -408,6 +440,7 @@ class AsyncPGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> AsyncPGVectorStore:
         """Create an AsyncPGVectorStore instance from texts.
@@ -453,6 +486,7 @@ class AsyncPGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         await vs.aadd_texts(texts, metadatas=metadatas, ids=ids, **kwargs)
         return vs
@@ -478,6 +512,7 @@ class AsyncPGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> AsyncPGVectorStore:
         """Create an AsyncPGVectorStore instance from documents.
@@ -524,6 +559,7 @@ class AsyncPGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         texts = [doc.page_content for doc in documents]
         metadatas = [doc.metadata for doc in documents]
@@ -538,16 +574,30 @@ class AsyncPGVectorStore(VectorStore):
         filter: Optional[dict] = None,
         **kwargs: Any,
     ) -> Sequence[RowMapping]:
-        """Perform similarity search query on database."""
-        k = k if k else self.k
+        """
+        Perform similarity search (or hybrid search) query on database.
+        Queries might be slow if the hybrid search column does not exist.
+        For best hybrid search performance, consider creating a TSV column
+        and adding GIN index.
+        """
+        hybrid_search_config = kwargs.get(
+            "hybrid_search_config", self.hybrid_search_config
+        )
+
+        final_k = k if k is not None else self.k
+
+        dense_limit = final_k
+        if hybrid_search_config:
+            dense_limit = hybrid_search_config.primary_top_k
+
         operator = self.distance_strategy.operator
         search_function = self.distance_strategy.search_function
 
-        columns = self.metadata_columns + [
+        columns = [
             self.id_column,
             self.content_column,
             self.embedding_column,
-        ]
+        ] + self.metadata_columns
         if self.metadata_json_column:
             columns.append(self.metadata_json_column)
 
@@ -557,16 +607,19 @@ class AsyncPGVectorStore(VectorStore):
         filter_dict = None
         if filter and isinstance(filter, dict):
             safe_filter, filter_dict = self._create_filter_clause(filter)
-        param_filter = f"WHERE {safe_filter}" if safe_filter else ""
+
         inline_embed_func = getattr(self.embedding_service, "embed_query_inline", None)
         if not embedding and callable(inline_embed_func) and "query" in kwargs:
             query_embedding = self.embedding_service.embed_query_inline(kwargs["query"])  # type: ignore
+            embedding_data_string = f"{query_embedding}"
         else:
             query_embedding = f"{[float(dimension) for dimension in embedding]}"
-        stmt = f"""SELECT {column_names}, {search_function}("{self.embedding_column}", :query_embedding) as distance
-        FROM "{self.schema_name}"."{self.table_name}" {param_filter} ORDER BY "{self.embedding_column}" {operator} :query_embedding LIMIT :k;
+            embedding_data_string = ":query_embedding"
+        where_filters = f"WHERE {safe_filter}" if safe_filter else ""
+        dense_query_stmt = f"""SELECT {column_names}, {search_function}("{self.embedding_column}", {embedding_data_string}) as distance
+        FROM "{self.schema_name}"."{self.table_name}" {where_filters} ORDER BY "{self.embedding_column}" {operator} {embedding_data_string} LIMIT :dense_limit;
         """
-        param_dict = {"query_embedding": query_embedding, "k": k}
+        param_dict = {"query_embedding": query_embedding, "dense_limit": dense_limit}
         if filter_dict:
             param_dict.update(filter_dict)
         if self.index_query_options:
@@ -575,15 +628,49 @@ class AsyncPGVectorStore(VectorStore):
                 for query_option in self.index_query_options.to_parameter():
                     query_options_stmt = f"SET LOCAL {query_option};"
                     await conn.execute(text(query_options_stmt))
-                result = await conn.execute(text(stmt), param_dict)
+                result = await conn.execute(text(dense_query_stmt), param_dict)
                 result_map = result.mappings()
-                results = result_map.fetchall()
+                dense_results = result_map.fetchall()
         else:
             async with self.engine.connect() as conn:
-                result = await conn.execute(text(stmt), param_dict)
+                result = await conn.execute(text(dense_query_stmt), param_dict)
+                result_map = result.mappings()
+                dense_results = result_map.fetchall()
+
+        fts_query = (
+            hybrid_search_config.fts_query
+            if hybrid_search_config and hybrid_search_config.fts_query
+            else kwargs.get("fts_query", "")
+        )
+        if hybrid_search_config and fts_query:
+            hybrid_search_config.fusion_function_parameters["fetch_top_k"] = final_k
+            # do the sparse query
+            lang = (
+                f"'{hybrid_search_config.tsv_lang}',"
+                if hybrid_search_config.tsv_lang
+                else ""
+            )
+            query_tsv = f"plainto_tsquery({lang} :fts_query)"
+            param_dict["fts_query"] = fts_query
+            if hybrid_search_config.tsv_column:
+                content_tsv = f'"{hybrid_search_config.tsv_column}"'
+            else:
+                content_tsv = f'to_tsvector({lang} "{self.content_column}")'
+            and_filters = f"AND ({safe_filter})" if safe_filter else ""
+            sparse_query_stmt = f'SELECT {column_names}, ts_rank_cd({content_tsv}, {query_tsv}) as distance FROM "{self.schema_name}"."{self.table_name}" WHERE {content_tsv} @@ {query_tsv} {and_filters}  ORDER BY distance desc LIMIT {hybrid_search_config.secondary_top_k};'
+            async with self.engine.connect() as conn:
+                result = await conn.execute(text(sparse_query_stmt), param_dict)
                 result_map = result.mappings()
-                results = result_map.fetchall()
-        return results
+                sparse_results = result_map.fetchall()
+
+            combined_results = hybrid_search_config.fusion_function(
+                dense_results,
+                sparse_results,
+                **hybrid_search_config.fusion_function_parameters,
+                distance_strategy=self.distance_strategy,
+            )
+            return combined_results
+        return dense_results
 
     async def asimilarity_search(
         self,
@@ -601,6 +688,14 @@ class AsyncPGVectorStore(VectorStore):
         )
         kwargs["query"] = query
 
+        # add fts_query to hybrid_search_config
+        hybrid_search_config = kwargs.get(
+            "hybrid_search_config", self.hybrid_search_config
+        )
+        if hybrid_search_config and not hybrid_search_config.fts_query:
+            hybrid_search_config.fts_query = query
+            kwargs["hybrid_search_config"] = hybrid_search_config
+
         return await self.asimilarity_search_by_vector(
             embedding=embedding, k=k, filter=filter, **kwargs
         )
@@ -632,6 +727,14 @@ class AsyncPGVectorStore(VectorStore):
         )
         kwargs["query"] = query
 
+        # add fts_query to hybrid_search_config
+        hybrid_search_config = kwargs.get(
+            "hybrid_search_config", self.hybrid_search_config
+        )
+        if hybrid_search_config and not hybrid_search_config.fts_query:
+            hybrid_search_config.fts_query = query
+            kwargs["hybrid_search_config"] = hybrid_search_config
+
         docs = await self.asimilarity_search_with_score_by_vector(
             embedding=embedding, k=k, filter=filter, **kwargs
         )
@@ -776,6 +879,41 @@ class AsyncPGVectorStore(VectorStore):
 
         return [r for i, r in enumerate(documents_with_scores) if i in mmr_selected]
 
+    async def aapply_hybrid_search_index(
+        self,
+        concurrently: bool = False,
+    ) -> None:
+        """Creates a TSV index in the vector store table if possible."""
+        if (
+            not self.hybrid_search_config
+            or not self.hybrid_search_config.index_type
+            or not self.hybrid_search_config.index_name
+        ):
+            # no index needs to be created
+            raise ValueError("Hybrid Search Config cannot create index.")
+
+        lang = (
+            f"'{self.hybrid_search_config.tsv_lang}',"
+            if self.hybrid_search_config.tsv_lang
+            else ""
+        )
+        tsv_column_name = (
+            self.hybrid_search_config.tsv_column
+            if self.hybrid_search_config.tsv_column
+            else f"to_tsvector({lang} {self.content_column})"
+        )
+        tsv_index_query = f'CREATE INDEX {"CONCURRENTLY" if concurrently else ""} {self.hybrid_search_config.index_name} ON "{self.schema_name}"."{self.table_name}" USING {self.hybrid_search_config.index_type}({tsv_column_name});'
+        if concurrently:
+            async with self.engine.connect() as conn:
+                autocommit_conn = await conn.execution_options(
+                    isolation_level="AUTOCOMMIT"
+                )
+                await autocommit_conn.execute(text(tsv_index_query))
+        else:
+            async with self.engine.connect() as conn:
+                await conn.execute(text(tsv_index_query))
+                await conn.commit()
+
     async def aapply_vector_index(
         self,
         index: BaseIndex,
@@ -800,10 +938,11 @@ class AsyncPGVectorStore(VectorStore):
         filter = f"WHERE ({index.partial_indexes})" if index.partial_indexes else ""
         params = "WITH " + index.index_options()
         if name is None:
-            if index.name == None:
+            if index.name is None:
                 index.name = self.table_name + DEFAULT_INDEX_NAME_SUFFIX
             name = index.name
         stmt = f'CREATE INDEX {"CONCURRENTLY" if concurrently else ""} "{name}" ON "{self.schema_name}"."{self.table_name}" USING {index.index_type} ({self.embedding_column} {function}) {params} {filter};'
+
         if concurrently:
             async with self.engine.connect() as conn:
                 autocommit_conn = await conn.execution_options(
@@ -954,46 +1093,48 @@ class AsyncPGVectorStore(VectorStore):
             operator = "$eq"
             filter_value = value
 
+        suffix_id = str(uuid.uuid4()).split("-")[0]
         if operator in COMPARISONS_TO_NATIVE:
             # Then we implement an equality filter
             # native is trusted input
             native = COMPARISONS_TO_NATIVE[operator]
-            id = str(uuid.uuid4()).split("-")[0]
-            return f"{field} {native} :{field}_{id}", {f"{field}_{id}": filter_value}
+            param_name = f"{field}_{suffix_id}"
+            return f"{field} {native} :{param_name}", {f"{param_name}": filter_value}
         elif operator == "$between":
             # Use AND with two comparisons
             low, high = filter_value
-
-            return f"({field} BETWEEN :{field}_low AND :{field}_high)", {
-                f"{field}_low": low,
-                f"{field}_high": high,
+            low_param_name = f"{field}_low_{suffix_id}"
+            high_param_name = f"{field}_high_{suffix_id}"
+            return f"({field} BETWEEN :{low_param_name} AND :{high_param_name})", {
+                f"{low_param_name}": low,
+                f"{high_param_name}": high,
             }
-        elif operator in {"$in", "$nin", "$like", "$ilike"}:
+        elif operator in {"$in", "$nin"}:
             # We'll do force coercion to text
-            if operator in {"$in", "$nin"}:
-                for val in filter_value:
-                    if not isinstance(val, (str, int, float)):
-                        raise NotImplementedError(
-                            f"Unsupported type: {type(val)} for value: {val}"
-                        )
-
-                    if isinstance(val, bool):  # b/c bool is an instance of int
-                        raise NotImplementedError(
-                            f"Unsupported type: {type(val)} for value: {val}"
-                        )
-
-            if operator in {"$in"}:
-                return f"{field} = ANY(:{field}_in)", {f"{field}_in": filter_value}
-            elif operator in {"$nin"}:
-                return f"{field} <> ALL (:{field}_nin)", {f"{field}_nin": filter_value}
-            elif operator in {"$like"}:
-                return f"({field} LIKE :{field}_like)", {f"{field}_like": filter_value}
-            elif operator in {"$ilike"}:
-                return f"({field} ILIKE :{field}_ilike)", {
-                    f"{field}_ilike": filter_value
+            for val in filter_value:
+                if not isinstance(val, (str, int, float)):
+                    raise NotImplementedError(
+                        f"Unsupported type: {type(val)} for value: {val}"
+                    )
+
+                if isinstance(val, bool):  # b/c bool is an instance of int
+                    raise NotImplementedError(
+                        f"Unsupported type: {type(val)} for value: {val}"
+                    )
+            param_name = f"{field}_{operator.replace('$', '')}_{suffix_id}"
+            if operator == "$in":
+                return f"{field} = ANY(:{param_name})", {f"{param_name}": filter_value}
+            else:  # i.e. $nin
+                return f"{field} <> ALL (:{param_name})", {
+                    f"{param_name}": filter_value
                 }
-            else:
-                raise NotImplementedError()
+
+        elif operator in {"$like", "$ilike"}:
+            param_name = f"{field}_{operator.replace('$', '')}_{suffix_id}"
+            if operator == "$like":
+                return f"({field} LIKE :{param_name})", {f"{param_name}": filter_value}
+            else:  # i.e. $ilike
+                return f"({field} ILIKE :{param_name})", {f"{param_name}": filter_value}
         elif operator == "$exists":
             if not isinstance(filter_value, bool):
                 raise ValueError(

langchain_postgres/v2/engine.py

@@ -3,14 +3,13 @@ from __future__ import annotations
 import asyncio
 from dataclasses import dataclass
 from threading import Thread
-from typing import TYPE_CHECKING, Any, Awaitable, Optional, TypeVar, TypedDict, Union
+from typing import Any, Awaitable, Optional, TypedDict, TypeVar, Union
 
 from sqlalchemy import text
 from sqlalchemy.engine import URL
 from sqlalchemy.ext.asyncio import AsyncEngine, create_async_engine
 
-if TYPE_CHECKING:
-    import asyncpg  # type: ignore
+from .hybrid_search_config import HybridSearchConfig
 
 T = TypeVar("T")
 
@@ -120,7 +119,7 @@ class PGEngine:
             return await coro
         # Otherwise, run in the background thread
         return await asyncio.wrap_future(
-            asyncio.run_coroutine_threadsafe(coro, self._loop)
+            asyncio.run_coroutine_threadsafe(coro, self._loop)  # type: ignore[arg-type]
         )
 
     def _run_as_sync(self, coro: Awaitable[T]) -> T:
@@ -129,7 +128,7 @@ class PGEngine:
             raise Exception(
                 "Engine was initialized without a background loop and cannot call sync methods."
             )
-        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()
+        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()  # type: ignore[arg-type]
 
     async def close(self) -> None:
         """Dispose of connection pool"""
@@ -159,6 +158,7 @@ class PGEngine:
         id_column: Union[str, Column, ColumnDict] = "langchain_id",
         overwrite_existing: bool = False,
         store_metadata: bool = True,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> None:
         """
         Create a table for saving of vectors to be used with PGVectorStore.
@@ -181,6 +181,8 @@ class PGEngine:
             overwrite_existing (bool): Whether to drop existing table. Default: False.
             store_metadata (bool): Whether to store metadata in the table.
                 Default: True.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration.
+                Default: None.
 
         Raises:
             :class:`DuplicateTableError <asyncpg.exceptions.DuplicateTableError>`: if table already exists.
@@ -189,6 +191,7 @@ class PGEngine:
 
         schema_name = self._escape_postgres_identifier(schema_name)
         table_name = self._escape_postgres_identifier(table_name)
+        hybrid_search_default_column_name = content_column + "_tsv"
         content_column = self._escape_postgres_identifier(content_column)
         embedding_column = self._escape_postgres_identifier(embedding_column)
         if metadata_columns is None:
@@ -229,10 +232,22 @@ class PGEngine:
             id_data_type = id_column["data_type"]
             id_column_name = id_column["name"]
 
+        hybrid_search_column = ""  # Default is no TSV column for hybrid search
+        if hybrid_search_config:
+            hybrid_search_column_name = (
+                hybrid_search_config.tsv_column or hybrid_search_default_column_name
+            )
+            hybrid_search_column_name = self._escape_postgres_identifier(
+                hybrid_search_column_name
+            )
+            hybrid_search_config.tsv_column = hybrid_search_column_name
+            hybrid_search_column = f',"{self._escape_postgres_identifier(hybrid_search_column_name)}" TSVECTOR NOT NULL'
+
         query = f"""CREATE TABLE "{schema_name}"."{table_name}"(
             "{id_column_name}" {id_data_type} PRIMARY KEY,
             "{content_column}" TEXT NOT NULL,
-            "{embedding_column}" vector({vector_size}) NOT NULL"""
+            "{embedding_column}" vector({vector_size}) NOT NULL
+            {hybrid_search_column}"""
         for column in metadata_columns:
             if isinstance(column, Column):
                 nullable = "NOT NULL" if not column.nullable else ""
@@ -261,6 +276,7 @@ class PGEngine:
         id_column: Union[str, Column, ColumnDict] = "langchain_id",
         overwrite_existing: bool = False,
         store_metadata: bool = True,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> None:
         """
         Create a table for saving of vectors to be used with PGVectorStore.
@@ -283,6 +299,10 @@ class PGEngine:
             overwrite_existing (bool): Whether to drop existing table. Default: False.
             store_metadata (bool): Whether to store metadata in the table.
                 Default: True.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration.
+                Note that queries might be slow if the hybrid search column does not exist.
+                For best hybrid search performance, consider creating a TSV column and adding GIN index.
+                Default: None.
         """
         await self._run_as_async(
             self._ainit_vectorstore_table(
@@ -296,6 +316,7 @@ class PGEngine:
                 id_column=id_column,
                 overwrite_existing=overwrite_existing,
                 store_metadata=store_metadata,
+                hybrid_search_config=hybrid_search_config,
             )
         )
 
@@ -312,6 +333,7 @@ class PGEngine:
         id_column: Union[str, Column, ColumnDict] = "langchain_id",
         overwrite_existing: bool = False,
         store_metadata: bool = True,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> None:
         """
         Create a table for saving of vectors to be used with PGVectorStore.
@@ -334,6 +356,10 @@ class PGEngine:
             overwrite_existing (bool): Whether to drop existing table. Default: False.
             store_metadata (bool): Whether to store metadata in the table.
                 Default: True.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration.
+                Note that queries might be slow if the hybrid search column does not exist.
+                For best hybrid search performance, consider creating a TSV column and adding GIN index.
+                Default: None.
         """
         self._run_as_sync(
             self._ainit_vectorstore_table(
@@ -347,5 +373,38 @@ class PGEngine:
                 id_column=id_column,
                 overwrite_existing=overwrite_existing,
                 store_metadata=store_metadata,
+                hybrid_search_config=hybrid_search_config,
             )
         )
+
+    async def _adrop_table(
+        self,
+        table_name: str,
+        *,
+        schema_name: str = "public",
+    ) -> None:
+        """Drop the vector store table"""
+        query = f'DROP TABLE IF EXISTS "{schema_name}"."{table_name}";'
+        async with self._pool.connect() as conn:
+            await conn.execute(text(query))
+            await conn.commit()
+
+    async def adrop_table(
+        self,
+        table_name: str,
+        *,
+        schema_name: str = "public",
+    ) -> None:
+        await self._run_as_async(
+            self._adrop_table(table_name=table_name, schema_name=schema_name)
+        )
+
+    def drop_table(
+        self,
+        table_name: str,
+        *,
+        schema_name: str = "public",
+    ) -> None:
+        self._run_as_sync(
+            self._adrop_table(table_name=table_name, schema_name=schema_name)
+        )

langchain_postgres/v2/hybrid_search_config.py

@@ -0,0 +1,212 @@
+from abc import ABC
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional, Sequence
+
+from sqlalchemy import RowMapping
+
+from .indexes import DistanceStrategy
+
+
+def _normalize_scores(
+    results: Sequence[dict[str, Any]], is_distance_metric: bool
+) -> Sequence[dict[str, Any]]:
+    """Normalizes scores to a 0-1 scale, where 1 is best."""
+    if not results:
+        return []
+
+    # Get scores from the last column of each result
+    scores = [float(list(item.values())[-1]) for item in results]
+    min_score, max_score = min(scores), max(scores)
+    score_range = max_score - min_score
+
+    if score_range == 0:
+        # All documents are of the highest quality (1.0)
+        for item in results:
+            item["normalized_score"] = 1.0
+        return list(results)
+
+    for item in results:
+        # Access the score again from the last column for calculation
+        score = list(item.values())[-1]
+        normalized = (score - min_score) / score_range
+        if is_distance_metric:
+            # For distance, a lower score is better, so we invert the result.
+            item["normalized_score"] = 1.0 - normalized
+        else:
+            # For similarity (like keyword search), a higher score is better.
+            item["normalized_score"] = normalized
+
+    return list(results)
+
+
+def weighted_sum_ranking(
+    primary_search_results: Sequence[RowMapping],
+    secondary_search_results: Sequence[RowMapping],
+    primary_results_weight: float = 0.5,
+    secondary_results_weight: float = 0.5,
+    fetch_top_k: int = 4,
+    **kwargs: Any,
+) -> Sequence[dict[str, Any]]:
+    """
+    Ranks documents using a weighted sum of scores from two sources.
+
+    Args:
+        primary_search_results: A list of (document, distance) tuples from
+            the primary search.
+        secondary_search_results: A list of (document, distance) tuples from
+            the secondary search.
+        primary_results_weight: The weight for the primary source's scores.
+            Defaults to 0.5.
+        secondary_results_weight: The weight for the secondary source's scores.
+            Defaults to 0.5.
+        fetch_top_k: The number of documents to fetch after merging the results.
+            Defaults to 4.
+
+    Returns:
+        A list of (document, distance) tuples, sorted by weighted_score in
+        descending order.
+    """
+
+    distance_strategy = kwargs.get(
+        "distance_strategy", DistanceStrategy.COSINE_DISTANCE
+    )
+    is_primary_distance = distance_strategy != DistanceStrategy.INNER_PRODUCT
+
+    # Normalize both sets of results onto a 0-1 scale
+    normalized_primary = _normalize_scores(
+        [dict(row) for row in primary_search_results],
+        is_distance_metric=is_primary_distance,
+    )
+
+    # Keyword search relevance is a similarity score (higher is better)
+    normalized_secondary = _normalize_scores(
+        [dict(row) for row in secondary_search_results], is_distance_metric=False
+    )
+
+    # stores computed metric with provided distance metric and weights
+    weighted_scores: dict[str, dict[str, Any]] = {}
+
+    # Process primary results
+    for item in normalized_primary:
+        doc_id = str(list(item.values())[0])
+        # Set the 'distance' key with the weighted primary score
+        item["distance"] = item["normalized_score"] * primary_results_weight
+        weighted_scores[doc_id] = item
+
+    # Process secondary results
+    for item in normalized_secondary:
+        doc_id = str(list(item.values())[0])
+        secondary_weighted_score = item["normalized_score"] * secondary_results_weight
+
+        if doc_id in weighted_scores:
+            # Add to the existing 'distance' score
+            weighted_scores[doc_id]["distance"] += secondary_weighted_score
+        else:
+            # Set the 'distance' key for the new item
+            item["distance"] = secondary_weighted_score
+            weighted_scores[doc_id] = item
+
+    ranked_results = sorted(
+        weighted_scores.values(), key=lambda item: item["distance"], reverse=True
+    )
+
+    for result in ranked_results:
+        result.pop("normalized_score", None)
+
+    return ranked_results[:fetch_top_k]
+
+
+def reciprocal_rank_fusion(
+    primary_search_results: Sequence[RowMapping],
+    secondary_search_results: Sequence[RowMapping],
+    rrf_k: float = 60,
+    fetch_top_k: int = 4,
+    **kwargs: Any,
+) -> Sequence[dict[str, Any]]:
+    """
+    Ranks documents using Reciprocal Rank Fusion (RRF) of scores from two sources.
+
+    Args:
+        primary_search_results: A list of (document, distance) tuples from
+            the primary search.
+        secondary_search_results: A list of (document, distance) tuples from
+            the secondary search.
+        rrf_k: The RRF parameter k.
+            Defaults to 60.
+        fetch_top_k: The number of documents to fetch after merging the results.
+            Defaults to 4.
+
+    Returns:
+        A list of (document_id, rrf_score) tuples, sorted by rrf_score
+        in descending order.
+    """
+    distance_strategy = kwargs.get(
+        "distance_strategy", DistanceStrategy.COSINE_DISTANCE
+    )
+    rrf_scores: dict[str, dict[str, Any]] = {}
+
+    # Process results from primary source
+    # Determine sorting order based on the vector distance strategy.
+    # For COSINE & EUCLIDEAN(distance), we sort ascending (reverse=False).
+    # For INNER_PRODUCT (similarity), we sort descending (reverse=True).
+    is_similarity_metric = distance_strategy == DistanceStrategy.INNER_PRODUCT
+    sorted_primary = sorted(
+        primary_search_results,
+        key=lambda item: item["distance"],
+        reverse=is_similarity_metric,
+    )
+
+    for rank, row in enumerate(sorted_primary):
+        doc_id = str(list(row.values())[0])
+        if doc_id not in rrf_scores:
+            rrf_scores[doc_id] = dict(row)
+            rrf_scores[doc_id]["distance"] = 0.0
+        # Add the "normalized" rank score
+        rrf_scores[doc_id]["distance"] += 1.0 / (rank + rrf_k)
+
+    # Process results from secondary source
+    # Keyword search relevance is always "higher is better" -> sort descending
+    sorted_secondary = sorted(
+        secondary_search_results,
+        key=lambda item: item["distance"],
+        reverse=True,
+    )
+
+    for rank, row in enumerate(sorted_secondary):
+        doc_id = str(list(row.values())[0])
+        if doc_id not in rrf_scores:
+            rrf_scores[doc_id] = dict(row)
+            rrf_scores[doc_id]["distance"] = 0.0
+        # Add the rank score from this list to the existing score
+        rrf_scores[doc_id]["distance"] += 1.0 / (rank + rrf_k)
+
+    # Sort the results by rrf score in descending order
+    # Sort the results by weighted score in descending order
+    ranked_results = sorted(
+        rrf_scores.values(), key=lambda item: item["distance"], reverse=True
+    )
+    # Extract only the RowMapping for the top results
+    return ranked_results[:fetch_top_k]
+
+
+@dataclass
+class HybridSearchConfig(ABC):
+    """
+    AlloyDB Vector Store Hybrid Search Config.
+
+    Queries might be slow if the hybrid search column does not exist.
+    For best hybrid search performance, consider creating a TSV column
+    and adding GIN index.
+    """
+
+    tsv_column: Optional[str] = ""
+    tsv_lang: Optional[str] = "pg_catalog.english"
+    fts_query: Optional[str] = ""
+    fusion_function: Callable[
+        [Sequence[RowMapping], Sequence[RowMapping], Any], Sequence[Any]
+    ] = weighted_sum_ranking  # Updated default
+    fusion_function_parameters: dict[str, Any] = field(default_factory=dict)
+    primary_top_k: int = 4
+    secondary_top_k: int = 4
+    index_name: str = "langchain_tsv_index"
+    index_type: str = "GIN"

langchain_postgres/v2/vectorstores.py

@@ -9,6 +9,7 @@ from langchain_core.vectorstores import VectorStore
 
 from .async_vectorstore import AsyncPGVectorStore
 from .engine import PGEngine
+from .hybrid_search_config import HybridSearchConfig
 from .indexes import (
     DEFAULT_DISTANCE_STRATEGY,
     BaseIndex,
@@ -59,6 +60,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance.
 
@@ -78,6 +80,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Returns:
             PGVectorStore
@@ -98,6 +101,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         vs = await engine._run_as_async(coro)
         return cls(cls.__create_key, engine, vs)
@@ -120,6 +124,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance.
 
@@ -140,6 +145,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int, optional): Number of Documents to fetch to pass to MMR algorithm. Defaults to 20.
             lambda_mult (float, optional): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (Optional[QueryOptions], optional): Index query option. Defaults to None.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Returns:
             PGVectorStore
@@ -160,6 +166,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         vs = engine._run_as_sync(coro)
         return cls(cls.__create_key, engine, vs)
@@ -301,6 +308,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance from texts.
@@ -324,6 +332,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Raises:
             :class:`InvalidTextRepresentationError <asyncpg.exceptions.InvalidTextRepresentationError>`: if the `ids` data type does not match that of the `id_column`.
@@ -347,6 +356,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         await vs.aadd_texts(texts, metadatas=metadatas, ids=ids)
         return vs
@@ -371,6 +381,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance from documents.
@@ -393,6 +404,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Raises:
             :class:`InvalidTextRepresentationError <asyncpg.exceptions.InvalidTextRepresentationError>`: if the `ids` data type does not match that of the `id_column`.
@@ -417,6 +429,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
         )
         await vs.aadd_documents(documents, ids=ids)
         return vs
@@ -442,6 +455,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance from texts.
@@ -465,6 +479,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Raises:
             :class:`InvalidTextRepresentationError <asyncpg.exceptions.InvalidTextRepresentationError>`: if the `ids` data type does not match that of the `id_column`.
@@ -488,6 +503,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
             **kwargs,
         )
         vs.add_texts(texts, metadatas=metadatas, ids=ids)
@@ -513,6 +529,7 @@ class PGVectorStore(VectorStore):
         fetch_k: int = 20,
         lambda_mult: float = 0.5,
         index_query_options: Optional[QueryOptions] = None,
+        hybrid_search_config: Optional[HybridSearchConfig] = None,
         **kwargs: Any,
     ) -> PGVectorStore:
         """Create an PGVectorStore instance from documents.
@@ -535,6 +552,7 @@ class PGVectorStore(VectorStore):
             fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
             lambda_mult (float): Number between 0 and 1 that determines the degree of diversity among the results with 0 corresponding to maximum diversity and 1 to minimum diversity. Defaults to 0.5.
             index_query_options (QueryOptions): Index query option.
+            hybrid_search_config (HybridSearchConfig): Hybrid search configuration. Defaults to None.
 
         Raises:
             :class:`InvalidTextRepresentationError <asyncpg.exceptions.InvalidTextRepresentationError>`: if the `ids` data type does not match that of the `id_column`.
@@ -558,6 +576,7 @@ class PGVectorStore(VectorStore):
             fetch_k=fetch_k,
             lambda_mult=lambda_mult,
             index_query_options=index_query_options,
+            hybrid_search_config=hybrid_search_config,
             **kwargs,
         )
         vs.add_documents(documents, ids=ids)
@@ -770,6 +789,24 @@ class PGVectorStore(VectorStore):
             )
         )
 
+    async def aapply_hybrid_search_index(
+        self,
+        concurrently: bool = False,
+    ) -> None:
+        """Creates a TSV index in the vector store table if possible."""
+        return await self._engine._run_as_async(
+            self.__vs.aapply_hybrid_search_index(concurrently=concurrently)
+        )
+
+    def apply_hybrid_search_index(
+        self,
+        concurrently: bool = False,
+    ) -> None:
+        """Creates a TSV index in the vector store table if possible."""
+        return self._engine._run_as_sync(
+            self.__vs.aapply_hybrid_search_index(concurrently=concurrently)
+        )
+
     async def aapply_vector_index(
         self,
         index: BaseIndex,

langchain_postgres/vectorstores.py

@@ -5,6 +5,7 @@ import contextlib
 import enum
 import logging
 import uuid
+import warnings
 from typing import (
     Any,
     AsyncGenerator,
@@ -19,7 +20,6 @@ from typing import (
     Type,
     Union,
 )
-import warnings
 from typing import (
     cast as typing_cast,
 )
@@ -429,13 +429,6 @@ class PGVector(VectorStore):
         self._async_engine: Optional[AsyncEngine] = None
         self._async_init = False
 
-        warnings.warn(
-            "PGVector is being deprecated and will be removed in the future. "
-            "Please migrate to PGVectorStore. "
-            "Refer to the migration guide at [https://github.com/langchain-ai/langchain-postgres/blob/main/examples/migrate_pgvector_to_pgvectorstore.md] for details.",
-            PendingDeprecationWarning,
-        )
-
         if isinstance(connection, str):
             if async_mode:
                 self._async_engine = create_async_engine(

{langchain_postgres-0.0.14rc1.dist-info → langchain_postgres-0.0.16.dist-info}/METADATA

@@ -1,25 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: langchain-postgres
-Version: 0.0.14rc1
+Version: 0.0.16
 Summary: An integration package connecting Postgres and LangChain
-Home-page: https://github.com/langchain-ai/langchain-postgres
-License: MIT
-Requires-Python: >=3.9,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: asyncpg (>=0.30.0,<0.31.0)
-Requires-Dist: langchain-core (>=0.2.13,<0.4.0)
-Requires-Dist: numpy (>=1.21,<2.0)
-Requires-Dist: pgvector (>=0.2.5,<0.4)
-Requires-Dist: psycopg (>=3,<4)
-Requires-Dist: psycopg-pool (>=3.2.1,<4.0.0)
-Requires-Dist: sqlalchemy (>=2,<3)
-Project-URL: Repository, https://github.com/langchain-ai/langchain-postgres
-Project-URL: Source Code, https://github.com/langchain-ai/langchain-postgres/tree/master/langchain_postgres
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: langchain-core<2.0,>=0.2.13
+Requires-Dist: numpy<3,>=1.21
+Requires-Dist: pgvector<0.4,>=0.2.5
+Requires-Dist: psycopg-pool<4,>=3.2.1
+Requires-Dist: psycopg[binary]<4,>=3
+Requires-Dist: sqlalchemy[asyncio]<3,>=2
 Description-Content-Type: text/markdown
 
 # langchain-postgres
@@ -39,7 +31,7 @@ Feel free to use the abstraction as provided or else modify them / extend them a
 
 ## Requirements
 
-The package supports the [asyncpg](https://github.com/MagicStack/asyncpg) and [psycogp3](https://www.psycopg.org/psycopg3/) drivers.
+The package supports the [asyncpg](https://github.com/MagicStack/asyncpg) and [psycopg3](https://www.psycopg.org/psycopg3/) drivers.
 
 ## Installation
 
@@ -47,17 +39,19 @@ The package supports the [asyncpg](https://github.com/MagicStack/asyncpg) and [p
 pip install -U langchain-postgres
 ```
 
-## Usage
-
-### Vectorstore
+## Vectorstore
 
 > [!WARNING]
 > In v0.0.14+, `PGVector` is deprecated. Please migrate to `PGVectorStore`
-> Version 0.0.14+ has not been released yet, but you can test version of the vectorstore on the main branch. Until official release do not use in production.
 > for improved performance and manageability.
-> See the [migration guide](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/migrate_pgvector_to_pgvectorstore.md) for details on how to migrate from `PGVector` to `PGVectorStore`.
+> See the [migration guide](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/migrate_pgvector_to_pgvectorstore.ipynb) for details on how to migrate from `PGVector` to `PGVectorStore`.
+
+### Documentation
 
-For a detailed example on `PGVectorStore` see [here](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb).
+* [Quickstart](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb)
+* [How-to](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore_how_to.ipynb)
+
+### Example
 
 ```python
 from langchain_core.documents import Document
@@ -101,7 +95,25 @@ print(docs)
 > [!TIP]
 > All synchronous functions have corresponding asynchronous functions
 
-### ChatMessageHistory
+### Hybrid Search with PGVectorStore
+
+With PGVectorStore you can use hybrid search for more comprehensive and relevant search results.
+
+```python
+vs = PGVectorStore.create_sync(
+    engine=engine,
+    table_name=TABLE_NAME,
+    embedding_service=embedding,
+    hybrid_search_config=HybridSearchConfig(
+      fusion_function=reciprocal_rank_fusion
+    ),
+)
+hybrid_docs = vector_store.similarity_search("products", k=5)
+```
+
+For a detailed guide on how to use hybrid search, see the [documentation](/examples/pg_vectorstore_how_to.ipynb#hybrid-search-with-pgvectorstore ).
+
+## ChatMessageHistory
 
 The chat message history abstraction helps to persist chat message history
 in a postgres table.
@@ -167,4 +179,3 @@ Using the Google Cloud integrations provides the following benefits:
 | Google AlloyDB           |          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
 | Google Cloud SQL Postgres|          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
 
-

langchain_postgres-0.0.16.dist-info/RECORD

@@ -0,0 +1,17 @@
+langchain_postgres/__init__.py,sha256=-ovoLrNuzL-kMUV-RrIxoEI8wmgOAg4vfE8xevYSA3Q,702
+langchain_postgres/_utils.py,sha256=N_OBzYFCb_bsHOnZ-YRg6izhmuudorQhupgeG-rSKUc,2848
+langchain_postgres/chat_message_histories.py,sha256=Hq_0nGX1BoBxq5jg0LwfQg7iXm6B4izYVr6iLkMGoEY,14214
+langchain_postgres/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_postgres/translator.py,sha256=6cTS2RJUodMUdsurJM-f-vgPXl6Ad6bfMo8ECuh5Jr4,1524
+langchain_postgres/vectorstores.py,sha256=vzRbPwU1Rn-pOsnTsz1u72cSYD7H8jMlW4N7A58QIt4,83826
+langchain_postgres/utils/pgvector_migrator.py,sha256=OxW2_FxaomZw5kqPAz-3lmZ5t2hSXU4ZW3xK6O62MH4,11771
+langchain_postgres/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_postgres/v2/async_vectorstore.py,sha256=MuRjlRcANOnxrXRGcyGEzIZYr4v75tk8jbMZZCexSAc,58711
+langchain_postgres/v2/engine.py,sha256=UC3upYnqmgKBw4E6t62CbjUEdVO67t1j0rCbdFmoQnI,16902
+langchain_postgres/v2/hybrid_search_config.py,sha256=dhBeedqpVXv2VP2_RLs_jNHLLLrukJ-UXytxRD3zVts,7658
+langchain_postgres/v2/indexes.py,sha256=aLCFGYiIbLBUr88drMLD6l41MPRI7lv0ALMVRWfqdq4,4888
+langchain_postgres/v2/vectorstores.py,sha256=Iq5z3KU0Ne_djMLlhJNL43zprii0O1JdUN2uEuvvKNI,39213
+langchain_postgres-0.0.16.dist-info/METADATA,sha256=fLsfXjrnlW412RDvPW5nv4uFJqaujUQkIBujCCsERWc,7143
+langchain_postgres-0.0.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_postgres-0.0.16.dist-info/licenses/LICENSE,sha256=2btS8uNUDWD_UNjw9ba6ZJt_00aUjEw9CGyK-xIHY8c,1072
+langchain_postgres-0.0.16.dist-info/RECORD,,

{langchain_postgres-0.0.14rc1.dist-info → langchain_postgres-0.0.16.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.8.1
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

langchain_postgres-0.0.14rc1.dist-info/RECORD

@@ -1,16 +0,0 @@
-langchain_postgres/__init__.py,sha256=UxIanyWPeUVtWFKCT-sWGXbWUO5I76akABXhXolY9bM,702
-langchain_postgres/_utils.py,sha256=N_OBzYFCb_bsHOnZ-YRg6izhmuudorQhupgeG-rSKUc,2848
-langchain_postgres/chat_message_histories.py,sha256=Et5AgXSRBCghLC5sn6EEUDd1xupaiPv-A5IyNBjpaTc,14213
-langchain_postgres/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_postgres/translator.py,sha256=6cTS2RJUodMUdsurJM-f-vgPXl6Ad6bfMo8ECuh5Jr4,1524
-langchain_postgres/utils/pgvector_migrator.py,sha256=OIclFsCKWQAtJ1JyFQsVQoWZSrEJg67GVnY84aBlucE,11776
-langchain_postgres/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_postgres/v2/async_vectorstore.py,sha256=FMV-IwH7cJ2VuxnrMCy0X0WWG65oHNXfKAwsdf0Tp20,51786
-langchain_postgres/v2/engine.py,sha256=8XD6ta2HzuYtHnxhvY-I_vMYqZd33yj2y9ZqQFbEz1g,14266
-langchain_postgres/v2/indexes.py,sha256=aLCFGYiIbLBUr88drMLD6l41MPRI7lv0ALMVRWfqdq4,4888
-langchain_postgres/v2/vectorstores.py,sha256=R17q1KIEZPBwEHgE6JYiRSiN8rZXzVPCmBoJobiyjM8,37198
-langchain_postgres/vectorstores.py,sha256=Xjyqxa_nL7Xvq6dwqWUu4VdNZ5z6ypjFoSU9wj6Ad5c,84195
-langchain_postgres-0.0.14rc1.dist-info/LICENSE,sha256=2btS8uNUDWD_UNjw9ba6ZJt_00aUjEw9CGyK-xIHY8c,1072
-langchain_postgres-0.0.14rc1.dist-info/METADATA,sha256=ZOG0qTuKUt4_uz2VUAy4Cj4A-DtsfouNBB6ITk7bihk,7179
-langchain_postgres-0.0.14rc1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langchain_postgres-0.0.14rc1.dist-info/RECORD,,