langroid 0.39.5__py3-none-any.whl → 0.41.0__py3-none-any.whl

langroid/vector_store/postgres.py

@@ -0,0 +1,422 @@
+import hashlib
+import json
+import logging
+import os
+import uuid
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+from langroid.embedding_models.base import (
+    EmbeddingModelsConfig,
+)
+from langroid.embedding_models.models import OpenAIEmbeddingsConfig
+from langroid.exceptions import LangroidImportError
+from langroid.mytypes import DocMetaData, Document
+from langroid.vector_store.base import VectorStore, VectorStoreConfig
+
+has_postgres: bool = True
+try:
+    from sqlalchemy import (
+        Column,
+        MetaData,
+        String,
+        Table,
+        case,
+        create_engine,
+        inspect,
+        text,
+    )
+    from sqlalchemy.dialects.postgresql import JSONB
+    from sqlalchemy.engine import Connection, Engine
+    from sqlalchemy.orm import sessionmaker
+    from sqlalchemy.sql.expression import insert
+except ImportError:
+    Engine = Any  # type: ignore
+    Connection = Any  # type: ignore
+    has_postgres = False
+
+logger = logging.getLogger(__name__)
+
+
+class PostgresDBConfig(VectorStoreConfig):
+    collection_name: str = "embeddings"
+    cloud: bool = False
+    docker: bool = True
+    host: str = "127.0.0.1"
+    port: int = 5432
+    replace_collection: bool = False
+    embedding: EmbeddingModelsConfig = OpenAIEmbeddingsConfig()
+    pool_size: int = 10
+    max_overflow: int = 20
+    hnsw_m: int = 16
+    hnsw_ef_construction: int = 200
+
+
+class PostgresDB(VectorStore):
+    def __init__(self, config: PostgresDBConfig = PostgresDBConfig()):
+        super().__init__(config)
+        if not has_postgres:
+            raise LangroidImportError("pgvector", "postgres")
+        self.config: PostgresDBConfig = config
+        self.engine = self._create_engine()
+        PostgresDB._create_vector_extension(self.engine)
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.engine
+        )
+        self.metadata = MetaData()
+        self._setup_table()
+
+    def _create_engine(self) -> Engine:
+        """Creates a SQLAlchemy engine based on the configuration."""
+
+        connection_string: str | None = None  # Ensure variable is always defined
+
+        if self.config.cloud:
+            connection_string = os.getenv("POSTGRES_CONNECTION_STRING")
+
+            if connection_string and connection_string.startswith("postgres://"):
+                connection_string = connection_string.replace(
+                    "postgres://", "postgresql+psycopg2://", 1
+                )
+            elif not connection_string:
+                raise ValueError("Provide the POSTGRES_CONNECTION_STRING.")
+
+        elif self.config.docker:
+            username = os.getenv("POSTGRES_USER", "postgres")
+            password = os.getenv("POSTGRES_PASSWORD", "postgres")
+            database = os.getenv("POSTGRES_DB", "langroid")
+
+            if not (username and password and database):
+                raise ValueError(
+                    "Provide POSTGRES_USER, POSTGRES_PASSWORD, " "POSTGRES_DB. "
+                )
+
+            connection_string = (
+                f"postgresql+psycopg2://{username}:{password}@"
+                f"{self.config.host}:{self.config.port}/{database}"
+            )
+            self.config.cloud = False  # Ensures cloud is disabled if using Docker
+
+        else:
+            raise ValueError(
+                "Provide either Docker or Cloud config to connect to the database."
+            )
+
+        return create_engine(
+            connection_string,
+            pool_size=self.config.pool_size,
+            max_overflow=self.config.max_overflow,
+        )
+
+    def _setup_table(self) -> None:
+        try:
+            from pgvector.sqlalchemy import Vector
+        except ImportError as e:
+            raise LangroidImportError(extra="postgres", error=str(e))
+
+        if self.config.replace_collection:
+            self.delete_collection(self.config.collection_name)
+
+        self.embeddings_table = Table(
+            self.config.collection_name,
+            self.metadata,
+            Column("id", String, primary_key=True, nullable=False, unique=True),
+            Column("embedding", Vector(self.embedding_dim)),
+            Column("document", String),
+            Column("cmetadata", JSONB),
+            extend_existing=True,
+        )
+
+        self.metadata.create_all(self.engine)
+        self.metadata.reflect(bind=self.engine, only=[self.config.collection_name])
+
+        # Create HNSW index for embeddings column if it doesn't exist.
+        # This index enables efficient nearest-neighbor search using cosine similarity.
+        # PostgreSQL automatically builds the index after creation;
+        # no manual step required.
+        # Read more about pgvector hnsw index here:
+        # https://github.com/pgvector/pgvector?tab=readme-ov-file#hnsw
+
+        index_name = f"hnsw_index_{self.config.collection_name}_embedding"
+        with self.engine.connect() as connection:
+            if not self.index_exists(connection, index_name):
+                connection.execute(text("COMMIT"))
+                create_index_query = text(
+                    f"""
+                    CREATE INDEX CONCURRENTLY IF NOT EXISTS {index_name}
+                    ON {self.config.collection_name}
+                    USING hnsw (embedding vector_cosine_ops)
+                    WITH (
+                        m = {self.config.hnsw_m},
+                        ef_construction = {self.config.hnsw_ef_construction}
+                    );
+                    """
+                )
+                connection.execute(create_index_query)
+
+    def index_exists(self, connection: Connection, index_name: str) -> bool:
+        """Check if an index exists."""
+        query = text(
+            "SELECT 1 FROM pg_indexes WHERE indexname = :index_name"
+        ).bindparams(index_name=index_name)
+        result = connection.execute(query).scalar()
+        return bool(result)
+
+    @staticmethod
+    def _create_vector_extension(conn: Engine) -> None:
+
+        with conn.connect() as connection:
+            with connection.begin():
+                # The number is a unique identifier used to lock a specific resource
+                # during transaction. Any 64-bit integer can be used for advisory locks.
+                # Acquire advisory lock to ensure atomic, isolated setup
+                # and prevent race conditions.
+
+                statement = text(
+                    "SELECT pg_advisory_xact_lock(1573678846307946496);"
+                    "CREATE EXTENSION IF NOT EXISTS vector;"
+                )
+                connection.execute(statement)
+
+    def set_collection(self, collection_name: str, replace: bool = False) -> None:
+        inspector = inspect(self.engine)
+        table_exists = collection_name in inspector.get_table_names()
+
+        if (
+            collection_name == self.config.collection_name
+            and table_exists
+            and not replace
+        ):
+            return
+        else:
+            self.config.collection_name = collection_name
+            self.config.replace_collection = replace
+            self._setup_table()
+
+    def list_collections(self, empty: bool = True) -> List[str]:
+        inspector = inspect(self.engine)
+        table_names = inspector.get_table_names()
+
+        with self.SessionLocal() as session:
+            collections = []
+            for table_name in table_names:
+                table = Table(table_name, self.metadata, autoload_with=self.engine)
+                if empty:
+                    collections.append(table_name)
+                else:
+                    # Efficiently check for non-emptiness
+                    if session.query(table.select().limit(1).exists()).scalar():
+                        collections.append(table_name)
+            return collections
+
+    def create_collection(self, collection_name: str, replace: bool = False) -> None:
+        self.set_collection(collection_name, replace=replace)
+
+    def delete_collection(self, collection_name: str) -> None:
+        """
+        Deletes a collection and its associated HNSW index, handling metadata
+        synchronization issues.
+        """
+        with self.engine.connect() as connection:
+            connection.execute(text("COMMIT"))
+            index_name = f"hnsw_index_{collection_name}_embedding"
+            drop_index_query = text(f"DROP INDEX CONCURRENTLY IF EXISTS {index_name}")
+            connection.execute(drop_index_query)
+
+            # 3. Now, drop the table using SQLAlchemy
+            table = Table(collection_name, self.metadata)
+            table.drop(self.engine, checkfirst=True)
+
+            # 4. Refresh metadata again after dropping the table
+            self.metadata.clear()
+            self.metadata.reflect(bind=self.engine)
+
+    def clear_all_collections(self, really: bool = False, prefix: str = "") -> int:
+        if not really:
+            logger.warning("Not deleting all tables, set really=True to confirm")
+            return 0
+
+        inspector = inspect(self.engine)
+        table_names = inspector.get_table_names()
+
+        with self.SessionLocal() as session:
+            deleted_count = 0
+            for table_name in table_names:
+                if table_name.startswith(prefix):
+                    # Use delete_collection to handle index and table deletion
+                    self.delete_collection(table_name)
+                    deleted_count += 1
+            session.commit()
+            logger.warning(f"Deleted {deleted_count} tables with prefix '{prefix}'.")
+            return deleted_count
+
+    def clear_empty_collections(self) -> int:
+        inspector = inspect(self.engine)
+        table_names = inspector.get_table_names()
+
+        with self.SessionLocal() as session:
+            deleted_count = 0
+            for table_name in table_names:
+                table = Table(table_name, self.metadata, autoload_with=self.engine)
+
+                # Efficiently check for emptiness without fetching all rows
+                if session.query(table.select().limit(1).exists()).scalar():
+                    continue
+
+                # Use delete_collection to handle index and table deletion
+                self.delete_collection(table_name)
+                deleted_count += 1
+
+            session.commit()  # Commit is likely not needed here
+            logger.warning(f"Deleted {deleted_count} empty tables.")
+            return deleted_count
+
+    def _parse_embedding_store_record(self, res: Any) -> Dict[str, Any]:
+        metadata = res.cmetadata or {}
+        metadata["id"] = res.id
+        return {
+            "content": res.document,
+            "metadata": DocMetaData(**metadata),
+        }
+
+    def get_all_documents(self, where: str = "") -> List[Document]:
+        with self.SessionLocal() as session:
+            query = session.query(self.embeddings_table)
+
+            # Apply 'where' clause if provided
+            if where:
+                try:
+                    where_json = json.loads(where)
+                    query = query.filter(
+                        self.embeddings_table.c.cmetadata.contains(where_json)
+                    )
+                except json.JSONDecodeError:
+                    logger.error(f"Invalid JSON in 'where' clause: {where}")
+                    return []  # Return empty list or handle error as appropriate
+
+            results = query.all()
+            documents = [
+                Document(**self._parse_embedding_store_record(res)) for res in results
+            ]
+            return documents
+
+    def get_documents_by_ids(self, ids: List[str]) -> List[Document]:
+        with self.SessionLocal() as session:
+            # Add a CASE statement to preserve the order of IDs
+            case_stmt = case(
+                {id_: index for index, id_ in enumerate(ids)},
+                value=self.embeddings_table.c.id,
+            )
+
+            query = (
+                session.query(self.embeddings_table)
+                .filter(self.embeddings_table.c.id.in_(ids))
+                .order_by(case_stmt)  # Order by the CASE statement
+            )
+            results = query.all()
+
+            documents = [
+                Document(**self._parse_embedding_store_record(row)) for row in results
+            ]
+            return documents
+
+    def add_documents(self, documents: Sequence[Document]) -> None:
+        super().maybe_add_ids(documents)
+        for doc in documents:
+            doc.metadata.id = str(PostgresDB._id_to_uuid(doc.metadata.id, doc.metadata))
+
+        embeddings = self.embedding_fn([doc.content for doc in documents])
+
+        batch_size = self.config.batch_size
+        with self.SessionLocal() as session:
+            for i in range(0, len(documents), batch_size):
+                batch_docs = documents[i : i + batch_size]
+                batch_embeddings = embeddings[i : i + batch_size]
+
+                new_records = [
+                    {
+                        "id": doc.metadata.id,
+                        "embedding": embedding,
+                        "document": doc.content,
+                        "cmetadata": doc.metadata.dict(),
+                    }
+                    for doc, embedding in zip(batch_docs, batch_embeddings)
+                ]
+
+                if new_records:
+                    stmt = insert(self.embeddings_table).values(new_records)
+                    session.execute(stmt)
+                session.commit()
+
+    @staticmethod
+    def _id_to_uuid(id: str, obj: object) -> str:
+        try:
+            doc_id = str(uuid.UUID(id))
+        except ValueError:
+            obj_repr = repr(obj)
+
+            obj_hash = hashlib.sha256(obj_repr.encode()).hexdigest()
+
+            combined = f"{id}-{obj_hash}"
+
+            doc_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, combined))
+
+        return doc_id
+
+    def similar_texts_with_scores(
+        self,
+        query: str,
+        k: int = 1,
+        where: Optional[str] = None,
+        neighbors: int = 1,  # Parameter not used in this implementation
+    ) -> List[Tuple[Document, float]]:
+        embedding = self.embedding_fn([query])[0]
+
+        with self.SessionLocal() as session:
+            # Calculate the score (1 - cosine_distance) and label it as "score"
+            score = (
+                1 - (self.embeddings_table.c.embedding.cosine_distance(embedding))
+            ).label("score")
+
+            if where is not None:
+                try:
+                    json_query = json.loads(where)
+                except json.JSONDecodeError:
+                    raise ValueError(f"Invalid JSON in 'where' clause: {where}")
+
+                results = (
+                    session.query(
+                        self.embeddings_table.c.id,
+                        self.embeddings_table.c.document,
+                        self.embeddings_table.c.cmetadata,
+                        score,  # Select the calculated score
+                    )
+                    .filter(self.embeddings_table.c.cmetadata.contains(json_query))
+                    .order_by(score.desc())  # Order by score in descending order
+                    .limit(k)
+                    .all()
+                )
+            else:
+                results = (
+                    session.query(
+                        self.embeddings_table.c.id,
+                        self.embeddings_table.c.document,
+                        self.embeddings_table.c.cmetadata,
+                        score,  # Select the calculated score
+                    )
+                    .order_by(score.desc())  # Order by score in descending order
+                    .limit(k)
+                    .all()
+                )
+
+            documents_with_scores = [
+                (
+                    Document(
+                        content=result.document,
+                        metadata=DocMetaData(**(result.cmetadata or {})),
+                    ),
+                    result.score,  # Use the score from the query result
+                )
+                for result in results
+            ]
+
+            return documents_with_scores

langroid/vector_store/weaviatedb.py

@@ -1,7 +1,7 @@
 import logging
 import os
 import re
-from typing import Any, List, Optional, Sequence, Tuple
+from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Tuple
 
 from dotenv import load_dotenv
 
@@ -15,6 +15,7 @@ from langroid.utils.configuration import settings
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
 logger = logging.getLogger(__name__)
+has_weaviate: bool = True
 try:
     import weaviate
     from weaviate.classes.config import (
@@ -25,7 +26,18 @@ try:
     from weaviate.classes.query import Filter, MetadataQuery
     from weaviate.util import generate_uuid5, get_valid_uuid
 except ImportError:
-    raise LangroidImportError("weaviate", "weaviate")
+    has_weaviate = False
+
+    if not TYPE_CHECKING:
+
+        class VectorDistances:
+            """
+            Fallback class when weaviate is not installed, to avoid import errors.
+            """
+
+            COSINE: str = "cosine"
+            DOTPRODUCT: str = "dot"
+            L2: str = "l2"
 
 
 class WeaviateDBConfig(VectorStoreConfig):
@@ -39,6 +51,8 @@ class WeaviateDBConfig(VectorStoreConfig):
 class WeaviateDB(VectorStore):
     def __init__(self, config: WeaviateDBConfig = WeaviateDBConfig()):
         super().__init__(config)
+        if not has_weaviate:
+            raise LangroidImportError("weaviate", "weaviate")
         self.config: WeaviateDBConfig = config
         load_dotenv()
         if not self.config.cloud:

{langroid-0.39.5.dist-info → langroid-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.39.5
+Version: 0.41.0
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -15,6 +15,7 @@ Requires-Dist: colorlog<7.0.0,>=6.7.0
 Requires-Dist: docling<3.0.0,>=2.16.0
 Requires-Dist: docstring-parser<1.0,>=0.16
 Requires-Dist: duckduckgo-search<7.0.0,>=6.0.0
+Requires-Dist: exa-py>=1.8.7
 Requires-Dist: faker<19.0.0,>=18.9.0
 Requires-Dist: fakeredis<3.0.0,>=2.12.1
 Requires-Dist: fire<1.0.0,>=0.5.0
@@ -48,6 +49,7 @@ Requires-Dist: redis<6.0.0,>=5.0.1
 Requires-Dist: requests-oauthlib<2.0.0,>=1.3.1
 Requires-Dist: requests<3.0.0,>=2.31.0
 Requires-Dist: rich<14.0.0,>=13.3.4
+Requires-Dist: tavily-python>=0.5.0
 Requires-Dist: thefuzz<1.0.0,>=0.20.0
 Requires-Dist: tiktoken<1.0.0,>=0.7.0
 Requires-Dist: trafilatura<2.0.0,>=1.5.0
@@ -64,6 +66,8 @@ Requires-Dist: litellm<2.0.0,>=1.30.1; extra == 'all'
 Requires-Dist: metaphor-python<0.2.0,>=0.1.23; extra == 'all'
 Requires-Dist: neo4j<6.0.0,>=5.14.1; extra == 'all'
 Requires-Dist: pdf2image<2.0.0,>=1.17.0; extra == 'all'
+Requires-Dist: pgvector>=0.3.6; extra == 'all'
+Requires-Dist: psycopg2-binary>=2.9.10; extra == 'all'
 Requires-Dist: psycopg2<3.0.0,>=2.9.7; extra == 'all'
 Requires-Dist: pymupdf4llm<0.1.0,>=0.0.17; extra == 'all'
 Requires-Dist: pymupdf<2.0.0,>=1.23.3; extra == 'all'
@@ -104,6 +108,8 @@ Provides-Extra: docling
 Requires-Dist: docling<3.0.0,>=2.16.0; extra == 'docling'
 Provides-Extra: docx
 Requires-Dist: python-docx<2.0.0,>=1.1.0; extra == 'docx'
+Provides-Extra: exa
+Requires-Dist: exa-py>=1.8.7; extra == 'exa'
 Provides-Extra: fastembed
 Requires-Dist: fastembed<0.4.0,>=0.3.1; extra == 'fastembed'
 Provides-Extra: google-generativeai
@@ -139,8 +145,13 @@ Requires-Dist: pymupdf4llm<0.1.0,>=0.0.17; extra == 'pdf-parsers'
 Requires-Dist: pymupdf<2.0.0,>=1.23.3; extra == 'pdf-parsers'
 Requires-Dist: pypdf>=5.1.0; extra == 'pdf-parsers'
 Requires-Dist: pytesseract<0.4.0,>=0.3.10; extra == 'pdf-parsers'
+Provides-Extra: pinecone
+Requires-Dist: pinecone-client>=5.0.1; extra == 'pinecone'
 Provides-Extra: postgres
+Requires-Dist: pgvector>=0.3.6; extra == 'postgres'
+Requires-Dist: psycopg2-binary>=2.9.10; extra == 'postgres'
 Requires-Dist: psycopg2<3.0.0,>=2.9.7; extra == 'postgres'
+Requires-Dist: sqlalchemy<3.0.0,>=2.0.19; extra == 'postgres'
 Provides-Extra: pymupdf4llm
 Requires-Dist: pymupdf4llm<0.1.0,>=0.0.17; extra == 'pymupdf4llm'
 Provides-Extra: scrapy
@@ -149,6 +160,8 @@ Provides-Extra: sql
 Requires-Dist: psycopg2<3.0.0,>=2.9.7; extra == 'sql'
 Requires-Dist: pymysql<2.0.0,>=1.1.0; extra == 'sql'
 Requires-Dist: sqlalchemy<3.0.0,>=2.0.19; extra == 'sql'
+Provides-Extra: tavily
+Requires-Dist: tavily-python>=0.5.0; extra == 'tavily'
 Provides-Extra: transformers
 Requires-Dist: huggingface-hub<1.0.0,>=0.21.2; extra == 'transformers'
 Requires-Dist: torch<3.0.0,>=2.0.0; extra == 'transformers'
@@ -158,6 +171,7 @@ Requires-Dist: unstructured[docx,pdf,pptx]<1.0.0,>=0.16.15; extra == 'unstructur
 Provides-Extra: vecdbs
 Requires-Dist: chromadb<=0.4.23,>=0.4.21; extra == 'vecdbs'
 Requires-Dist: lancedb<0.9.0,>=0.8.2; extra == 'vecdbs'
+Requires-Dist: pinecone-client>=5.0.1; extra == 'vecdbs'
 Requires-Dist: pyarrow<16.0.0,>=15.0.0; extra == 'vecdbs'
 Requires-Dist: tantivy<0.22.0,>=0.21.0; extra == 'vecdbs'
 Requires-Dist: weaviate-client>=4.9.6; extra == 'vecdbs'

{langroid-0.39.5.dist-info → langroid-0.41.0.dist-info}/RECORD

@@ -43,6 +43,7 @@ langroid/agent/special/sql/utils/system_message.py,sha256=qKLHkvQWRQodTtPLPxr1GS
 langroid/agent/special/sql/utils/tools.py,sha256=ovCePzq5cmbqw0vsVPBzxdZpUcSUIfTiDSMGXustZW8,1749
 langroid/agent/tools/__init__.py,sha256=IMgCte-_ZIvCkozGQmvMqxIw7_nKLKzD78ccJL1bnQU,804
 langroid/agent/tools/duckduckgo_search_tool.py,sha256=NhsCaGZkdv28nja7yveAhSK_w6l_Ftym8agbrdzqgfo,1935
+langroid/agent/tools/exa_search_tool.py,sha256=qxDs6vIiUtFyfX6gmS-PxoCXes-55in3ef5AkUQhiM0,2469
 langroid/agent/tools/file_tools.py,sha256=GjPB5YDILucYapElnvvoYpGJuZQ25ecLs2REv7edPEo,7292
 langroid/agent/tools/google_search_tool.py,sha256=y7b-3FtgXf0lfF4AYxrZ3K5pH2dhidvibUOAGBE--WI,1456
 langroid/agent/tools/metaphor_search_tool.py,sha256=ccyEhkShH5MxW6-sx1n0BLpD_GForQddS_nNvBZ67Ik,2561
@@ -51,6 +52,7 @@ langroid/agent/tools/recipient_tool.py,sha256=dr0yTxgNEIoxUYxH6TtaExC4G_8WdJ0xGo
 langroid/agent/tools/retrieval_tool.py,sha256=zcAV20PP_6VzSd-UE-IJcabaBseFL_QNz59Bnig8-lE,946
 langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,5606
 langroid/agent/tools/segment_extract_tool.py,sha256=__srZ_VGYLVOdPrITUM8S0HpmX4q7r5FHWMDdHdEv8w,1440
+langroid/agent/tools/tavily_search_tool.py,sha256=soI-j0HdgVQLf09wRQScaEK4b5RpAX9C4cwOivRFWWI,1903
 langroid/cachedb/__init__.py,sha256=icAT2s7Vhf-ZGUeqpDQGNU6ob6o0aFEyjwcxxUGRFjg,225
 langroid/cachedb/base.py,sha256=ztVjB1DtN6pLCujCWnR6xruHxwVj3XkYniRTYAKKqk0,1354
 langroid/cachedb/momento_cachedb.py,sha256=YEOJ62hEcV6iIeMr5aGgRYgWQqFYaej9gEDEcY0sm7M,3172
@@ -86,13 +88,13 @@ langroid/parsing/parser.py,sha256=pPzM3zXQvFtwTyQPtDha15oZhu1O3OKDLECnkB8waxg,12
 langroid/parsing/pdf_utils.py,sha256=rmNJ9UzuBgXTAYwj1TtRJcD8h53x7cizhgyYHKO88I4,1513
 langroid/parsing/repo_loader.py,sha256=3GjvPJS6Vf5L6gV2zOU8s-Tf1oq_fZm-IB_RL_7CTsY,29373
 langroid/parsing/routing.py,sha256=-FcnlqldzL4ZoxuDwXjQPNHgBe9F9-F4R6q7b_z9CvI,1232
-langroid/parsing/search.py,sha256=M1swZfZEMEsalmTwVCkql3DzBNBemky7pWt0PrcwGdQ,9779
+langroid/parsing/search.py,sha256=YPCwezM0c4PWbNUMEmQ5RrJBtvX4aWZ1CMCJFs4sqFo,9806
 langroid/parsing/spider.py,sha256=hAVM6wxh1pQ0EN4tI5wMBtAjIk0T-xnpi-ZUzWybhos,3258
 langroid/parsing/table_loader.py,sha256=qNM4obT_0Y4tjrxNBCNUYjKQ9oETCZ7FbolKBTcz-GM,3410
 langroid/parsing/url_loader.py,sha256=JK48KktLRDBfjrt4nsUfy92M6yGdEeicAqOum2MdULM,4656
 langroid/parsing/urls.py,sha256=86omykgxo4hg2jyF10Ef-FJa9n6MgXdSXy2mImqgo5c,8076
-langroid/parsing/utils.py,sha256=YrV2GNL4EOBGknA4AClPGdJ4S5B31radrt-Ou8OAKoU,12749
-langroid/parsing/web_search.py,sha256=8rW8EI3tyHITaB2l9MT_6yLMeQfo8y-Ih-8N2v2uMpk,4931
+langroid/parsing/utils.py,sha256=ZWMS7oG04GUY9EAIwnFN6KKo_ePCKhqk_H8jW6TDT0s,12805
+langroid/parsing/web_search.py,sha256=wWSmV0METFTGPhHJIs-M4tog2Aur_75Pxr4a49cKDkU,7042
 langroid/prompts/__init__.py,sha256=RW11vK6jiLPuaUh4GpeFvstti73gkm8_rDMtrbo2YsU,142
 langroid/prompts/dialog.py,sha256=SpfiSyofSgy2pwD1YboHR_yHO3LEEMbv6j2sm874jKo,331
 langroid/prompts/prompts_config.py,sha256=p_lp9nbMuQwhhMwAZsOxveRw9C0ZFZvql7pdIfgVZYo,143
@@ -116,15 +118,17 @@ langroid/utils/output/__init__.py,sha256=7P0f--4IZneNsTxXY5fd6d6iW-CeVe-KSsl-87s
 langroid/utils/output/citations.py,sha256=9T69O_N6mxPQjQ-qC1vKS8_kyg1z5hDQXMhBsA45xkk,3147
 langroid/utils/output/printing.py,sha256=yzPJZN-8_jyOJmI9N_oLwEDfjMwVgk3IDiwnZ4eK_AE,2962
 langroid/utils/output/status.py,sha256=rzbE7mDJcgNNvdtylCseQcPGCGghtJvVq3lB-OPJ49E,1049
-langroid/vector_store/__init__.py,sha256=BcoOm1tG3y0EqjkIGmMOHkY9iTUhDHgyruknWDKgqIg,1214
-langroid/vector_store/base.py,sha256=69keYWkUD0fcGXC0STcdO1-jn8H4Ez-L_fnxmRvUoNw,14412
+langroid/vector_store/__init__.py,sha256=8ktJUVsVUoc7FMmkUFpFBZu7VMWUqQY9zpm4kEJ8yTs,1537
+langroid/vector_store/base.py,sha256=BgQzTScKNzKr3F3o9jrQNG-b3Dv16wKEGSM9jg-W03Y,14752
 langroid/vector_store/chromadb.py,sha256=p9mEqJwO2BrL2jSSXfa23kCPlPOwWpF3xJYd5zoWw_c,8661
 langroid/vector_store/lancedb.py,sha256=Qd20gKjWozPWfW5-D66J6U8dSrJo1yl-maj6s1lbf1c,14688
 langroid/vector_store/meilisearch.py,sha256=6frB7GFWeWmeKzRfLZIvzRjllniZ1cYj3HmhHQICXLs,11663
 langroid/vector_store/momento.py,sha256=xOaU7Hlyyn_5ihb0ARS5JHtmrKrTCt2IdRA-ioMM5ek,10307
+langroid/vector_store/pineconedb.py,sha256=otxXZNaBKb9f_H75HTaU3lMHiaR2NUp5MqwLZXpEY9M,14994
+langroid/vector_store/postgres.py,sha256=DQHd6dt-OcV_QVNm-ymn28rlTfhI6hqgcpLTPCsm0jI,15990
 langroid/vector_store/qdrantdb.py,sha256=v7TAsIoj_vxeKDYS9tpwJLBZA8fuTweTYxHo0X_uawM,17949
-langroid/vector_store/weaviatedb.py,sha256=cMg9kqJXlD1WURs6QivHvwausCyLYGr4mOK2v9uYkhw,11105
-langroid-0.39.5.dist-info/METADATA,sha256=BPira_zYZOFY685gg9eWMVM7q-x8o710qWCNBRKJAMw,60634
-langroid-0.39.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langroid-0.39.5.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.39.5.dist-info/RECORD,,
+langroid/vector_store/weaviatedb.py,sha256=ONEr2iGS0Ii73oMe7tRk6bB-BEXQUa70fYSrdI8d3yo,11481
+langroid-0.41.0.dist-info/METADATA,sha256=jCbP1nZgmhcN4XJE7eh8SBMbFEwNVV8yVoZqrmV8pCQ,61259
+langroid-0.41.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langroid-0.41.0.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.41.0.dist-info/RECORD,,