langroid 0.1.231__tar.gz → 0.1.233__tar.gz

{langroid-0.1.231 → langroid-0.1.233}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.231
+Version: 0.1.233
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani

{langroid-0.1.231 → langroid-0.1.233}/langroid/agent/batch.py

@@ -32,6 +32,7 @@ def run_batch_task_gen(
     message: Optional[str] = None,
     handle_exceptions: bool = False,
     max_cost: float = 0.0,
+    max_tokens: int = 0,
 ) -> list[U]:
     """
     Generate and run copies of a task async/concurrently one per item in `items` list.
@@ -53,6 +54,7 @@ def run_batch_task_gen(
         handle_exceptions: bool: Whether to replace exceptions with outputs of None
         max_cost: float: maximum cost to run the task (default 0.0 for unlimited)
 
+
     Returns:
         list[Any]: list of final results
     """
@@ -64,7 +66,9 @@ def run_batch_task_gen(
             task_i.agent.llm.set_stream(False)
         task_i.agent.config.show_stats = False
 
-        result = await task_i.run_async(input, turns=turns, max_cost=max_cost)
+        result = await task_i.run_async(
+            input, turns=turns, max_cost=max_cost, max_tokens=max_tokens
+        )
         return result
 
     async def _do_all(
@@ -123,6 +127,7 @@ def run_batch_tasks(
     batch_size: Optional[int] = None,
     turns: int = -1,
     max_cost: float = 0.0,
+    max_tokens: int = 0,
 ) -> List[U]:
     """
     Run copies of `task` async/concurrently one per item in `items` list.
@@ -141,6 +146,7 @@ def run_batch_tasks(
             if None, unbatched
         turns (int): number of turns to run, -1 for infinite
         max_cost: float: maximum cost to run the task (default 0.0 for unlimited)
+        max_tokens: int: maximum token usage (in and out) (default 0 for unlimited)
 
     Returns:
         list[Any]: list of final results
@@ -156,6 +162,7 @@ def run_batch_tasks(
         turns,
         message,
         max_cost=max_cost,
+        max_tokens=max_tokens,
     )
 
 

{langroid-0.1.231 → langroid-0.1.233}/langroid/agent/special/doc_chat_agent.py

@@ -117,6 +117,7 @@ class DocChatAgentConfig(ChatAgentConfig):
     )
     rerank_diversity: bool = True  # rerank to maximize diversity?
     rerank_periphery: bool = True  # rerank to avoid Lost In the Middle effect?
+    rerank_after_adding_context: bool = True  # rerank after adding context window?
     embed_batch_size: int = 500  # get embedding of at most this many at a time
     cache: bool = True  # cache results
     debug: bool = False
@@ -1110,9 +1111,10 @@ class DocChatAgent(ChatAgent):
         if len(passages) == 0:
             return []
 
-        passages_scores = [(p, 0.0) for p in passages]
-        passages_scores = self.add_context_window(passages_scores)
-        passages = [p for p, _ in passages_scores]
+        if self.config.rerank_after_adding_context:
+            passages_scores = [(p, 0.0) for p in passages]
+            passages_scores = self.add_context_window(passages_scores)
+            passages = [p for p, _ in passages_scores]
         # now passages can potentially have a lot of doc chunks,
         # so we re-rank them using a cross-encoder scoring model,
         # and pick top k where k = config.parsing.n_similar_docs
@@ -1129,6 +1131,11 @@ class DocChatAgent(ChatAgent):
             # (see Lost In the Middle issue).
             passages = self.rerank_to_periphery(passages)
 
+        if not self.config.rerank_after_adding_context:
+            passages_scores = [(p, 0.0) for p in passages]
+            passages_scores = self.add_context_window(passages_scores)
+            passages = [p for p, _ in passages_scores]
+
         return passages
 
     @no_type_check

{langroid-0.1.231 → langroid-0.1.233}/langroid/agent/task.py

@@ -171,6 +171,7 @@ class Task:
             if user_message:
                 agent.set_user_message(user_message)
         self.max_cost: float = 0
+        self.max_tokens: int = 0
         self.logger: None | RichFileLogger = None
         self.tsv_logger: None | logging.Logger = None
         self.color_log: bool = False if settings.notebook else True
@@ -376,12 +377,14 @@ class Task:
         turns: int = -1,
         caller: None | Task = None,
         max_cost: float = 0,
+        max_tokens: int = 0,
     ) -> Optional[ChatDocument]:
         """Synchronous version of `run_async()`.
         See `run_async()` for details."""
         self.task_progress = False
         self.n_stalled_steps = 0
         self.max_cost = max_cost
+        self.max_tokens = max_tokens
         assert (
             msg is None or isinstance(msg, str) or isinstance(msg, ChatDocument)
         ), f"msg arg in Task.run() must be None, str, or ChatDocument, not {type(msg)}"
@@ -421,6 +424,7 @@ class Task:
         turns: int = -1,
         caller: None | Task = None,
         max_cost: float = 0,
+        max_tokens: int = 0,
     ) -> Optional[ChatDocument]:
         """
         Loop over `step()` until task is considered done or `turns` is reached.
@@ -437,7 +441,8 @@ class Task:
             turns (int): number of turns to run the task for;
                 default is -1, which means run until task is done.
             caller (Task|None): the calling task, if any
-            max_cost (float): maximum cost allowed for the task (default 0 -> no limit)
+            max_cost (float): max cost allowed for the task (default 0 -> no limit)
+            max_tokens (int): max tokens allowed for the task (default 0 -> no limit)
 
         Returns:
             Optional[ChatDocument]: valid result of the task.
@@ -450,6 +455,7 @@ class Task:
         self.task_progress = False
         self.n_stalled_steps = 0
         self.max_cost = max_cost
+        self.max_tokens = max_tokens
         if (
             isinstance(msg, ChatDocument)
             and msg.metadata.recipient != ""
@@ -826,6 +832,7 @@ class Task:
                 turns=actual_turns,
                 caller=self,
                 max_cost=self.max_cost,
+                max_tokens=self.max_tokens,
             )
             result_str = str(ChatDocument.to_LLMMessage(result))
             maybe_tool = len(extract_top_level_json(result_str)) > 0
@@ -901,6 +908,8 @@ class Task:
                 self.pending_message,
                 turns=actual_turns,
                 caller=self,
+                max_cost=self.max_cost,
+                max_tokens=self.max_tokens,
             )
             result_str = str(ChatDocument.to_LLMMessage(result))
             maybe_tool = len(extract_top_level_json(result_str)) > 0
@@ -1062,12 +1071,21 @@ class Task:
             try:
                 if self.agent.llm.tot_tokens_cost()[1] > self.max_cost:
                     logger.warning(
-                        f"Task {self.name} exceeded max cost {self.max_cost}; exiting."
+                        f"Task {self.name} cost exceeded {self.max_cost}; exiting."
                     )
                     return True
             except Exception:
                 pass
 
+        if self.max_tokens > 0 and self.agent.llm is not None:
+            try:
+                if self.agent.llm.tot_tokens_cost()[0] > self.max_tokens:
+                    logger.warning(
+                        f"Task {self.name} uses > {self.max_tokens} tokens; exiting."
+                    )
+                    return True
+            except Exception:
+                pass
         return (
             # no valid response from any entity/agent in current turn
             result is None

{langroid-0.1.231 → langroid-0.1.233}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.1.231"
+version = "0.1.233"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"