langchain-google-cloud-sql-pg 0.14.1__tar.gz → 0.16.0__tar.gz

{langchain_google_cloud_sql_pg-0.14.1/src/langchain_google_cloud_sql_pg.egg-info → langchain_google_cloud_sql_pg-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-google-cloud-sql-pg
-Version: 0.14.1
+Version: 0.16.0
 Summary: LangChain integrations for Google Cloud SQL for PostgreSQL
 Author-email: Google LLC <googleapis-packages@google.com>
 License: 
@@ -214,31 +214,28 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 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-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Requires-Dist: cloud-sql-python-connector[asyncpg]<2.0.0,>=1.10.0
-Requires-Dist: langchain-core<1.0.0,>=0.2.36
 Requires-Dist: numpy<3.0.0,>=1.24.4; python_version >= "3.11"
 Requires-Dist: numpy<=2.2.6,>=1.24.4; python_version == "3.10"
-Requires-Dist: numpy<=2.0.2,>=1.24.4; python_version <= "3.9"
-Requires-Dist: pgvector<1.0.0,>=0.2.5
-Requires-Dist: SQLAlchemy[asyncio]<3.0.0,>=2.0.25
+Requires-Dist: langchain-postgres>=0.0.16
 Provides-Extra: langgraph
-Requires-Dist: langgraph-checkpoint<3.0.0,>=2.0.9; extra == "langgraph"
+Requires-Dist: langgraph-checkpoint<5.0.0,>=4.0.0; extra == "langgraph"
 Provides-Extra: test
-Requires-Dist: black[jupyter]==25.1.0; extra == "test"
-Requires-Dist: isort==6.0.1; extra == "test"
-Requires-Dist: mypy==1.15.0; extra == "test"
+Requires-Dist: black[jupyter]==26.3.1; extra == "test"
+Requires-Dist: isort==9.0.2; extra == "test"
+Requires-Dist: mypy==1.19.1; extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
-Requires-Dist: pytest==8.4.1; extra == "test"
-Requires-Dist: pytest-cov==6.2.1; extra == "test"
-Requires-Dist: langchain-tests==0.3.20; extra == "test"
-Requires-Dist: langgraph==0.5.2; extra == "test"
+Requires-Dist: pytest==8.4.2; extra == "test"
+Requires-Dist: pytest-cov==7.0.0; extra == "test"
+Requires-Dist: langchain-tests==1.1.2; extra == "test"
+Requires-Dist: langgraph>=1.2.2; extra == "test"
 Dynamic: license-file
 
 Cloud SQL for PostgreSQL for LangChain
@@ -299,7 +296,7 @@ dependencies.
 Supported Python Versions
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Python >= 3.9
+Python >= 3.10
 
 Mac/Linux
 ^^^^^^^^^
@@ -354,6 +351,26 @@ Use a Vector Store to store embedded data and perform vector search.
             embeddings=embedding_service
         )
 
+Hybrid search
+~~~~~~~~~~~~~
+
+The `PostgresVectorStore` supports hybrid search (dense vectors + full text) for more comprehensive and relevant search results.
+
+.. code-block:: python
+
+  from langchain_google_cloud_sql_pg import HybridSearchConfig, reciprocal_rank_fusion
+
+  vs = PostgresVectorStore.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)
+
+
 See the full `Vector Store`_ tutorial.
 
 .. _`Vector Store`: https://github.com/googleapis/langchain-google-cloud-sql-pg-python/tree/main/docs/vector_store.ipynb

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/README.rst

@@ -56,7 +56,7 @@ dependencies.
 Supported Python Versions
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-Python >= 3.9
+Python >= 3.10
 
 Mac/Linux
 ^^^^^^^^^
@@ -111,6 +111,26 @@ Use a Vector Store to store embedded data and perform vector search.
             embeddings=embedding_service
         )
 
+Hybrid search
+~~~~~~~~~~~~~
+
+The `PostgresVectorStore` supports hybrid search (dense vectors + full text) for more comprehensive and relevant search results.
+
+.. code-block:: python
+
+  from langchain_google_cloud_sql_pg import HybridSearchConfig, reciprocal_rank_fusion
+
+  vs = PostgresVectorStore.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)
+
+
 See the full `Vector Store`_ tutorial.
 
 .. _`Vector Store`: https://github.com/googleapis/langchain-google-cloud-sql-pg-python/tree/main/docs/vector_store.ipynb

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/pyproject.toml

@@ -4,19 +4,16 @@ dynamic = ["version"]
 description = "LangChain integrations for Google Cloud SQL for PostgreSQL"
 readme = "README.rst"
 license = {file = "LICENSE"}
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [
     {name = "Google LLC", email = "googleapis-packages@google.com"}
 ]
 
 dependencies = [
     "cloud-sql-python-connector[asyncpg] >= 1.10.0, <2.0.0",
-    "langchain-core>=0.2.36, <1.0.0 ",
     "numpy>=1.24.4, <3.0.0; python_version >= '3.11'",
     "numpy>=1.24.4, <=2.2.6; python_version == '3.10'",
-    "numpy>=1.24.4, <=2.0.2; python_version <= '3.9'",
-    "pgvector>=0.2.5, <1.0.0",
-    "SQLAlchemy[asyncio]>=2.0.25, <3.0.0"
+    "langchain-postgres>=0.0.16",
 ]
 
 classifiers = [
@@ -24,10 +21,10 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
 ]
 
 [tool.setuptools.dynamic]
@@ -41,17 +38,17 @@ Changelog = "https://github.com/googleapis/langchain-google-cloud-sql-pg-python/
 
 [project.optional-dependencies]
 langgraph = [
-    "langgraph-checkpoint>=2.0.9, <3.0.0"
+    "langgraph-checkpoint>=4.0.0, <5.0.0"
 ]
 test = [
-    "black[jupyter]==25.1.0",
-    "isort==6.0.1",
-    "mypy==1.15.0",
+    "black[jupyter]==26.3.1",
+    "isort==9.0.2",
+    "mypy==1.19.1",
     "pytest-asyncio==0.26.0",
-    "pytest==8.4.1",
-    "pytest-cov==6.2.1",
-    "langchain-tests==0.3.20",
-    "langgraph==0.5.2"
+    "pytest==8.4.2",
+    "pytest-cov==7.0.0",
+    "langchain-tests==1.1.2",
+    "langgraph>=1.2.2"
 ]
 
 [build-system]
@@ -65,7 +62,7 @@ target-version = ['py39']
 profile = "black"
 
 [tool.mypy]
-python_version = 3.9
+python_version = "3.10"
 warn_unused_configs = true
 disallow_incomplete_defs = true
 

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/src/langchain_google_cloud_sql_pg/__init__.py

@@ -12,10 +12,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from langchain_postgres import Column
+from langchain_postgres.v2.hybrid_search_config import (
+    HybridSearchConfig,
+    reciprocal_rank_fusion,
+    weighted_sum_ranking,
+)
+
 from . import indexes
 from .chat_message_history import PostgresChatMessageHistory
 from .checkpoint import PostgresSaver
-from .engine import Column, PostgresEngine
+from .engine import PostgresEngine
 from .loader import PostgresDocumentSaver, PostgresLoader
 from .vectorstore import PostgresVectorStore
 from .version import __version__
@@ -29,5 +36,8 @@ __all__ = [
     "PostgresLoader",
     "PostgresDocumentSaver",
     "PostgresSaver",
+    "HybridSearchConfig",
+    "reciprocal_rank_fusion",
+    "weighted_sum_ranking",
     "__version__",
 ]

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/src/langchain_google_cloud_sql_pg/async_chat_message_history.py

@@ -98,7 +98,7 @@ class AsyncPostgresChatMessageHistory(BaseChatMessageHistory):
                 "\n    type TEXT NOT NULL"
                 "\n);"
             )
-        return cls(cls.__create_key, engine._pool, session_id, table_name)
+        return cls(cls.__create_key, engine._pool, session_id, table_name, schema_name)
 
     async def aadd_message(self, message: BaseMessage) -> None:
         """Append the message to the record in PostgreSQL"""

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/src/langchain_google_cloud_sql_pg/async_checkpoint.py

@@ -276,7 +276,9 @@ class AsyncPostgresSaver(BaseCheckpointSaver[str]):
 
         async with self.pool.connect() as conn:
             type_, serialized_checkpoint = self.serde.dumps_typed(checkpoint)
-            serialized_metadata = self.jsonplus_serde.dumps(metadata)
+            serialized_metadata = json.dumps(metadata, ensure_ascii=False).encode(
+                "utf-8", "ignore"
+            )
             await conn.execute(
                 text(query),
                 {
@@ -409,7 +411,7 @@ class AsyncPostgresSaver(BaseCheckpointSaver[str]):
                         (value["type"], value["checkpoint"])
                     ),
                     metadata=(
-                        self.jsonplus_serde.loads(value["metadata"])  # type: ignore
+                        json.loads(value["metadata"])  # type: ignore
                         if value["metadata"] is not None
                         else {}
                     ),
@@ -494,7 +496,7 @@ class AsyncPostgresSaver(BaseCheckpointSaver[str]):
                 },
                 checkpoint=self.serde.loads_typed((value["type"], value["checkpoint"])),
                 metadata=(
-                    self.jsonplus_serde.loads(value["metadata"])  # type: ignore
+                    json.loads(value["metadata"])  # type: ignore
                     if value["metadata"] is not None
                     else {}
                 ),

langchain_google_cloud_sql_pg-0.16.0/src/langchain_google_cloud_sql_pg/async_vectorstore.py

@@ -0,0 +1,25 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO: Remove below import when minimum supported Python version is 3.10
+from __future__ import annotations
+
+from langchain_postgres.v2.async_vectorstore import AsyncPGVectorStore
+
+
+class AsyncPostgresVectorStore(AsyncPGVectorStore):
+    """Google Cloud SQL for PostgreSQL Vector Store class"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)

{langchain_google_cloud_sql_pg-0.14.1 → langchain_google_cloud_sql_pg-0.16.0}/src/langchain_google_cloud_sql_pg/engine.py

@@ -24,6 +24,7 @@ import aiohttp
 import google.auth  # type: ignore
 import google.auth.transport.requests  # type: ignore
 from google.cloud.sql.connector import Connector, IPTypes, RefreshStrategy
+from langchain_postgres import Column, PGEngine
 from sqlalchemy import MetaData, Table, text
 from sqlalchemy.engine import URL
 from sqlalchemy.exc import InvalidRequestError
@@ -78,58 +79,10 @@ async def _get_iam_principal_email(
     return email.replace(".gserviceaccount.com", "")
 
 
-@dataclass
-class Column:
-    name: str
-    data_type: str
-    nullable: bool = True
-
-    def __post_init__(self):
-        """Check if initialization parameters are valid.
-
-        Raises:
-            ValueError: Raises error if Column name is not string.
-            ValueError: Raises error if data_type is not type string.
-        """
-        if not isinstance(self.name, str):
-            raise ValueError("Column name must be type string")
-        if not isinstance(self.data_type, str):
-            raise ValueError("Column data_type must be type string")
-
-
-class PostgresEngine:
+class PostgresEngine(PGEngine):
     """A class for managing connections to a Cloud SQL for Postgres database."""
 
     _connector: Optional[Connector] = None
-    _default_loop: Optional[asyncio.AbstractEventLoop] = None
-    _default_thread: Optional[Thread] = None
-    __create_key = object()
-
-    def __init__(
-        self,
-        key: object,
-        pool: AsyncEngine,
-        loop: Optional[asyncio.AbstractEventLoop],
-        thread: Optional[Thread],
-    ):
-        """PostgresEngine constructor.
-
-        Args:
-            key (object): Prevent direct constructor usage.
-            pool (AsyncEngine): Async engine connection pool.
-            loop (Optional[asyncio.AbstractEventLoop]): Async event loop used to create the engine.
-            thread (Optional[Thread]): Thread used to create the engine async.
-
-        Raises:
-            Exception: If the constructor is called directly by the user.
-        """
-        if key != PostgresEngine.__create_key:
-            raise Exception(
-                "Only create class through 'create' or 'create_sync' methods!"
-            )
-        self._pool = pool
-        self._loop = loop
-        self._thread = thread
 
     @classmethod
     async def _create(
@@ -219,7 +172,7 @@ class PostgresEngine:
             async_creator=getconn,
             **engine_args,
         )
-        return cls(cls.__create_key, engine, loop, thread)
+        return cls(PGEngine._PGEngine__create_key, engine, loop, thread)  # type: ignore
 
     @classmethod
     def __start_background_loop(
@@ -354,13 +307,22 @@ class PostgresEngine:
         return await asyncio.wrap_future(future)
 
     @classmethod
-    def from_engine(
+    def from_connection_string(
         cls,
-        engine: AsyncEngine,
-        loop: Optional[asyncio.AbstractEventLoop] = None,
+        url: str | URL,
+        **kwargs: Any,
     ) -> PostgresEngine:
-        """Create an PostgresEngine instance from an AsyncEngine."""
-        return cls(cls.__create_key, engine, loop, None)
+        """Create an PostgresEngine instance from arguments. These parameters are pass directly into sqlalchemy's create_async_engine function.
+        Args:
+            url (Union[str | URL]): the URL used to connect to a database
+            **kwargs (Any, optional): sqlalchemy `create_async_engine` arguments
+        Raises:
+            ValueError: If `postgresql+asyncpg` is not specified as the PG driver
+        Returns:
+            PostgresEngine
+        """
+
+        return PostgresEngine.from_engine_args(url=url, **kwargs)
 
     @classmethod
     def from_engine_args(
@@ -396,198 +358,7 @@ class PostgresEngine:
             raise ValueError("Driver must be type 'postgresql+asyncpg'")
 
         engine = create_async_engine(url, **kwargs)
-        return cls(cls.__create_key, engine, cls._default_loop, cls._default_thread)
-
-    async def _run_as_async(self, coro: Awaitable[T]) -> T:
-        """Run an async coroutine asynchronously"""
-        # If a loop has not been provided, attempt to run in current thread
-        if not self._loop:
-            return await coro
-        # Otherwise, run in the background thread
-        return await asyncio.wrap_future(
-            asyncio.run_coroutine_threadsafe(coro, self._loop)
-        )
-
-    def _run_as_sync(self, coro: Awaitable[T]) -> T:
-        """Run an async coroutine synchronously"""
-        if not self._loop:
-            raise Exception(
-                "Engine was initialized without a background loop and cannot call sync methods."
-            )
-        return asyncio.run_coroutine_threadsafe(coro, self._loop).result()
-
-    async def close(self) -> None:
-        """Dispose of connection pool"""
-        await self._run_as_async(self._pool.dispose())
-
-    async def _ainit_vectorstore_table(
-        self,
-        table_name: str,
-        vector_size: int,
-        schema_name: str = "public",
-        content_column: str = "content",
-        embedding_column: str = "embedding",
-        metadata_columns: list[Column] = [],
-        metadata_json_column: str = "langchain_metadata",
-        id_column: Union[str, Column] = "langchain_id",
-        overwrite_existing: bool = False,
-        store_metadata: bool = True,
-    ) -> None:
-        """
-        Create a table for saving of vectors to be used with PostgresVectorStore.
-
-        Args:
-            table_name (str): The Postgres database table name.
-            vector_size (int): Vector size for the embedding model to be used.
-            schema_name (str): The schema name to store Postgres database table.
-                Default: "public".
-            content_column (str): Name of the column to store document content.
-                Default: "page_content".
-            embedding_column (str) : Name of the column to store vector embeddings.
-                Default: "embedding".
-            metadata_columns (list[Column]): A list of Columns to create for custom
-                metadata. Default: []. Optional.
-            metadata_json_column (str): The column to store extra metadata in JSON format.
-                Default: "langchain_metadata". Optional.
-            id_column (Union[str, Column]) : Column to store ids.
-                Default: "langchain_id" column name with data type UUID. Optional.
-            overwrite_existing (bool): Whether to drop existing table. Default: False.
-            store_metadata (bool): Whether to store metadata in the table.
-                Default: True.
-        Raises:
-            :class:`DuplicateTableError <asyncpg.exceptions.DuplicateTableError>`: if table already exists and overwrite flag is not set.
-            :class:`UndefinedObjectError <asyncpg.exceptions.UndefinedObjectError>`: if the data type of the id column is not a postgreSQL data type.
-        """
-        async with self._pool.connect() as conn:
-            await conn.execute(text("CREATE EXTENSION IF NOT EXISTS vector"))
-            await conn.commit()
-
-        if overwrite_existing:
-            async with self._pool.connect() as conn:
-                await conn.execute(
-                    text(f'DROP TABLE IF EXISTS "{schema_name}"."{table_name}"')
-                )
-                await conn.commit()
-
-        id_data_type = "UUID" if isinstance(id_column, str) else id_column.data_type
-        id_column_name = id_column if isinstance(id_column, str) else id_column.name
-
-        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"""
-        for column in metadata_columns:
-            nullable = "NOT NULL" if not column.nullable else ""
-            query += f',\n"{column.name}" {column.data_type} {nullable}'
-        if store_metadata:
-            query += f""",\n"{metadata_json_column}" JSON"""
-        query += "\n);"
-
-        async with self._pool.connect() as conn:
-            await conn.execute(text(query))
-            await conn.commit()
-
-    async def ainit_vectorstore_table(
-        self,
-        table_name: str,
-        vector_size: int,
-        schema_name: str = "public",
-        content_column: str = "content",
-        embedding_column: str = "embedding",
-        metadata_columns: list[Column] = [],
-        metadata_json_column: str = "langchain_metadata",
-        id_column: Union[str, Column] = "langchain_id",
-        overwrite_existing: bool = False,
-        store_metadata: bool = True,
-    ) -> None:
-        """
-        Create a table for saving of vectors to be used with PostgresVectorStore.
-
-        Args:
-            table_name (str): The Postgres database table name.
-            vector_size (int): Vector size for the embedding model to be used.
-            schema_name (str): The schema name to store Postgres database table.
-                Default: "public".
-            content_column (str): Name of the column to store document content.
-                Default: "page_content".
-            embedding_column (str) : Name of the column to store vector embeddings.
-                Default: "embedding".
-            metadata_columns (list[Column]): A list of Columns to create for custom
-                metadata. Default: []. Optional.
-            metadata_json_column (str): The column to store extra metadata in JSON format.
-                Default: "langchain_metadata". Optional.
-            id_column (Union[str, Column]) : Column to store ids.
-                Default: "langchain_id" column name with data type UUID. Optional.
-            overwrite_existing (bool): Whether to drop existing table. Default: False.
-            store_metadata (bool): Whether to store metadata in the table.
-                Default: True.
-        """
-        await self._run_as_async(
-            self._ainit_vectorstore_table(
-                table_name,
-                vector_size,
-                schema_name,
-                content_column,
-                embedding_column,
-                metadata_columns,
-                metadata_json_column,
-                id_column,
-                overwrite_existing,
-                store_metadata,
-            )
-        )
-
-    def init_vectorstore_table(
-        self,
-        table_name: str,
-        vector_size: int,
-        schema_name: str = "public",
-        content_column: str = "content",
-        embedding_column: str = "embedding",
-        metadata_columns: list[Column] = [],
-        metadata_json_column: str = "langchain_metadata",
-        id_column: Union[str, Column] = "langchain_id",
-        overwrite_existing: bool = False,
-        store_metadata: bool = True,
-    ) -> None:
-        """
-        Create a table for saving of vectors to be used with PostgresVectorStore.
-
-        Args:
-            table_name (str): The Postgres database table name.
-            vector_size (int): Vector size for the embedding model to be used.
-            schema_name (str): The schema name to store Postgres database table.
-                Default: "public".
-            content_column (str): Name of the column to store document content.
-                Default: "page_content".
-            embedding_column (str) : Name of the column to store vector embeddings.
-                Default: "embedding".
-            metadata_columns (list[Column]): A list of Columns to create for custom
-                metadata. Default: []. Optional.
-            metadata_json_column (str): The column to store extra metadata in JSON format.
-                Default: "langchain_metadata". Optional.
-            id_column (Union[str, Column]) : Column to store ids.
-                Default: "langchain_id" column name with data type UUID. Optional.
-            overwrite_existing (bool): Whether to drop existing table. Default: False.
-            store_metadata (bool): Whether to store metadata in the table.
-                Default: True.
-        Raises:
-            :class:`UndefinedObjectError <asyncpg.exceptions.UndefinedObjectError>`: if the `ids` data type does not match that of the `id_column`.
-        """
-        self._run_as_sync(
-            self._ainit_vectorstore_table(
-                table_name,
-                vector_size,
-                schema_name,
-                content_column,
-                embedding_column,
-                metadata_columns,
-                metadata_json_column,
-                id_column,
-                overwrite_existing,
-                store_metadata,
-            )
-        )
+        return cls(PGEngine._PGEngine__create_key, engine, cls._default_loop, cls._default_thread)  # type: ignore
 
     async def _ainit_chat_history_table(
         self, table_name: str, schema_name: str = "public"

langchain_google_cloud_sql_pg-0.16.0/src/langchain_google_cloud_sql_pg/indexes.py

@@ -0,0 +1,27 @@
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from langchain_postgres.v2.indexes import (
+    DEFAULT_DISTANCE_STRATEGY,
+    DEFAULT_INDEX_NAME_SUFFIX,
+    BaseIndex,
+    DistanceStrategy,
+    ExactNearestNeighbor,
+    HNSWIndex,
+    HNSWQueryOptions,
+    IVFFlatIndex,
+    IVFFlatQueryOptions,
+    QueryOptions,
+    StrategyMixin,
+)