langroid 0.1.214__tar.gz → 0.1.217__tar.gz

{langroid-0.1.214 → langroid-0.1.217}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.214
+Version: 0.1.217
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -26,7 +26,7 @@ Requires-Dist: agent-search (>=0.0.7,<0.0.8) ; extra == "sciphi"
 Requires-Dist: aiohttp (>=3.9.1,<4.0.0)
 Requires-Dist: async-generator (>=1.10,<2.0)
 Requires-Dist: autopep8 (>=2.0.2,<3.0.0)
-Requires-Dist: black[jupyter] (>=23.3.0,<24.0.0)
+Requires-Dist: black[jupyter] (>=24.3.0,<25.0.0)
 Requires-Dist: bs4 (>=0.0.1,<0.0.2)
 Requires-Dist: chainlit (>=1.0.400,<2.0.0) ; extra == "chainlit"
 Requires-Dist: chromadb (>=0.4.21,<=0.4.23) ; extra == "chromadb"
@@ -232,6 +232,11 @@ teacher_task.run()
 <summary> <b>Click to expand</b></summary>
 
 - **Mar 2024:**
+  - **0.1.216:** Improvements to allow concurrent runs of `DocChatAgent`, see the
+    [`test_doc_chat_agent.py`](https://github.com/langroid/langroid/blob/main/tests/main/test_doc_chat_agent.py)
+    in particular the `test_doc_chat_batch()`;
+    New task run utility: [`run_batch_task_gen`](https://github.com/langroid/langroid/blob/main/langroid/agent/batch.py) 
+    where a task generator can be specified, to generate one task per input. 
   - **0.1.212:** ImagePdfParser: support for extracting text from image-based PDFs.
     (this means `DocChatAgent` will now work with image-pdfs).
   - **0.1.194 - 0.1.211:** Misc fixes, improvements, and features:

{langroid-0.1.214 → langroid-0.1.217}/README.md

@@ -123,6 +123,11 @@ teacher_task.run()
 <summary> <b>Click to expand</b></summary>
 
 - **Mar 2024:**
+  - **0.1.216:** Improvements to allow concurrent runs of `DocChatAgent`, see the
+    [`test_doc_chat_agent.py`](https://github.com/langroid/langroid/blob/main/tests/main/test_doc_chat_agent.py)
+    in particular the `test_doc_chat_batch()`;
+    New task run utility: [`run_batch_task_gen`](https://github.com/langroid/langroid/blob/main/langroid/agent/batch.py) 
+    where a task generator can be specified, to generate one task per input. 
   - **0.1.212:** ImagePdfParser: support for extracting text from image-based PDFs.
     (this means `DocChatAgent` will now work with image-pdfs).
   - **0.1.194 - 0.1.211:** Misc fixes, improvements, and features:

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/__init__.py

@@ -13,6 +13,7 @@ from . import base
 from . import chat_document
 from . import chat_agent
 from . import task
+from . import batch
 from . import tool_message
 from . import tools
 from . import special
@@ -32,6 +33,7 @@ __all__ = [
     "chat_document",
     "chat_agent",
     "task",
+    "batch",
     "tool_message",
     "tools",
     "special",

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/base.py

@@ -42,6 +42,7 @@ from langroid.parsing.parser import Parser, ParsingConfig
 from langroid.prompts.prompts_config import PromptsConfig
 from langroid.utils.configuration import settings
 from langroid.utils.constants import NO_ANSWER
+from langroid.utils.output import status
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
 console = Console(quiet=settings.quiet)
@@ -517,7 +518,7 @@ class Agent(ABC):
         with ExitStack() as stack:  # for conditionally using rich spinner
             if not self.llm.get_stream():
                 # show rich spinner only if not streaming!
-                cm = console.status("LLM responding to message...")
+                cm = status("LLM responding to message...")
                 stack.enter_context(cm)
             output_len = self.config.llm.max_output_tokens
             if (

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/batch.py

@@ -1,84 +1,159 @@
 import asyncio
 import copy
 import inspect
-from typing import Any, Callable, Coroutine, List
+from typing import Any, Callable, Coroutine, Iterable, List, Optional, TypeVar
 
 from dotenv import load_dotenv
-from rich.console import Console
 
 from langroid.agent.base import Agent
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.task import Task
-from langroid.utils.configuration import quiet_mode, settings
+from langroid.parsing.utils import batched
+from langroid.utils.configuration import quiet_mode
 from langroid.utils.logging import setup_colored_logging
-from langroid.utils.output.printing import SuppressLoggerWarnings
-
-console = Console(quiet=settings.quiet)
+from langroid.utils.output import SuppressLoggerWarnings, status
 
 setup_colored_logging()
 
 load_dotenv()
 
+T = TypeVar("T")
+U = TypeVar("U")
 
-def run_batch_tasks(
-    task: Task,
-    items: List[Any],
-    input_map: Callable[[Any], str | ChatDocument] = lambda x: str(x),
-    output_map: Callable[[ChatDocument | None], Any] = lambda x: x,
+
+def run_batch_task_gen(
+    gen_task: Callable[[int], Task],
+    items: list[T],
+    input_map: Callable[[T], str | ChatDocument] = lambda x: str(x),
+    output_map: Callable[[ChatDocument | None], U] = lambda x: x,  # type: ignore
     sequential: bool = True,
+    batch_size: Optional[int] = None,
     turns: int = -1,
-) -> List[Any]:
+    message: Optional[str] = None,
+    handle_exceptions: bool = False,
+) -> list[U]:
     """
-    Run copies of `task` async/concurrently one per item in `items` list.
+    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.
     For each result, apply `output_map` to get the final result.
     Args:
-        task (Task): task to run
-        items (List[Any]): list of items to process
-        input_map (Callable[[Any], str|ChatDocument]): function to map item to
+        gen_task (Callable[[int], Task]): generates the tasks to run
+        items (list[T]): list of items to process
+        input_map (Callable[[T], str|ChatDocument]): function to map item to
             initial message to process
-        output_map (Callable[[ChatDocument|str], Any]): function to map result
+        output_map (Callable[[ChatDocument|str], U]): function to map result
             to final result
         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,
+            if None, unbatched
         turns (int): number of turns to run, -1 for infinite
+        message (Optional[str]): optionally overrides the console status messages
+        handle_exceptions: bool: Whether to replace exceptions with outputs of None
 
     Returns:
-        List[Any]: list of final results
+        list[Any]: list of final results
     """
-
     inputs = [input_map(item) for item in items]
 
-    async def _do_task(input: str | ChatDocument, i: int) -> Any:
-        task_i = task.clone(i)
+    async def _do_task(input: str | ChatDocument, i: 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)
-        return output_map(result)
+        return result
 
-    async def _do_all() -> List[Any]:
-        with quiet_mode(not settings.debug), SuppressLoggerWarnings():
-            if sequential:
-                results = []
-                for i, input in enumerate(inputs):
-                    result = await _do_task(input, i)
-                    results.append(result)
-                return results
-            return await asyncio.gather(
-                *(_do_task(input, i) for i, input in enumerate(inputs))
+    async def _do_all(
+        inputs: Iterable[str | ChatDocument], start_idx: int = 0
+    ) -> list[U]:
+        results: list[Optional[ChatDocument]] = []
+        if sequential:
+            for i, input in enumerate(inputs):
+                try:
+                    result = await _do_task(input, i + start_idx)
+                except BaseException as e:
+                    if handle_exceptions:
+                        result = None
+                    else:
+                        raise e
+                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,
             )
 
-    # show rich console spinner
+            results = [
+                r if not isinstance(r, BaseException) else None
+                for r in results_with_exceptions
+            ]
 
-    n = len(items)
-    with console.status(f"[bold green]Running {n} copies of {task.name}..."):
-        results = asyncio.run(_do_all())
+        return list(map(output_map, results))
+
+    results: List[U] = []
+    if batch_size is None:
+        msg = message or f"[bold green]Running {len(items)} tasks:"
+
+        with status(msg), SuppressLoggerWarnings():
+            results = asyncio.run(_do_all(inputs))
+    else:
+        batches = batched(inputs, batch_size)
+
+        for batch in batches:
+            start_idx = len(results)
+            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)))
 
     return results
 
 
+def run_batch_tasks(
+    task: Task,
+    items: list[T],
+    input_map: Callable[[T], str | ChatDocument] = lambda x: str(x),
+    output_map: Callable[[ChatDocument | None], U] = lambda x: x,  # type: ignore
+    sequential: bool = True,
+    batch_size: Optional[int] = None,
+    turns: int = -1,
+) -> List[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.
+    For each result, apply `output_map` to get the final result.
+    Args:
+        task (Task): task to run
+        items (list[T]): list of items to process
+        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
+        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,
+            if None, unbatched
+        turns (int): number of turns to run, -1 for infinite
+
+    Returns:
+        list[Any]: list of final results
+    """
+    message = f"[bold green]Running {len(items)} copies of {task.name}..."
+    return run_batch_task_gen(
+        lambda i: task.clone(i),
+        items,
+        input_map,
+        output_map,
+        sequential,
+        batch_size,
+        turns,
+        message,
+    )
+
+
 def run_batch_agent_method(
     agent: Agent,
     method: Callable[
@@ -149,7 +224,7 @@ def run_batch_agent_method(
             )
 
     n = len(items)
-    with console.status(f"[bold green]Running {n} copies of {agent_name}..."):
+    with status(f"[bold green]Running {n} copies of {agent_name}..."):
         results = asyncio.run(_do_all())
 
     return results

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/chat_agent.py

@@ -20,8 +20,9 @@ from langroid.language_models.base import (
 )
 from langroid.language_models.openai_gpt import OpenAIGPT
 from langroid.utils.configuration import settings
+from langroid.utils.output import status
 
-console = Console(quiet=settings.quiet)
+console = Console()
 
 logger = logging.getLogger(__name__)
 
@@ -154,6 +155,8 @@ class ChatAgent(Agent):
         new_agent.llm_functions_handled = self.llm_functions_handled
         new_agent.llm_functions_usable = self.llm_functions_usable
         new_agent.llm_function_force = self.llm_function_force
+        # Caution - we are copying the vector-db, maybe we don't always want this?
+        new_agent.vecdb = self.vecdb
         return new_agent
 
     def _fn_call_available(self) -> bool:
@@ -490,9 +493,7 @@ class ChatAgent(Agent):
         response.metadata.tool_ids = (
             []
             if isinstance(message, str)
-            else message.metadata.tool_ids
-            if message is not None
-            else []
+            else message.metadata.tool_ids if message is not None else []
         )
         return response
 
@@ -515,9 +516,7 @@ class ChatAgent(Agent):
         response.metadata.tool_ids = (
             []
             if isinstance(message, str)
-            else message.metadata.tool_ids
-            if message is not None
-            else []
+            else message.metadata.tool_ids if message is not None else []
         )
         return response
 
@@ -682,9 +681,12 @@ class ChatAgent(Agent):
             streamer = self.callbacks.start_llm_stream()
         self.llm.config.streamer = streamer
         with ExitStack() as stack:  # for conditionally using rich spinner
-            if not self.llm.get_stream() and not settings.quiet:
+            if not self.llm.get_stream():
                 # show rich spinner only if not streaming!
-                cm = console.status("LLM responding to messages...")
+                cm = status(
+                    "LLM responding to messages...",
+                    log_if_quiet=False,
+                )
                 stack.enter_context(cm)
             if self.llm.get_stream() and not settings.quiet:
                 console.print(f"[green]{self.indent}", end="")

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/openai_assistant.py

@@ -80,7 +80,6 @@ class OpenAIAssistantConfig(ChatAgentConfig):
 
 
 class OpenAIAssistant(ChatAgent):
-
     """
     A ChatAgent powered by OpenAI Assistant API:
     mainly, in `llm_response` method, we avoid maintaining conversation state,

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/doc_chat_agent.py

@@ -12,14 +12,15 @@ langroid with the [hf-embeddings] extra, e.g.:
 pip install "langroid[hf-embeddings]"
 
 """
+
 import logging
 from contextlib import ExitStack
+from functools import cache
 from typing import Any, Dict, List, Optional, Set, Tuple, no_type_check
 
+import nest_asyncio
 import numpy as np
 import pandas as pd
-from rich import print
-from rich.console import Console
 from rich.prompt import Prompt
 
 from langroid.agent.batch import run_batch_tasks
@@ -49,14 +50,18 @@ from langroid.prompts.prompts_config import PromptsConfig
 from langroid.prompts.templates import SUMMARY_ANSWER_PROMPT_GPT4
 from langroid.utils.configuration import settings
 from langroid.utils.constants import NO_ANSWER
-from langroid.utils.output.printing import show_if_debug
+from langroid.utils.output import show_if_debug, status
 from langroid.utils.pydantic_utils import dataframe_to_documents, extract_fields
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 from langroid.vector_store.lancedb import LanceDBConfig
 
-logger = logging.getLogger(__name__)
 
-console = Console()
+@cache
+def apply_nest_asyncio() -> None:
+    nest_asyncio.apply()
+
+
+logger = logging.getLogger(__name__)
 
 DEFAULT_DOC_CHAT_INSTRUCTIONS = """
 Your task is to answer questions about various documents.
@@ -248,10 +253,9 @@ class DocChatAgent(ChatAgent):
     def ingest_doc_paths(
         self,
         paths: List[str],
-        metadata: List[Dict[str, Any]]
-        | Dict[str, Any]
-        | DocMetaData
-        | List[DocMetaData] = [],
+        metadata: (
+            List[Dict[str, Any]] | Dict[str, Any] | DocMetaData | List[DocMetaData]
+        ) = [],
     ) -> List[Document]:
         """Split, ingest docs from specified paths,
         do not add these to config.doc_paths.
@@ -272,9 +276,11 @@ class DocChatAgent(ChatAgent):
         ):
             if isinstance(metadata, list):
                 path2meta = {
-                    p: m
-                    if isinstance(m, dict)
-                    else (isinstance(m, DocMetaData) and m.dict())  # appease mypy
+                    p: (
+                        m
+                        if isinstance(m, dict)
+                        else (isinstance(m, DocMetaData) and m.dict())
+                    )  # appease mypy
                     for p, m in zip(all_paths, metadata)
                 }
             elif isinstance(metadata, dict):
@@ -322,10 +328,9 @@ class DocChatAgent(ChatAgent):
         self,
         docs: List[Document],
         split: bool = True,
-        metadata: List[Dict[str, Any]]
-        | Dict[str, Any]
-        | DocMetaData
-        | List[DocMetaData] = [],
+        metadata: (
+            List[Dict[str, Any]] | Dict[str, Any] | DocMetaData | List[DocMetaData]
+        ) = [],
     ) -> int:
         """
         Chunk docs into pieces, map each chunk to vec-embedding, store in vec-db
@@ -623,7 +628,7 @@ class DocChatAgent(ChatAgent):
             query_str = query_str[1:] if query_str is not None else None
             if self.llm is None:
                 raise ValueError("LLM not set")
-            with StreamingIfAllowed(self.llm):
+            with StreamingIfAllowed(self.llm, self.llm.get_stream()):
                 response = super().llm_response(query_str)
             if query_str is not None:
                 self.update_dialog(
@@ -649,6 +654,49 @@ class DocChatAgent(ChatAgent):
                 ),
             )
 
+    async def llm_response_async(
+        self,
+        query: None | str | ChatDocument = None,
+    ) -> Optional[ChatDocument]:
+        apply_nest_asyncio()
+        if not self.llm_can_respond(query):
+            return None
+        query_str: str | None
+        if isinstance(query, ChatDocument):
+            query_str = query.content
+        else:
+            query_str = query
+        if query_str is None or query_str.startswith("!"):
+            # direct query to LLM
+            query_str = query_str[1:] if query_str is not None else None
+            if self.llm is None:
+                raise ValueError("LLM not set")
+            with StreamingIfAllowed(self.llm, self.llm.get_stream()):
+                response = await super().llm_response_async(query_str)
+            if query_str is not None:
+                self.update_dialog(
+                    query_str, "" if response is None else response.content
+                )
+            return response
+        if query_str == "":
+            return None
+        elif query_str == "?" and self.response is not None:
+            return self.justify_response()
+        elif (query_str.startswith(("summar", "?")) and self.response is None) or (
+            query_str == "??"
+        ):
+            return self.summarize_docs()
+        else:
+            self.callbacks.show_start_response(entity="llm")
+            response = self.answer_from_docs(query_str)
+            return ChatDocument(
+                content=response.content,
+                metadata=ChatDocMetaData(
+                    source=response.metadata.source,
+                    sender=Entity.LLM,
+                ),
+            )
+
     @staticmethod
     def doc_string(docs: List[Document]) -> str:
         """
@@ -735,7 +783,7 @@ class DocChatAgent(ChatAgent):
     def llm_hypothetical_answer(self, query: str) -> str:
         if self.llm is None:
             raise ValueError("LLM not set")
-        with console.status("[cyan]LLM generating hypothetical answer..."):
+        with status("[cyan]LLM generating hypothetical answer..."):
             with StreamingIfAllowed(self.llm, False):
                 # TODO: provide an easy way to
                 # Adjust this prompt depending on context.
@@ -755,7 +803,7 @@ class DocChatAgent(ChatAgent):
     def llm_rephrase_query(self, query: str) -> List[str]:
         if self.llm is None:
             raise ValueError("LLM not set")
-        with console.status("[cyan]LLM generating rephrases of query..."):
+        with status("[cyan]LLM generating rephrases of query..."):
             with StreamingIfAllowed(self.llm, False):
                 rephrases = self.llm_response_forget(
                     f"""
@@ -771,7 +819,7 @@ class DocChatAgent(ChatAgent):
     ) -> List[Tuple[Document, float]]:
         # find similar docs using bm25 similarity:
         # these may sometimes be more likely to contain a relevant verbatim extract
-        with console.status("[cyan]Searching for similar chunks using bm25..."):
+        with status("[cyan]Searching for similar chunks using bm25..."):
             if self.chunked_docs is None or len(self.chunked_docs) == 0:
                 logger.warning("No chunked docs; cannot use bm25-similarity")
                 return []
@@ -789,7 +837,7 @@ class DocChatAgent(ChatAgent):
     def get_fuzzy_matches(self, query: str, multiple: int) -> List[Document]:
         # find similar docs using fuzzy matching:
         # these may sometimes be more likely to contain a relevant verbatim extract
-        with console.status("[cyan]Finding fuzzy matches in chunks..."):
+        with status("[cyan]Finding fuzzy matches in chunks..."):
             if self.chunked_docs is None:
                 logger.warning("No chunked docs; cannot use fuzzy matching")
                 return []
@@ -809,7 +857,7 @@ class DocChatAgent(ChatAgent):
     def rerank_with_cross_encoder(
         self, query: str, passages: List[Document]
     ) -> List[Document]:
-        with console.status("[cyan]Re-ranking retrieved chunks using cross-encoder..."):
+        with status("[cyan]Re-ranking retrieved chunks using cross-encoder..."):
             try:
                 from sentence_transformers import CrossEncoder
             except ImportError:
@@ -954,7 +1002,7 @@ class DocChatAgent(ChatAgent):
         # Note: for dynamic filtering based on a query, users can
         # use the `temp_update` context-manager to pass in a `filter` to self.config,
         # e.g.:
-        # with temp_update(self.config, filter="metadata.source=='source1'"):
+        # with temp_update(self.config, {"filter": "metadata.source=='source1'"}):
         #     docs_scores = self.get_semantic_search_results(query, k=k)
         # This avoids having pass the `filter` argument to every function call
         # upstream of this one.
@@ -1002,7 +1050,7 @@ class DocChatAgent(ChatAgent):
         if self.vecdb is None:
             raise ValueError("VecDB not set")
 
-        with console.status("[cyan]Searching VecDB for relevant doc passages..."):
+        with status("[cyan]Searching VecDB for relevant doc passages..."):
             docs_and_scores: List[Tuple[Document, float]] = []
             for q in [query] + query_proxies:
                 docs_and_scores += self.get_semantic_search_results(
@@ -1078,7 +1126,7 @@ class DocChatAgent(ChatAgent):
             # Regardless of whether we are in conversation mode or not,
             # for relevant doc/chunk extraction, we must convert the query
             # to a standalone query to get more relevant results.
-            with console.status("[cyan]Converting to stand-alone query...[/cyan]"):
+            with status("[cyan]Converting to stand-alone query...[/cyan]"):
                 with StreamingIfAllowed(self.llm, False):
                     query = self.llm.followup_to_standalone(self.dialog, query)
             print(f"[orange2]New query: {query}")
@@ -1097,7 +1145,7 @@ class DocChatAgent(ChatAgent):
         if len(passages) == 0:
             return query, []
 
-        with console.status("[cyan]LLM Extracting verbatim passages..."):
+        with status("[cyan]LLM Extracting verbatim passages..."):
             with StreamingIfAllowed(self.llm, False):
                 # these are async calls, one per passage; turn off streaming
                 extracts = self.get_verbatim_extracts(query, passages)
@@ -1198,7 +1246,7 @@ class DocChatAgent(ChatAgent):
             cm = (
                 StreamingIfAllowed(self.llm)
                 if settings.stream
-                else (console.status("LLM Generating final answer..."))
+                else (status("LLM Generating final answer..."))
             )
             stack.enter_context(cm)  # type: ignore
             response = self.get_summary_answer(query, extracts)

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/lance_doc_chat_agent.py

@@ -9,6 +9,7 @@ For usage see:
  - example script `examples/docqa/lance_rag.py`.
 
 """
+
 import json
 import logging
 from typing import Any, Dict, List, Tuple
@@ -162,10 +163,9 @@ class LanceDocChatAgent(DocChatAgent):
         self,
         docs: List[Document],
         split: bool = True,
-        metadata: List[Dict[str, Any]]
-        | Dict[str, Any]
-        | DocMetaData
-        | List[DocMetaData] = [],
+        metadata: (
+            List[Dict[str, Any]] | Dict[str, Any] | DocMetaData | List[DocMetaData]
+        ) = [],
     ) -> int:
         n = super().ingest_docs(docs, split, metadata)
         tbl = self.vecdb.client.open_table(self.vecdb.config.collection_name)

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/neo4j/csv_kg_chat.py

@@ -2,7 +2,6 @@ from typing import List, Optional
 
 import pandas as pd
 import typer
-from rich.console import Console
 
 from langroid.agent.special.neo4j.neo4j_chat_agent import (
     Neo4jChatAgent,
@@ -11,9 +10,9 @@ from langroid.agent.special.neo4j.neo4j_chat_agent import (
 from langroid.agent.tool_message import ToolMessage
 from langroid.language_models.openai_gpt import OpenAIChatModel, OpenAIGPTConfig
 from langroid.parsing.table_loader import read_tabular_data
+from langroid.utils.output import status
 from langroid.vector_store.base import VectorStoreConfig
 
-console = Console()
 app = typer.Typer()
 
 
@@ -159,7 +158,7 @@ class CSVGraphAgent(Neo4jChatAgent):
         Returns:
             str: A string indicating the success or failure of the operation.
         """
-        with console.status("[cyan]Generating graph database..."):
+        with status("[cyan]Generating graph database..."):
             if self.df is not None and hasattr(self.df, "iterrows"):
                 for counter, (index, row) in enumerate(self.df.iterrows()):
                     row_dict = row.to_dict()

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/relevance_extractor_agent.py

@@ -3,6 +3,7 @@ Agent to retrieve relevant segments from a body of text,
 that are relevant to a query.
 
 """
+
 import logging
 from typing import Optional, no_type_check
 

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/retriever_agent.py

@@ -11,6 +11,7 @@ generating final summary answer based on relevant extracts, it just returns
 those extracts.
 See test_retriever_agent.py for example usage.
 """
+
 import logging
 from typing import Sequence
 

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/sql/sql_chat_agent.py

@@ -6,6 +6,7 @@ Functionality includes:
 - adding table and column context
 - asking a question about a SQL schema
 """
+
 import logging
 from typing import Any, Dict, List, Optional, Sequence, Union
 

{langroid-0.1.214 → langroid-0.1.217}/langroid/agent/special/sql/utils/populate_metadata.py

@@ -60,9 +60,9 @@ def populate_metadata(
         Dict: A dictionary containing populated metadata information.
     """
     # Fetch basic metadata info using available tools
-    db_info: Dict[
-        str, Dict[str, Union[str, Dict[str, str]]]
-    ] = populate_metadata_with_schema_tools(metadata=metadata, info=info)
+    db_info: Dict[str, Dict[str, Union[str, Dict[str, str]]]] = (
+        populate_metadata_with_schema_tools(metadata=metadata, info=info)
+    )
 
     # Iterate over tables to update column metadata
     for table_name in db_info.keys():