langroid 0.1.263__py3-none-any.whl → 0.2.0__py3-none-any.whl

langroid/language_models/base.py

@@ -4,7 +4,17 @@ import logging
 from abc import ABC, abstractmethod
 from datetime import datetime
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
 
 from langroid.cachedb.base import CacheDBConfig
 from langroid.parsing.agent_chats import parse_message
@@ -134,12 +144,15 @@ class LLMMessage(BaseModel):
     content: str
     function_call: Optional[LLMFunctionCall] = None
     timestamp: datetime = Field(default_factory=datetime.utcnow)
+    # link to corresponding chat document, for provenance/rewind purposes
+    chat_document_id: str = ""
 
     def api_dict(self) -> Dict[str, Any]:
         """
-        Convert to dictionary for API request.
-        DROP the tool_id, since it is only for use in the Assistant API,
-        not the completion API.
+        Convert to dictionary for API request, keeping ONLY
+        the fields that are expected in an API call!
+        E.g., DROP the tool_id, since it is only for use in the Assistant API,
+            not the completion API.
         Returns:
             dict: dictionary representation of LLM message
         """
@@ -155,8 +168,10 @@ class LLMMessage(BaseModel):
                 dict_no_none["function_call"]["arguments"] = json.dumps(
                     dict_no_none["function_call"]["arguments"]
                 )
+        # IMPORTANT! drop fields that are not expected in API call
         dict_no_none.pop("tool_id", None)
         dict_no_none.pop("timestamp", None)
+        dict_no_none.pop("chat_document_id", None)
         return dict_no_none
 
     def __str__(self) -> str:
@@ -268,11 +283,15 @@ class LanguageModel(ABC):
                 """
             )
         from langroid.language_models.azure_openai import AzureGPT
+        from langroid.language_models.mock_lm import MockLM, MockLMConfig
         from langroid.language_models.openai_gpt import OpenAIGPT
 
         if config is None or config.type is None:
             return None
 
+        if config.type == "mock":
+            return MockLM(cast(MockLMConfig, config))
+
         openai: Union[Type[AzureGPT], Type[OpenAIGPT]]
 
         if config.type == "azure":

langroid/language_models/mock_lm.py

@@ -0,0 +1,96 @@
+"""Mock Language Model for testing"""
+
+from typing import Dict, List, Optional, Union
+
+import langroid.language_models as lm
+from langroid.language_models import LLMResponse
+from langroid.language_models.base import LanguageModel, LLMConfig
+
+
+class MockLMConfig(LLMConfig):
+    """
+    Mock Language Model Configuration.
+
+    Attributes:
+        response_dict (Dict[str, str]): A "response rule-book", in the form of a
+            dictionary; if last msg in dialog is x,then respond with response_dict[x]
+    """
+
+    response_dict: Dict[str, str] = {}
+    default_response: str = "Mock response"
+    type: str = "mock"
+
+
+class MockLM(LanguageModel):
+
+    def __init__(self, config: MockLMConfig = MockLMConfig()):
+        super().__init__(config)
+        self.config: MockLMConfig = config
+
+    def chat(
+        self,
+        messages: Union[str, List[lm.LLMMessage]],
+        max_tokens: int = 200,
+        functions: Optional[List[lm.LLMFunctionSpec]] = None,
+        function_call: str | Dict[str, str] = "auto",
+    ) -> lm.LLMResponse:
+        """
+        Mock chat function for testing
+        """
+        last_msg = messages[-1].content if isinstance(messages, list) else messages
+        return lm.LLMResponse(
+            message=self.config.response_dict.get(
+                last_msg,
+                self.config.default_response,
+            ),
+            cached=False,
+        )
+
+    async def achat(
+        self,
+        messages: Union[str, List[lm.LLMMessage]],
+        max_tokens: int = 200,
+        functions: Optional[List[lm.LLMFunctionSpec]] = None,
+        function_call: str | Dict[str, str] = "auto",
+    ) -> lm.LLMResponse:
+        """
+        Mock chat function for testing
+        """
+        last_msg = messages[-1].content if isinstance(messages, list) else messages
+        return lm.LLMResponse(
+            message=self.config.response_dict.get(
+                last_msg,
+                self.config.default_response,
+            ),
+            cached=False,
+        )
+
+    def generate(self, prompt: str, max_tokens: int = 200) -> lm.LLMResponse:
+        """
+        Mock generate function for testing
+        """
+        return lm.LLMResponse(
+            message=self.config.response_dict.get(
+                prompt,
+                self.config.default_response,
+            ),
+            cached=False,
+        )
+
+    async def agenerate(self, prompt: str, max_tokens: int = 200) -> LLMResponse:
+        """
+        Mock generate function for testing
+        """
+        return lm.LLMResponse(
+            message=self.config.response_dict.get(
+                prompt,
+                self.config.default_response,
+            ),
+            cached=False,
+        )
+
+    def get_stream(self) -> bool:
+        return False
+
+    def set_stream(self, stream: bool) -> bool:
+        return False

langroid/language_models/utils.py

@@ -62,7 +62,7 @@ def retry_with_exponential_backoff(
                 if num_retries > max_retries:
                     raise Exception(
                         f"Maximum number of retries ({max_retries}) exceeded."
-                        f" Last error: {e}."
+                        f" Last error: {str(e)}."
                     )
 
                 # Increment the delay
@@ -128,6 +128,7 @@ def async_retry_with_exponential_backoff(
                 if num_retries > max_retries:
                     raise Exception(
                         f"Maximum number of retries ({max_retries}) exceeded."
+                        f" Last error: {str(e)}."
                     )
 
                 # Increment the delay

langroid/mytypes.py

@@ -1,10 +1,9 @@
-import hashlib
-import uuid
 from enum import Enum
 from textwrap import dedent
 from typing import Any, Callable, Dict, List, Union
+from uuid import uuid4
 
-from langroid.pydantic_v1 import BaseModel, Extra
+from langroid.pydantic_v1 import BaseModel, Extra, Field
 
 Number = Union[int, float]
 Embedding = List[Number]
@@ -40,7 +39,7 @@ class DocMetaData(BaseModel):
 
     source: str = "context"
     is_chunk: bool = False  # if it is a chunk, don't split
-    id: str = ""  # unique id for the document
+    id: str = Field(default_factory=lambda: str(uuid4()))
     window_ids: List[str] = []  # for RAG: ids of chunks around this one
 
     def dict_bool_int(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
@@ -67,41 +66,11 @@ class Document(BaseModel):
     content: str
     metadata: DocMetaData
 
-    @staticmethod
-    def hash_id(doc: str) -> str:
-        # Encode the document as UTF-8
-        doc_utf8 = str(doc).encode("utf-8")
-
-        # Create a SHA256 hash object
-        sha256_hash = hashlib.sha256()
-
-        # Update the hash object with the bytes of the document
-        sha256_hash.update(doc_utf8)
-
-        # Get the hexadecimal representation of the hash
-        hash_hex = sha256_hash.hexdigest()
-
-        # Convert the first part of the hash to a UUID
-        hash_uuid = uuid.UUID(hash_hex[:32])
-
-        return str(hash_uuid)
-
-    def _unique_hash_id(self) -> str:
-        return self.hash_id(str(self))
-
     def id(self) -> str:
-        if (
-            hasattr(self.metadata, "id")
-            and self.metadata.id is not None
-            and self.metadata.id != ""
-        ):
-            return self.metadata.id
-        else:
-            return self._unique_hash_id()
+        return self.metadata.id
 
     def __str__(self) -> str:
         # TODO: make metadata a pydantic model to enforce "source"
-        self.metadata.json()
         return dedent(
             f"""
         CONTENT: {self.content}         

langroid/parsing/document_parser.py

@@ -8,6 +8,7 @@ from io import BytesIO
 from typing import TYPE_CHECKING, Any, Generator, List, Tuple
 
 from langroid.exceptions import LangroidImportError
+from langroid.utils.object_registry import ObjectRegistry
 
 try:
     import fitz
@@ -341,6 +342,8 @@ class DocumentParser(Parser):
         split = []  # tokens in curr split
         pages: List[str] = []
         docs: List[Document] = []
+        # metadata.id to be shared by ALL chunks of this document
+        common_id = ObjectRegistry.new_id()
         for i, page in self.iterate_pages():
             page_text = self.extract_text_from_page(page)
             split += self.tokenizer.encode(page_text)
@@ -358,6 +361,7 @@ class DocumentParser(Parser):
                         metadata=DocMetaData(
                             source=f"{self.source} pages {pg}",
                             is_chunk=True,
+                            id=common_id,
                         ),
                     )
                 )
@@ -372,6 +376,7 @@ class DocumentParser(Parser):
                     metadata=DocMetaData(
                         source=f"{self.source} pages {pg}",
                         is_chunk=True,
+                        id=common_id,
                     ),
                 )
             )

langroid/parsing/parser.py

@@ -7,6 +7,7 @@ import tiktoken
 from langroid.mytypes import Document
 from langroid.parsing.para_sentence_split import create_chunks, remove_extra_whitespace
 from langroid.pydantic_v1 import BaseSettings
+from langroid.utils.object_registry import ObjectRegistry
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
@@ -75,11 +76,13 @@ class Parser:
             return
         # The original metadata.id (if any) is ignored since it will be same for all
         # chunks and is useless. We want a distinct id for each chunk.
+        # ASSUMPTION: all chunks c of a doc have same c.metadata.id !
         orig_ids = [c.metadata.id for c in chunks]
-        ids = [Document.hash_id(str(c)) for c in chunks]
+        ids = [ObjectRegistry.new_id() for c in chunks]
         id2chunk = {id: c for id, c in zip(ids, chunks)}
 
         # group the ids by orig_id
+        # (each distinct orig_id refers to a different document)
         orig_id_to_ids: Dict[str, List[str]] = {}
         for orig_id, id in zip(orig_ids, ids):
             if orig_id not in orig_id_to_ids:
@@ -108,6 +111,10 @@ class Parser:
             if d.content.strip() == "":
                 continue
             chunks = remove_extra_whitespace(d.content).split(self.config.separators[0])
+            # note we are ensuring we COPY the document metadata into each chunk,
+            # which ensures all chunks of a given doc have same metadata
+            # (and in particular same metadata.id, which is important later for
+            # add_window_ids)
             chunk_docs = [
                 Document(
                     content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
@@ -156,6 +163,10 @@ class Parser:
             if d.content.strip() == "":
                 continue
             chunks = create_chunks(d.content, self.config.chunk_size, self.num_tokens)
+            # note we are ensuring we COPY the document metadata into each chunk,
+            # which ensures all chunks of a given doc have same metadata
+            # (and in particular same metadata.id, which is important later for
+            # add_window_ids)
             chunk_docs = [
                 Document(
                     content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
@@ -171,6 +182,10 @@ class Parser:
         final_docs = []
         for d in docs:
             chunks = self.chunk_tokens(d.content)
+            # note we are ensuring we COPY the document metadata into each chunk,
+            # which ensures all chunks of a given doc have same metadata
+            # (and in particular same metadata.id, which is important later for
+            # add_window_ids)
             chunk_docs = [
                 Document(
                     content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
@@ -274,7 +289,7 @@ class Parser:
         # we need this to distinguish docs later in add_window_ids
         for d in docs:
             if d.metadata.id in [None, ""]:
-                d.metadata.id = d._unique_hash_id()
+                d.metadata.id = ObjectRegistry.new_id()
         # some docs are already splits, so don't split them further!
         chunked_docs = [d for d in docs if d.metadata.is_chunk]
         big_docs = [d for d in docs if not d.metadata.is_chunk]

langroid/utils/__init__.py

@@ -5,6 +5,7 @@ from . import logging
 from . import pydantic_utils
 from . import system
 from . import output
+from . import object_registry
 
 __all__ = [
     "configuration",
@@ -14,4 +15,5 @@ __all__ = [
     "pydantic_utils",
     "system",
     "output",
+    "object_registry",
 ]

langroid/utils/object_registry.py

@@ -0,0 +1,66 @@
+import time
+from typing import TYPE_CHECKING, Dict, Optional, TypeAlias, TypeVar
+from uuid import uuid4
+
+from langroid.pydantic_v1 import BaseModel
+
+if TYPE_CHECKING:
+    from langroid.agent.base import Agent
+    from langroid.agent.chat_agent import ChatAgent
+    from langroid.agent.chat_document import ChatDocument
+
+    # any derivative of BaseModel that has an id() method or an id attribute
+    ObjWithId: TypeAlias = ChatDocument | ChatAgent | Agent
+else:
+    ObjWithId = BaseModel
+
+# Define a type variable that can be any subclass of BaseModel
+T = TypeVar("T", bound=BaseModel)
+
+
+class ObjectRegistry:
+    """A global registry to hold id -> object mappings."""
+
+    registry: Dict[str, ObjWithId] = {}
+
+    @classmethod
+    def add(cls, obj: ObjWithId) -> str:
+        """Adds an object to the registry, returning the object's ID."""
+        object_id = obj.id() if callable(obj.id) else obj.id
+        cls.registry[object_id] = obj
+        return object_id
+
+    @classmethod
+    def get(cls, obj_id: str) -> Optional[ObjWithId]:
+        """Retrieves an object by ID if it still exists."""
+        return cls.registry.get(obj_id)
+
+    @classmethod
+    def register_object(cls, obj: ObjWithId) -> str:
+        """Registers an object in the registry, returning the object's ID."""
+        return cls.add(obj)
+
+    @classmethod
+    def remove(cls, obj_id: str) -> None:
+        """Removes an object from the registry."""
+        if obj_id in cls.registry:
+            del cls.registry[obj_id]
+
+    @classmethod
+    def cleanup(cls) -> None:
+        """Cleans up the registry by removing entries where the object is None."""
+        to_remove = [key for key, value in cls.registry.items() if value is None]
+        for key in to_remove:
+            del cls.registry[key]
+
+    @staticmethod
+    def new_id() -> str:
+        """Generates a new unique ID."""
+        return str(uuid4())
+
+
+def scheduled_cleanup(interval: int = 600) -> None:
+    """Periodically cleans up the global registry every 'interval' seconds."""
+    while True:
+        ObjectRegistry.cleanup()
+        time.sleep(interval)

langroid/utils/system.py

@@ -1,6 +1,7 @@
 import getpass
 import hashlib
 import importlib
+import importlib.metadata
 import inspect
 import logging
 import shutil
@@ -18,6 +19,15 @@ DELETION_ALLOWED_PATHS = [
 ]
 
 
+def pydantic_major_version() -> int:
+    try:
+        pydantic_version = importlib.metadata.version("pydantic")
+        major_version = int(pydantic_version.split(".")[0])
+        return major_version
+    except importlib.metadata.PackageNotFoundError:
+        return -1
+
+
 class LazyLoad:
     """Lazy loading of modules or classes."""
 
@@ -171,5 +181,4 @@ def hash(s: str) -> str:
 
 def generate_unique_id() -> str:
     """Generate a unique ID using UUID4."""
-    unique_id = str(uuid.uuid4())
-    return unique_id
+    return str(uuid.uuid4())

langroid/vector_store/base.py

@@ -12,6 +12,7 @@ from langroid.mytypes import Document
 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
 from langroid.utils.output.printing import print_long_text
 from langroid.utils.pandas_utils import stringify
 
@@ -163,7 +164,7 @@ class VectorStore(ABC):
         vecdbs don't like having blank ids."""
         for d in documents:
             if d.metadata.id in [None, ""]:
-                d.metadata.id = d._unique_hash_id()
+                d.metadata.id = ObjectRegistry.new_id()
 
     @abstractmethod
     def similar_texts_with_scores(
@@ -254,7 +255,7 @@ class VectorStore(ABC):
                 metadata=metadata,
             )
             # make a fresh id since content is in general different
-            document.metadata.id = document.hash_id(document.content)
+            document.metadata.id = ObjectRegistry.new_id()
             final_docs += [document]
             final_scores += [max(id2max_score[id] for id in w)]
         return list(zip(final_docs, final_scores))

langroid/vector_store/lancedb.py

@@ -38,6 +38,7 @@ from langroid.utils.pydantic_utils import (
     flatten_pydantic_model,
     nested_dict_from_flat,
 )
+from langroid.utils.system import pydantic_major_version
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
 try:
@@ -121,17 +122,21 @@ class LanceDB(VectorStore):
                 else self.unflattened_schema
             )
         except (AttributeError, TypeError) as e:
-            raise ValueError(
-                f"""
-                {e}
-                ====
-                One reason for this error is that you may be using Pydantic v2,
-                which is not yet compatible with Langroid's LanceDB integration.
-                If so, to use Lancedb with Langroid, please install the 
-                latest pydantic 1.10.15 instead of pydantic v2, e.g. 
-                pip install pydantic==1.10.15
-                """
-            )
+            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()
@@ -264,18 +269,22 @@ class LanceDB(VectorStore):
             self.client.create_table(
                 collection_name, schema=self.schema, mode="overwrite"
             )
-        except TypeError as e:
-            raise TypeError(
-                f"""
-                {e}
-                ====
-                One reason for this error is that you may be using Pydantic v2,
-                which is not yet compatible with Langroid's LanceDB integration.
-                If so, to use Lancedb with Langroid, please install the 
-                latest pydantic 1.10.15 instead of pydantic v2, e.g. 
-                pip install pydantic==1.10.15
-                """
-            )
+        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()

{langroid-0.1.263.dist-info → langroid-0.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.263
+Version: 0.2.0
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -19,7 +19,6 @@ Provides-Extra: docx
 Provides-Extra: hf-embeddings
 Provides-Extra: hf-transformers
 Provides-Extra: lancedb
-Provides-Extra: langroid-pydantic-v1
 Provides-Extra: litellm
 Provides-Extra: meilisearch
 Provides-Extra: metaphor
@@ -53,10 +52,8 @@ Requires-Dist: halo (>=0.0.31,<0.0.32)
 Requires-Dist: huggingface-hub (>=0.21.2,<0.22.0) ; extra == "hf-transformers" or extra == "all" or extra == "transformers"
 Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
 Requires-Dist: lancedb (>=0.8.2,<0.9.0) ; extra == "vecdbs" or extra == "lancedb"
-Requires-Dist: langroid_pydantic_v1 (>=0.1.0,<0.2.0) ; extra == "langroid-pydantic-v1" or extra == "lancedb"
 Requires-Dist: litellm (>=1.30.1,<2.0.0) ; extra == "all" or extra == "litellm"
 Requires-Dist: lxml (>=4.9.3,<5.0.0)
-Requires-Dist: meilisearch (>=0.28.3,<0.29.0) ; extra == "meilisearch"
 Requires-Dist: meilisearch-python-sdk (>=2.2.3,<3.0.0) ; extra == "meilisearch"
 Requires-Dist: metaphor-python (>=0.1.23,<0.2.0) ; extra == "all" or extra == "metaphor"
 Requires-Dist: momento (>=1.10.2,<2.0.0) ; extra == "momento"
@@ -426,7 +423,7 @@ Here is what it looks like in action
 
 # :zap: Highlights
 (For a more up-to-date list see the 
-[release](https://github.com/langroid/langroid?tab=readme-ov-file#fire-updatesreleases) 
+[Updates/Releases](https://github.com/langroid/langroid?tab=readme-ov-file#fire-updatesreleases) 
 section above)
 - **Agents as first-class citizens:** The [Agent](https://langroid.github.io/langroid/reference/agent/base/#langroid.agent.base.Agent) class encapsulates LLM conversation state,
   and optionally a vector-store and tools. Agents are a core abstraction in Langroid;
@@ -442,8 +439,8 @@ section above)
 - **Modularity, Reusability, Loose coupling:** The `Agent` and `Task` abstractions allow users to design
   Agents with specific skills, wrap them in Tasks, and combine tasks in a flexible way.
 - **LLM Support**: Langroid supports OpenAI LLMs as well as LLMs from hundreds of 
-providers (local/open or remote/commercial) via proxy libraries and local model servers
-such as [LiteLLM](https://docs.litellm.ai/docs/providers) that in effect mimic the OpenAI API. 
+providers ([local/open](https://langroid.github.io/langroid/tutorials/local-llm-setup/) or [remote/commercial](https://langroid.github.io/langroid/tutorials/non-openai-llms/)) via proxy libraries and local model servers
+such as [ollama](https://github.com/ollama), [oobabooga](https://github.com/oobabooga/text-generation-webui), [LiteLLM](https://docs.litellm.ai/docs/providers) that in effect mimic the OpenAI API. 
 - **Caching of LLM responses:** Langroid supports [Redis](https://redis.com/try-free/) and 
   [Momento](https://www.gomomento.com/) to cache LLM responses.
 - **Vector-stores**: [LanceDB](https://github.com/lancedb/lancedb), [Qdrant](https://qdrant.tech/), [Chroma](https://www.trychroma.com/) are currently supported.
@@ -453,7 +450,7 @@ such as [LiteLLM](https://docs.litellm.ai/docs/providers) that in effect mimic t
 - **Observability, Logging, Lineage:** Langroid generates detailed logs of multi-agent interactions and
   maintains provenance/lineage of messages, so that you can trace back
   the origin of a message.
-- **Tools/Plugins/Function-calling**: Langroid supports OpenAI's recently
+- **[Tools/Plugins/Function-calling](https://langroid.github.io/langroid/quick-start/chat-agent-tool/)**: Langroid supports OpenAI's recently
   released [function calling](https://platform.openai.com/docs/guides/gpt/function-calling)
   feature. In addition, Langroid has its own native equivalent, which we
   call **tools** (also known as "plugins" in other contexts). Function