langchain-postgres 0.0.12__tar.gz → 0.0.14__tar.gz

langchain_postgres-0.0.14/PKG-INFO

@@ -0,0 +1,170 @@
+Metadata-Version: 2.1
+Name: langchain-postgres
+Version: 0.0.14
+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
+Description-Content-Type: text/markdown
+
+# langchain-postgres
+
+[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain-postgres)](https://github.com/langchain-ai/langchain-postgres/releases)
+[![CI](https://github.com/langchain-ai/langchain-postgres/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchain-postgres/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
+[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain-postgres)](https://github.com/langchain-ai/langchain-postgres/issues)
+
+The `langchain-postgres` package implementations of core LangChain abstractions using `Postgres`.
+
+The package is released under the MIT license.
+
+Feel free to use the abstraction as provided or else modify them / extend them as appropriate for your own application.
+
+## Requirements
+
+The package supports the [asyncpg](https://github.com/MagicStack/asyncpg) and [psycogp3](https://www.psycopg.org/psycopg3/) drivers.
+
+## Installation
+
+```bash
+pip install -U langchain-postgres
+```
+
+## Usage
+
+### 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`.
+
+For a detailed example on `PGVectorStore` see [here](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb).
+
+```python
+from langchain_core.documents import Document
+from langchain_core.embeddings import DeterministicFakeEmbedding
+from langchain_postgres import PGEngine, PGVectorStore
+
+# Replace the connection string with your own Postgres connection string
+CONNECTION_STRING = "postgresql+psycopg3://langchain:langchain@localhost:6024/langchain"
+engine = PGEngine.from_connection_string(url=CONNECTION_STRING)
+
+# Replace the vector size with your own vector size
+VECTOR_SIZE = 768
+embedding = DeterministicFakeEmbedding(size=VECTOR_SIZE)
+
+TABLE_NAME = "my_doc_collection"
+
+engine.init_vectorstore_table(
+    table_name=TABLE_NAME,
+    vector_size=VECTOR_SIZE,
+)
+
+store = PGVectorStore.create_sync(
+    engine=engine,
+    table_name=TABLE_NAME,
+    embedding_service=embedding,
+)
+
+docs = [
+    Document(page_content="Apples and oranges"),
+    Document(page_content="Cars and airplanes"),
+    Document(page_content="Train")
+]
+
+store.add_documents(docs)
+
+query = "I'd like a fruit."
+docs = store.similarity_search(query)
+print(docs)
+```
+
+> [!TIP]
+> All synchronous functions have corresponding asynchronous functions
+
+### ChatMessageHistory
+
+The chat message history abstraction helps to persist chat message history
+in a postgres table.
+
+PostgresChatMessageHistory is parameterized using a `table_name` and a `session_id`.
+
+The `table_name` is the name of the table in the database where
+the chat messages will be stored.
+
+The `session_id` is a unique identifier for the chat session. It can be assigned
+by the caller using `uuid.uuid4()`.
+
+```python
+import uuid
+
+from langchain_core.messages import SystemMessage, AIMessage, HumanMessage
+from langchain_postgres import PostgresChatMessageHistory
+import psycopg
+
+# Establish a synchronous connection to the database
+# (or use psycopg.AsyncConnection for async)
+conn_info = ... # Fill in with your connection info
+sync_connection = psycopg.connect(conn_info)
+
+# Create the table schema (only needs to be done once)
+table_name = "chat_history"
+PostgresChatMessageHistory.create_tables(sync_connection, table_name)
+
+session_id = str(uuid.uuid4())
+
+# Initialize the chat history manager
+chat_history = PostgresChatMessageHistory(
+    table_name,
+    session_id,
+    sync_connection=sync_connection
+)
+
+# Add messages to the chat history
+chat_history.add_messages([
+    SystemMessage(content="Meow"),
+    AIMessage(content="woof"),
+    HumanMessage(content="bark"),
+])
+
+print(chat_history.messages)
+```
+
+## Google Cloud Integrations
+
+[Google Cloud](https://python.langchain.com/docs/integrations/providers/google/) provides Vector Store, Chat Message History, and Data Loader integrations for [AlloyDB](https://cloud.google.com/alloydb) and [Cloud SQL](https://cloud.google.com/sql) for PostgreSQL databases via the following PyPi packages:
+
+* [`langchain-google-alloydb-pg`](https://github.com/googleapis/langchain-google-alloydb-pg-python)
+
+* [`langchain-google-cloud-sql-pg`](https://github.com/googleapis/langchain-google-cloud-sql-pg-python)
+
+Using the Google Cloud integrations provides the following benefits:
+
+- **Enhanced Security**: Securely connect to Google Cloud databases utilizing IAM for authorization and database authentication without needing to manage SSL certificates, configure firewall rules, or enable authorized networks.
+- **Simplified and Secure Connections:** Connect to Google Cloud databases effortlessly using the instance name instead of complex connection strings. The integrations creates a secure connection pool that can be easily shared across your application using the `engine` object.
+
+| Vector Store             | Metadata filtering | Async support  | Schema Flexibility | Improved metadata handling | Hybrid Search |
+|--------------------------|--------------------|----------------|--------------------|----------------------------|---------------|
+| Google AlloyDB           |          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
+| Google Cloud SQL Postgres|          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
+
+

langchain_postgres-0.0.14/README.md

@@ -0,0 +1,145 @@
+# langchain-postgres
+
+[![Release Notes](https://img.shields.io/github/release/langchain-ai/langchain-postgres)](https://github.com/langchain-ai/langchain-postgres/releases)
+[![CI](https://github.com/langchain-ai/langchain-postgres/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchain-postgres/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai)
+[![](https://dcbadge.vercel.app/api/server/6adMQxSpJS?compact=true&style=flat)](https://discord.gg/6adMQxSpJS)
+[![Open Issues](https://img.shields.io/github/issues-raw/langchain-ai/langchain-postgres)](https://github.com/langchain-ai/langchain-postgres/issues)
+
+The `langchain-postgres` package implementations of core LangChain abstractions using `Postgres`.
+
+The package is released under the MIT license.
+
+Feel free to use the abstraction as provided or else modify them / extend them as appropriate for your own application.
+
+## Requirements
+
+The package supports the [asyncpg](https://github.com/MagicStack/asyncpg) and [psycogp3](https://www.psycopg.org/psycopg3/) drivers.
+
+## Installation
+
+```bash
+pip install -U langchain-postgres
+```
+
+## Usage
+
+### 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`.
+
+For a detailed example on `PGVectorStore` see [here](https://github.com/langchain-ai/langchain-postgres/blob/main/examples/pg_vectorstore.ipynb).
+
+```python
+from langchain_core.documents import Document
+from langchain_core.embeddings import DeterministicFakeEmbedding
+from langchain_postgres import PGEngine, PGVectorStore
+
+# Replace the connection string with your own Postgres connection string
+CONNECTION_STRING = "postgresql+psycopg3://langchain:langchain@localhost:6024/langchain"
+engine = PGEngine.from_connection_string(url=CONNECTION_STRING)
+
+# Replace the vector size with your own vector size
+VECTOR_SIZE = 768
+embedding = DeterministicFakeEmbedding(size=VECTOR_SIZE)
+
+TABLE_NAME = "my_doc_collection"
+
+engine.init_vectorstore_table(
+    table_name=TABLE_NAME,
+    vector_size=VECTOR_SIZE,
+)
+
+store = PGVectorStore.create_sync(
+    engine=engine,
+    table_name=TABLE_NAME,
+    embedding_service=embedding,
+)
+
+docs = [
+    Document(page_content="Apples and oranges"),
+    Document(page_content="Cars and airplanes"),
+    Document(page_content="Train")
+]
+
+store.add_documents(docs)
+
+query = "I'd like a fruit."
+docs = store.similarity_search(query)
+print(docs)
+```
+
+> [!TIP]
+> All synchronous functions have corresponding asynchronous functions
+
+### ChatMessageHistory
+
+The chat message history abstraction helps to persist chat message history
+in a postgres table.
+
+PostgresChatMessageHistory is parameterized using a `table_name` and a `session_id`.
+
+The `table_name` is the name of the table in the database where
+the chat messages will be stored.
+
+The `session_id` is a unique identifier for the chat session. It can be assigned
+by the caller using `uuid.uuid4()`.
+
+```python
+import uuid
+
+from langchain_core.messages import SystemMessage, AIMessage, HumanMessage
+from langchain_postgres import PostgresChatMessageHistory
+import psycopg
+
+# Establish a synchronous connection to the database
+# (or use psycopg.AsyncConnection for async)
+conn_info = ... # Fill in with your connection info
+sync_connection = psycopg.connect(conn_info)
+
+# Create the table schema (only needs to be done once)
+table_name = "chat_history"
+PostgresChatMessageHistory.create_tables(sync_connection, table_name)
+
+session_id = str(uuid.uuid4())
+
+# Initialize the chat history manager
+chat_history = PostgresChatMessageHistory(
+    table_name,
+    session_id,
+    sync_connection=sync_connection
+)
+
+# Add messages to the chat history
+chat_history.add_messages([
+    SystemMessage(content="Meow"),
+    AIMessage(content="woof"),
+    HumanMessage(content="bark"),
+])
+
+print(chat_history.messages)
+```
+
+## Google Cloud Integrations
+
+[Google Cloud](https://python.langchain.com/docs/integrations/providers/google/) provides Vector Store, Chat Message History, and Data Loader integrations for [AlloyDB](https://cloud.google.com/alloydb) and [Cloud SQL](https://cloud.google.com/sql) for PostgreSQL databases via the following PyPi packages:
+
+* [`langchain-google-alloydb-pg`](https://github.com/googleapis/langchain-google-alloydb-pg-python)
+
+* [`langchain-google-cloud-sql-pg`](https://github.com/googleapis/langchain-google-cloud-sql-pg-python)
+
+Using the Google Cloud integrations provides the following benefits:
+
+- **Enhanced Security**: Securely connect to Google Cloud databases utilizing IAM for authorization and database authentication without needing to manage SSL certificates, configure firewall rules, or enable authorized networks.
+- **Simplified and Secure Connections:** Connect to Google Cloud databases effortlessly using the instance name instead of complex connection strings. The integrations creates a secure connection pool that can be easily shared across your application using the `engine` object.
+
+| Vector Store             | Metadata filtering | Async support  | Schema Flexibility | Improved metadata handling | Hybrid Search |
+|--------------------------|--------------------|----------------|--------------------|----------------------------|---------------|
+| Google AlloyDB           |          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
+| Google Cloud SQL Postgres|          ✓         |        ✓       |         ✓          |             ✓              |       ✗       |
+

{langchain_postgres-0.0.12 → langchain_postgres-0.0.14}/langchain_postgres/__init__.py

@@ -2,6 +2,8 @@ from importlib import metadata
 
 from langchain_postgres.chat_message_histories import PostgresChatMessageHistory
 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
 
 try:
@@ -12,7 +14,11 @@ except metadata.PackageNotFoundError:
 
 __all__ = [
     "__version__",
+    "Column",
+    "ColumnDict",
+    "PGEngine",
     "PostgresChatMessageHistory",
     "PGVector",
+    "PGVectorStore",
     "PGVectorTranslator",
 ]

{langchain_postgres-0.0.12 → langchain_postgres-0.0.14}/langchain_postgres/chat_message_histories.py

@@ -340,11 +340,17 @@ class PostgresChatMessageHistory(BaseChatMessageHistory):
         messages = messages_from_dict(items)
         return messages
 
-    @property  # type: ignore[override]
+    @property
     def messages(self) -> List[BaseMessage]:
         """The abstraction required a property."""
         return self.get_messages()
 
+    @messages.setter
+    def messages(self, value: list[BaseMessage]) -> None:
+        """Clear the stored messages and appends a list of messages."""
+        self.clear()
+        self.add_messages(value)
+
     def clear(self) -> None:
         """Clear the chat message history for the GIVEN session."""
         if self._connection is None:

langchain_postgres-0.0.14/langchain_postgres/utils/pgvector_migrator.py

@@ -0,0 +1,321 @@
+import asyncio
+import json
+import warnings
+from typing import Any, AsyncIterator, Iterator, Optional, Sequence, TypeVar
+
+from sqlalchemy import RowMapping, text
+from sqlalchemy.exc import ProgrammingError, SQLAlchemyError
+
+from ..v2.engine import PGEngine
+from ..v2.vectorstores import PGVectorStore
+
+COLLECTIONS_TABLE = "langchain_pg_collection"
+EMBEDDINGS_TABLE = "langchain_pg_embedding"
+
+T = TypeVar("T")
+
+
+async def __aget_collection_uuid(
+    engine: PGEngine,
+    collection_name: str,
+) -> str:
+    """
+    Get the collection uuid for a collection present in PGVector tables.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The name of the collection to get the uuid for.
+    Returns:
+        The uuid corresponding to the collection.
+    """
+    query = f"SELECT name, uuid FROM {COLLECTIONS_TABLE} WHERE name = :collection_name"
+    async with engine._pool.connect() as conn:
+        result = await conn.execute(
+            text(query), parameters={"collection_name": collection_name}
+        )
+        result_map = result.mappings()
+        result_fetch = result_map.fetchone()
+    if result_fetch is None:
+        raise ValueError(f"Collection, {collection_name} not found.")
+    return result_fetch.uuid
+
+
+async def __aextract_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    batch_size: int = 1000,
+) -> AsyncIterator[Sequence[RowMapping]]:
+    """
+    Extract all data belonging to a PGVector collection.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The name of the collection to get the data for.
+        batch_size (int): The batch size for collection extraction.
+            Default: 1000. Optional.
+
+    Yields:
+        The data present in the collection.
+    """
+    try:
+        uuid_task = asyncio.create_task(__aget_collection_uuid(engine, collection_name))
+        query = f"SELECT * FROM {EMBEDDINGS_TABLE} WHERE collection_id = :id"
+        async with engine._pool.connect() as conn:
+            uuid = await uuid_task
+            result_proxy = await conn.execute(text(query), parameters={"id": uuid})
+            while True:
+                rows = result_proxy.fetchmany(size=batch_size)
+                if not rows:
+                    break
+                yield [row._mapping for row in rows]
+    except ValueError:
+        raise ValueError(f"Collection, {collection_name} does not exist.")
+    except SQLAlchemyError as e:
+        raise ProgrammingError(
+            statement=f"Failed to extract data from collection '{collection_name}': {e}",
+            params={"id": uuid},
+            orig=e,
+        ) from e
+
+
+async def __concurrent_batch_insert(
+    data_batches: AsyncIterator[Sequence[RowMapping]],
+    vector_store: PGVectorStore,
+    max_concurrency: int = 100,
+) -> None:
+    pending: set[Any] = set()
+    async for batch_data in data_batches:
+        pending.add(
+            asyncio.ensure_future(
+                vector_store.aadd_embeddings(
+                    texts=[data.document for data in batch_data],
+                    embeddings=[json.loads(data.embedding) for data in batch_data],
+                    metadatas=[data.cmetadata for data in batch_data],
+                    ids=[data.id for data in batch_data],
+                )
+            )
+        )
+        if len(pending) >= max_concurrency:
+            _, pending = await asyncio.wait(
+                pending, return_when=asyncio.FIRST_COMPLETED
+            )
+    if pending:
+        await asyncio.wait(pending)
+
+
+async def __amigrate_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    vector_store: PGVectorStore,
+    delete_pg_collection: Optional[bool] = False,
+    insert_batch_size: int = 1000,
+) -> None:
+    """
+    Migrate all data present in a PGVector collection to use separate tables for each collection.
+    The new data format is compatible with the PGVectoreStore interface.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The collection to migrate.
+        vector_store (PGVectorStore): The PGVectorStore object corresponding to the new collection table.
+        delete_pg_collection (bool): An option to delete the original data upon migration.
+            Default: False. Optional.
+        insert_batch_size (int): Number of rows to insert at once in the table.
+            Default: 1000.
+    """
+    destination_table = vector_store.get_table_name()
+
+    # Get row count in PGVector collection
+    uuid_task = asyncio.create_task(__aget_collection_uuid(engine, collection_name))
+    query = (
+        f"SELECT COUNT(*) FROM {EMBEDDINGS_TABLE} WHERE collection_id=:collection_id"
+    )
+    async with engine._pool.connect() as conn:
+        uuid = await uuid_task
+        result = await conn.execute(text(query), parameters={"collection_id": uuid})
+        result_map = result.mappings()
+        collection_data_len = result_map.fetchone()
+    if collection_data_len is None:
+        warnings.warn(f"Collection, {collection_name} contains no elements.")
+        return
+
+    # Extract data from the collection and batch insert into the new table
+    data_batches = __aextract_pgvector_collection(
+        engine, collection_name, batch_size=insert_batch_size
+    )
+    await __concurrent_batch_insert(data_batches, vector_store, max_concurrency=100)
+
+    # Validate data migration
+    query = f"SELECT COUNT(*) FROM {destination_table}"
+    async with engine._pool.connect() as conn:
+        result = await conn.execute(text(query))
+        result_map = result.mappings()
+        table_size = result_map.fetchone()
+    if not table_size:
+        raise ValueError(f"Table: {destination_table} does not exist.")
+
+    if collection_data_len["count"] != table_size["count"]:
+        raise ValueError(
+            "All data not yet migrated.\n"
+            f"Original row count: {collection_data_len['count']}\n"
+            f"Collection table, {destination_table} row count: {table_size['count']}"
+        )
+    elif delete_pg_collection:
+        # Delete PGVector data
+        query = f"DELETE FROM {EMBEDDINGS_TABLE} WHERE collection_id=:collection_id"
+        async with engine._pool.connect() as conn:
+            await conn.execute(text(query), parameters={"collection_id": uuid})
+            await conn.commit()
+
+        query = f"DELETE FROM {COLLECTIONS_TABLE} WHERE name=:collection_name"
+        async with engine._pool.connect() as conn:
+            await conn.execute(
+                text(query), parameters={"collection_name": collection_name}
+            )
+            await conn.commit()
+        print(f"Successfully deleted PGVector collection, {collection_name}")
+
+
+async def __alist_pgvector_collection_names(
+    engine: PGEngine,
+) -> list[str]:
+    """Lists all collection names present in PGVector table."""
+    try:
+        query = f"SELECT name from {COLLECTIONS_TABLE}"
+        async with engine._pool.connect() as conn:
+            result = await conn.execute(text(query))
+            result_map = result.mappings()
+            all_rows = result_map.fetchall()
+        return [row["name"] for row in all_rows]
+    except ProgrammingError as e:
+        raise ValueError(
+            "Please provide the correct collection table name: " + str(e)
+        ) from e
+
+
+async def aextract_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    batch_size: int = 1000,
+) -> AsyncIterator[Sequence[RowMapping]]:
+    """
+    Extract all data belonging to a PGVector collection.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The name of the collection to get the data for.
+        batch_size (int): The batch size for collection extraction.
+            Default: 1000. Optional.
+
+    Yields:
+        The data present in the collection.
+    """
+    iterator = __aextract_pgvector_collection(engine, collection_name, batch_size)
+    while True:
+        try:
+            result = await engine._run_as_async(iterator.__anext__())
+            yield result
+        except StopAsyncIteration:
+            break
+
+
+async def alist_pgvector_collection_names(
+    engine: PGEngine,
+) -> list[str]:
+    """Lists all collection names present in PGVector table."""
+    return await engine._run_as_async(__alist_pgvector_collection_names(engine))
+
+
+async def amigrate_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    vector_store: PGVectorStore,
+    delete_pg_collection: Optional[bool] = False,
+    insert_batch_size: int = 1000,
+) -> None:
+    """
+    Migrate all data present in a PGVector collection to use separate tables for each collection.
+    The new data format is compatible with the PGVectorStore interface.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The collection to migrate.
+        vector_store (PGVectorStore): The PGVectorStore object corresponding to the new collection table.
+        use_json_metadata (bool): An option to keep the PGVector metadata as json in the new table.
+            Default: False. Optional.
+        delete_pg_collection (bool): An option to delete the original data upon migration.
+            Default: False. Optional.
+        insert_batch_size (int): Number of rows to insert at once in the table.
+            Default: 1000.
+    """
+    await engine._run_as_async(
+        __amigrate_pgvector_collection(
+            engine,
+            collection_name,
+            vector_store,
+            delete_pg_collection,
+            insert_batch_size,
+        )
+    )
+
+
+def extract_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    batch_size: int = 1000,
+) -> Iterator[Sequence[RowMapping]]:
+    """
+    Extract all data belonging to a PGVector collection.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The name of the collection to get the data for.
+        batch_size (int): The batch size for collection extraction.
+            Default: 1000. Optional.
+
+    Yields:
+        The data present in the collection.
+    """
+    iterator = __aextract_pgvector_collection(engine, collection_name, batch_size)
+    while True:
+        try:
+            result = engine._run_as_sync(iterator.__anext__())
+            yield result
+        except StopAsyncIteration:
+            break
+
+
+def list_pgvector_collection_names(engine: PGEngine) -> list[str]:
+    """Lists all collection names present in PGVector table."""
+    return engine._run_as_sync(__alist_pgvector_collection_names(engine))
+
+
+def migrate_pgvector_collection(
+    engine: PGEngine,
+    collection_name: str,
+    vector_store: PGVectorStore,
+    delete_pg_collection: Optional[bool] = False,
+    insert_batch_size: int = 1000,
+) -> None:
+    """
+    Migrate all data present in a PGVector collection to use separate tables for each collection.
+    The new data format is compatible with the PGVectorStore interface.
+
+    Args:
+        engine (PGEngine): The PG engine corresponding to the Database.
+        collection_name (str): The collection to migrate.
+        vector_store (PGVectorStore): The PGVectorStore object corresponding to the new collection table.
+        delete_pg_collection (bool): An option to delete the original data upon migration.
+            Default: False. Optional.
+        insert_batch_size (int): Number of rows to insert at once in the table.
+            Default: 1000.
+    """
+    engine._run_as_sync(
+        __amigrate_pgvector_collection(
+            engine,
+            collection_name,
+            vector_store,
+            delete_pg_collection,
+            insert_batch_size,
+        )
+    )