langroid 0.58.2__py3-none-any.whl → 0.59.0__py3-none-any.whl

langroid/parsing/url_loader.py

@@ -7,12 +7,12 @@ from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
 
 import markdownify as md
 from dotenv import load_dotenv
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from langroid.exceptions import LangroidImportError
 from langroid.mytypes import DocMetaData, Document
 from langroid.parsing.document_parser import DocumentParser, ImagePdfParser
 from langroid.parsing.parser import Parser, ParsingConfig
-from langroid.pydantic_v1 import BaseSettings
 
 if TYPE_CHECKING:
     from firecrawl import FirecrawlApp
@@ -54,20 +54,13 @@ class FirecrawlConfig(BaseCrawlerConfig):
     params: Dict[str, Any] = {}
     timeout: Optional[int] = None
 
-    class Config:
-        # Leverage Pydantic's BaseSettings to
-        # allow setting of fields via env vars,
-        # e.g. FIRECRAWL_MODE=scrape and FIRECRAWL_API_KEY=...
-        env_prefix = "FIRECRAWL_"
+    model_config = SettingsConfigDict(env_prefix="FIRECRAWL_")
 
 
 class ExaCrawlerConfig(BaseCrawlerConfig):
     api_key: str = ""
 
-    class Config:
-        # Allow setting of fields via env vars with prefix EXA_
-        # e.g., EXA_API_KEY=your_api_key
-        env_prefix = "EXA_"
+    model_config = SettingsConfigDict(env_prefix="EXA_")
 
 
 class Crawl4aiConfig(BaseCrawlerConfig):
@@ -81,49 +74,22 @@ class Crawl4aiConfig(BaseCrawlerConfig):
     browser_config: Optional["BrowserConfig"] = None
     run_config: Optional["CrawlerRunConfig"] = None
 
-    _refs_resolved: bool = False
+    model_config = SettingsConfigDict(arbitrary_types_allowed=True)
 
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Resolve forward references when class is first subclassed or instantiated."""
-        super().__init_subclass__(**kwargs)
-        cls._resolve_forward_refs()
 
-    @classmethod
-    def _resolve_forward_refs(cls) -> None:
-        """Resolve forward references only when needed."""
-        if not cls._refs_resolved:
-            try:
-                from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
-                from crawl4ai.content_scraping_strategy import ContentScrapingStrategy
-                from crawl4ai.deep_crawling import DeepCrawlStrategy
-                from crawl4ai.extraction_strategy import ExtractionStrategy
-                from crawl4ai.markdown_generation_strategy import (
-                    MarkdownGenerationStrategy,
-                )
-
-                # Create namespace for update_forward_refs
-                namespace = {
-                    "BrowserConfig": BrowserConfig,
-                    "CrawlerRunConfig": CrawlerRunConfig,
-                    "ContentScrapingStrategy": ContentScrapingStrategy,
-                    "DeepCrawlStrategy": DeepCrawlStrategy,
-                    "ExtractionStrategy": ExtractionStrategy,
-                    "MarkdownGenerationStrategy": MarkdownGenerationStrategy,
-                }
-
-                cls.update_forward_refs(**namespace)
-                cls._refs_resolved = True
-            except ImportError:
-                # If crawl4ai is not installed, leave forward refs as strings
-                pass
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Initialize and ensure forward refs are resolved."""
-        self._resolve_forward_refs()
-        super().__init__(**kwargs)
+# Resolve forward references for Crawl4aiConfig after the class is defined
+try:
+    from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
+    from crawl4ai.content_scraping_strategy import ContentScrapingStrategy
+    from crawl4ai.deep_crawling import DeepCrawlStrategy
+    from crawl4ai.extraction_strategy import ExtractionStrategy
+    from crawl4ai.markdown_generation_strategy import MarkdownGenerationStrategy
 
-    class Config:
-        arbitrary_types_allowed = True
+    # Rebuild the model with resolved references
+    Crawl4aiConfig.model_rebuild()
+except ImportError:
+    # If crawl4ai is not installed, leave forward refs as strings
+    pass
 
 
 class BaseCrawler(ABC):
@@ -347,7 +313,7 @@ class FirecrawlCrawler(BaseCrawler):
                     )
                     processed_urls.add(url)
                     new_pages += 1
-            pbar.update(new_pages)  # Update progress bar with new pages
+            pbar.model_copy(update=new_pages)  # Update progress bar with new pages
 
             # Break if crawl is complete
             if status["status"] == "completed":

langroid/parsing/urls.py

@@ -9,11 +9,10 @@ from urllib.parse import urldefrag, urljoin, urlparse
 import fire
 import requests
 from bs4 import BeautifulSoup
+from pydantic import BaseModel, HttpUrl, TypeAdapter, ValidationError
 from rich import print
 from rich.prompt import Prompt
 
-from langroid.pydantic_v1 import BaseModel, HttpUrl, ValidationError, parse_obj_as
-
 logger = logging.getLogger(__name__)
 
 
@@ -106,7 +105,8 @@ class Url(BaseModel):
 
 def is_url(s: str) -> bool:
     try:
-        Url(url=parse_obj_as(HttpUrl, s))
+        url_adapter = TypeAdapter(HttpUrl)
+        Url(url=url_adapter.validate_python(s))
         return True
     except ValidationError:
         return False
@@ -133,7 +133,8 @@ def get_urls_paths_bytes_indices(
             byte_list.append(i)
             continue
         try:
-            Url(url=parse_obj_as(HttpUrl, item))
+            url_adapter = TypeAdapter(HttpUrl)
+            Url(url=url_adapter.validate_python(item))
             urls.append(i)
         except ValidationError:
             if os.path.exists(item):

langroid/prompts/prompts_config.py

@@ -1,4 +1,4 @@
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings
 
 
 class PromptsConfig(BaseSettings):

langroid/pydantic_v1/__init__.py

@@ -1,10 +1,67 @@
 """
-If we're on Pydantic v2, use the v1 namespace, else just use the main namespace.
+Compatibility layer for Langroid's Pydantic migration.
 
-This allows compatibility with both Pydantic v1 and v2
+IMPORTANT: You are importing from langroid.pydantic_v1 but getting Pydantic v2 classes!
+Langroid has fully migrated to Pydantic v2, and this compatibility layer is deprecated.
 """
 
+import warnings
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Only show the visual warning, not the standard deprecation warning
+# The standard warning is too noisy and shows the import line
+logger.warning(
+    """
+╔════════════════════════════════════════════════════════════════════════╗
+║                    ⚠️  DEPRECATION WARNING ⚠️                          ║
+╠════════════════════════════════════════════════════════════════════════╣
+║                                                                        ║
+║  You are importing from langroid.pydantic_v1, but you're actually      ║
+║  getting Pydantic v2 classes. Langroid has fully migrated to v2.       ║
+║                                                                        ║
+║  Please update your imports:                                           ║
+║    OLD: from langroid.pydantic_v1 import BaseModel, Field              ║
+║    NEW: from pydantic import BaseModel, Field                          ║
+║                                                                        ║
+║  Also ensure your code uses Pydantic v2 patterns:                      ║
+║    • Use model_dump() instead of dict()                                ║
+║    • Use model_dump_json() instead of json()                           ║
+║    • Use ConfigDict instead of class Config                            ║
+║    • Use model_validate() instead of parse_obj()                       ║
+║                                                                        ║
+║  This compatibility layer will be removed in a future version.         ║
+╚════════════════════════════════════════════════════════════════════════╝
+"""
+)
+
+# Import from pydantic v2 directly (not from pydantic.v1)
+# This allows existing code to continue working if it's already v2-compatible
+from pydantic import *  # noqa: F403, F401
+
+# BaseSettings has moved in v2, import it explicitly
 try:
-    from pydantic.v1 import *  # noqa: F403, F401
+    from pydantic_settings import BaseSettings  # noqa: F401
 except ImportError:
-    from pydantic import *  # type: ignore # noqa: F403, F401
+    # Fallback for older pydantic versions
+    from pydantic import BaseSettings  # type: ignore[no-redef] # noqa: F401
+
+# Explicitly export all items for mypy
+__all__ = [
+    "BaseModel",
+    "BaseSettings",
+    "SettingsConfigDict",
+    "Field",
+    "ConfigDict",
+    "ValidationError",
+    "field_validator",
+    "model_validator",
+    "create_model",
+    "HttpUrl",
+    "AnyUrl",
+    "TypeAdapter",
+    "parse_obj_as",
+    "validator",
+    "root_validator",
+]

langroid/pydantic_v1/main.py

@@ -1,4 +1,10 @@
-try:
-    from pydantic.v1.main import *  # noqa: F403, F401
-except ImportError:
-    from pydantic.main import *  # type: ignore # noqa: F403, F401
+"""
+Compatibility layer for Pydantic v2 migration.
+
+This module now imports directly from Pydantic v2 since all internal code
+has been migrated to use Pydantic v2 patterns.
+"""
+
+# Import from pydantic.main but don't trigger the warning again
+# The warning is already shown when importing from langroid.pydantic_v1
+from pydantic.main import *  # noqa: F403, F401

langroid/utils/configuration.py

@@ -4,8 +4,7 @@ from contextlib import contextmanager
 from typing import Any, Dict, Iterator, List, Literal, cast
 
 from dotenv import find_dotenv, load_dotenv
-
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Global reentrant lock to serialize any modifications to the global settings.
 _global_lock = threading.RLock()
@@ -22,8 +21,7 @@ class Settings(BaseSettings):
     quiet: bool = False  # quiet mode (i.e. suppress all output)?
     notebook: bool = False  # running in a notebook?
 
-    class Config:
-        extra = "forbid"
+    model_config = SettingsConfigDict(extra="forbid")
 
 
 # Load environment variables from .env file.
@@ -60,8 +58,10 @@ class SettingsProxy:
         # Return a dict view of the settings as seen by the caller.
         # Note that temporary overrides are not “merged” with global settings.
         if hasattr(_thread_local, "override"):
-            return cast(Dict[str, Any], cast(Settings, _thread_local.override.dict()))
-        return _global_settings.dict()
+            return cast(
+                Dict[str, Any], cast(Settings, _thread_local.override.model_dump())
+            )
+        return _global_settings.model_dump()
 
 
 settings = SettingsProxy()
@@ -76,7 +76,7 @@ def update_global_settings(cfg: BaseSettings, keys: List[str]) -> None:
 
     This updates the global default.
     """
-    config_dict = cfg.dict()
+    config_dict = cfg.model_dump()
     filtered_config = {key: config_dict[key] for key in keys if key in config_dict}
     new_settings = Settings(**filtered_config)
     _global_settings.__dict__.update(new_settings.__dict__)
@@ -117,7 +117,9 @@ def quiet_mode(quiet: bool = True) -> Iterator[None]:
     if quiet is already True (from an outer context),
     then it remains True even if a nested context passes quiet=False.
     """
-    current_effective = settings.dict()  # get the current thread's effective settings
+    current_effective = (
+        settings.model_dump()
+    )  # get the current thread's effective settings
     # Create a new settings instance from the current effective state.
     temp = Settings(**current_effective)
     # Merge the new flag: once quiet is enabled, it stays enabled.
@@ -132,6 +134,6 @@ def set_env(settings_instance: BaseSettings) -> None:
 
     Each field in the settings is written to os.environ.
     """
-    for field_name, field in settings_instance.__class__.__fields__.items():
-        env_var_name = field.field_info.extra.get("env", field_name).upper()
-        os.environ[env_var_name] = str(settings_instance.dict()[field_name])
+    for field_name, field in settings_instance.__class__.model_fields.items():
+        env_var_name = field.alias or field_name.upper()
+        os.environ[env_var_name] = str(settings_instance.model_dump()[field_name])

langroid/utils/constants.py

@@ -1,4 +1,4 @@
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 
 # Define the ANSI escape sequences for various colors and reset

langroid/utils/globals.py

@@ -1,6 +1,8 @@
-from typing import Any, Dict, Optional, Type, TypeVar
+from typing import Any, Dict, Optional, Type, TypeVar, cast
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
+from pydantic.fields import ModelPrivateAttr
+from pydantic_core import PydanticUndefined
 
 T = TypeVar("T", bound="GlobalState")
 
@@ -18,9 +20,23 @@ class GlobalState(BaseModel):
         Returns:
             The global instance of the subclass.
         """
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
+        # Get the actual value from ModelPrivateAttr when accessing on class
+        instance_attr = getattr(cls, "_instance", None)
+        actual_instance: Optional["GlobalState"]
+        if isinstance(instance_attr, ModelPrivateAttr):
+            default_value = instance_attr.default
+            if default_value is PydanticUndefined:
+                actual_instance = None
+            else:
+                actual_instance = cast(Optional["GlobalState"], default_value)
+        else:
+            actual_instance = instance_attr
+
+        if actual_instance is None:
+            new_instance = cls()
+            cls._instance = new_instance
+            return new_instance
+        return actual_instance  # type: ignore
 
     @classmethod
     def set_values(cls: Type[T], **kwargs: Dict[str, Any]) -> None:

langroid/utils/html_logger.py

@@ -10,7 +10,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
+
 from langroid.utils.logging import setup_logger
 
 

langroid/utils/object_registry.py

@@ -2,7 +2,7 @@ import time
 from typing import TYPE_CHECKING, Dict, Optional, TypeAlias, TypeVar
 from uuid import uuid4
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from langroid.agent.base import Agent

langroid/utils/pydantic_utils.py

@@ -15,9 +15,9 @@ from typing import (
 
 import numpy as np
 import pandas as pd
+from pydantic import BaseModel, ValidationError, create_model
 
 from langroid.mytypes import DocMetaData, Document
-from langroid.pydantic_v1 import BaseModel, ValidationError, create_model
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +42,7 @@ def flatten_dict(
 
 def has_field(model_class: Type[BaseModel], field_name: str) -> bool:
     """Check if a Pydantic model class has a field with the given name."""
-    return field_name in model_class.__fields__
+    return field_name in model_class.model_fields
 
 
 def _recursive_purge_dict_key(d: Dict[str, Any], k: str) -> None:
@@ -125,29 +125,31 @@ def flatten_pydantic_model(
     while models_to_process:
         current_model, current_prefix = models_to_process.pop()
 
-        for name, field in current_model.__fields__.items():
-            if isinstance(field.outer_type_, type) and issubclass(
-                field.outer_type_, BaseModel
-            ):
+        for name, field in current_model.model_fields.items():
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            if isinstance(field_type, type) and issubclass(field_type, BaseModel):
                 new_prefix = (
                     f"{current_prefix}{name}__" if current_prefix else f"{name}__"
                 )
-                models_to_process.append((field.outer_type_, new_prefix))
+                models_to_process.append((field_type, new_prefix))
             else:
                 flattened_name = f"{current_prefix}{name}"
 
-                if field.default_factory is not field.default_factory:
+                if (
+                    hasattr(field, "default_factory")
+                    and field.default_factory is not None
+                ):
                     flattened_fields[flattened_name] = (
-                        field.outer_type_,
+                        field_type,
                         field.default_factory,
                     )
-                elif field.default is not field.default:
+                elif hasattr(field, "default") and field.default is not ...:
                     flattened_fields[flattened_name] = (
-                        field.outer_type_,
+                        field_type,
                         field.default,
                     )
                 else:
-                    flattened_fields[flattened_name] = (field.outer_type_, ...)
+                    flattened_fields[flattened_name] = (field_type, ...)
 
     return create_model("FlatModel", __base__=base_model, **flattened_fields)
 
@@ -155,7 +157,7 @@ def flatten_pydantic_model(
 def get_field_names(model: Type[BaseModel]) -> List[str]:
     """Get all field names from a possibly nested Pydantic model."""
     mdl = flatten_pydantic_model(model)
-    fields = list(mdl.__fields__.keys())
+    fields = list(mdl.model_fields.keys())
     # fields may be like a__b__c , so we only want the last part
     return [f.split("__")[-1] for f in fields]
 
@@ -180,19 +182,22 @@ def generate_simple_schema(
         Dict[str, Any]: A dictionary representing the JSON schema of the provided model,
                         with specified fields excluded.
     """
-    if hasattr(model, "__fields__"):
+    if hasattr(model, "model_fields"):
         output: Dict[str, Any] = {}
-        for field_name, field in model.__fields__.items():
+        for field_name, field in model.model_fields.items():
             if field_name in exclude:
                 continue  # Skip excluded fields
 
-            field_type = field.type_
-            if issubclass(field_type, BaseModel):
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            if isinstance(field_type, type) and issubclass(field_type, BaseModel):
                 # Recursively generate schema for nested models
                 output[field_name] = generate_simple_schema(field_type, exclude)
-            else:
+            elif field_type is not None and hasattr(field_type, "__name__"):
                 # Represent the type as a string here
                 output[field_name] = {"type": field_type.__name__}
+            else:
+                # Fallback for complex types
+                output[field_name] = {"type": str(field_type)}
         return output
     else:
         # Non-model type, return a simplified representation
@@ -218,14 +223,28 @@ def flatten_pydantic_instance(
 
     """
     flat_data: Dict[str, Any] = {}
-    for name, value in instance.dict().items():
+    for name, value in instance.model_dump().items():
         # Assuming nested pydantic model will be a dict here
         if isinstance(value, dict):
-            nested_flat_data = flatten_pydantic_instance(
-                instance.__fields__[name].type_(**value),
-                prefix=f"{prefix}{name}__",
-                force_str=force_str,
+            # Get field info from model_fields
+            field_info = instance.model_fields[name]
+            # Try to get the nested model type from field annotation
+            field_type = (
+                field_info.annotation if hasattr(field_info, "annotation") else None
             )
+            if (
+                field_type
+                and isinstance(field_type, type)
+                and issubclass(field_type, BaseModel)
+            ):
+                nested_flat_data = flatten_pydantic_instance(
+                    field_type(**value),
+                    prefix=f"{prefix}{name}__",
+                    force_str=force_str,
+                )
+            else:
+                # Skip non-Pydantic nested fields for safety
+                continue
             flat_data.update(nested_flat_data)
         else:
             flat_data[f"{prefix}{name}"] = str(value) if force_str else value
@@ -531,10 +550,19 @@ def extra_metadata(document: Document, doc_cls: Type[Document] = Document) -> Li
         in the document's metadata.
     """
     # Convert metadata to dict, including extra fields.
-    metadata_fields = set(document.metadata.dict().keys())
+    metadata_fields = set(document.metadata.model_dump().keys())
 
     # Get defined fields in the metadata of doc_cls
-    defined_fields = set(doc_cls.__fields__["metadata"].type_.__fields__.keys())
+    metadata_field = doc_cls.model_fields["metadata"]
+    metadata_type = (
+        metadata_field.annotation
+        if hasattr(metadata_field, "annotation")
+        else metadata_field
+    )
+    if isinstance(metadata_type, type) and hasattr(metadata_type, "model_fields"):
+        defined_fields = set(metadata_type.model_fields.keys())
+    else:
+        defined_fields = set()
 
     # Identify extra fields not in defined fields.
     extra_fields = list(metadata_fields - defined_fields)
@@ -561,14 +589,13 @@ def extend_document_class(d: Document) -> Type[Document]:
     # Extract the fields from the original metadata class, including types,
     # correctly handling special types like List[str].
     original_metadata_fields = {
-        k: (v.outer_type_ if v.shape != 1 else v.type_, ...)
-        for k, v in DocMetaData.__fields__.items()
+        k: (v.annotation, ...) for k, v in DocMetaData.model_fields.items()
     }
     # Extract extra fields from the metadata instance with their types
     extra_fields = {
         k: (type(v), ...)
         for k, v in d.metadata.__dict__.items()
-        if k not in DocMetaData.__fields__
+        if k not in DocMetaData.model_fields
     }
 
     # Combine original and extra fields for the new metadata class

langroid/utils/types.py

@@ -3,7 +3,7 @@ import logging
 from inspect import signature
 from typing import Any, Optional, Type, TypeVar, Union, get_args, get_origin
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 PrimitiveType = Union[int, float, bool, str]
@@ -55,7 +55,7 @@ def to_string(msg: Any) -> str:
     if isinstance(msg, str):
         return msg
     if isinstance(msg, BaseModel):
-        return msg.json()
+        return msg.model_dump_json()
     # last resort: use json.dumps() or str() to make it a str
     try:
         return json.dumps(msg)

langroid/vector_store/base.py

@@ -5,11 +5,11 @@ from typing import Dict, List, Optional, Sequence, Tuple, Type
 
 import numpy as np
 import pandas as pd
+from pydantic_settings import BaseSettings
 
 from langroid.embedding_models.base import EmbeddingModel, EmbeddingModelsConfig
 from langroid.embedding_models.models import OpenAIEmbeddingsConfig
 from langroid.mytypes import DocMetaData, Document, EmbeddingFunction
-from langroid.pydantic_v1 import BaseSettings
 from langroid.utils.algorithms.graph import components, topological_sort
 from langroid.utils.configuration import settings
 from langroid.utils.object_registry import ObjectRegistry
@@ -82,7 +82,7 @@ class VectorStore(ABC):
         else:
             logger.warning(
                 f"""
-                Unknown vector store config: {config.__repr_name__()},
+                Unknown vector store config: {config.__class__.__name__},
                 so skipping vector store creation!
                 If you intended to use a vector-store, please set a specific 
                 vector-store in your script, typically in the `vecdb` field of a 
@@ -160,7 +160,7 @@ class VectorStore(ABC):
         If full_eval is True, sanitization is bypassed - use only with trusted input!
         """
         # convert each doc to a dict, using dotted paths for nested fields
-        dicts = [flatten_dict(doc.dict(by_alias=True)) for doc in docs]
+        dicts = [flatten_dict(doc.model_dump(by_alias=True)) for doc in docs]
         df = pd.DataFrame(dicts)
 
         try:

langroid/vector_store/lancedb.py

@@ -15,8 +15,7 @@ from typing import (
 
 import pandas as pd
 from dotenv import load_dotenv
-
-from langroid.pydantic_v1 import BaseModel, ValidationError, create_model
+from pydantic import BaseModel, ValidationError, create_model
 
 if TYPE_CHECKING:
     from lancedb.query import LanceVectorQueryBuilder
@@ -175,11 +174,12 @@ class LanceDB(VectorStore):
         fields = {"id": (str, ...), "vector": (Vector(n), ...)}
 
         sorted_fields = dict(
-            sorted(doc_cls.__fields__.items(), key=lambda item: item[0])
+            sorted(doc_cls.model_fields.items(), key=lambda item: item[0])
         )
         # Add both statically and dynamically defined fields from doc_cls
         for field_name, field in sorted_fields.items():
-            fields[field_name] = (field.outer_type_, field.default)
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            fields[field_name] = (field_type, field.default)
 
         # Create the new model with dynamic fields
         NewModel = create_model(
@@ -227,7 +227,7 @@ class LanceDB(VectorStore):
                     dict(
                         id=ids[i + j],
                         vector=embedding_vecs[i + j],
-                        **doc.dict(),
+                        **doc.model_dump(),
                     )
                     for j, doc in enumerate(documents[i : i + b])
                 ]

langroid/vector_store/meilisearch.py

@@ -33,7 +33,7 @@ class MeiliSearchConfig(VectorStoreConfig):
     cloud: bool = False
     collection_name: str | None = None
     primary_key: str = "id"
-    port = 7700
+    port: int = 7700
 
 
 class MeiliSearch(VectorStore):
@@ -193,7 +193,7 @@ class MeiliSearch(VectorStore):
             dict(
                 id=d.id(),
                 content=d.content,
-                metadata=d.metadata.dict(),
+                metadata=d.metadata.model_dump(),
             )
             for d in documents
         ]

langroid/vector_store/pineconedb.py

@@ -17,11 +17,11 @@ from typing import (
 
 from dotenv import load_dotenv
 
+# import dataclass
+from pydantic import BaseModel
+
 from langroid import LangroidImportError
 from langroid.mytypes import Document
-
-# import dataclass
-from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
@@ -246,7 +246,7 @@ class PineconeDB(VectorStore):
             return
 
         super().maybe_add_ids(documents)
-        document_dicts = [doc.dict() for doc in documents]
+        document_dicts = [doc.model_dump() for doc in documents]
         document_ids = [doc.id() for doc in documents]
         embedding_vectors = self.embedding_fn([doc.content for doc in documents])
         vectors = [