langroid 0.2.2__tar.gz → 0.2.4__tar.gz

{langroid-0.2.2 → langroid-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.2.2
+Version: 0.2.4
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -149,6 +149,12 @@ This Multi-Agent paradigm is inspired by the
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
 into simplifying the developer experience; it does not use `Langchain`.
 
+Companies are using/adapting Langroid in production. Here is a quote from one of them:
+
+>[Nullify](https://www.nullify.ai) uses AI Agents for secure software development. 
+> It finds, prioritizes and fixes vulnerabilities. We have internally adapted Langroid's multi-agent orchestration framework in production, after evaluating CrewAI, Autogen, LangChain, Langflow, etc. We found Langroid to be far superior to those frameworks in terms of ease of setup and flexibility. Langroid's Agent and Task abstractions are intuitive, well thought out, and provide a great developer  experience. We wanted the quickest way to get something in production. With other frameworks it would have taken us weeks, but with Langroid we got to good results in minutes. Highly recommended! <br> -- Jacky Wong, Head of AI at Nullify.
+
+
 :fire: See this [Intro to Langroid](https://lancedb.substack.com/p/langoid-multi-agent-programming-framework)
 blog post from the LanceDB team
 

{langroid-0.2.2 → langroid-0.2.4}/README.md

@@ -46,6 +46,12 @@ This Multi-Agent paradigm is inspired by the
 `Langroid` is a fresh take on LLM app-development, where considerable thought has gone 
 into simplifying the developer experience; it does not use `Langchain`.
 
+Companies are using/adapting Langroid in production. Here is a quote from one of them:
+
+>[Nullify](https://www.nullify.ai) uses AI Agents for secure software development. 
+> It finds, prioritizes and fixes vulnerabilities. We have internally adapted Langroid's multi-agent orchestration framework in production, after evaluating CrewAI, Autogen, LangChain, Langflow, etc. We found Langroid to be far superior to those frameworks in terms of ease of setup and flexibility. Langroid's Agent and Task abstractions are intuitive, well thought out, and provide a great developer  experience. We wanted the quickest way to get something in production. With other frameworks it would have taken us weeks, but with Langroid we got to good results in minutes. Highly recommended! <br> -- Jacky Wong, Head of AI at Nullify.
+
+
 :fire: See this [Intro to Langroid](https://lancedb.substack.com/p/langoid-multi-agent-programming-framework)
 blog post from the LanceDB team
 

{langroid-0.2.2 → langroid-0.2.4}/langroid/agent/task.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import asyncio
 import copy
 import logging
+import re
 import threading
 from collections import Counter, deque
 from pathlib import Path
@@ -184,8 +185,8 @@ class Task:
                 Note: erasing can reduce prompt sizes, but results in repetitive
                 sub-task delegation.
             allow_null_result (bool):
-                If true, allow null (empty or NO_ANSWER) as the result of a step or
-                overall task result.
+                If true, create dummy NO_ANSWER response when no valid response is found
+                in a step.
                 Optional, default is False.
                 *Note:* In non-interactive mode, when this is set to True,
                 you can have a situation where an LLM generates (non-tool) text,
@@ -193,7 +194,9 @@ class Task:
                 is inserted as a dummy response from the User entity, so the LLM
                 will now respond to this Null result, and this will continue
                 until the LLM emits a DONE signal (if instructed to do so),
-                otherwise it can result in an infinite loop.
+                otherwise langroid detects a potential infinite loop after
+                a certain number of such steps (= `TaskConfig.inf_loop_wait_factor`)
+                and will raise an InfiniteLoopException.
             max_stalled_steps (int): task considered done after this many consecutive
                 steps with no progress. Default is 3.
             done_if_no_response (List[Responder]): consider task done if NULL
@@ -254,7 +257,7 @@ class Task:
         # how many 2-step-apart alternations of no_answer step-result have we had,
         # i.e. x1, N/A, x2, N/A, x3, N/A ...
         self.n_no_answer_alternations = 0
-        self._no_answer_step: int = -1
+        self._no_answer_step: int = -5
         self._step_idx = -1  # current step index
         self.max_stalled_steps = max_stalled_steps
         self.done_if_response = [r.value for r in done_if_response]
@@ -577,7 +580,7 @@ class Task:
             self.reset_all_sub_tasks()
 
         self.n_stalled_steps = 0
-        self._no_answer_step = -1  # last step where the best explicit response was N/A
+        self._no_answer_step = -5  # last step where the best explicit response was N/A
         # how many N/A alternations have we had so far? (for Inf loop detection)
         self.n_no_answer_alternations = 0
         self.max_cost = max_cost
@@ -637,6 +640,7 @@ class Task:
                 self.config.inf_loop_cycle_len > 0
                 and i % self.config.inf_loop_cycle_len == 0
                 and self._maybe_infinite_loop()
+                or self.n_no_answer_alternations > self.config.inf_loop_wait_factor
             ):
                 raise InfiniteLoopException(
                     """Possible infinite loop detected!
@@ -702,7 +706,7 @@ class Task:
             self.reset_all_sub_tasks()
 
         self.n_stalled_steps = 0
-        self._no_answer_step = -1  # last step where the best explicit response was N/A
+        self._no_answer_step = -5  # last step where the best explicit response was N/A
         # how many N/A alternations have we had so far? (for Inf loop detection)
         self.n_no_answer_alternations = 0
         self.max_cost = max_cost
@@ -759,6 +763,7 @@ class Task:
                 self.config.inf_loop_cycle_len > 0
                 and i % self.config.inf_loop_cycle_len == 0
                 and self._maybe_infinite_loop()
+                or self.n_no_answer_alternations > self.config.inf_loop_wait_factor
             ):
                 raise InfiniteLoopException(
                     """Possible infinite loop detected!
@@ -878,7 +883,6 @@ class Task:
 
         if (
             Entity.USER in self.responders
-            and self.interactive
             and not self.human_tried
             and not self.agent.has_tool_message_attempt(self.pending_message)
         ):
@@ -930,7 +934,7 @@ class Task:
             if self.is_done:
                 # skip trying other responders in this step
                 break
-        if not found_response:  # did not find a Non-NO_ANSWER response
+        if not found_response:  # did not find a valid response
             if no_answer_response:
                 # even though there was no valid response from anyone in this step,
                 # if there was at least one who EXPLICITLY said NO_ANSWER, then
@@ -986,7 +990,6 @@ class Task:
 
         if (
             Entity.USER in self.responders
-            and self.interactive
             and not self.human_tried
             and not self.agent.has_tool_message_attempt(self.pending_message)
         ):
@@ -1047,15 +1050,10 @@ class Task:
         self._show_pending_message_if_debug()
         return self.pending_message
 
-    def _process_valid_responder_result(
-        self,
-        r: Responder,
-        parent: ChatDocument | None,
-        result: ChatDocument,
-    ) -> None:
-        """Processes valid result from a responder, during a step"""
+    def _update_no_answer_vars(self, result: ChatDocument) -> None:
+        """Update variables related to NO_ANSWER responses, to aid
+        in alternating NO_ANSWER infinite-loop detection."""
 
-        # in case the valid response was a NO_ANSWER,
         if NO_ANSWER in result.content:
             if self._no_answer_step == self._step_idx - 2:
                 # N/A two steps ago
@@ -1067,6 +1065,16 @@ class Task:
             # record the last step where the best explicit response was N/A
             self._no_answer_step = self._step_idx
 
+    def _process_valid_responder_result(
+        self,
+        r: Responder,
+        parent: ChatDocument | None,
+        result: ChatDocument,
+    ) -> None:
+        """Processes valid result from a responder, during a step"""
+
+        self._update_no_answer_vars(result)
+
         # pending_sender is of type Responder,
         # i.e. it is either one of the agent's entities
         # OR a sub-task, that has produced a valid response.
@@ -1131,6 +1139,7 @@ class Task:
                 metadata=ChatDocMetaData(sender=responder, parent_id=parent_id),
             )
             self.pending_sender = responder
+            self._update_no_answer_vars(self.pending_message)
         self.log_message(self.pending_sender, self.pending_message, mark=True)
 
     def _show_pending_message_if_debug(self) -> None:
@@ -1346,13 +1355,20 @@ class Task:
     def _maybe_infinite_loop(self) -> bool:
         """
         Detect possible infinite loop based on message frequencies.
-        NOTE: This only (attempts to) detect "exact" loops, i.e. a cycle
-        of messages that repeats exactly, e.g.
+        NOTE: This detects two types of loops:
+        - Alternating NO_ANSWER loops, specifically of the form
+        x1 NO_ANSWER x2 NO_ANSWER x3 NO_ANSWER...
+        (e.g. an LLM repeatedly saying something different, and another responder
+        or sub-task saying NO_ANSWER -- i.e. "DO-NOT-KNOW")
+
+        - "exact" loops, i.e. a cycle of messages that repeats exactly, e.g.
         a r b i t r a t e r a t e r a t e r a t e ...
 
-        [It does not detect "approximate" loops, where the LLM is generating a
-        sequence of messages that are similar, but not exactly the same.]
+        [It does not detect more general "approximate" loops, where two entities are
+        responding to each other potentially forever, with (slightly) different
+        messages each time]
 
+        Here is the logic for the exact-loop detection:
         Intuition: when you look at a sufficiently long sequence with an m-message
         loop, then the frequencies of these m messages will "dominate" those
         of all other messages.
@@ -1370,8 +1386,6 @@ class Task:
            If the set of last (W * m) messages are the same as the
            set of m dominant messages,  then we are likely in a loop.
         """
-        if self.n_no_answer_alternations > self.config.inf_loop_wait_factor:
-            return True
 
         max_cycle_len = self.config.inf_loop_cycle_len
         if max_cycle_len <= 0:
@@ -1438,7 +1452,7 @@ class Task:
         result = result or self.pending_message
         user_quit = (
             result is not None
-            and result.content in USER_QUIT_STRINGS
+            and (result.content in USER_QUIT_STRINGS or DONE in result.content)
             and result.metadata.sender == Entity.USER
         )
         if self._level == 0 and self.interactive and self.only_user_quits_root:
@@ -1509,7 +1523,9 @@ class Task:
         return (
             result is not None
             and not self._is_empty_message(result)
-            and result.content.strip() != NO_ANSWER
+            # some weaker LLMs, including even GPT-4o, may say "DO-NOT-KNOW."
+            # (with a punctuation at the end), so need to strip out punctuation
+            and re.sub(r"[,.!?:]", "", result.content.strip()) != NO_ANSWER
         )
 
     def log_message(
@@ -1590,7 +1606,7 @@ class Task:
         return (
             self.pending_message is not None
             and (recipient := self.pending_message.metadata.recipient) != ""
-            and recipient != e  # case insensitive
+            and not (recipient == e)  # case insensitive for entities
             and recipient != e.name
             and recipient != self.name  # case sensitive
         )

{langroid-0.2.2 → langroid-0.2.4}/langroid/cachedb/redis_cachedb.py

@@ -54,7 +54,7 @@ class RedisCache(CacheDB):
                     host=redis_host,
                     port=redis_port,
                     password=redis_password,
-                    max_connections=50,
+                    max_connections=500,
                     socket_timeout=5,
                     socket_keepalive=True,
                     retry_on_timeout=True,

langroid-0.2.4/langroid/parsing/routing.py

@@ -0,0 +1,36 @@
+import re
+from typing import Optional, Tuple
+
+
+def parse_addressed_message(
+    content: str, addressing: str = "@"
+) -> Tuple[Optional[str], str]:
+    """In a message-string containing possibly multiple @<recipient> occurrences,
+    find the last addressee and extract their name,
+    and the message content following it.
+
+    E.g. "thank you @bob, now I will ask @alice again. @alice, where is the mirror?" =>
+    ("alice", "where is the mirror?")
+
+    Args:
+        content (str): The message content.
+        addressing (str, optional): The addressing character. Defaults to "@".
+
+    Returns:
+        Tuple[Optional[str], str]:
+        A tuple containing the last addressee and the subsequent message content.
+    """
+    # Regex to find all occurrences of the pattern
+    pattern = re.compile(rf"{re.escape(addressing)}(\w+)[^\w]")
+    matches = list(pattern.finditer(content))
+
+    if not matches:
+        return None, content  # No addressee found, return None and original content
+
+    # Get the last match
+    last_match = matches[-1]
+    last_addressee = last_match.group(1)
+    # Extract content after the last addressee
+    content_after = content[last_match.end() :].strip()
+
+    return last_addressee, content_after

{langroid-0.2.2 → langroid-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.2.2"
+version = "0.2.4"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -231,3 +231,4 @@ lint.extend-ignore = ["F821"]
 
 [tool.pytest.ini_options]
 filterwarnings = ["ignore::DeprecationWarning"]
+

langroid-0.2.2/langroid/parsing/routing.py

@@ -1,27 +0,0 @@
-import re
-from typing import Optional, Tuple
-
-
-def parse_addressed_message(
-    content: str, addressing: str = "@"
-) -> Tuple[Optional[str], str]:
-    # escape special characters in addressing prefix for regex use
-    addressing_escaped = re.escape(addressing)
-    pattern = rf"{addressing_escaped}(\w+)[,:\s]?"
-    # Regular expression to find a username prefixed by addressing character or string
-    match = re.findall(pattern, content)
-
-    addressee = None
-    if match:
-        # select the last match as the addressee
-        addressee = match[-1]
-
-        # Remove the last occurrence of the addressing prefix followed by the
-        # username and optional punctuation or whitespace
-        # To remove only the last occurrence, we'll construct a new pattern that
-        # specifically matches the last addressee
-        last_occurrence_pattern = rf"{addressing_escaped}{addressee}[,:\\s]?"
-        # Replace the last occurrence found in the content
-        content = re.sub(last_occurrence_pattern, "", content, count=1).strip()
-
-    return addressee, content