langroid 0.11.0__tar.gz → 0.13.0__tar.gz

{langroid-0.11.0 → langroid-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.11.0
+Version: 0.13.0
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -239,7 +239,9 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
-- **Aug 2024:** 
+- **Aug 2024:**
+  - **[0.11.0](https://github.com/langroid/langroid/releases/tag/0.11.0)** Polymorphic `Task.run(), Task.run_async`.
+  - **[0.10.0](https://github.com/langroid/langroid/releases/tag/0.10.0)** Allow tool handlers to return arbitrary result type, including other tools.
   - **[0.9.0](https://github.com/langroid/langroid/releases/tag/0.9.0)** Orchestration Tools, to signal various task statuses, and to pass messages between agents.
   - **[0.7.0](https://github.com/langroid/langroid/releases/tag/0.7.0)** OpenAI tools API support, including multi-tools.
 - **Jul 2024:**

{langroid-0.11.0 → langroid-0.13.0}/README.md

@@ -132,7 +132,9 @@ teacher_task.run()
 <details>
 <summary> <b>Click to expand</b></summary>
 
-- **Aug 2024:** 
+- **Aug 2024:**
+  - **[0.11.0](https://github.com/langroid/langroid/releases/tag/0.11.0)** Polymorphic `Task.run(), Task.run_async`.
+  - **[0.10.0](https://github.com/langroid/langroid/releases/tag/0.10.0)** Allow tool handlers to return arbitrary result type, including other tools.
   - **[0.9.0](https://github.com/langroid/langroid/releases/tag/0.9.0)** Orchestration Tools, to signal various task statuses, and to pass messages between agents.
   - **[0.7.0](https://github.com/langroid/langroid/releases/tag/0.7.0)** OpenAI tools API support, including multi-tools.
 - **Jul 2024:**

{langroid-0.11.0 → langroid-0.13.0}/langroid/agent/batch.py

@@ -1,7 +1,7 @@
 import asyncio
 import copy
 import inspect
-from typing import Any, Callable, Coroutine, Iterable, List, Optional, TypeVar
+from typing import Any, Callable, Coroutine, Iterable, List, Optional, TypeVar, cast
 
 from dotenv import load_dotenv
 
@@ -26,6 +26,7 @@ def run_batch_task_gen(
     items: list[T],
     input_map: Callable[[T], str | ChatDocument] = lambda x: str(x),
     output_map: Callable[[ChatDocument | None], U] = lambda x: x,  # type: ignore
+    stop_on_first_result: bool = False,
     sequential: bool = True,
     batch_size: Optional[int] = None,
     turns: int = -1,
@@ -33,7 +34,7 @@ def run_batch_task_gen(
     handle_exceptions: bool = False,
     max_cost: float = 0.0,
     max_tokens: int = 0,
-) -> list[U]:
+) -> list[Optional[U]]:
     """
     Generate and run copies of a task async/concurrently one per item in `items` list.
     For each item, apply `input_map` to get the initial message to process.
@@ -44,7 +45,13 @@ def run_batch_task_gen(
         input_map (Callable[[T], str|ChatDocument]): function to map item to
             initial message to process
         output_map (Callable[[ChatDocument|str], U]): function to map result
-            to final result
+            to final result. If stop_on_first_result is enabled, then
+            map any invalid output to None. We continue until some non-None
+            result is obtained.
+        stop_on_first_result (bool): whether to stop after the first valid
+            (not-None) result. In this case all other tasks are
+            cancelled, and their corresponding result is None in the
+            returned list.
         sequential (bool): whether to run sequentially
             (e.g. some APIs such as ooba don't support concurrent requests)
         batch_size (Optional[int]): The number of tasks to run at a time,
@@ -57,39 +64,91 @@ def run_batch_task_gen(
 
 
     Returns:
-        list[Any]: list of final results
+        list[Optional[U]]: list of final results. Always list[U] if
+        `stop_on_first_result` is disabled
     """
     inputs = [input_map(item) for item in items]
 
-    async def _do_task(input: str | ChatDocument, i: int) -> Optional[ChatDocument]:
+    async def _do_task(
+        input: str | ChatDocument,
+        i: int,
+        return_idx: Optional[int] = None,
+    ) -> BaseException | Optional[ChatDocument] | tuple[int, Optional[ChatDocument]]:
         task_i = gen_task(i)
         if task_i.agent.llm is not None:
             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, max_tokens=max_tokens
-        )
-        return result
+        try:
+            result = await task_i.run_async(
+                input, turns=turns, max_cost=max_cost, max_tokens=max_tokens
+            )
+            if return_idx is not None:
+                return return_idx, result
+            else:
+                return result
+        except asyncio.CancelledError as e:
+            task_i.kill()
+            if handle_exceptions:
+                return e
+            else:
+                raise e
+        except BaseException as e:
+            if handle_exceptions:
+                return e
+            else:
+                raise e
 
     async def _do_all(
         inputs: Iterable[str | ChatDocument], start_idx: int = 0
-    ) -> list[U]:
+    ) -> list[Optional[U]]:
         results: list[Optional[ChatDocument]] = []
-        if sequential:
-            for i, input in enumerate(inputs):
+        if stop_on_first_result:
+            outputs: list[Optional[U]] = [None] * len(list(inputs))
+            tasks = set(
+                asyncio.create_task(_do_task(input, i + start_idx, return_idx=i))
+                for i, input in enumerate(inputs)
+            )
+            while tasks:
                 try:
-                    result = await _do_task(input, i + start_idx)
-                except BaseException as e:
-                    if handle_exceptions:
-                        result = None
-                    else:
-                        raise e
+                    done, tasks = await asyncio.wait(
+                        tasks, return_when=asyncio.FIRST_COMPLETED
+                    )
+                    for task in done:
+                        idx_result = task.result()
+                        if not isinstance(idx_result, tuple):
+                            continue
+                        index, output = idx_result
+                        outputs[index] = output_map(output)
+
+                    if any(r is not None for r in outputs):
+                        return outputs
+                finally:
+                    # Cancel all remaining tasks
+                    for task in tasks:
+                        task.cancel()
+                    # Wait for cancellations to complete
+                    try:
+                        await asyncio.gather(*tasks, return_exceptions=True)
+                    except BaseException as e:
+                        if not handle_exceptions:
+                            raise e
+            return outputs
+        elif sequential:
+            for i, input in enumerate(inputs):
+                result: Optional[ChatDocument] | BaseException = await _do_task(
+                    input, i + start_idx
+                )  # type: ignore
+
+                if isinstance(result, BaseException):
+                    result = None
+
                 results.append(result)
         else:
-            results_with_exceptions = await asyncio.gather(
-                *(_do_task(input, i + start_idx) for i, input in enumerate(inputs)),
-                return_exceptions=handle_exceptions,
+            results_with_exceptions = cast(
+                list[Optional[ChatDocument | BaseException]],
+                await asyncio.gather(
+                    *(_do_task(input, i + start_idx) for i, input in enumerate(inputs)),
+                ),
             )
 
             results = [
@@ -99,7 +158,7 @@ def run_batch_task_gen(
 
         return list(map(output_map, results))
 
-    results: List[U] = []
+    results: List[Optional[U]] = []
     if batch_size is None:
         msg = message or f"[bold green]Running {len(items)} tasks:"
 
@@ -113,8 +172,11 @@ def run_batch_task_gen(
             complete_str = f", {start_idx} complete" if start_idx > 0 else ""
             msg = message or f"[bold green]Running {len(items)} tasks{complete_str}:"
 
-            with status(msg), SuppressLoggerWarnings():
-                results.extend(asyncio.run(_do_all(batch, start_idx=start_idx)))
+            if stop_on_first_result and any(r is not None for r in results):
+                results.extend([None] * len(batch))
+            else:
+                with status(msg), SuppressLoggerWarnings():
+                    results.extend(asyncio.run(_do_all(batch, start_idx=start_idx)))
 
     return results
 
@@ -124,12 +186,13 @@ def run_batch_tasks(
     items: list[T],
     input_map: Callable[[T], str | ChatDocument] = lambda x: str(x),
     output_map: Callable[[ChatDocument | None], U] = lambda x: x,  # type: ignore
+    stop_on_first_result: bool = False,
     sequential: bool = True,
     batch_size: Optional[int] = None,
     turns: int = -1,
     max_cost: float = 0.0,
     max_tokens: int = 0,
-) -> List[U]:
+) -> List[Optional[U]]:
     """
     Run copies of `task` async/concurrently one per item in `items` list.
     For each item, apply `input_map` to get the initial message to process.
@@ -150,7 +213,8 @@ def run_batch_tasks(
         max_tokens: int: maximum token usage (in and out) (default 0 for unlimited)
 
     Returns:
-        list[Any]: list of final results
+        list[Optional[U]]: list of final results. Always list[U] if
+        `stop_on_first_result` is disabled
     """
     message = f"[bold green]Running {len(items)} copies of {task.name}..."
     return run_batch_task_gen(
@@ -158,6 +222,7 @@ def run_batch_tasks(
         items,
         input_map,
         output_map,
+        stop_on_first_result,
         sequential,
         batch_size,
         turns,
@@ -176,6 +241,7 @@ def run_batch_agent_method(
     input_map: Callable[[Any], str | ChatDocument] = lambda x: str(x),
     output_map: Callable[[ChatDocument | None], Any] = lambda x: x,
     sequential: bool = True,
+    stop_on_first_result: bool = False,
 ) -> List[Any]:
     """
     Run the `method` on copies of `agent`, async/concurrently one per
@@ -225,7 +291,25 @@ def run_batch_agent_method(
         return output_map(result)
 
     async def _do_all() -> List[Any]:
-        if sequential:
+        if stop_on_first_result:
+            tasks = [
+                asyncio.create_task(_do_task(input, i))
+                for i, input in enumerate(inputs)
+            ]
+            results = [None] * len(tasks)
+            try:
+                done, pending = await asyncio.wait(
+                    tasks, return_when=asyncio.FIRST_COMPLETED
+                )
+                for task in done:
+                    index = tasks.index(task)
+                    results[index] = await task
+            finally:
+                for task in pending:
+                    task.cancel()
+                await asyncio.gather(*pending, return_exceptions=True)
+            return results
+        elif sequential:
             results = []
             for i, input in enumerate(inputs):
                 result = await _do_task(input, i)
@@ -249,6 +333,7 @@ def llm_response_batch(
     input_map: Callable[[Any], str | ChatDocument] = lambda x: str(x),
     output_map: Callable[[ChatDocument | None], Any] = lambda x: x,
     sequential: bool = True,
+    stop_on_first_result: bool = False,
 ) -> List[Any]:
     return run_batch_agent_method(
         agent,
@@ -257,6 +342,7 @@ def llm_response_batch(
         input_map=input_map,
         output_map=output_map,
         sequential=sequential,
+        stop_on_first_result=stop_on_first_result,
     )
 
 
@@ -266,6 +352,7 @@ def agent_response_batch(
     input_map: Callable[[Any], str | ChatDocument] = lambda x: str(x),
     output_map: Callable[[ChatDocument | None], Any] = lambda x: x,
     sequential: bool = True,
+    stop_on_first_result: bool = False,
 ) -> List[Any]:
     return run_batch_agent_method(
         agent,
@@ -274,4 +361,5 @@ def agent_response_batch(
         input_map=input_map,
         output_map=output_map,
         sequential=sequential,
+        stop_on_first_result=stop_on_first_result,
     )

{langroid-0.11.0 → langroid-0.13.0}/langroid/agent/special/doc_chat_agent.py

@@ -49,7 +49,6 @@ from langroid.parsing.search import (
 from langroid.parsing.table_loader import describe_dataframe
 from langroid.parsing.url_loader import URLLoader
 from langroid.parsing.urls import get_list_from_user, get_urls_paths_bytes_indices
-from langroid.parsing.utils import batched
 from langroid.prompts.prompts_config import PromptsConfig
 from langroid.prompts.templates import SUMMARY_ANSWER_PROMPT_GPT4
 from langroid.utils.constants import NO_ANSWER
@@ -137,7 +136,6 @@ 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
     stream: bool = True  # allow streaming where needed
@@ -400,7 +398,11 @@ class DocChatAgent(ChatAgent):
         if split:
             docs = self.parser.split(docs)
         else:
-            self.parser.add_window_ids(docs)
+            if self.config.n_neighbor_chunks > 0:
+                self.parser.add_window_ids(docs)
+            # we're not splitting, so we mark each doc as a chunk
+            for d in docs:
+                d.metadata.is_chunk = True
         if self.vecdb is None:
             raise ValueError("VecDB not set")
 
@@ -422,10 +424,9 @@ class DocChatAgent(ChatAgent):
                         + d.content
                     )
         docs = docs[: self.config.parsing.max_chunks]
-        # add embeddings in batches, to stay under limit of embeddings API
-        batches = list(batched(docs, self.config.embed_batch_size))
-        for batch in batches:
-            self.vecdb.add_documents(batch)
+        # vecdb should take care of adding docs in batches;
+        # batching can be controlled via vecdb.config.batch_size
+        self.vecdb.add_documents(docs)
         self.original_docs_length = self.doc_length(docs)
         self.setup_documents(docs, filter=self.config.filter)
         return len(docs)
@@ -894,7 +895,9 @@ class DocChatAgent(ChatAgent):
             )
         return docs_scores
 
-    def get_fuzzy_matches(self, query: str, multiple: int) -> List[Document]:
+    def get_fuzzy_matches(
+        self, query: str, multiple: int
+    ) -> List[Tuple[Document, float]]:
         # find similar docs using fuzzy matching:
         # these may sometimes be more likely to contain a relevant verbatim extract
         with status("[cyan]Finding fuzzy matches in chunks..."):
@@ -909,8 +912,8 @@ class DocChatAgent(ChatAgent):
                 self.chunked_docs,
                 self.chunked_docs_clean,
                 k=self.config.parsing.n_similar_docs * multiple,
-                words_before=self.config.n_fuzzy_neighbor_words,
-                words_after=self.config.n_fuzzy_neighbor_words,
+                words_before=self.config.n_fuzzy_neighbor_words or None,
+                words_after=self.config.n_fuzzy_neighbor_words or None,
             )
         return fuzzy_match_docs
 
@@ -1127,12 +1130,14 @@ class DocChatAgent(ChatAgent):
         # ]
 
         if self.config.use_bm25_search:
+            # TODO: Add score threshold in config
             docs_scores = self.get_similar_chunks_bm25(query, retrieval_multiple)
             passages += [d for (d, _) in docs_scores]
 
         if self.config.use_fuzzy_match:
-            fuzzy_match_docs = self.get_fuzzy_matches(query, retrieval_multiple)
-            passages += fuzzy_match_docs
+            # TODO: Add score threshold in config
+            fuzzy_match_doc_scores = self.get_fuzzy_matches(query, retrieval_multiple)
+            passages += [d for (d, _) in fuzzy_match_doc_scores]
 
         # keep unique passages
         id2passage = {p.id(): p for p in passages}
@@ -1253,12 +1258,12 @@ class DocChatAgent(ChatAgent):
             interactive=False,
         )
 
-        extracts = run_batch_tasks(
+        extracts: list[str] = run_batch_tasks(
             task,
             passages,
             input_map=lambda msg: msg.content,
             output_map=lambda ans: ans.content if ans is not None else NO_ANSWER,
-        )
+        )  # type: ignore
 
         # Caution: Retain ALL other fields in the Documents (which could be
         # other than just `content` and `metadata`), while simply replacing

{langroid-0.11.0 → langroid-0.13.0}/langroid/agent/task.py

@@ -1000,9 +1000,10 @@ class Task:
             and not self.human_tried
             and not self.agent.has_tool_message_attempt(self.pending_message)
         ):
-            # When in interactive mode,
             # Give human first chance if they haven't been tried in last step,
             # and the msg is not a tool-call attempt;
+            # (When `interactive=False`, human is only allowed to respond only if
+            #  if explicitly addressed)
             # This ensures human gets a chance to respond,
             #   other than to a LLM tool-call.
             # When there's a tool msg attempt we want the

{langroid-0.11.0 → langroid-0.13.0}/langroid/language_models/mock_lm.py

@@ -1,6 +1,6 @@
 """Mock Language Model for testing"""
 
-from typing import Callable, Dict, List, Optional, Union
+from typing import Awaitable, Callable, Dict, List, Optional, Union
 
 import langroid.language_models as lm
 from langroid.language_models import LLMResponse
@@ -28,6 +28,7 @@ class MockLMConfig(LLMConfig):
 
     response_dict: Dict[str, str] = {}
     response_fn: Callable[[str], None | str] = none_fn
+    response_fn_async: Optional[Callable[[str], Awaitable[Optional[str]]]] = None
     default_response: str = "Mock response"
 
     type: str = "mock"
@@ -52,6 +53,25 @@ class MockLM(LanguageModel):
             cached=False,
         )
 
+    async def _response_async(self, msg: str) -> LLMResponse:
+        # response is based on this fallback order:
+        # - response_dict
+        # - response_fn_async
+        # - response_fn
+        # - default_response
+        if self.config.response_fn_async is not None:
+            response = await self.config.response_fn_async(msg)
+        else:
+            response = self.config.response_fn(msg)
+
+        mapped_response = self.config.response_dict.get(
+            msg, response or self.config.default_response
+        )
+        return lm.LLMResponse(
+            message=to_string(mapped_response),
+            cached=False,
+        )
+
     def chat(
         self,
         messages: Union[str, List[lm.LLMMessage]],
@@ -80,7 +100,7 @@ class MockLM(LanguageModel):
         Mock chat function for testing
         """
         last_msg = messages[-1].content if isinstance(messages, list) else messages
-        return self._response(last_msg)
+        return await self._response_async(last_msg)
 
     def generate(self, prompt: str, max_tokens: int = 200) -> lm.LLMResponse:
         """
@@ -92,7 +112,7 @@ class MockLM(LanguageModel):
         """
         Mock generate function for testing
         """
-        return self._response(prompt)
+        return await self._response_async(prompt)
 
     def get_stream(self) -> bool:
         return False

{langroid-0.11.0 → langroid-0.13.0}/langroid/parsing/search.py

@@ -27,7 +27,7 @@ def find_fuzzy_matches_in_docs(
     k: int,
     words_before: int | None = None,
     words_after: int | None = None,
-) -> List[Document]:
+) -> List[Tuple[Document, float]]:
     """
     Find approximate matches of the query in the docs and return surrounding
     characters.
@@ -35,6 +35,7 @@ def find_fuzzy_matches_in_docs(
     Args:
         query (str): The search string.
         docs (List[Document]): List of Document objects to search through.
+        docs_clean (List[Document]): List of Document objects with cleaned content.
         k (int): Number of best matches to return.
         words_before (int|None): Number of words to include before each match.
             Default None => return max
@@ -42,8 +43,7 @@ def find_fuzzy_matches_in_docs(
             Default None => return max
 
     Returns:
-        List[Document]: List of Documents containing the matches,
-            including the given number of words around the match.
+        List[Tuple[Document,float]]: List of (Document, score) tuples.
     """
     if len(docs) == 0:
         return []
@@ -54,19 +54,19 @@ def find_fuzzy_matches_in_docs(
         scorer=fuzz.partial_ratio,
     )
 
-    real_matches = [m for m, score in best_matches if score > 50]
+    real_matches = [(m, score) for m, score in best_matches if score > 50]
     # find the original docs that corresponding to the matches
     orig_doc_matches = []
-    for i, m in enumerate(real_matches):
+    for i, (m, s) in enumerate(real_matches):
         for j, doc_clean in enumerate(docs_clean):
             if m in doc_clean.content:
-                orig_doc_matches.append(docs[j])
+                orig_doc_matches.append((docs[j], s))
                 break
     if words_after is None and words_before is None:
         return orig_doc_matches
     if len(orig_doc_matches) == 0:
         return []
-    if set(orig_doc_matches[0].__fields__) != {"content", "metadata"}:
+    if set(orig_doc_matches[0][0].__fields__) != {"content", "metadata"}:
         # If there are fields beyond just content and metadata,
         # we do NOT want to create new document objects with content fields
         # based on words_before and words_after, since we don't know how to
@@ -74,7 +74,7 @@ def find_fuzzy_matches_in_docs(
         return orig_doc_matches
 
     contextual_matches = []
-    for match in orig_doc_matches:
+    for match, score in orig_doc_matches:
         choice_text = match.content
         contexts = []
         while choice_text != "":
@@ -89,9 +89,12 @@ def find_fuzzy_matches_in_docs(
             choice_text = " ".join(words[end_pos:])
         if len(contexts) > 0:
             contextual_matches.append(
-                Document(
-                    content=" ... ".join(contexts),
-                    metadata=match.metadata,
+                (
+                    Document(
+                        content=" ... ".join(contexts),
+                        metadata=match.metadata,
+                    ),
+                    score,
                 )
             )
 

{langroid-0.11.0 → langroid-0.13.0}/pyproject.toml

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