Add a schema name to PGVector

[OmiWakode]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from langchain.vectorstores.pgvector import PGVector

db = PGVector(
    embedding = embeddings,
    collection_name= "__",
    connection_string=CONNECTION_STRING
)

Description

How to override the PGVector class so that I can specify the schema name? I tries adding table_args: {"schema": 'text"}
to the collectionstore and the embedding store but nothing seems to work.
Error:
sqlalchemy.exc.NoReferencedTableError: Foreign key associated with column 'langchain_pg_embedding.collection_id' could not find table 'langchain_pg_collection' with which to generate a foreign key to target column 'uuid'

When I remove the table_args it works perfectly fine with in my custom PGVector

IDK can anyone please help? Stuck on this since days , new to this:(

System Info

System Information

OS: Windows
OS Version: 10.0.17763
Python Version: 3.10.0 (tags/v3.10.0:b494f59, Oct 4 2021, 19:00:18) [MSC v.1929 64 bit (AMD64)]
Package Information

---

langchain_core: 0.1.30
langchain: 0.1.11
langchain_community: 0.0.27
langsmith: 0.1.22
langchain_openai: 0.0.8
langchain_text_splitters: 0.0.1
langchainplus_sdk: 0.0.20
Packages not installed (Not Necessarily a Problem)

---

The following packages were not found:

langgraph
langserve

[dosubot[bot]]

To successfully add a schema name to PGVector in LangChain without encountering the sqlalchemy.exc.NoReferencedTableError error, you need to ensure that the schema you're trying to use already exists in your PostgreSQL database. The error you're encountering typically happens when SQLAlchemy tries to reference a table in a schema that does not exist.

In the provided context, there is no direct mention of setting or using a specific schema name in the PGVector class or its methods. However, you can specify the schema name in the PostgreSQL connection string or explicitly set it in your SQLAlchemy models or during the table creation process in SQLAlchemy.

Here's a general approach to specify the schema in SQLAlchemy, which you can adapt to the PGVector setup:

1. Ensure the Schema Exists: Before running your application, make sure the schema you want to use exists in your PostgreSQL database. You can create a schema using the PostgreSQL command line or a GUI tool:

   CREATE SCHEMA IF NOT EXISTS your_schema_name;

2. Specify Schema in SQLAlchemy Models: When defining your models in SQLAlchemy, you can specify the schema name using the __table_args__ attribute in your model class. For example:

   class YourModel(Base):
       __tablename__ = 'your_table_name'
       __table_args__ = {'schema': 'your_schema_name'}
       # define your columns here

3. Adjust PGVector Initialization: If PGVector or its underlying components support specifying a schema (not shown in the provided context), ensure you pass the schema name when initializing PGVector or when creating tables.

4. Modify Connection String (Optional): Some setups might allow specifying the default schema in the connection string. This approach is less common and might not be supported directly by PGVector or SQLAlchemy. A typical PostgreSQL connection string does not include a schema parameter, as the schema is a level below the database in the hierarchy.

Given the context does not show how PGVector handles schemas directly, you would likely need to modify the PGVector class or the way you use SQLAlchemy within the LangChain framework to support specifying a schema. This could involve adjusting the table creation logic to include the schema name or extending PGVector to accept a schema parameter and use it in all database operations.

If PGVector and LangChain have specific mechanisms or configurations for handling schemas that are not shown in the provided context, you would need to refer to their documentation or source code to make the necessary adjustments.

For more information, you can refer to the LangChain PGVector test file which might provide some insights on how the PGVector class is implemented and used.

Sources

• libs/community/tests/integration_tests/vectorstores/test_pgvector.py
• tests/integration_tests/vectorstores/test_pgvector.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[OmiWakode]

@dosu-bot I have already tried creating the schema first, and get the same error

[dosubot[bot]]

Based on the error message you're encountering, it seems like SQLAlchemy is unable to find the table 'langchain_pg_collection' in the specified schema. This could be due to a few reasons:

1. The schema 'text' does not exist in your PostgreSQL database. You can verify this by running the following SQL command in your PostgreSQL database:

   SELECT schema_name
   FROM information_schema.schemata
   WHERE schema_name = 'text';

   If the schema does not exist, you can create it using the following SQL command:

   CREATE SCHEMA text;

2. The table 'langchain_pg_collection' does not exist in the schema 'text'. You can verify this by running the following SQL command in your PostgreSQL database:

   SELECT table_name
   FROM information_schema.tables
   WHERE table_schema = 'text' AND table_name = 'langchain_pg_collection';

   If the table does not exist, you will need to create it. However, this should be handled by LangChain's migration scripts, so if the table is missing, it might indicate a problem with the migration scripts or the way they're being run.

3. The __table_args__ attribute is not being correctly applied to the SQLAlchemy models used by PGVector. You mentioned that you tried adding __table_args__: {"schema": 'text"} to the collectionstore and the embedding store, but it didn't seem to work. Could you provide more details about how you're applying this attribute? It should be applied at the class level, like so:

   class CollectionStore(Base):
       __tablename__ = 'langchain_pg_collection'
       __table_args__ = {'schema': 'text'}
       # model fields go here

   Similarly for the embedding store:

   class EmbeddingStore(Base):
       __tablename__ = 'langchain_pg_embedding'
       __table_args__ = {'schema': 'text'}
       # model fields go here

   If you're applying the __table_args__ attribute in this way and it's still not working, there might be a problem with how PGVector is using these models.

4. There might be a problem with your connection string. Could you verify that your connection string is correctly formatted and includes the correct credentials for your PostgreSQL database?

If none of these suggestions resolve your issue, could you provide more details about your PostgreSQL database setup and the exact steps you're taking to reproduce this error? This will help me better understand your situation and provide more targeted assistance.

Sources

• libs/community/tests/integration_tests/vectorstores/test_pgvector.py
• tests/integration_tests/vectorstores/test_pgvector.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[maximeperrindev]

Hi @OmiWakode ,

The table name is hard coded in langchain_community/vectorstores/pgvector.py (all examples below refer to this file) :

def _get_embedding_collection_store(vector_dimension: Optional[int] = None) -> Any:
    global _classes
    if _classes is not None:
        return _classes

    from pgvector.sqlalchemy import Vector

    class CollectionStore(BaseModel):
        """Collection store."""

        __tablename__ = "langchain_pg_collection"

        name = sqlalchemy.Column(sqlalchemy.String)
        cmetadata = sqlalchemy.Column(JSON)

        embeddings = relationship(
            "EmbeddingStore",
            back_populates="collection",
            passive_deletes=True,
        )

And here :

    class EmbeddingStore(BaseModel):
        """Embedding store."""

        __tablename__ = "langchain_pg_embedding"

        collection_id = sqlalchemy.Column(
            UUID(as_uuid=True),
            sqlalchemy.ForeignKey(
                f"{CollectionStore.__tablename__}.uuid",
                ondelete="CASCADE",
            ),
        )

I'm not sure if it's recommended to change this variable but just in case, you could try to add parameters or hard code your updated schema

[paulonasc]

Looking to implement this into a feature as well. Please feel free to upvote the idea here if you find it helpful: #20878

[anupkg1985]

Proposed this PR - langchain-ai/langchain-postgres#138