langroid 0.1.231__tar.gz → 0.1.234__tar.gz

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

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

{langroid-0.1.231 → langroid-0.1.234}/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.234}/langroid/agent/special/__init__.py

@@ -14,7 +14,7 @@ from .table_chat_agent import (
     dataframe_summary,
     TableChatAgent,
     TableChatAgentConfig,
-    RunCodeTool,
+    PandasEvalTool,
 )
 from . import sql
 from . import relevance_extractor_agent
@@ -38,7 +38,7 @@ __all__ = [
     "dataframe_summary",
     "TableChatAgent",
     "TableChatAgentConfig",
-    "RunCodeTool",
+    "PandasEvalTool",
     "sql",
     "relevance_extractor_agent",
     "doc_chat_agent",

{langroid-0.1.231 → langroid-0.1.234}/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.234}/langroid/agent/special/table_chat_agent.py

@@ -2,10 +2,11 @@
 Agent that supports asking queries about a tabular dataset, internally
 represented as a Pandas dataframe. The `TableChatAgent` is configured with a
 dataset, which can be a Pandas df, file or URL. The delimiter/separator
-is auto-detected. In response to a user query, the Agent's LLM generates Pandas
-code to answer the query. The code is passed via the `run_code` tool/function-call,
-which is handled by the Agent's `run_code` method. This method executes/evaluates
-the code and returns the result as a string.
+is auto-detected. In response to a user query, the Agent's LLM generates a Pandas
+expression (involving a dataframe `df`) to answer the query.
+The expression is passed via the `pandas_eval` tool/function-call,
+which is handled by the Agent's `pandas_eval` method. This method evaluates
+the expression and returns the result as a string.
 """
 
 import io
@@ -35,25 +36,26 @@ DEFAULT_TABLE_CHAT_SYSTEM_MESSAGE = f"""
 You are a savvy data scientist, with expertise in analyzing tabular datasets,
 using Python and the Pandas library for dataframe manipulation.
 Since you do not have access to the dataframe 'df', you
-will need to use the `run_code` tool/function-call to answer my questions.
+will need to use the `pandas_eval` tool/function-call to answer my questions.
 Here is a summary of the dataframe:
 {{summary}}
 Do not assume any columns other than those shown.
-In the code you submit to the `run_code` tool/function, 
-do not forget to include any necessary imports, such as `import pandas as pd`.
-Sometimes you may not be able to answer the question in a single call to `run_code`,
-so you can use a series of calls to `run_code` to build up the answer. 
+In the expression you submit to the `pandas_eval` tool/function, 
+you are allowed to use the variable 'df' to refer to the dataframe.
+
+Sometimes you may not be able to answer the question in a single call to `pandas_eval`,
+so you can use a series of calls to `pandas_eval` to build up the answer. 
 For example you may first want to know something about the possible values in a column.
 
 If you receive a null or other unexpected result, see if you have made an assumption
-in your code, and try another way, or use `run_code` to explore the dataframe 
+in your code, and try another way, or use `pandas_eval` to explore the dataframe 
 before submitting your final code. 
 
 Once you have the answer to the question, possibly after a few steps,
 say {DONE} and show me the answer. If you receive an error message, 
-try using the `run_code` tool/function again with the corrected code. 
+try using the `pandas_eval` tool/function again with the corrected code. 
 
-VERY IMPORTANT: When using the `run_code` tool/function, DO NOT EXPLAIN ANYTHING,
+VERY IMPORTANT: When using the `pandas_eval` tool/function, DO NOT EXPLAIN ANYTHING,
    SIMPLY USE THE TOOL, with the CODE.
 Start by asking me what I want to know about the data.
 """
@@ -123,22 +125,22 @@ class TableChatAgentConfig(ChatAgentConfig):
     )
 
 
-class RunCodeTool(ToolMessage):
-    """Tool/function to run code on a dataframe named `df`"""
+class PandasEvalTool(ToolMessage):
+    """Tool/function to evaluate a pandas expression involving a dataframe `df`"""
 
-    request: str = "run_code"
+    request: str = "pandas_eval"
     purpose: str = """
-            To run <code> on the dataframe 'df' and 
+            To eval a pandas <expression> on the dataframe 'df' and 
             return the results to answer a question.
-            IMPORTANT: ALL the code should be in the <code> field.
+            IMPORTANT: the <expression> field should be a valid pandas expression.
             """
-    code: str
+    expression: str
 
     @classmethod
     def examples(cls) -> List["ToolMessage"]:
         return [
-            cls(code="df.head()"),
-            cls(code="df[(df['gender'] == 'Male')]['income'].mean()"),
+            cls(expression="df.head()"),
+            cls(expression="df[(df['gender'] == 'Male')]['income'].mean()"),
         ]
 
 
@@ -147,7 +149,7 @@ class TableChatAgent(ChatAgent):
     Agent for chatting with a collection of documents.
     """
 
-    sent_code: bool = False
+    sent_expression: bool = False
 
     def __init__(self, config: TableChatAgentConfig):
         if isinstance(config.data, pd.DataFrame):
@@ -170,8 +172,8 @@ class TableChatAgent(ChatAgent):
             {self.df.columns}
             """
         )
-        # enable the agent to use and handle the RunCodeTool
-        self.enable_message(RunCodeTool)
+        # enable the agent to use and handle the PandasEvalTool
+        self.enable_message(PandasEvalTool)
 
     def user_response(
         self,
@@ -179,44 +181,32 @@ class TableChatAgent(ChatAgent):
     ) -> Optional[ChatDocument]:
         response = super().user_response(msg)
         if response is not None and response.content != "":
-            self.sent_code = False
+            self.sent_expression = False
         return response
 
-    def run_code(self, msg: RunCodeTool) -> str:
+    def pandas_eval(self, msg: PandasEvalTool) -> str:
         """
-        Handle a RunCodeTool message by running the code and returning the result.
+        Handle a PandasEvalTool message by evaluating the `expression` field
+            and returning the result.
         Args:
-            msg (RunCodeTool): The tool-message to handle.
+            msg (PandasEvalTool): The tool-message to handle.
 
         Returns:
             str: The result of running the code along with any print output.
         """
-        self.sent_code = True
-        code = msg.code
-        # Create a dictionary that maps 'df' to the actual DataFrame
+        self.sent_expression = True
+        exprn = msg.expression
         local_vars = {"df": self.df}
-
         # Create a string-based I/O stream
         code_out = io.StringIO()
 
         # Temporarily redirect standard output to our string-based I/O stream
         sys.stdout = code_out
 
-        # Split the code into lines
-        lines = code.strip().split("\n")
-
-        lines = [
-            "import pandas as pd",
-            "import numpy as np",
-        ] + lines
-
-        # Run all lines as statements except for the last one
-        for line in lines[:-1]:
-            exec(line, {}, local_vars)
 
         # Evaluate the last line and get the result
         try:
-            eval_result = pd.eval(lines[-1], local_dict=local_vars)
+            eval_result = pd.eval(exprn, local_dict=local_vars)
         except Exception as e:
             eval_result = f"ERROR: {type(e)}: {e}"
 
@@ -242,15 +232,15 @@ class TableChatAgent(ChatAgent):
     def handle_message_fallback(
         self, msg: str | ChatDocument
     ) -> str | ChatDocument | None:
-        """Handle scenario where LLM forgets to say DONE or forgets to use run_code"""
+        """Handle scenario where LLM forgets to say DONE or
+        forgets to use pandas_eval"""
         if isinstance(msg, ChatDocument) and msg.metadata.sender == lr.Entity.LLM:
-            if self.sent_code:
+            if self.sent_expression:
                 return DONE
             else:
                 return """
-                    You forgot to use the `run_code` tool/function to find the answer.
-                    Try again using the `run_code` tool/function.
-                    Remember that ALL your code, including imports, 
-                    should be in the `code` field.
+                    You forgot to use the `pandas_eval` tool/function 
+                    to find the answer.
+                    Try again using the `pandas_eval` tool/function.
                     """
         return None

{langroid-0.1.231 → langroid-0.1.234}/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.234}/pyproject.toml

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