langroid 0.1.21__py3-none-any.whl → 0.1.23__py3-none-any.whl

langroid/agent/base.py

@@ -31,7 +31,7 @@ logger = logging.getLogger(__name__)
 class AgentConfig(BaseSettings):
     """
     General config settings for an LLM agent. This is nested, combining configs of
-    various components, in a hierarchy.
+    various components.
     """
 
     name: str = "LLM-Agent"
@@ -43,6 +43,16 @@ class AgentConfig(BaseSettings):
 
 
 class Agent(ABC):
+    """
+    An Agent is an abstraction that encapsulates mainly two components:
+
+    - a language model (LLM)
+    - a vector store (vecdb)
+
+    plus associated components such as a parser, and variables that hold
+    information about any tool/function-calling messages that have been defined.
+    """
+
     def __init__(self, config: AgentConfig):
         self.config = config
         self.dialog: List[Tuple[str, str]] = []  # seq of LLM (prompt, response) tuples

langroid/agent/chat_agent.py

@@ -44,13 +44,16 @@ class ChatAgent(Agent):
     """
     Chat Agent interacting with external env
     (could be human, or external tools).
-    The agent (the LLM actually) is provided with a "Task Spec", and told to think in
-    small steps. It may be given a set of possible "Actions", and if so it is told to
-    emit the appropriate action in each round. Each round consists of:
-    - LLM emits an Action, or says Done
-    - LLM receives an Observation from that Action
-        (which could be a human response but not necessarily)
-    - LLM thinks
+    The agent (the LLM actually) is provided with an optional "Task Spec",
+    which is a sequence of `LLMMessage`s. These are used to initialize
+    the `task_messages` of the agent.
+    In most applications we will use a `ChatAgent` rather than a bare `Agent`.
+    The `Agent` class mainly exists to hold various common methods and attributes.
+    One difference between `ChatAgent` and `Agent` is that `ChatAgent`'s
+    `llm_response` method uses "chat mode" API (i.e. one that takes a
+    message sequence rather than a single message),
+    whereas the same method in the `Agent` class uses "completion mode" API (i.e. one
+    that takes a single message).
     """
 
     def __init__(
@@ -61,24 +64,6 @@ class ChatAgent(Agent):
         Args:
             config: settings for the agent
 
-        !!! note
-             `self.message_history` is different from `self.dialog` (in Agent class):
-
-            - `self.message_history` is the sequence of messages sent to the LLM in
-            **chat mode** (e.g. when using OpenAI `ChatCompletion.create()`)
-                Typically we send a sequence of such messages to "prime"
-            the LLM context for some task, and we extend and re-send this sequence to
-            continue interaction. Note that consecutive messages in the sequence could
-            have different or same roles (e.g. "user", "assistant"). Each message has a
-            "dict" structure, which we call :class:`LLMMessage`.
-
-            - `self.dialog` is the sequence of `(prompt, response)` tuples produced
-            when interacting with an LLM in **completion mode**,
-            where `prompt (str)` is sent TO the LLM, and `response (str)` is received
-            FROM the LLM. Typically as an LLM conversation goes on, we collate
-            `self.dialog` into a single string, and insert it into the context part
-            of the next prompt to the LLM.
-
         """
         super().__init__(config)
         self.config: ChatAgentConfig = config

langroid/agent/special/doc_chat_agent.py

@@ -324,7 +324,7 @@ class DocChatAgent(ChatAgent):
 
         passages = self.original_docs
 
-        # if original docs not too long, no need to look for relevant parts.
+        # if original docs too long, no need to look for relevant parts.
         if (
             passages is None
             or self.original_docs_length > self.config.max_context_tokens
@@ -380,8 +380,13 @@ class DocChatAgent(ChatAgent):
         if self.parser is None:
             raise ValueError("No parser defined")
         tot_tokens = self.parser.num_tokens(full_text)
+        model = (
+            self.config.llm.chat_model
+            if self.config.llm.use_chat_for_completion
+            else self.config.llm.completion_model
+        )
         MAX_INPUT_TOKENS = (
-            self.config.llm.context_length[self.config.llm.completion_model]
+            self.config.llm.context_length[model]
             - self.config.llm.max_output_tokens
             - 100
         )

langroid/agent/task.py

@@ -1,8 +1,3 @@
-"""
-Class that runs the Task loop of an agent;
-maintains state while various responders (agent's own methods, or external sub-tasks)
-take turns attempting to respond to the `self.pending_message`.
-"""
 from __future__ import annotations
 
 import logging
@@ -28,12 +23,32 @@ Responder = Entity | Type["Task"]
 
 class Task:
     """
-    Class to loop through maintain state needed to run a __task__. A __task__ generally
-    is associated with a goal, typically represented by the initial "priming"
-    messages of the LLM. Various entities take turns responding to
-    `pending_message`, which is updated with the latest response.
-    Tasks can have sub-tasks. A task is finished when `done()` returns true, and the
-    final result is `result()`, which is returned to the "calling task" (if any).
+    A `Task` wraps an `Agent` object, and sets up the `Agent`'s goals and instructions.
+    A `Task` maintains two key variables:
+
+    - `self.pending_message`, which is the message awaiting a response, and
+    - `self.pending_sender`, which is the entity that sent the pending message.
+
+    The possible responders to `self.pending_message` are the `Agent`'s own "native"
+    responders (`agent_response`, `llm_response`, and `user_response`), and
+    the `run()` methods of any sub-tasks. All responders have the same type-signature
+    (somewhat simplified):
+    ```
+    str | ChatDocument -> ChatDocument
+    ```
+    Responders may or may not specify an intended recipient of their generated response.
+
+    The main top-level method in the `Task` class is `run()`, which repeatedly calls
+    `step()` until `done()` returns true. The `step()` represents a "turn" in the
+    conversation: this method sequentially (in round-robin fashion) calls the responders
+    until it finds one that generates a *valid* response to the `pending_message`
+    (as determined by the `valid()` method). Once a valid response is found,
+    `step()` updates the `pending_message` and `pending_sender` variables,
+    and on the next iteration, `step()` re-starts its search for a valid response
+    *from the beginning* of the list of responders (the exception being that the
+    human user always gets a chance to respond after each non-human valid response).
+    This process repeats until `done()` returns true, at which point `run()` returns
+    the value of `result()`, which is the final result of the task.
     """
 
     def __init__(
@@ -51,8 +66,10 @@ class Task:
     ):
         """
         A task to be performed by an agent.
+
         Args:
-            agent (Agent): agent to perform the task
+            agent (Agent): agent associated with the task
+            name (str): name of the task
             llm_delegate (bool): whether to delegate control to LLM; conceptually,
                 the "controlling entity" is the one "seeking" responses to its queries,
                 and has a goal it is aiming to achieve. The "controlling entity" is
@@ -73,7 +90,6 @@ class Task:
                 erase all subtask agents' `message_history`.
                 Note: erasing can reduce prompt sizes, but results in repetitive
                 sub-task delegation.
-
         """
         if isinstance(agent, ChatAgent) and len(agent.message_history) == 0 or restart:
             agent = cast(ChatAgent, agent)

langroid/agent/tool_message.py

@@ -68,7 +68,8 @@ class ToolMessage(ABC, BaseModel):
     LLM. Depending on context, "tools" are also referred to as "plugins",
     or "function calls" (in the context of OpenAI LLMs).
     Essentially, they are a way for the LLM to express its intent to run a special
-    function or method. Currently we implement these as methods of the agent.
+    function or method. Currently these "tools" are handled by methods of the
+    agent.
 
     Attributes:
         request (str): name of agent method to map to.

langroid/embedding_models/base.py

@@ -12,7 +12,10 @@ class EmbeddingModelsConfig(BaseSettings):
 
 
 class EmbeddingModel(ABC):
-    # factory method
+    """
+    Abstract base class for an embedding model.
+    """
+
     @classmethod
     def create(cls, config: EmbeddingModelsConfig) -> "EmbeddingModel":
         from langroid.embedding_models.models import (

langroid/language_models/base.py

@@ -111,6 +111,10 @@ class LLMMessage(BaseModel):
 
 
 class LLMResponse(BaseModel):
+    """
+    Class representing response from LLM.
+    """
+
     message: str
     function_call: Optional[LLMFunctionCall] = None
     usage: int

langroid/vector_store/base.py

@@ -30,6 +30,10 @@ class VectorStoreConfig(BaseSettings):
 
 
 class VectorStore(ABC):
+    """
+    Abstract base class for a vector store.
+    """
+
     def __init__(self, config: VectorStoreConfig):
         self.config = config
 

{langroid-0.1.21.dist-info → langroid-0.1.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.21
+Version: 0.1.23
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -61,61 +61,51 @@ Description-Content-Type: text/markdown
   <h1>Langroid: Harness LLMs with Multi-Agent Programming</h1>
 </div>
 
+<div align="center">
+
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
 [![Lint](https://github.com/langroid/langroid/actions/workflows/validate.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/validate.yml)
 [![Docs](https://github.com/langroid/langroid/actions/workflows/mkdocs-deploy.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/mkdocs-deploy.yml)
+[![Static Badge](https://img.shields.io/badge/Documentation-blue?link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F&link=https%3A%2F%2Flangroid.github.io%2Flangroid%2F)](https://langroid.github.io/langroid)
+[![Static Badge](https://img.shields.io/badge/Discord-Orange?link=https%3A%2F%2Fdiscord.gg%2Fg3nAXCbZ&link=https%3A%2F%2Fdiscord.gg%2Fg3nAXCbZ)](https://discord.gg/g3nAXCbZ)
+
+</div>
 
 Langroid is an intuitive, lightweight, transparent, flexible, extensible and principled
-Python framework to harness LLMs using Multi-Agent Programming (MAP).
+Python framework to build LLM-powered applications using Multi-Agent Programming. 
 We welcome [contributions](CONTRIBUTING.md)!
 
+Langroid is the first Python LLM-application framework that was explicitly
+designed  with Agents as first-class citizens, and Multi-Agent Programming
+as the core  design principle. The framework is inspired by ideas from the
+[Actor Framework](https://en.wikipedia.org/wiki/Actor_model).
+For more details see [here](https://langroid.github.io/langroid/).
+
 Documentation: https://langroid.github.io/langroid/
 
 Usage examples: https://github.com/langroid/langroid-examples
 
-## Overview
-
-### The LLM Opportunity
-
-Given the remarkable abilities of recent Large Language Models (LLMs), there
-is an unprecedented opportunity to build intelligent applications powered by
-this transformative technology. The top question for any enterprise is: how
-best to harness the power of LLMs for complex applications? For technical and
-practical reasons, building LLM-powered applications is not as simple as
-throwing a task at an LLM-system and expecting it to do it.
+Community: Join us on [Discord!](https://discord.gg/g3nAXCbZ)
 
-### Langroid's Multi-Agent Programming Framework
+## :rocket: Demo
 
-Effectively leveraging LLMs at scale requires a *principled programming
-framework*. In particular, there is often a need to maintain multiple LLM
-conversations, each instructed in different ways, and "responsible" for
-different aspects of a task.
+A `LeaseExtractor` agent is tasked with extracting structured information
+from a commercial lease document. It generates questions that are 
+answerred by a `DocAgent` using Retrieval from a vector-database
+(into which the lease has been sharded + embedded).
+When it has all the information it needs, the `LeaseExtractor` agent
+presents the information in a structured format using a Tool/Function-calling.
 
-An *agent* is a convenient abstraction that encapsulates LLM conversation
-state, along with access to long-term memory (vector-stores) and tools (a.k.a functions
-or plugins). Thus a **Multi-Agent Programming** framework is a natural fit
-for complex LLM-based applications.
+![Demo](lease-extractor-demo.gif)
 
-> Langroid is the first Python LLM-application framework that was explicitly
-designed  with Agents as first-class citizens, and Multi-Agent Programming
-as the core  design principle. The framework is inspired by ideas from the
-[Actor Framework](https://en.wikipedia.org/wiki/Actor_model).
 
-Langroid allows an intuitive definition of agents, tasks and task-delegation
-among agents. There is a principled mechanism to orchestrate multi-agent
-collaboration. Agents act as message-transformers, and take turns responding to (and
-transforming) the current message. The architecture is lightweight, transparent,
-flexible, and allows other types of orchestration to be implemented.
-Besides Agents, Langroid also provides simple ways to directly interact with  
-LLMs and vector-stores.
+## :zap: Highlights
 
-### Highlights
 Highlights of Langroid's features as of July 2023:
 
 - **Agents as first-class citizens:** The `Agent` class encapsulates LLM conversation state,
   and optionally a vector-store and tools. Agents are a core abstraction in Langroid;
-  Agents act as _message transformers_, and by default provide 3 _responder_ methods,  
-  one corresponding to each entity: LLM, Agent, User.
+  Agents act as _message transformers_, and by default provide 3 _responder_ methods, one corresponding to each entity: LLM, Agent, User.
 - **Tasks:** A Task class wraps an Agent, and gives the agent instructions (or roles, or goals), 
   manages iteration over an Agent's responder methods, 
   and orchestrates multi-agent interactions via hierarchical, recursive
@@ -130,7 +120,7 @@ Highlights of Langroid's features as of July 2023:
   GPT-4-0613
 - **Caching of LLM prompts, responses:** Langroid uses [Redis](https://redis.com/try-free/) for caching.
 - **Vector-stores**: [Qdrant](https://qdrant.tech/) and [Chroma](https://www.trychroma.com/) are currently supported.
-  Vector stores allow for Retrieval-Augmented-Generaation (RAG).
+  Vector stores allow for Retrieval-Augmented-Generation (RAG).
 - **Grounding and source-citation:** Access to external documents via vector-stores 
    allows for grounding and source-citation.
 - **Observability, Logging, Lineage:** Langroid generates detailed logs of multi-agent interactions and
@@ -148,11 +138,9 @@ Highlights of Langroid's features as of July 2023:
   hallucinates malformed JSON, the Pydantic error message is sent back to
   the LLM so it can fix it!
 
-# Usage/quick-start
-These are quick teasers to give a glimpse of what you can do with Langroid
-and how your code would look. See the 
-[`Getting Started Guide`](https://langroid.github.io/langroid/getting_started/)
-for a detailed tutorial.
+--- 
+
+# :gear: Installation and Setup
 
 ## Install `langroid` 
 Use `pip` to install `langroid` (from PyPi) to your virtual environment:
@@ -173,7 +161,7 @@ Copy the `.env-template` file to a new file `.env` and
 insert these secrets:
 - **OpenAI API** key (required): If you don't have one, see [this OpenAI Page](https://help.openai.com/en/collections/3675940-getting-started-with-openai-api).
 - **Qdrant** Vector Store API Key (required for apps that need retrieval from
-  documents): Sign up for a free 1GB account at [Qdrant cloud](https://cloud.qdrant.io)
+  documents): Sign up for a free 1GB account at [Qdrant cloud](https://cloud.qdrant.io).
   Alternatively [Chroma](https://docs.trychroma.com/) is also currently supported. 
   We use the local-storage version of Chroma, so there is no need for an API key.
 - **GitHub** Personal Access Token (required for apps that need to analyze git
@@ -198,7 +186,32 @@ QDRANT_API_KEY=<your key>
 Currently only OpenAI models are supported. Others will be added later
 (Pull Requests welcome!).
 
-## Direct interaction with OpenAI LLM
+---
+
+# :tada: Usage Examples
+
+These are quick teasers to give a glimpse of what you can do with Langroid
+and how your code would look. 
+
+:warning: The code snippets below are intended to give a flavor of the code
+and they are **not** complete runnable examples! For that we encourage you to 
+consult the [`langroid-examples`](https://github.com/langroid/langroid-examples) 
+repository.
+
+Also see the
+[`Getting Started Guide`](https://langroid.github.io/langroid/quick-start/)
+for a detailed tutorial. 
+
+- [Direct chat with LLM](#direct-llm)
+- [Simple Agent and Task](#agent-task)
+- [Three Communicating Agents](#three-agents)
+- [Agent with Tool/Function-calling](#agent-tool)
+- [Extract Structured Info with Tool/Function-calling](#agent-tool-structured)
+- [Retrieval-Augmented-Generation: Chat with Docs](#agent-rag)
+
+---
+
+## Direct interaction with OpenAI LLM <a name="direct-llm"></a>
 
 ```python
 from langroid.language_models.openai_gpt import ( 
@@ -213,11 +226,14 @@ mdl = OpenAIGPT(cfg)
 messages = [
   LLMMessage(content="You are a helpful assistant",  role=Role.SYSTEM), 
   LLMMessage(content="What is the capital of Ontario?",  role=Role.USER),
-],
+]
 response = mdl.chat(messages, max_tokens=200)
+print(response.message)
 ```
 
-## Define an agent, set up a task, and run it
+---
+
+## Define an agent, set up a task, and run it <a name="agent-task"></a>
 
 ```python
 from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
@@ -232,13 +248,15 @@ config = ChatAgentConfig(
 )
 agent = ChatAgent(config)
 # get response from agent's LLM, and put this in an interactive loop...
-answer = agent.llm_response("What is the capital of Ontario?")
-# ... or set up a task (which has a built-in loop) and run it
+# answer = agent.llm_response("What is the capital of Ontario?")
+  # ... OR instead, set up a task (which has a built-in loop) and run it
 task = Task(agent, name="Bot") 
-task.run() # ... a loop seeking response from Agent, LLM or User at each turn
+task.run() # ... a loop seeking response from LLM or User at each turn
 ```
 
-## Three communicating agents
+---
+
+## Three communicating agents <a name="three-agents"></a>
 
 A toy numbers game, where when given a number `n`:
 - `repeater_agent`'s LLM simply returns `n`,
@@ -248,57 +266,66 @@ A toy numbers game, where when given a number `n`:
 First define the 3 agents, and set up their tasks with instructions:
 
 ```python
-    config = ChatAgentConfig(
-        llm = OpenAIGPTConfig(
-            chat_model=OpenAIChatModel.GPT4,
-        ),
-        vecdb = None,
-    )
-    repeater_agent = ChatAgent(config)
-    repeater_task = Task(
-        repeater_agent,
-        name = "Repeater",
-        system_message="""
-        Your job is to repeat whatever number you receive.
-        """,
-        llm_delegate=True, # LLM takes charge of task
-        single_round=False, 
-    )
-    even_agent = ChatAgent(config)
-    even_task = Task(
-        even_agent,
-        name = "EvenHandler",
-        system_message=f"""
-        You will be given a number. 
-        If it is even, divide by 2 and say the result, nothing else.
-        If it is odd, say {NO_ANSWER}
-        """,
-        single_round=True,  # task done after 1 step() with valid response
-    )
+from langroid.utils.constants import NO_ANSWER
+from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
+from langroid.agent.task import Task
+from langroid.language_models.openai_gpt import OpenAIChatModel, OpenAIGPTConfig
+config = ChatAgentConfig(
+    llm = OpenAIGPTConfig(
+        chat_model=OpenAIChatModel.GPT4,
+    ),
+    vecdb = None,
+)
+repeater_agent = ChatAgent(config)
+repeater_task = Task(
+    repeater_agent,
+    name = "Repeater",
+    system_message="""
+    Your job is to repeat whatever number you receive.
+    """,
+    llm_delegate=True, # LLM takes charge of task
+    single_round=False, 
+)
+even_agent = ChatAgent(config)
+even_task = Task(
+    even_agent,
+    name = "EvenHandler",
+    system_message=f"""
+    You will be given a number. 
+    If it is even, divide by 2 and say the result, nothing else.
+    If it is odd, say {NO_ANSWER}
+    """,
+    single_round=True,  # task done after 1 step() with valid response
+)
 
-    odd_agent = ChatAgent(config)
-    odd_task = Task(
-        odd_agent,
-        name = "OddHandler",
-        system_message=f"""
-        You will be given a number n. 
-        If it is odd, return (n*3+1), say nothing else. 
-        If it is even, say {NO_ANSWER}
-        """,
-        single_round=True,  # task done after 1 step() with valid response
-    )
+odd_agent = ChatAgent(config)
+odd_task = Task(
+    odd_agent,
+    name = "OddHandler",
+    system_message=f"""
+    You will be given a number n. 
+    If it is odd, return (n*3+1), say nothing else. 
+    If it is even, say {NO_ANSWER}
+    """,
+    single_round=True,  # task done after 1 step() with valid response
+)
 ```
 Then add the `even_task` and `odd_task` as sub-tasks of `repeater_task`, 
 and run the `repeater_task`, kicking it off with a number as input:
 ```python
-    repeater_task.add_sub_task([even_task, odd_task])
-    repeater_task.run("3")
+repeater_task.add_sub_task([even_task, odd_task])
+repeater_task.run("3")
 ```
+---
+
+## Simple Tool/Function-calling example <a name="agent-tool"></a>
 
-### Simple Tool/Function-calling example
 Langroid leverages Pydantic to support OpenAI's
 [Function-calling API](https://platform.openai.com/docs/guides/gpt/function-calling)
-as well as its own native tools.
+as well as its own native tools. The benefits are that you don't have to write
+any JSON to specify the schema, and also if the LLM hallucinates a malformed
+tool syntax, Langroid sends the Pydantic validation error (suitiably sanitized) 
+to the LLM so it can fix it!
 
 Simple example: Say the agent has a secret list of numbers, 
 and we want the LLM to find the smallest number in the list. 
@@ -357,7 +384,9 @@ For a full working example see the
 [chat-agent-tool.py](https://github.com/langroid/langroid-examples/blob/main/examples/quick-start/chat-agent-tool.py)
 script in the `langroid-examples` repo.
 
-### Tool/Function-calling to extract structured information from text
+---
+
+## Tool/Function-calling to extract structured information from text <a name="agent-tool-structured"></a>
 
 Suppose you want an agent to extract 
 the key terms of a lease, from a lease document, as a nested JSON structure.
@@ -381,7 +410,7 @@ class Lease(BaseModel):
 ```
 
 Then define the `LeaseMessage` tool as a subclass of Langroid's `ToolMessage`.
-Note the tool as a required argument `terms` of type `Lease`:
+Note the tool has a required argument `terms` of type `Lease`:
 
 ```python
 class LeaseMessage(ToolMessage):
@@ -419,8 +448,9 @@ lease_extractor_agent.enable_message(LeaseMessage)
 See the [`chat_multi_extract.py`](https://github.com/langroid/langroid-examples/blob/main/examples/docqa/chat_multi_extract.py)
 script in the `langroid-examples` repo for a full working example.
 
+---
 
-### Chat with documents (file paths, URLs, etc)
+## Chat with documents (file paths, URLs, etc) <a name="agent-docs"></a>
 
 Langroid provides a specialized agent class `DocChatAgent` for this purpose.
 It incorporates document sharding, embedding, storage in a vector-DB, 
@@ -467,8 +497,9 @@ See full working scripts in the
 [`docqa`](https://github.com/langroid/langroid-examples/tree/main/examples/docqa)
 folder of the `langroid-examples` repo.
 
+---
 
-## Contributors
+# Contributors
 
 - Prasad Chalasani (IIT BTech/CS, CMU PhD/ML; Independent ML Consultant)
 - Somesh Jha (IIT BTech/CS, CMU PhD/CS; Professor of CS, U Wisc at Madison)

{langroid-0.1.21.dist-info → langroid-0.1.23.dist-info}/RECORD

@@ -1,26 +1,26 @@
 langroid/__init__.py,sha256=sEKJ_5WJBAMZApevfeE3gxLK-eotVzJMJlT83G0rAko,30
 langroid/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/agent/base.py,sha256=VrHamEShYwPGdrwcLrFLR7ubFIWhC8eYEzp6XXMCbws,20634
-langroid/agent/chat_agent.py,sha256=W_BtjfhEEpScmoduIrBxrz5gTU2vS6Cma1dAn_rrwTA,21381
+langroid/agent/base.py,sha256=J-SyNvmG1nhWSnz7qFyP_tvOl8GF5rUv8a7fNsAhZFM,20921
+langroid/agent/chat_agent.py,sha256=mLCHlYxU1lB7PGOLjjkaEQUqMNKcq0-HOjlG4ZcDjQE,20522
 langroid/agent/chat_document.py,sha256=Rj7Hfp_FrNjuKsTMA3KyZhno5zKpmvnPPk7WgAuAF2Y,5745
 langroid/agent/helpers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/agent/junk,sha256=LxfuuW7Cijsg0szAzT81OjWWv1PMNI-6w_-DspVIO2s,339
 langroid/agent/special/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/agent/special/doc_chat_agent.py,sha256=hcGbB9Vb0qdnPI9qHdQj1EIR8qPIluId7VlSP4cHfco,15600
+langroid/agent/special/doc_chat_agent.py,sha256=NhoS02rlLr3nAfRvLB1YNcmfsWZJH24K8O-m-uYnb-I,15741
 langroid/agent/special/recipient_validator_agent.py,sha256=x2UprcGlh-fyxQCZbb_fkKrruU5Om0mgOnNzk_PYBNM,4527
 langroid/agent/special/retriever_agent.py,sha256=AiGKIJdndV4u5kr3woINw-vLKhwWnsINlvXtXxHcJgQ,6995
-langroid/agent/task.py,sha256=fsd2m9AXSyAdwnD-dVJou6sFz78BXJIrircu0auq-h4,24116
-langroid/agent/tool_message.py,sha256=XRDpx3zwQm650bosaLlpaadpAzYvTkLywpVo1diQJEU,5368
+langroid/agent/task.py,sha256=5P3S7thuYBvdaowOk1KMyDLukDtc-LLJactJcSgEJqA,25093
+langroid/agent/tool_message.py,sha256=7OdVcV7UyOZD2ihYgV1C_1fIwiWM-2pR8FFxoA1IgOo,5379
 langroid/agent_config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/cachedb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langroid/cachedb/base.py,sha256=F-QSDlRXrC0tBRbxL397MX8hulfBMAnZNs1e9zH71OQ,790
 langroid/cachedb/redis_cachedb.py,sha256=TUBQJ5etrU4jN2bJ3wNHC3h3Le8ez65psNiMrVAfh4w,2335
 langroid/embedding_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/embedding_models/base.py,sha256=1kwWyIq-fNbfe3CM9tbikOAU6NgahrWeW0BG6hjx8AU,939
+langroid/embedding_models/base.py,sha256=176jDrjEAAhNzdFCG8pfossd8SAhvHR8Q5Y8pOOm0LI,983
 langroid/embedding_models/clustering.py,sha256=tZWElUqXl9Etqla0FAa7og96iDKgjqWjucZR_Egtp-A,6684
 langroid/embedding_models/models.py,sha256=1xcv9hqmCTsbUbS8v7XeZRsf25Tu79JUoSipIYpvNoo,2765
 langroid/language_models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/language_models/base.py,sha256=BNbj5Ar0RoVfZXee1uXS0TJuSgL-vUAFtbwfQcA1KG8,12619
+langroid/language_models/base.py,sha256=Cr42pTm8XwGgq0bKGiSvedbnXpCTW37BYPm4LRcfBVY,12678
 langroid/language_models/openai_gpt.py,sha256=tWRSnzswQlGurQbe1eGUs3HhgaJKe4xj_fshGEqWr78,17538
 langroid/language_models/utils.py,sha256=rmnSn-sJ3aKl_wBdeLPkck0Li4Ed6zkCxZYYl7n1V34,4668
 langroid/mytypes.py,sha256=YA42IJcooJnTxAwk-B4FmZ1hqzIIF1ZZKcpUKzBTGGo,1537
@@ -56,11 +56,11 @@ langroid/utils/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 langroid/utils/web/login.py,sha256=1iz9eUAHa87vpKIkzwkmFa00avwFWivDSAr7QUhK7U0,2528
 langroid/utils/web/selenium_login.py,sha256=mYI6EvVmne34N9RajlsxxRqJQJvV-WG4LGp6sEECHPw,1156
 langroid/vector_store/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langroid/vector_store/base.py,sha256=-RGD7juAkmX40F8sTU0qObL2n-Nw51GdEq7phVX8lAQ,3679
+langroid/vector_store/base.py,sha256=QZx3NUNwf2I0r3A7iuoUHIRGbqt_pFGD0hq1R-Yg8iM,3740
 langroid/vector_store/chromadb.py,sha256=GPaXNPgPGIVUwYx2eO_-kreQoJ_33IFo13oigH5BP1c,5200
 langroid/vector_store/qdrant_cloud.py,sha256=3im4Mip0QXLkR6wiqVsjV1QvhSElfxdFSuDKddBDQ-4,188
 langroid/vector_store/qdrantdb.py,sha256=y7-fMxOqMJoYbdSfIr_HKcTIWTRpnb9j3Yg5EcOyFd4,8522
-langroid-0.1.21.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.1.21.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
-langroid-0.1.21.dist-info/METADATA,sha256=sOXFpMAcA6zwU_p9gUbKdklIjMXs3Gf9w794v5CC84w,18591
-langroid-0.1.21.dist-info/RECORD,,
+langroid-0.1.23.dist-info/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.1.23.dist-info/WHEEL,sha256=vVCvjcmxuUltf8cYhJ0sJMRDLr1XsPuxEId8YDzbyCY,88
+langroid-0.1.23.dist-info/METADATA,sha256=xuEtaXD4fPlxFI9r1ieWlDbj8VUZ-moCd2WFtOdeX5E,19215
+langroid-0.1.23.dist-info/RECORD,,