langroid 0.1.258__tar.gz → 0.1.261__tar.gz

{langroid-0.1.258 → langroid-0.1.261}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.258
+Version: 0.1.261
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -110,6 +110,7 @@ Description-Content-Type: text/markdown
 <div align="center">
 
 [![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
+[![Downloads](https://img.shields.io/pypi/dm/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
 [![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
 [![Multi-Architecture DockerHub](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml)
@@ -436,7 +437,7 @@ section above)
   a task of an agent can delegate to other sub-tasks: from the point of view of a Task,
   sub-tasks are simply additional responders, to be used in a round-robin fashion 
   after the agent's own responders.
-- **Modularity, Reusabilily, Loose coupling:** The `Agent` and `Task` abstractions allow users to design
+- **Modularity, Reusability, Loose coupling:** The `Agent` and `Task` abstractions allow users to design
   Agents with specific skills, wrap them in Tasks, and combine tasks in a flexible way.
 - **LLM Support**: Langroid supports OpenAI LLMs as well as LLMs from hundreds of 
 providers (local/open or remote/commercial) via proxy libraries and local model servers

{langroid-0.1.258 → langroid-0.1.261}/README.md

@@ -6,6 +6,7 @@
 <div align="center">
 
 [![PyPI - Version](https://img.shields.io/pypi/v/langroid)](https://pypi.org/project/langroid/)
+[![Downloads](https://img.shields.io/pypi/dm/langroid)](https://pypi.org/project/langroid/)
 [![Pytest](https://github.com/langroid/langroid/actions/workflows/pytest.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/pytest.yml)
 [![codecov](https://codecov.io/gh/langroid/langroid/branch/main/graph/badge.svg?token=H94BX5F0TE)](https://codecov.io/gh/langroid/langroid)
 [![Multi-Architecture DockerHub](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml/badge.svg)](https://github.com/langroid/langroid/actions/workflows/docker-publish.yml)
@@ -332,7 +333,7 @@ section above)
   a task of an agent can delegate to other sub-tasks: from the point of view of a Task,
   sub-tasks are simply additional responders, to be used in a round-robin fashion 
   after the agent's own responders.
-- **Modularity, Reusabilily, Loose coupling:** The `Agent` and `Task` abstractions allow users to design
+- **Modularity, Reusability, Loose coupling:** The `Agent` and `Task` abstractions allow users to design
   Agents with specific skills, wrap them in Tasks, and combine tasks in a flexible way.
 - **LLM Support**: Langroid supports OpenAI LLMs as well as LLMs from hundreds of 
 providers (local/open or remote/commercial) via proxy libraries and local model servers

{langroid-0.1.258 → langroid-0.1.261}/langroid/agent/callbacks/chainlit.py

@@ -214,6 +214,7 @@ def wrap_text_preserving_structure(text: str, width: int = 90) -> str:
 
 class ChainlitCallbackConfig(BaseSettings):
     user_has_agent_name: bool = True  # show agent name in front of "YOU" ?
+    show_subtask_response: bool = True  # show sub-task response as a step?
 
 
 class ChainlitAgentCallbacks:
@@ -277,12 +278,6 @@ class ChainlitAgentCallbacks:
 
     def start_llm_stream(self) -> Callable[[str], None]:
         """Returns a streaming fn that can be passed to the LLM class"""
-        logger.info(
-            f"""
-            Starting LLM stream for {self.agent.config.name} 
-            under parent {self._get_parent_id()}
-        """
-        )
         self.stream = cl.Step(
             id=self.curr_step.id if self.curr_step is not None else None,
             name=self._entity_name("llm"),
@@ -291,6 +286,13 @@ class ChainlitAgentCallbacks:
         )
         self.last_step = self.stream
         self.curr_step = None
+        logger.info(
+            f"""
+            Starting LLM stream for {self.agent.config.name}
+            id = {self.stream.id} 
+            under parent {self._get_parent_id()}
+        """
+        )
         run_sync(self.stream.send())  # type: ignore
 
         def stream_token(t: str) -> None:
@@ -323,6 +325,13 @@ class ChainlitAgentCallbacks:
             language="json" if is_tool else None,
         )
         step.output = textwrap.dedent(content) or NO_ANSWER
+        logger.info(
+            f"""
+            Finish STREAM LLM response for {self.agent.config.name}
+            id = {step.id} 
+            under parent {self._get_parent_id()}
+            """
+        )
         run_sync(step.update())  # type: ignore
 
     def show_llm_response(
@@ -343,6 +352,13 @@ class ChainlitAgentCallbacks:
         self.last_step = step
         self.curr_step = None
         step.output = textwrap.dedent(content) or NO_ANSWER
+        logger.info(
+            f"""
+            Showing NON-STREAM LLM response for {self.agent.config.name}
+            id = {step.id} 
+            under parent {self._get_parent_id()}
+            """
+        )
         run_sync(step.send())  # type: ignore
 
     def show_error_message(self, error: str) -> None:
@@ -374,6 +390,13 @@ class ChainlitAgentCallbacks:
         self.last_step = step
         self.curr_step = None
         step.output = content
+        logger.info(
+            f"""
+            Showing AGENT response for {self.agent.config.name}
+            id = {step.id} 
+            under parent {self._get_parent_id()}
+            """
+        )
         run_sync(step.send())  # type: ignore
 
     def show_start_response(self, entity: str) -> None:
@@ -390,6 +413,13 @@ class ChainlitAgentCallbacks:
         step.output = ""
         self.last_step = step
         self.curr_step = step
+        logger.info(
+            f"""
+            Showing START response for {self.agent.config.name} ({entity})
+            id = {step.id} 
+            under parent {self._get_parent_id()}
+            """
+        )
         run_sync(step.send())  # type: ignore
 
     def _entity_name(
@@ -459,6 +489,13 @@ class ChainlitAgentCallbacks:
             parent_id=self._get_parent_id(),
         )
         step.output = message
+        logger.info(
+            f"""
+            Showing USER response for {self.agent.config.name}
+            id = {step.id} 
+            under parent {self._get_parent_id()}
+            """
+        )
         run_sync(step.send())
 
     def show_first_user_message(self, msg: cl.Message):
@@ -575,7 +612,8 @@ class ChainlitTaskCallbacks(ChainlitAgentCallbacks):
         super().__init__(task.agent, msg, config)
         self._inject_callbacks(task)
         self.task = task
-        self.task.callbacks.show_subtask_response = self.show_subtask_response
+        if config.show_subtask_response:
+            self.task.callbacks.show_subtask_response = self.show_subtask_response
 
     @classmethod
     def _inject_callbacks(

{langroid-0.1.258 → langroid-0.1.261}/langroid/agent/chat_document.py

@@ -45,8 +45,6 @@ class ChatDocMetaData(DocMetaData):
     parent: Optional["ChatDocument"] = None
     sender: Entity
     tool_ids: List[str] = []  # stack of tool_ids; used by OpenAIAssistant
-    # when result returns to parent, pretend message is from this entity
-    parent_responder: None | Entity = None
     block: None | Entity = None
     sender_name: str = ""
     recipient: str = ""

{langroid-0.1.258 → langroid-0.1.261}/langroid/agent/task.py

@@ -72,7 +72,7 @@ class TaskConfig(BaseModel):
 
     inf_loop_cycle_len: int = 10
     inf_loop_dominance_factor: float = 1.5
-    inf_loop_wait_factor: float = 5.0
+    inf_loop_wait_factor: int = 5
 
 
 class Task:
@@ -156,6 +156,11 @@ class Task:
             interactive (bool): if true, wait for human input after each non-human
                 response (prevents infinite loop of non-human responses).
                 Default is true. If false, then `default_human_response` is set to ""
+                Note: When interactive = False, the one exception is when the user
+                is explicitly addressed, via "@user" or using RecipientTool, in which
+                case the system will wait for a user response. In other words, use
+                `interactive=False` when you want a "largely non-interactive"
+                run, with the exception of explicit user addressing.
             only_user_quits_root (bool): if true, only user can quit the root task.
                 [This param is ignored & deprecated; Keeping for backward compatibility.
                 Instead of this, setting `interactive` suffices]
@@ -185,7 +190,11 @@ class Task:
         # counts of distinct pending messages in history,
         # to help detect (exact) infinite loops
         self.message_counter: Counter[str] = Counter()
-        self.history_count: Deque[int] = deque(maxlen=self.config.inf_loop_cycle_len)
+        self._init_message_counter()
+
+        self.history: Deque[str] = deque(
+            maxlen=self.config.inf_loop_cycle_len * self.config.inf_loop_wait_factor
+        )
         # copy the agent's config, so that we don't modify the original agent's config,
         # which may be shared by other agents.
         try:
@@ -329,6 +338,12 @@ class Task:
     def __str__(self) -> str:
         return f"{self.name}"
 
+    def _init_message_counter(self) -> None:
+        self.message_counter.clear()
+        # create a unique string that will not likely be in any message,
+        # so we always have a message with count=1
+        self.message_counter.update([hash("___NO_MESSAGE___")])
+
     def _cache_session_store(self, key: str, value: str) -> None:
         """
         Cache a key-value pair for the current session.
@@ -440,7 +455,7 @@ class Task:
                 ),
             )
         else:
-            self.pending_message = msg
+            self.pending_message = copy.deepcopy(msg)
             if self.pending_message is not None and self.caller is not None:
                 # msg may have come from `caller`, so we pretend this is from
                 # the CURRENT task's USER entity
@@ -480,8 +495,8 @@ class Task:
         self.max_tokens = max_tokens
         self.session_id = session_id
         self._set_alive()
-        self.message_counter.clear()
-        self.history_count.clear()
+        self._init_message_counter()
+        self.history.clear()
 
         assert (
             msg is None or isinstance(msg, str) or isinstance(msg, ChatDocument)
@@ -580,8 +595,8 @@ class Task:
         self.max_tokens = max_tokens
         self.session_id = session_id
         self._set_alive()
-        self.message_counter.clear()
-        self.history_count.clear()
+        self._init_message_counter()
+        self.history.clear()
 
         if (
             isinstance(msg, ChatDocument)
@@ -661,9 +676,7 @@ class Task:
             )
         # TODO decide on whether or not to print, based on is_async
         llm_model = (
-            "no-LLM"
-            if self.agent.config.llm is None
-            else self.agent.config.llm.chat_model
+            "no-LLM" if self.agent.llm is None else self.agent.llm.config.chat_model
         )
         if not settings.quiet:
             print(
@@ -774,7 +787,7 @@ class Task:
                 # skip trying other responders in this step
                 break
         if not found_response:
-            self._process_invalid_step_result(parent)
+            self._process_invalid_step_result()
         self._show_pending_message_if_debug()
         return self.pending_message
 
@@ -866,7 +879,7 @@ class Task:
                 # skip trying other responders in this step
                 break
         if not found_response:
-            self._process_invalid_step_result(parent)
+            self._process_invalid_step_result()
         self._show_pending_message_if_debug()
         return self.pending_message
 
@@ -901,30 +914,13 @@ class Task:
         if self.pending_message is not None:
             hashed_msg = hash(str(self.pending_message))
             self.message_counter.update([hashed_msg])
-            self.history_count.append(self.message_counter[hashed_msg])
+            self.history.append(hashed_msg)
 
-    def _process_invalid_step_result(self, parent: ChatDocument | None) -> None:
+    def _process_invalid_step_result(self) -> None:
         """
-        Since step had no valid result from any responder, decide whether to update the
-        self.pending_message to a NO_ANSWER message from the opposite entity,
-        or leave it as is.
-        Args:
-            parent (ChatDocument|None): parent message of the current message
+        No valid result from any responder => increment stalled counter.
         """
         self.n_stalled_steps += 1
-        if (not self.task_progress or self.allow_null_result) and not self.is_pass_thru:
-            # There has been no progress at all in this task, so we
-            # update the pending_message to a dummy NO_ANSWER msg
-            # from the entity 'opposite' to the current pending_sender,
-            # so we show "progress" and avoid getting stuck in an infinite loop.
-            responder = (
-                Entity.LLM if self.pending_sender == Entity.USER else Entity.USER
-            )
-            self.pending_message = ChatDocument(
-                content=NO_ANSWER,
-                metadata=ChatDocMetaData(sender=responder, parent=parent),
-            )
-            self.pending_sender = responder
         self.log_message(self.pending_sender, self.pending_message, mark=True)
 
     def _show_pending_message_if_debug(self) -> None:
@@ -1059,7 +1055,6 @@ class Task:
         tool_messages = result_msg.tool_messages if result_msg else []
         block = result_msg.metadata.block if result_msg else None
         recipient = result_msg.metadata.recipient if result_msg else None
-        responder = result_msg.metadata.parent_responder if result_msg else None
         tool_ids = result_msg.metadata.tool_ids if result_msg else []
         status = result_msg.metadata.status if result_msg else None
 
@@ -1075,7 +1070,6 @@ class Task:
                 sender=Entity.USER,
                 block=block,
                 status=status,
-                parent_responder=responder,
                 sender_name=self.name,
                 recipient=recipient,
                 tool_ids=tool_ids,
@@ -1145,9 +1139,9 @@ class Task:
             So if you plot these frequencies in decreasing order,
             you will see a big drop in the plot, from m to m+1.
             We call the freqs until m the "dominant" freqs.
-        2. Say we found m such dominant frequencies.
-           If these are the same as the freqs of the last m messages,
-           then we are likely in a loop.
+        2. Say we found m such dominant messages
+           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.
         """
         max_cycle_len = self.config.inf_loop_cycle_len
         if max_cycle_len <= 0:
@@ -1158,6 +1152,7 @@ class Task:
             # we haven't seen enough messages to detect a loop
             return False
 
+        # recall there's always a dummy msg with freq = 1
         most_common_msg_counts: List[Tuple[str, int]] = (
             self.message_counter.most_common(max_cycle_len + 1)
         )
@@ -1170,7 +1165,7 @@ class Task:
         ratios = counts[:-1] / counts[1:]
         diffs = counts[:-1] - counts[1:]
         indices = np.where((ratios > F) & (diffs > wait_factor))[0]
-        m = indices[0] if indices.size > 0 else -1
+        m = indices[-1] if indices.size > 0 else -1
         if m < 0:
             # no dominance found, but...
             if len(most_common_msg_counts) <= max_cycle_len:
@@ -1186,12 +1181,13 @@ class Task:
                 return False
 
         dominant_msg_counts = most_common_msg_counts[: m + 1]
-        # if the dominant m message counts are the same as the
-        # counts of the last m messages, then we are likely in a loop
-        dominant_counts = sorted([c for _, c in dominant_msg_counts])
-        recent_counts = sorted(list(self.history_count)[-(m + 1) :])
-
-        return dominant_counts == recent_counts
+        # if the SET of dominant m messages is the same as the
+        # the SET of last m*w messages, (where w = config.inf_loop_wait_factor),
+        # then we are likely in a loop
+        dominant_msgs = set([msg for msg, _ in dominant_msg_counts])
+        lookback = wait_factor * (m + 1)
+        recent_msgs = set(list(self.history)[-lookback:])
+        return dominant_msgs == recent_msgs
 
     def done(
         self, result: ChatDocument | None = None, r: Responder | None = None
@@ -1375,9 +1371,18 @@ class Task:
         )
 
     def _can_respond(self, e: Responder) -> bool:
-        if self.pending_sender == e:
-            # Responder cannot respond to its own message
+        user_can_respond = self.interactive or (
+            # regardless of self.interactive, if a msg is explicitly addressed to
+            # user, then wait for user response
+            self.pending_message is not None
+            and self.pending_message.metadata.recipient == Entity.USER
+        )
+
+        if self.pending_sender == e or (e == Entity.USER and not user_can_respond):
+            # sender is same as e (an entity cannot respond to its own msg),
+            # or user cannot respond
             return False
+
         if self.pending_message is None:
             return True
         if self._recipient_mismatch(e):

{langroid-0.1.258 → langroid-0.1.261}/langroid/language_models/openai_gpt.py

@@ -421,7 +421,9 @@ class OpenAIGPT(LanguageModel):
                 self.api_base = "http://" + self.api_base
         elif self.config.chat_model.startswith("ollama/"):
             self.config.ollama = True
-            self.api_base = OLLAMA_BASE_URL
+
+            # use api_base from config if set, else fall back on OLLAMA_BASE_URL
+            self.api_base = self.config.api_base or OLLAMA_BASE_URL
             self.api_key = OLLAMA_API_KEY
             self.config.chat_model = self.config.chat_model.replace("ollama/", "")
         else:

{langroid-0.1.258 → langroid-0.1.261}/langroid/vector_store/qdrantdb.py

@@ -68,7 +68,7 @@ class QdrantDBConfig(VectorStoreConfig):
     embedding: EmbeddingModelsConfig = OpenAIEmbeddingsConfig()
     distance: str = Distance.COSINE
     use_sparse_embeddings: bool = False
-    sparse_embedding_model: str = ""
+    sparse_embedding_model: str = "naver/splade-v3-distilbert"
     sparse_limit: int = 3
 
 

{langroid-0.1.258 → langroid-0.1.261}/pyproject.toml

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