langroid 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

langroid/agent/tool_message.py

@@ -35,12 +35,10 @@ class ToolMessage(ABC, BaseModel):
         request (str): name of agent method to map to.
         purpose (str): purpose of agent method, expressed in general terms.
             (This is used when auto-generating the tool instruction to the LLM)
-        result (str): example of result of agent method.
     """
 
     request: str
     purpose: str
-    result: str = ""
 
     class Config:
         arbitrary_types_allowed = False
@@ -48,7 +46,7 @@ class ToolMessage(ABC, BaseModel):
         validate_assignment = True
         # do not include these fields in the generated schema
         # since we don't require the LLM to specify them
-        schema_extra = {"exclude": {"purpose", "result"}}
+        schema_extra = {"exclude": {"purpose"}}
 
     @classmethod
     def instructions(cls) -> str:
@@ -110,13 +108,13 @@ class ToolMessage(ABC, BaseModel):
         return "\n\n".join(examples_jsons)
 
     def to_json(self) -> str:
-        return self.json(indent=4, exclude={"result", "purpose"})
+        return self.json(indent=4, exclude={"purpose"})
 
     def json_example(self) -> str:
-        return self.json(indent=4, exclude={"result", "purpose"})
+        return self.json(indent=4, exclude={"purpose"})
 
     def dict_example(self) -> Dict[str, Any]:
-        return self.dict(exclude={"result", "purpose"})
+        return self.dict(exclude={"purpose"})
 
     @classmethod
     def default_value(cls, f: str) -> Any:
@@ -220,9 +218,7 @@ class ToolMessage(ABC, BaseModel):
                 if "description" not in parameters["properties"][name]:
                     parameters["properties"][name]["description"] = description
 
-        excludes = (
-            ["result", "purpose"] if request else ["request", "result", "purpose"]
-        )
+        excludes = ["purpose"] if request else ["request", "purpose"]
         # exclude 'excludes' from parameters["properties"]:
         parameters["properties"] = {
             field: details
@@ -263,5 +259,5 @@ class ToolMessage(ABC, BaseModel):
         Returns:
             Dict[str, Any]: simplified schema
         """
-        schema = generate_simple_schema(cls, exclude=["result", "purpose"])
+        schema = generate_simple_schema(cls, exclude=["purpose"])
         return schema

langroid/language_models/azure_openai.py

@@ -133,12 +133,15 @@ class AzureGPT(OpenAIGPT):
         """
         Handles the setting of the GPT-4 model in the configuration.
         This function checks the `model_version` in the configuration.
-        If the version is not set, it raises a ValueError indicating that the model
-        version needs to be specified in the ``.env`` file.
-        It sets `OpenAIChatModel.GPT4_TURBO` if the version is
-        '1106-Preview', otherwise, it defaults to setting `OpenAIChatModel.GPT4`.
+        If the version is not set, it raises a ValueError indicating
+        that the model version needs to be specified in the ``.env``
+        file.  It sets `OpenAIChatMode.GPT4o` if the version is
+        '2024-05-13', `OpenAIChatModel.GPT4_TURBO` if the version is
+        '1106-Preview', otherwise, it defaults to setting
+        `OpenAIChatModel.GPT4`.
         """
         VERSION_1106_PREVIEW = "1106-Preview"
+        VERSION_GPT4o = "2024-05-13"
 
         if self.config.model_version == "":
             raise ValueError(
@@ -146,7 +149,9 @@ class AzureGPT(OpenAIGPT):
                 "Please set it to the chat model version used in your deployment."
             )
 
-        if self.config.model_version == VERSION_1106_PREVIEW:
+        if self.config.model_version == VERSION_GPT4o:
+            self.config.chat_model = OpenAIChatModel.GPT4o
+        elif self.config.model_version == VERSION_1106_PREVIEW:
             self.config.chat_model = OpenAIChatModel.GPT4_TURBO
         else:
             self.config.chat_model = OpenAIChatModel.GPT4

langroid/language_models/base.py

@@ -234,6 +234,7 @@ class LLMResponse(BaseModel):
             # in this case we ignore message, since all information is in function_call
             msg = ""
             args = self.function_call.arguments
+            recipient = ""
             if isinstance(args, dict):
                 recipient = args.get("recipient", "")
             return recipient, msg

langroid/language_models/openai_gpt.py

@@ -1,4 +1,3 @@
-import ast
 import hashlib
 import json
 import logging
@@ -49,6 +48,7 @@ from langroid.language_models.utils import (
     async_retry_with_exponential_backoff,
     retry_with_exponential_backoff,
 )
+from langroid.parsing.parse_json import parse_imperfect_json
 from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.utils.constants import Colors
@@ -797,11 +797,24 @@ class OpenAIGPT(LanguageModel):
         args = {}
         if has_function and function_args != "":
             try:
-                args = ast.literal_eval(function_args.strip())
-            except (SyntaxError, ValueError):
+                stripped_fn_args = function_args.strip()
+                dict_or_list = parse_imperfect_json(stripped_fn_args)
+                if not isinstance(dict_or_list, dict):
+                    raise ValueError(
+                        f"""
+                        Invalid function args: {stripped_fn_args} 
+                        parsed as {dict_or_list},
+                        which is not a valid dict.
+                        """
+                    )
+                args = dict_or_list
+            except (SyntaxError, ValueError) as e:
                 logging.warning(
-                    f"Parsing OpenAI function args failed: {function_args};"
-                    " treating args as normal message"
+                    f"""
+                    Parsing OpenAI function args failed: {function_args};
+                    treating args as normal message. Error detail:
+                    {e}
+                    """
                 )
                 has_function = False
                 completion = completion + function_args

langroid/parsing/parse_json.py

@@ -1,5 +1,6 @@
+import ast
 import json
-from typing import Any, Iterator, List
+from typing import Any, Dict, Iterator, List, Union
 
 import yaml
 from pyparsing import nestedExpr, originalTextFor
@@ -73,6 +74,31 @@ def add_quotes(s: str) -> str:
         return s
 
 
+def parse_imperfect_json(json_string: str) -> Union[Dict[str, Any], List[Any]]:
+    if not json_string.strip():
+        raise ValueError("Empty string is not valid JSON")
+
+    # First, try parsing with ast.literal_eval
+    try:
+        result = ast.literal_eval(json_string)
+        if isinstance(result, (dict, list)):
+            return result
+    except (ValueError, SyntaxError):
+        pass
+
+    # If ast.literal_eval fails or returns non-dict/list, try json.loads
+    try:
+        str = add_quotes(json_string)
+        result = json.loads(str)
+        if isinstance(result, (dict, list)):
+            return result
+    except json.JSONDecodeError:
+        pass
+
+    # If all methods fail, raise ValueError
+    raise ValueError(f"Unable to parse as JSON: {json_string}")
+
+
 def repair_newlines(s: str) -> str:
     """
     Attempt to load as json, and if it fails, try with newlines replaced by space.

langroid/utils/pydantic_utils.py

@@ -9,8 +9,6 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
-    get_args,
-    get_origin,
     no_type_check,
 )
 
@@ -313,54 +311,6 @@ def pydantic_obj_from_flat_dict(
     return model(**nested_data)
 
 
-def clean_schema(model: Type[BaseModel], excludes: List[str] = []) -> Dict[str, Any]:
-    """
-    Generate a simple schema for a given Pydantic model,
-    including inherited fields, with an option to exclude certain fields.
-    Handles cases where fields are Lists or other generic types and includes
-    field descriptions if available.
-
-    Args:
-        model (Type[BaseModel]): The Pydantic model class.
-        excludes (List[str]): A list of field names to exclude.
-
-    Returns:
-        Dict[str, Any]: A dictionary representing the simple schema.
-    """
-    schema = {}
-
-    for field_name, field_info in model.__fields__.items():
-        if field_name in excludes:
-            continue
-
-        field_type = field_info.outer_type_
-        description = field_info.field_info.description or ""
-
-        # Handle generic types like List[...]
-        if get_origin(field_type):
-            inner_types = get_args(field_type)
-            inner_type_names = [
-                t.__name__ if hasattr(t, "__name__") else str(t) for t in inner_types
-            ]
-            field_type_str = (
-                f"{get_origin(field_type).__name__}" f'[{", ".join(inner_type_names)}]'
-            )
-            schema[field_name] = {"type": field_type_str, "description": description}
-        elif issubclass(field_type, BaseModel):
-            # Directly use the nested model's schema,
-            # integrating it into the current level
-            nested_schema = clean_schema(field_type, excludes)
-            schema[field_name] = {**nested_schema, "description": description}
-        else:
-            # For basic types, use 'type'
-            schema[field_name] = {
-                "type": field_type.__name__,
-                "description": description,
-            }
-
-    return schema
-
-
 @contextmanager
 def temp_update(
     pydantic_object: BaseModel, updates: Dict[str, Any]

langroid/vector_store/base.py

@@ -1,14 +1,14 @@
 import copy
 import logging
 from abc import ABC, abstractmethod
-from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Dict, List, Optional, Sequence, Tuple, Type
 
 import numpy as np
 import pandas as pd
 
 from langroid.embedding_models.base import EmbeddingModel, EmbeddingModelsConfig
 from langroid.embedding_models.models import OpenAIEmbeddingsConfig
-from langroid.mytypes import Document
+from langroid.mytypes import DocMetaData, Document
 from langroid.pydantic_v1 import BaseSettings
 from langroid.utils.algorithms.graph import components, topological_sort
 from langroid.utils.configuration import settings
@@ -32,6 +32,9 @@ class VectorStoreConfig(BaseSettings):
     timeout: int = 60
     host: str = "127.0.0.1"
     port: int = 6333
+    # used when parsing search results back as Document objects
+    document_class: Type[Document] = Document
+    metadata_class: Type[DocMetaData] = DocMetaData
     # compose_file: str = "langroid/vector_store/docker-compose-qdrant.yml"
 
 
@@ -113,8 +116,7 @@ class VectorStore(ABC):
         """
 
         self.config.collection_name = collection_name
-        if collection_name not in self.list_collections() or replace:
-            self.create_collection(collection_name, replace=replace)
+        self.config.replace_collection = replace
 
     @abstractmethod
     def create_collection(self, collection_name: str, replace: bool = False) -> None:

langroid/vector_store/chromadb.py

@@ -8,7 +8,7 @@ from langroid.embedding_models.base import (
 )
 from langroid.embedding_models.models import OpenAIEmbeddingsConfig
 from langroid.exceptions import LangroidImportError
-from langroid.mytypes import DocMetaData, Document
+from langroid.mytypes import Document
 from langroid.utils.configuration import settings
 from langroid.utils.output.printing import print_long_text
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
@@ -200,7 +200,9 @@ class ChromaDB(VectorStore):
             else:
                 m["window_ids"] = m["window_ids"].split(",")
         docs = [
-            Document(content=d, metadata=DocMetaData(**m))
+            self.config.document_class(
+                content=d, metadata=self.config.metadata_class(**m)
+            )
             for d, m in zip(contents, metadatas)
         ]
         return docs

langroid/vector_store/lancedb.py

@@ -32,13 +32,7 @@ from langroid.utils.configuration import settings
 from langroid.utils.pydantic_utils import (
     dataframe_to_document_model,
     dataframe_to_documents,
-    extend_document_class,
-    extra_metadata,
-    flatten_pydantic_instance,
-    flatten_pydantic_model,
-    nested_dict_from_flat,
 )
-from langroid.utils.system import pydantic_major_version
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
 try:
@@ -58,10 +52,6 @@ class LanceDBConfig(VectorStoreConfig):
     storage_path: str = ".lancedb/data"
     embedding: EmbeddingModelsConfig = OpenAIEmbeddingsConfig()
     distance: str = "cosine"
-    # document_class is used to store in lancedb with right schema,
-    # and also to retrieve the right type of Documents when searching.
-    document_class: Type[Document] = Document
-    flatten: bool = False  # flatten Document class into LanceSchema ?
 
 
 class LanceDB(VectorStore):
@@ -78,7 +68,6 @@ class LanceDB(VectorStore):
         self.port = config.port
         self.is_from_dataframe = False  # were docs ingested from a dataframe?
         self.df_metadata_columns: List[str] = []  # metadata columns from dataframe
-        self._setup_schemas(config.document_class)
 
         load_dotenv()
         if self.config.cloud:
@@ -104,40 +93,6 @@ class LanceDB(VectorStore):
                     uri=new_storage_path,
                 )
 
-        # Note: Only create collection if a non-null collection name is provided.
-        # This is useful to delay creation of vecdb until we have a suitable
-        # collection name (e.g. we could get it from the url or folder path).
-        if config.collection_name is not None:
-            self.create_collection(
-                config.collection_name, replace=config.replace_collection
-            )
-
-    def _setup_schemas(self, doc_cls: Type[Document] | None) -> None:
-        try:
-            doc_cls = doc_cls or self.config.document_class
-            self.unflattened_schema = self._create_lance_schema(doc_cls)
-            self.schema = (
-                self._create_flat_lance_schema(doc_cls)
-                if self.config.flatten
-                else self.unflattened_schema
-            )
-        except (AttributeError, TypeError) as e:
-            pydantic_version = pydantic_major_version()
-            if pydantic_version > 1:
-                raise ValueError(
-                    f"""
-                    {e}
-                    ====
-                    You are using Pydantic v{pydantic_version},
-                    which is not yet compatible with Langroid's LanceDB integration.
-                    To use Lancedb with Langroid, please install the 
-                    latest pydantic 1.x instead of pydantic v2, e.g. 
-                    pip install "pydantic<2.0.0"
-                    """
-                )
-            else:
-                raise e
-
     def clear_empty_collections(self) -> int:
         coll_names = self.list_collections()
         n_deletes = 0
@@ -234,91 +189,8 @@ class LanceDB(VectorStore):
         )  # type: ignore
         return NewModel  # type: ignore
 
-    def _create_flat_lance_schema(self, doc_cls: Type[Document]) -> Type[BaseModel]:
-        """
-        Flat version of the lance_schema, as nested Pydantic schemas are not yet
-        supported by LanceDB.
-        """
-        if not has_lancedb:
-            raise LangroidImportError("lancedb", "lancedb")
-        lance_model = self._create_lance_schema(doc_cls)
-        FlatModel = flatten_pydantic_model(lance_model, base_model=LanceModel)
-        return FlatModel
-
     def create_collection(self, collection_name: str, replace: bool = False) -> None:
-        """
-        Create a collection with the given name, optionally replacing an existing
-            collection if `replace` is True.
-        Args:
-            collection_name (str): Name of the collection to create.
-            replace (bool): Whether to replace an existing collection
-                with the same name. Defaults to False.
-        """
-        self.config.collection_name = collection_name
-        collections = self.list_collections()
-        if collection_name in collections:
-            coll = self.client.open_table(collection_name)
-            if coll.head().shape[0] > 0:
-                logger.warning(f"Non-empty Collection {collection_name} already exists")
-                if not replace:
-                    logger.warning("Not replacing collection")
-                    return
-                else:
-                    logger.warning("Recreating fresh collection")
-        try:
-            self.client.create_table(
-                collection_name, schema=self.schema, mode="overwrite"
-            )
-        except (AttributeError, TypeError) as e:
-            pydantic_version = pydantic_major_version()
-            if pydantic_version > 1:
-                raise ValueError(
-                    f"""
-                    {e}
-                    ====
-                    You are using Pydantic v{pydantic_version},
-                    which is not yet compatible with Langroid's LanceDB integration.
-                    To use Lancedb with Langroid, please install the 
-                    latest pydantic 1.x instead of pydantic v2, e.g. 
-                    pip install "pydantic<2.0.0"
-                    """
-                )
-            else:
-                raise e
-
-        if settings.debug:
-            level = logger.getEffectiveLevel()
-            logger.setLevel(logging.INFO)
-            logger.setLevel(level)
-
-    def _maybe_set_doc_class_schema(self, doc: Document) -> None:
-        """
-        Set the config.document_class and self.schema based on doc if needed
-        Args:
-            doc: an instance of Document, to be added to a collection
-        """
-        extra_metadata_fields = extra_metadata(doc, self.config.document_class)
-        if len(extra_metadata_fields) > 0:
-            logger.warning(
-                f"""
-                    Added documents contain extra metadata fields:
-                    {extra_metadata_fields}
-                    which were not present in the original config.document_class.
-                    Trying to change document_class and corresponding schemas.
-                    Overriding LanceDBConfig.document_class with an auto-generated 
-                    Pydantic class that includes these extra fields.
-                    If this fails, or you see odd results, it is recommended that you 
-                    define a subclass of Document, with metadata of class derived from 
-                    DocMetaData, with extra fields defined via 
-                    `Field(..., description="...")` declarations,
-                    and set this document class as the value of the 
-                    LanceDBConfig.document_class attribute.
-                    """
-            )
-
-            doc_cls = extend_document_class(doc)
-            self.config.document_class = doc_cls
-            self._setup_schemas(doc_cls)
+        self.config.replace_collection = replace
 
     def add_documents(self, documents: Sequence[Document]) -> None:
         super().maybe_add_ids(documents)
@@ -329,39 +201,52 @@ class LanceDB(VectorStore):
         coll_name = self.config.collection_name
         if coll_name is None:
             raise ValueError("No collection name set, cannot ingest docs")
-        self._maybe_set_doc_class_schema(documents[0])
+        # self._maybe_set_doc_class_schema(documents[0])
+        table_exists = False
         if (
-            coll_name not in colls
-            or self.client.open_table(coll_name).head(1).shape[0] == 0
+            coll_name in colls
+            and self.client.open_table(coll_name).head(1).shape[0] > 0
         ):
-            # collection either doesn't exist or is empty, so replace it,
-            self.create_collection(coll_name, replace=True)
+            # collection exists and  is not empty:
+            # if replace_collection is True, we'll overwrite the existing collection,
+            # else we'll append to it.
+            if self.config.replace_collection:
+                self.client.drop_table(coll_name)
+            else:
+                table_exists = True
 
         ids = [str(d.id()) for d in documents]
         # don't insert all at once, batch in chunks of b,
         # else we get an API error
         b = self.config.batch_size
 
-        def make_batches() -> Generator[List[BaseModel], None, None]:
+        def make_batches() -> Generator[List[Dict[str, Any]], None, None]:
             for i in range(0, len(ids), b):
                 batch = [
-                    self.unflattened_schema(
+                    dict(
                         id=ids[i + j],
                         vector=embedding_vecs[i + j],
                         **doc.dict(),
                     )
                     for j, doc in enumerate(documents[i : i + b])
                 ]
-                if self.config.flatten:
-                    batch = [
-                        flatten_pydantic_instance(instance)  # type: ignore
-                        for instance in batch
-                    ]
                 yield batch
 
-        tbl = self.client.open_table(self.config.collection_name)
         try:
-            tbl.add(make_batches())
+            if table_exists:
+                tbl = self.client.open_table(coll_name)
+                tbl.add(make_batches())
+            else:
+                batch_gen = make_batches()
+                batch = next(batch_gen)
+                # use first batch to create table...
+                tbl = self.client.create_table(
+                    coll_name,
+                    data=batch,
+                    mode="create",
+                )
+                # ... and add the rest
+                tbl.add(batch_gen)
         except Exception as e:
             logger.error(
                 f"""
@@ -427,7 +312,6 @@ class LanceDB(VectorStore):
                 exclude=["vector"],
             )
             self.config.document_class = doc_cls  # type: ignore
-            self._setup_schemas(doc_cls)  # type: ignore
         else:
             # collection exists and is not empty, so append to it
             tbl = self.client.open_table(self.config.collection_name)
@@ -452,35 +336,19 @@ class LanceDB(VectorStore):
             return self._records_to_docs(records)
 
     def _records_to_docs(self, records: List[Dict[str, Any]]) -> List[Document]:
-        if self.config.flatten:
-            docs = [
-                self.unflattened_schema(**nested_dict_from_flat(rec)) for rec in records
-            ]
-        else:
-            try:
-                docs = [self.schema(**rec) for rec in records]
-            except ValidationError as e:
-                raise ValueError(
-                    f"""
-                Error validating LanceDB result: {e}
-                HINT: This could happen when you're re-using an 
-                existing LanceDB store with a different schema.
-                Try deleting your local lancedb storage at `{self.config.storage_path}`
-                re-ingesting your documents and/or replacing the collections.
-                """
-                )
-
-        doc_cls = self.config.document_class
-        doc_cls_field_names = doc_cls.__fields__.keys()
-        return [
-            doc_cls(
-                **{
-                    field_name: getattr(doc, field_name)
-                    for field_name in doc_cls_field_names
-                }
+        try:
+            docs = [self.config.document_class(**rec) for rec in records]
+        except ValidationError as e:
+            raise ValueError(
+                f"""
+            Error validating LanceDB result: {e}
+            HINT: This could happen when you're re-using an 
+            existing LanceDB store with a different schema.
+            Try deleting your local lancedb storage at `{self.config.storage_path}`
+            re-ingesting your documents and/or replacing the collections.
+            """
             )
-            for doc in docs
-        ]
+        return docs
 
     def get_all_documents(self, where: str = "") -> List[Document]:
         if self.config.collection_name is None:

langroid/vector_store/momento.py

@@ -1,6 +1,7 @@
 """
 Momento Vector Index.
 https://docs.momentohq.com/vector-index/develop/api-reference
+DEPRECATED: API is unstable.
 """
 
 from __future__ import annotations

langroid/vector_store/qdrantdb.py

@@ -63,6 +63,7 @@ def is_valid_uuid(uuid_to_test: str) -> bool:
 
 class QdrantDBConfig(VectorStoreConfig):
     cloud: bool = True
+    docker: bool = False
     collection_name: str | None = "temp"
     storage_path: str = ".qdrant/data"
     embedding: EmbeddingModelsConfig = OpenAIEmbeddingsConfig()
@@ -102,7 +103,19 @@ class QdrantDB(VectorStore):
         load_dotenv()
         key = os.getenv("QDRANT_API_KEY")
         url = os.getenv("QDRANT_API_URL")
-        if config.cloud and None in [key, url]:
+        if config.docker:
+            if url is None:
+                logger.warning(
+                    f"""The QDRANT_API_URL env variable must be set to use
+                    QdrantDB in local docker mode. Please set this
+                    value in your .env file.
+                    Switching to local storage at {config.storage_path}
+                    """
+                )
+                config.cloud = False
+            else:
+                config.cloud = True
+        elif config.cloud and None in [key, url]:
             logger.warning(
                 f"""QDRANT_API_KEY, QDRANT_API_URL env variable must be set to use 
                 QdrantDB in cloud mode. Please set these values 
@@ -111,6 +124,7 @@ class QdrantDB(VectorStore):
                 """
             )
             config.cloud = False
+
         if config.cloud:
             self.client = QdrantClient(
                 url=url,
@@ -366,7 +380,11 @@ class QdrantDB(VectorStore):
                 with_payload=True,
                 with_vectors=False,
             )
-            docs += [Document(**record.payload) for record in results]  # type: ignore
+            docs += [
+                self.config.document_class(**record.payload)  # type: ignore
+                for record in results
+            ]
+            # ignore
             if next_page_offset is None:
                 break
             offset = next_page_offset  # type: ignore
@@ -385,7 +403,7 @@ class QdrantDB(VectorStore):
         # Note the records may NOT be in the order of the ids,
         # so we re-order them here.
         id2payload = {record.id: record.payload for record in records}
-        ordered_payloads = [id2payload[id] for id in _ids]
+        ordered_payloads = [id2payload[id] for id in _ids if id in id2payload]
         docs = [Document(**payload) for payload in ordered_payloads]  # type: ignore
         return docs
 
@@ -437,7 +455,7 @@ class QdrantDB(VectorStore):
         ]  # 2D list -> 1D list
         scores = [match.score for match in search_result if match is not None]
         docs = [
-            Document(**(match.payload))  # type: ignore
+            self.config.document_class(**(match.payload))  # type: ignore
             for match in search_result
             if match is not None
         ]