langroid 0.1.161__tar.gz → 0.1.163__tar.gz

{langroid-0.1.161 → langroid-0.1.163}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.161
+Version: 0.1.163
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani
@@ -14,6 +14,8 @@ Provides-Extra: hf-embeddings
 Provides-Extra: litellm
 Provides-Extra: mysql
 Provides-Extra: postgres
+Provides-Extra: sciphi
+Requires-Dist: agent-search (>=0.0.7,<0.0.8) ; extra == "sciphi"
 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)
@@ -53,7 +55,7 @@ Requires-Dist: pdfplumber (>=0.10.2,<0.11.0)
 Requires-Dist: pre-commit (>=3.3.2,<4.0.0)
 Requires-Dist: prettytable (>=3.8.0,<4.0.0)
 Requires-Dist: psycopg2 (>=2.9.7,<3.0.0) ; extra == "postgres"
-Requires-Dist: pydantic (==1.10.11)
+Requires-Dist: pydantic (==1.10.13)
 Requires-Dist: pygithub (>=1.58.1,<2.0.0)
 Requires-Dist: pygments (>=2.15.1,<3.0.0)
 Requires-Dist: pymupdf (>=1.23.3,<2.0.0)
@@ -164,7 +166,7 @@ import langroid.language_models as lm
 # set up LLM
 llm_cfg = lm.OpenAIGPTConfig( # or OpenAIAssistant to use Assistant API 
   # any model served via an OpenAI-compatible API
-  chat_model=lm.OpenAIChatModel.GPT4_TURBO, # or, e.g., "local/ollama/mistral"
+  chat_model=lm.OpenAIChatModel.GPT4_TURBO, # or, e.g., "litellm/ollama/mistral"
 )
 # use LLM directly
 mdl = lm.OpenAIGPT(llm_cfg)

{langroid-0.1.161 → langroid-0.1.163}/README.md

@@ -74,7 +74,7 @@ import langroid.language_models as lm
 # set up LLM
 llm_cfg = lm.OpenAIGPTConfig( # or OpenAIAssistant to use Assistant API 
   # any model served via an OpenAI-compatible API
-  chat_model=lm.OpenAIChatModel.GPT4_TURBO, # or, e.g., "local/ollama/mistral"
+  chat_model=lm.OpenAIChatModel.GPT4_TURBO, # or, e.g., "litellm/ollama/mistral"
 )
 # use LLM directly
 mdl = lm.OpenAIGPT(llm_cfg)

{langroid-0.1.161 → langroid-0.1.163}/langroid/agent/special/doc_chat_agent.py

@@ -107,7 +107,9 @@ class DocChatAgentConfig(ChatAgentConfig):
     debug: bool = False
     stream: bool = True  # allow streaming where needed
     relevance_extractor_config: None | RelevanceExtractorAgentConfig = (
-        RelevanceExtractorAgentConfig()
+        RelevanceExtractorAgentConfig(
+            llm=None  # use the parent's llm unless explicitly set here
+        )
     )
     doc_paths: List[str] = []
     default_paths: List[str] = [
@@ -999,7 +1001,10 @@ class DocChatAgent(ChatAgent):
         if agent_cfg is None:
             # no relevance extraction: simply return passages
             return passages
-
+        if agent_cfg.llm is None:
+            # Use main DocChatAgent's LLM if not provided explicitly:
+            # this reduces setup burden on the user
+            agent_cfg.llm = self.config.llm
         agent_cfg.query = query
         agent_cfg.segment_length = self.config.extraction_granularity
         agent_cfg.llm.stream = False  # disable streaming for concurrent calls

{langroid-0.1.161 → langroid-0.1.163}/langroid/agent/special/relevance_extractor_agent.py

@@ -11,6 +11,7 @@ from rich.console import Console
 from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
 from langroid.agent.chat_document import ChatDocument
 from langroid.agent.tools.segment_extract_tool import SegmentExtractTool
+from langroid.language_models.base import LLMConfig
 from langroid.language_models.openai_gpt import OpenAIGPTConfig
 from langroid.mytypes import Entity
 from langroid.parsing.utils import extract_numbered_segments, number_segments
@@ -21,7 +22,7 @@ logger = logging.getLogger(__name__)
 
 
 class RelevanceExtractorAgentConfig(ChatAgentConfig):
-    llm: OpenAIGPTConfig = OpenAIGPTConfig()
+    llm: LLMConfig | None = OpenAIGPTConfig()
     segment_length: int = 1  # number of sentences per segment
     query: str = ""  # query for relevance extraction
     system_message = """

langroid-0.1.163/langroid/agent/tools/sciphi_search_rag_tool.py

@@ -0,0 +1,76 @@
+"""
+A tool which returns a Search RAG response from the SciPhi API.
+their titles, links, summaries. Since the tool is stateless (i.e. does not need
+access to agent state), it can be enabled for any agent, without having to define a
+special method inside the agent: `agent.enable_message(SciPhiSearchRAGTool)`
+
+Example return output appears as follows below:
+
+<-- Query -->
+```
+Find 3 results on the internet about the LK-99 superconducting material.
+``
+
+<-- Response (compressed for this example)-->
+```
+[ result1 ]
+
+[ result2 ]
+
+[ result3 ]
+
+```
+
+NOTE: Using this tool requires getting an API key from sciphi.ai.
+Setup is as simple as shown below
+# Get a free API key at https://www.sciphi.ai/account
+# export SCIPHI_API_KEY=$MY_SCIPHI_API_KEY before running the agent
+# OR add SCIPHI_API_KEY=$MY_SCIPHI_API_KEY to your .env file
+
+This tool requires installing langroid with the `sciphi` extra, e.g.
+`pip install langroid[sciphi]` or `poetry add langroid[sciphi]`
+(it installs the `agent-search` package from pypi).
+
+For more information, please refer to the official docs:
+https://agent-search.readthedocs.io/en/latest/
+"""
+
+try:
+    from agent_search import SciPhi
+except ImportError:
+    raise ImportError(
+        "You are attempting to use the `agent-search` library;"
+        "To use it, please install langroid with the `sciphi` extra, e.g. "
+        "`pip install langroid[sciphi]` or `poetry add langroid[sciphi]` "
+        "(it installs the `agent-search` package from pypi)."
+    )
+
+from langroid.agent.tool_message import ToolMessage
+
+
+class SciPhiSearchRAGTool(ToolMessage):
+    request: str = "web_search_rag"
+    purpose: str = """
+            To search the web with provider <search_provider> and 
+            return a response summary with llm model <llm_model> the given <query>. 
+            """
+    query: str
+    search_provider: str = "bing"  # bing or agent-search
+    include_related_queries: bool = True
+    llm_model: str = "SciPhi/Sensei-7B-V1"
+    recursive_mode: bool = True
+
+    def handle(self) -> str:
+        rag_response = SciPhi().get_search_rag_response(
+            query=self.query,
+            search_provider=self.search_provider,
+            llm_model=self.llm_model,
+        )
+        result = rag_response["response"]
+        if self.include_related_queries:
+            result = (
+                f"### RAG Response:\n{result}\n\n"
+                + "### Related Queries:\n"
+                + "\n".join(rag_response["related_queries"])
+            )
+        return result  # type: ignore

{langroid-0.1.161 → langroid-0.1.163}/langroid/language_models/openai_gpt.py

@@ -19,6 +19,7 @@ from typing import (
     no_type_check,
 )
 
+import openai
 from httpx import Timeout
 from openai import AsyncOpenAI, OpenAI
 from pydantic import BaseModel
@@ -95,7 +96,19 @@ openAICompletionModelPreferenceList = [
 
 
 if "OPENAI_API_KEY" in os.environ:
-    availableModels = set(map(lambda m: m.id, OpenAI().models.list()))
+    try:
+        availableModels = set(map(lambda m: m.id, OpenAI().models.list()))
+    except openai.AuthenticationError as e:
+        if settings.debug:
+            logging.warning(
+                f"""
+            OpenAI Authentication Error: {e}.
+            ---
+            If you intended to use an OpenAI Model, you should fix this,
+            otherwise you can ignore this warning.
+            """
+            )
+        availableModels = set()
 else:
     availableModels = set()
 
@@ -306,7 +319,8 @@ class OpenAIGPT(LanguageModel):
         # an explicit `export OPENAI_API_KEY=xxx` or `setenv OPENAI_API_KEY xxx`
         # Pydantic's BaseSettings will automatically pick it up from the
         # .env file
-        self.api_key = config.api_key or "xxx"
+        # The config.api_key is ignored when not using an OpenAI model
+        self.api_key = config.api_key if self.is_openai_chat_model() else "xxx"
         self.client = OpenAI(
             api_key=self.api_key,
             base_url=self.api_base,
@@ -352,10 +366,6 @@ class OpenAIGPT(LanguageModel):
         openai_chat_models = [e.value for e in OpenAIChatModel]
         return self.config.chat_model in openai_chat_models
 
-    def _is_openai_completion_model(self) -> bool:
-        openai_completion_models = [e.value for e in OpenAICompletionModel]
-        return self.config.completion_model in openai_completion_models
-
     def chat_context_length(self) -> int:
         """
         Context-length for chat-completion models/endpoints

{langroid-0.1.161 → langroid-0.1.163}/langroid/parsing/utils.py

@@ -101,14 +101,33 @@ def split_paragraphs(text: str) -> List[str]:
     return [para.strip() for para in paras if para.strip()]
 
 
-def number_segments(s: str, len: int = 1) -> str:
+def split_newlines(text: str) -> List[str]:
+    """
+    Split the input text into lines using "\n" as the delimiter.
+
+    Args:
+        text (str): The input text.
+
+    Returns:
+        list: A list of lines.
+    """
+    lines = re.split(r"\n", text)
+    return [line.strip() for line in lines if line.strip()]
+
+
+def number_segments(s: str, granularity: int = 1) -> str:
     """
     Number the segments in a given text, preserving paragraph structure.
-    A segment is a sequence of `len` consecutive sentences.
+    A segment is a sequence of `len` consecutive "sentences", where a "sentence"
+    is either a normal sentence, or if there isn't enough punctuation to properly
+    identify sentences, then we use a pseudo-sentence via heuristics (split by newline
+    or failing that, just split every 40 words). The goal here is simply to number
+    segments at a reasonable granularity so the LLM can identify relevant segments,
+    in the RelevanceExtractorAgent.
 
     Args:
         s (str): The input text.
-        len (int): The number of sentences in a segment.
+        granularity (int): The number of sentences in a segment.
             If this is -1, then the entire text is treated as a single segment,
             and is numbered as <#1#>.
 
@@ -119,7 +138,7 @@ def number_segments(s: str, len: int = 1) -> str:
         >>> number_segments("Hello world! How are you? Have a good day.")
         '<#1#> Hello world! <#2#> How are you? <#3#> Have a good day.'
     """
-    if len < 0:
+    if granularity < 0:
         return "<#1#> " + s
     numbered_text = []
     count = 0
@@ -127,9 +146,34 @@ def number_segments(s: str, len: int = 1) -> str:
     paragraphs = split_paragraphs(s)
     for paragraph in paragraphs:
         sentences = nltk.sent_tokenize(paragraph)
+        # Some docs are problematic (e.g. resumes) and have no (or too few) periods,
+        # so we can't split usefully into sentences.
+        # We try a series of heuristics to split into sentences,
+        # until the avg num words per sentence is less than 40.
+        avg_words_per_sentence = sum(
+            len(nltk.word_tokenize(sentence)) for sentence in sentences
+        ) / len(sentences)
+        if avg_words_per_sentence > 40:
+            sentences = split_newlines(paragraph)
+        avg_words_per_sentence = sum(
+            len(nltk.word_tokenize(sentence)) for sentence in sentences
+        ) / len(sentences)
+        if avg_words_per_sentence > 40:
+            # Still too long, just split on every 40 words
+            sentences = []
+            for sentence in nltk.sent_tokenize(paragraph):
+                words = nltk.word_tokenize(sentence)
+                for i in range(0, len(words), 40):
+                    # if there are less than 20 words left after this,
+                    # just add them to the last sentence and break
+                    if len(words) - i < 20:
+                        sentences.append(" ".join(words[i:]))
+                        break
+                    else:
+                        sentences.append(" ".join(words[i : i + 40]))
         for i, sentence in enumerate(sentences):
-            num = count // len + 1
-            number_prefix = f"<#{num}#>" if count % len == 0 else ""
+            num = count // granularity + 1
+            number_prefix = f"<#{num}#>" if count % granularity == 0 else ""
             sentence = f"{number_prefix} {sentence}"
             count += 1
             sentences[i] = sentence
@@ -140,7 +184,7 @@ def number_segments(s: str, len: int = 1) -> str:
 
 
 def number_sentences(s: str) -> str:
-    return number_segments(s, len=1)
+    return number_segments(s, granularity=1)
 
 
 def parse_number_range_list(specs: str) -> List[int]:

{langroid-0.1.161 → langroid-0.1.163}/langroid/vector_store/lancedb.py

@@ -210,13 +210,10 @@ class LanceDB(VectorStore):
                     return
                 else:
                     logger.warning("Recreating fresh collection")
-        tbl = self.client.create_table(
-            collection_name, schema=self.schema, mode="overwrite"
-        )
+        self.client.create_table(collection_name, schema=self.schema, mode="overwrite")
         if settings.debug:
             level = logger.getEffectiveLevel()
             logger.setLevel(logging.INFO)
-            logger.info(tbl.schema)
             logger.setLevel(level)
 
     def add_documents(self, documents: Sequence[Document]) -> None:

{langroid-0.1.161 → langroid-0.1.163}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langroid"
-version = "0.1.161"
+version = "0.1.163"
 description = "Harness LLMs with Multi-Agent Programming"
 authors = ["Prasad Chalasani <pchalasani@gmail.com>"]
 readme = "README.md"
@@ -47,7 +47,7 @@ types-requests = "^2.31.0.1"
 pyparsing = "^3.0.9"
 nltk = "^3.8.1"
 qdrant-client = "^1.7.0"
-pydantic = "1.10.11"
+pydantic = "1.10.13"
 pypdf = "^3.12.2"
 momento = "^1.10.2"
 pandas = "^2.0.3"
@@ -81,6 +81,7 @@ scrapy = "^2.11.0"
 async-generator = "^1.10"
 lancedb = "^0.4.1"
 pytest-redis = "^3.0.2"
+agent-search = {version = "^0.0.7", optional = true}
 python-docx = "^1.1.0"
 
 [tool.poetry.extras]
@@ -89,6 +90,7 @@ hf-embeddings = ["sentence-transformers", "torch"]
 postgres = ["psycopg2", "pytest-postgresql"]
 mysql = ["pymysql", "pytest-mysql"]
 litellm = ["litellm"]
+sciphi = ["agent-search"]
 
 
 [tool.poetry.group.dev.dependencies]