langroid 0.33.8__tar.gz → 0.33.10__tar.gz

{langroid-0.33.8 → langroid-0.33.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.33.8
+Version: 0.33.10
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT

{langroid-0.33.8 → langroid-0.33.10}/langroid/agent/chat_agent.py

@@ -539,6 +539,20 @@ class ChatAgent(Agent):
                 self.message_history[i].content = message
                 break
 
+    def delete_last_message(self, role: str = Role.USER) -> None:
+        """
+        Delete the last message that has role `role` from the message history.
+        Args:
+            role (str): role of message to delete
+        """
+        if len(self.message_history) == 0:
+            return
+        # find last message in self.message_history with role `role`
+        for i in range(len(self.message_history) - 1, -1, -1):
+            if self.message_history[i].role == role:
+                self.message_history.pop(i)
+                break
+
     def _create_system_and_tools_message(self) -> LLMMessage:
         """
         (Re-)Create the system message for the LLM of the agent,
@@ -1219,15 +1233,25 @@ class ChatAgent(Agent):
                 instructions=True,
             )
             recovery_message = self._strict_recovery_instructions(AnyTool)
+            augmented_message = message
+            if augmented_message is None:
+                augmented_message = recovery_message
+            elif isinstance(augmented_message, str):
+                augmented_message = augmented_message + recovery_message
+            else:
+                augmented_message.content = augmented_message.content + recovery_message
 
+            # only use the augmented message for this one response...
+            result = self.llm_response(augmented_message)
+            # ... restore the original user message so that the AnyTool recover
+            # instructions don't persist in the message history
+            # (this can cause the LLM to use the AnyTool directly as a tool)
             if message is None:
-                message = recovery_message
-            elif isinstance(message, str):
-                message = message + recovery_message
+                self.delete_last_message(role=Role.USER)
             else:
-                message.content = message.content + recovery_message
-
-            return self.llm_response(message)
+                msg = message if isinstance(message, str) else message.content
+                self.update_last_message(msg, role=Role.USER)
+            return result
 
         hist, output_len = self._prep_llm_messages(message)
         if len(hist) == 0:
@@ -1294,15 +1318,25 @@ class ChatAgent(Agent):
                 instructions=True,
             )
             recovery_message = self._strict_recovery_instructions(AnyTool)
+            augmented_message = message
+            if augmented_message is None:
+                augmented_message = recovery_message
+            elif isinstance(augmented_message, str):
+                augmented_message = augmented_message + recovery_message
+            else:
+                augmented_message.content = augmented_message.content + recovery_message
 
+            # only use the augmented message for this one response...
+            result = self.llm_response(augmented_message)
+            # ... restore the original user message so that the AnyTool recover
+            # instructions don't persist in the message history
+            # (this can cause the LLM to use the AnyTool directly as a tool)
             if message is None:
-                message = recovery_message
-            elif isinstance(message, str):
-                message = message + recovery_message
+                self.delete_last_message(role=Role.USER)
             else:
-                message.content = message.content + recovery_message
-
-            return self.llm_response(message)
+                msg = message if isinstance(message, str) else message.content
+                self.update_last_message(msg, role=Role.USER)
+            return result
 
         hist, output_len = self._prep_llm_messages(message)
         if len(hist) == 0:

{langroid-0.33.8 → langroid-0.33.10}/langroid/agent/special/sql/sql_chat_agent.py

@@ -13,6 +13,7 @@ from typing import Any, Dict, List, Optional, Sequence, Union
 from rich.console import Console
 
 from langroid.exceptions import LangroidImportError
+from langroid.mytypes import Entity
 from langroid.utils.constants import SEND_TO
 
 try:
@@ -43,10 +44,12 @@ from langroid.agent.special.sql.utils.tools import (
     RunQueryTool,
 )
 from langroid.agent.tools.orchestration import (
+    DonePassTool,
     DoneTool,
     ForwardTool,
     PassTool,
 )
+from langroid.language_models.base import Role
 from langroid.vector_store.base import VectorStoreConfig
 
 logger = logging.getLogger(__name__)
@@ -72,7 +75,8 @@ Start by asking what I would like to know about the data.
 
 ADDRESSING_INSTRUCTION = """
 IMPORTANT - Whenever you are NOT writing a SQL query, make sure you address the user
-using {prefix}User. You MUST use the EXACT syntax {prefix} !!!
+using {prefix}User (NO SPACE between {prefix} and User). 
+You MUST use the EXACT syntax {prefix}User !!!
 
 In other words, you ALWAYS write EITHER:
  - a SQL query using the `run_query` tool, 
@@ -110,6 +114,8 @@ class SQLChatAgentConfig(ChatAgentConfig):
     # as opposed to returning a result from the task.run()
     chat_mode: bool = False
     addressing_prefix: str = ""
+    max_result_rows: int | None = None  # limit query results to this
+    max_retained_tokens: int | None = None  # limit history of query results to this
 
     """
     Optional, but strongly recommended, context descriptions for tables, columns, 
@@ -181,6 +187,7 @@ class SQLChatAgent(ChatAgent):
             self.helper_config = self.config.copy()
             self.helper_config.is_helper = True
             self.helper_config.use_helper = False
+            self.helper_config.chat_mode = False
             self.helper_agent = SQLHelperAgent(self.helper_config)
 
     def _validate_config(self, config: "SQLChatAgentConfig") -> None:
@@ -264,11 +271,13 @@ class SQLChatAgent(ChatAgent):
 
     def _init_tools(self) -> None:
         """Initialize sys msg and tools."""
+        RunQueryTool._max_retained_tokens = self.config.max_retained_tokens
         self.enable_message([RunQueryTool, ForwardTool])
         if self.config.use_schema_tools:
             self._enable_schema_tools()
         if not self.config.chat_mode:
             self.enable_message(DoneTool)
+            self.enable_message(DonePassTool)
 
     def _format_message(self) -> str:
         if self.engine is None:
@@ -311,14 +320,11 @@ class SQLChatAgent(ChatAgent):
         """
         if self.config.chat_mode:
             return f"""
-                you must use the `{ForwardTool.name()}` with the `agent` 
+                you must use the TOOL `{ForwardTool.name()}` with the `agent` 
                 parameter set to "User"
                 """
         else:
-            return f"""
-                you must use the `{DoneTool.name()}` with the `content` 
-                set to the answer or result
-                """
+            return f"you must use the TOOL `{DonePassTool.name()}`"
 
     def _clarifying_message(self) -> str:
         tools_instruction = f"""
@@ -343,23 +349,24 @@ class SQLChatAgent(ChatAgent):
         self, message: str | ChatDocument
     ) -> str | ForwardTool | ChatDocument | None:
         """
-        Handle the scenario where current msg is not a tool.
-        Special handling is only needed if the message was from the LLM
-        (as indicated by self.llm_responded).
+        We'd end up here if the current msg has no tool.
+        If this is from LLM, we may need to handle the scenario where
+        it may have "forgotten" to generate a tool.
         """
-        if not self.llm_responded:
+        if (
+            not isinstance(message, ChatDocument)
+            or message.metadata.sender != Entity.LLM
+        ):
             return None
-        if self.interactive:
-            # self.interactive will be set to True by the Task,
-            # when chat_mode=True, so in this case
-            # we send any Non-tool msg to the user
+        if self.config.chat_mode:
+            # send any Non-tool msg to the user
             return ForwardTool(agent="User")
         # Agent intent not clear => use the helper agent to
         # do what this agent should have done, e.g. generate tool, etc.
         # This is likelier to succeed since this agent has no "baggage" of
         # prior conversation, other than the system msg, and special
         # "Intent-interpretation" instructions.
-        if self._json_schema_available():
+        if self._json_schema_available() and self.config.strict_recovery:
             AnyTool = self._get_any_tool_message(optional=False)
             self.set_output_format(
                 AnyTool,
@@ -371,15 +378,18 @@ class SQLChatAgent(ChatAgent):
             recovery_message = self._strict_recovery_instructions(
                 AnyTool, optional=False
             )
-            return self.llm_response(recovery_message)
-        else:
+            result = self.llm_response(recovery_message)
+            # remove the recovery_message (it has User role) from the chat history,
+            # else it may cause the LLM to directly use the AnyTool.
+            self.delete_last_message(role=Role.USER)  # delete last User-role msg
+            return result
+        elif self.config.use_helper:
             response = self.helper_agent.llm_response(message)
             tools = self.try_get_tool_messages(response)
             if tools:
                 return response
-            else:
-                # fall back on the clarification message
-                return self._clarifying_message()
+        # fall back on the clarification message
+        return self._clarifying_message()
 
     def retry_query(self, e: Exception, query: str) -> str:
         """
@@ -466,6 +476,14 @@ class SQLChatAgent(ChatAgent):
             try:
                 # attempt to fetch results: should work for normal SELECT queries
                 rows = query_result.fetchall()
+                n_rows = len(rows)
+                if self.config.max_result_rows and n_rows > self.config.max_result_rows:
+                    rows = rows[: self.config.max_result_rows]
+                    logger.warning(
+                        f"SQL query produced {n_rows} rows, "
+                        f"limiting to {self.config.max_result_rows}"
+                    )
+
                 response_message = self._format_rows(rows)
             except ResourceClosedError:
                 # If we get here, it's a non-SELECT query (UPDATE, INSERT, DELETE)

{langroid-0.33.8 → langroid-0.33.10}/langroid/agent/tool_message.py

@@ -101,7 +101,7 @@ class ToolMessage(ABC, BaseModel):
     # Some tools can have large results that we may not want to fully retain,
     # e.g. result of a db query, which the LLM later reduces to a summary, so
     # in subsequent dialog we may only want to retain the summary,
-    # and replace this raw result truncated to _max_result_tokens.
+    # and replace this raw result truncated to _max_retained_tokens.
     # Important to note: unlike _max_result_tokens, this param is used
     # NOT used to immediately truncate the result;
     # it is only used to truncate what is retained in msg history AFTER the

{langroid-0.33.8 → langroid-0.33.10}/langroid/agent/tools/orchestration.py

@@ -156,7 +156,7 @@ class PassTool(ToolMessage):
     def response(self, agent: ChatAgent, chat_doc: ChatDocument) -> ChatDocument:
         """When this tool is enabled for an Agent, this will result in a method
         added to the Agent with signature:
-        `forward_tool(self, tool: PassTool, chat_doc: ChatDocument) -> ChatDocument:`
+        `pass_tool(self, tool: PassTool, chat_doc: ChatDocument) -> ChatDocument:`
         """
         # if PassTool is in chat_doc, pass its parent, else pass chat_doc itself
         doc = chat_doc

{langroid-0.33.8 → langroid-0.33.10}/langroid/vector_store/qdrantdb.py

@@ -2,6 +2,7 @@ import hashlib
 import json
 import logging
 import os
+import time
 import uuid
 from typing import Dict, List, Optional, Sequence, Tuple, TypeVar
 
@@ -323,6 +324,26 @@ class QdrantDB(VectorStore):
             }
             if self.config.use_sparse_embeddings:
                 vectors["text-sparse"] = sparse_embedding_vecs[i : i + b]
+            coll_found: bool = False
+            for _ in range(3):
+                # poll until collection is ready
+                if (
+                    self.client.collection_exists(self.config.collection_name)
+                    and self.client.get_collection(self.config.collection_name).status
+                    == CollectionStatus.GREEN
+                ):
+                    coll_found = True
+                    break
+                time.sleep(1)
+
+            if not coll_found:
+                raise ValueError(
+                    f"""
+                    QdrantDB Collection {self.config.collection_name} 
+                    not found or not ready
+                    """
+                )
+
             self.client.upsert(
                 collection_name=self.config.collection_name,
                 points=Batch(

{langroid-0.33.8 → langroid-0.33.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "langroid"
-version = "0.33.8"
+version = "0.33.10"
 authors = [
     {name = "Prasad Chalasani", email = "pchalasani@gmail.com"},
 ]