langroid 0.1.195__tar.gz → 0.1.197__tar.gz

{langroid-0.1.195 → langroid-0.1.197}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langroid
-Version: 0.1.195
+Version: 0.1.197
 Summary: Harness LLMs with Multi-Agent Programming
 License: MIT
 Author: Prasad Chalasani

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/chat_agent.py

@@ -225,14 +225,22 @@ class ChatAgent(Agent):
         enabled_classes: List[Type[ToolMessage]] = list(self.llm_tools_map.values())
         if len(enabled_classes) == 0:
             return "You can ask questions in natural language."
-
         json_instructions = "\n\n".join(
             [
-                msg_cls.json_instructions()
+                msg_cls.json_instructions(tool=self.config.use_tools)
                 for _, msg_cls in enumerate(enabled_classes)
                 if msg_cls.default_value("request") in self.llm_tools_usable
             ]
         )
+        # if any of the enabled classes has json_group_instructions, then use that,
+        # else fall back to ToolMessage.json_group_instructions
+        for msg_cls in enabled_classes:
+            if hasattr(msg_cls, "json_group_instructions") and callable(
+                getattr(msg_cls, "json_group_instructions")
+            ):
+                return msg_cls.json_group_instructions().format(
+                    json_instructions=json_instructions
+                )
         return ToolMessage.json_group_instructions().format(
             json_instructions=json_instructions
         )

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/chat_document.py

@@ -84,7 +84,7 @@ class ChatDocument(Document):
             json_data = json.loads(j)
             tool = json_data.get("request")
             if tool is not None:
-                tools.append(tool)
+                tools.append(str(tool))
         return tools
 
     def log_fields(self) -> ChatDocLoggerFields:

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/special/doc_chat_agent.py

@@ -22,7 +22,6 @@ from rich import print
 from rich.console import Console
 from rich.prompt import Prompt
 
-from langroid.agent.base import Agent
 from langroid.agent.batch import run_batch_tasks
 from langroid.agent.chat_agent import ChatAgent, ChatAgentConfig
 from langroid.agent.chat_document import ChatDocMetaData, ChatDocument
@@ -1219,11 +1218,13 @@ class DocChatAgent(ChatAgent):
             )
         prompt = f"""
         {instruction}
+        
+        FULL TEXT:
         {full_text}
         """.strip()
         with StreamingIfAllowed(self.llm):
-            summary = Agent.llm_response(self, prompt)
-            return summary  # type: ignore
+            summary = ChatAgent.llm_response(self, prompt)
+            return summary
 
     def justify_response(self) -> ChatDocument | None:
         """Show evidence for last response"""

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/special/neo4j/neo4j_chat_agent.py

@@ -31,10 +31,17 @@ NEO4J_ERROR_MSG = "There was an error in your Cypher Query"
 # TOOLS to be used by the agent
 
 
-class CypherQueryTool(ToolMessage):
+class CypherRetrievalTool(ToolMessage):
     request: str = "retrieval_query"
-    purpose: str = """Use this tool to send the Generated Cypher query based on 
-    provided text description and schema."""
+    purpose: str = """Use this tool to send the Cypher query to retreive data from the 
+    graph database based provided text description and schema."""
+    cypher_query: str
+
+
+class CypherCreationTool(ToolMessage):
+    request: str = "create_query"
+    purpose: str = """Use this tool to send the Cypher query to create 
+    entities/relationships in the graph database."""
     cypher_query: str
 
 
@@ -238,12 +245,12 @@ class Neo4jChatAgent(ChatAgent):
         else:
             print("[red]Database is not deleted!")
 
-    def retrieval_query(self, msg: CypherQueryTool) -> str:
-        """
-        Handle a CypherQueryTool message by executing a Cypher query and
+    def retrieval_query(self, msg: CypherRetrievalTool) -> str:
+        """ "
+        Handle a CypherRetrievalTool message by executing a Cypher query and
         returning the result.
         Args:
-            msg (CypherQueryTool): The tool-message to handle.
+            msg (CypherRetrievalTool): The tool-message to handle.
 
         Returns:
             str: The result of executing the cypher_query.
@@ -257,6 +264,25 @@ class Neo4jChatAgent(ChatAgent):
         else:
             return str(response.data)
 
+    def create_query(self, msg: CypherCreationTool) -> str:
+        """ "
+        Handle a CypherCreationTool message by executing a Cypher query and
+        returning the result.
+        Args:
+            msg (CypherCreationTool): The tool-message to handle.
+
+        Returns:
+            str: The result of executing the cypher_query.
+        """
+        query = msg.cypher_query
+
+        logger.info(f"Executing Cypher query: {query}")
+        response = self.write_query(query)
+        if response.success:
+            return "Cypher query executed successfully"
+        else:
+            return str(response.data)
+
     # TODO: There are various ways to get the schema. The current one uses the func
     # `read_query`, which requires post processing to identify whether the response upon
     # the schema query is valid. Another way is to isolate this func from `read_query`.
@@ -293,7 +319,8 @@ class Neo4jChatAgent(ChatAgent):
         message = self._format_message()
         self.config.system_message = self.config.system_message.format(mode=message)
         super().__init__(self.config)
-        self.enable_message(CypherQueryTool)
+        self.enable_message(CypherRetrievalTool)
+        self.enable_message(CypherCreationTool)
         self.enable_message(GraphSchemaTool)
 
     def _format_message(self) -> str:

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/special/neo4j/utils/system_message.py

@@ -9,14 +9,16 @@ Use the tool/function to learn more about the database schema."""
 
 SCHEMA_TOOLS_SYS_MSG = """You are a data scientist and expert in Knowledge Graphs, 
 with expertise in answering questions by querying Neo4j database.
-You do not have access to the database directly, so you will need to use the 
-`retrieval_query` tool/function-call to answer questions.
+You have access to the following tools: 
+ - `retrieval_query` tool/function-call to retreive infomration from the graph database
+to answer questions.
 
-Use the `get_schema` tool/function-call to get all the node labels, relationship types,
- and property keys available in your Neo4j database.
+ - `create_query` tool/function-call to execute cypher query that creates
+   entities/relationships in the graph database.
+
+ - `get_schema` tool/function-call to get all the node labels, relationship 
+ types, and property keys available in your Neo4j database.
 
-ONLY the node labels, relationship types, and property keys listed in the specified 
-above should be used in the generated queries. 
 You must be smart about using the right node labels, relationship types, and property
 keys based on the english description. If you are thinking of using a node label,
 relationship type, or property key that does not exist, you are probably on the wrong 
@@ -31,8 +33,13 @@ You could make a sequence of Neo4j queries to help you write the final query.
 Also if you receive a null or other unexpected result,
 (a) make sure you use the available TOOLs correctly, and 
 (b) see if you have made an assumption in your Neo4j query, and try another way, 
-   or use `run_query` to explore the database contents before submitting your 
+   or use `retrieval_query` to explore the database contents before submitting your 
    final query. 
+(c) USE `create_query` tool/function-call to execute cypher query that creates
+   entities/relationships in the graph database.
+
+(d) USE `get_schema` tool/function-call to get all the node labels, relationship 
+ types, and property keys available in your Neo4j database.
 
 Start by asking what I would like to know about the data.
 

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/special/sql/sql_chat_agent.py

@@ -7,11 +7,11 @@ Functionality includes:
 - asking a question about a SQL schema
 """
 import logging
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Any, Dict, List, Optional, Sequence, Union
 
 from rich import print
 from rich.console import Console
-from sqlalchemy import MetaData, Row, create_engine, text
+from sqlalchemy import MetaData, Row, create_engine, inspect, text
 from sqlalchemy.engine import Engine
 from sqlalchemy.exc import SQLAlchemyError
 from sqlalchemy.orm import Session, sessionmaker
@@ -73,6 +73,7 @@ class SQLChatAgentConfig(ChatAgentConfig):
     vecdb: None | VectorStoreConfig = None
     context_descriptions: Dict[str, Dict[str, Union[str, Dict[str, str]]]] = {}
     use_schema_tools: bool = False
+    multi_schema: bool = False
 
     """
     Optional, but strongly recommended, context descriptions for tables, columns, 
@@ -87,6 +88,9 @@ class SQLChatAgentConfig(ChatAgentConfig):
     is another table name and the value is a description of the relationship to 
     that table.
 
+    If multi_schema support is enabled, the tables names in the description
+    should be of the form 'schema_name.table_name'.
+
     For example:
     {
         'table1': {
@@ -143,14 +147,37 @@ class SQLChatAgent(ChatAgent):
         """Initialize the database metadata."""
         if self.engine is None:
             raise ValueError("Database engine is None")
+        self.metadata: MetaData | List[MetaData] = []
 
-        self.metadata = MetaData()
-        self.metadata.reflect(self.engine)
-        logger.info(
-            "SQLChatAgent initialized with database: %s and tables: %s",
-            self.engine,
-            self.metadata.tables,
-        )
+        if self.config.multi_schema:
+            logger.info(
+                "Initializing SQLChatAgent with database: %s",
+                self.engine,
+            )
+
+            self.metadata = []
+            inspector = inspect(self.engine)
+
+            for schema in inspector.get_schema_names():
+                metadata = MetaData(schema=schema)
+                metadata.reflect(self.engine)
+                self.metadata.append(metadata)
+
+                logger.info(
+                    "Initializing SQLChatAgent with database: %s, schema: %s, "
+                    "and tables: %s",
+                    self.engine,
+                    schema,
+                    metadata.tables,
+                )
+        else:
+            self.metadata = MetaData()
+            self.metadata.reflect(self.engine)
+            logger.info(
+                "SQLChatAgent initialized with database: %s and tables: %s",
+                self.engine,
+                self.metadata.tables,
+            )
 
     def _init_table_metadata(self) -> None:
         """Initialize metadata for the tables present in the database."""
@@ -319,6 +346,10 @@ class SQLChatAgent(ChatAgent):
         Returns:
             str: The names of all tables in the database.
         """
+        if isinstance(self.metadata, list):
+            table_names = [", ".join(md.tables.keys()) for md in self.metadata]
+            return ", ".join(table_names)
+
         return ", ".join(self.metadata.tables.keys())
 
     def get_table_schema(self, msg: GetTableSchemaTool) -> str:

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/special/sql/utils/populate_metadata.py

@@ -1,10 +1,11 @@
-from typing import Dict, Union
+from typing import Dict, List, Union
 
 from sqlalchemy import MetaData
 
 
 def populate_metadata_with_schema_tools(
-    metadata: MetaData, info: Dict[str, Dict[str, Union[str, Dict[str, str]]]]
+    metadata: MetaData | List[MetaData],
+    info: Dict[str, Dict[str, Union[str, Dict[str, str]]]],
 ) -> Dict[str, Dict[str, Union[str, Dict[str, str]]]]:
     """
     Extracts information from an SQLAlchemy database's metadata and combines it
@@ -18,28 +19,35 @@ def populate_metadata_with_schema_tools(
     Returns:
         Dict[str, Dict[str, Any]]: A dictionary with table and context information.
     """
-
     db_info: Dict[str, Dict[str, Union[str, Dict[str, str]]]] = {}
 
-    # Create empty metadata dictionary with column datatypes
-    for table_name, table in metadata.tables.items():
-        # Populate tables with empty descriptions
-        db_info[str(table_name)] = {
-            "description": info[table_name]["description"] or "",
-            "columns": {},
-        }
-
-        for column in table.columns:
-            # Populate columns with datatype
-            db_info[str(table_name)]["columns"][str(column.name)] = (  # type: ignore
-                str(column.type)
-            )
+    def populate_metadata(md: MetaData) -> None:
+        # Create empty metadata dictionary with column datatypes
+        for table_name, table in md.tables.items():
+            # Populate tables with empty descriptions
+            db_info[table_name] = {
+                "description": info[table_name]["description"] or "",
+                "columns": {},
+            }
+
+            for column in table.columns:
+                # Populate columns with datatype
+                db_info[table_name]["columns"][str(column.name)] = (  # type: ignore
+                    str(column.type)
+                )
+
+    if isinstance(metadata, list):
+        for md in metadata:
+            populate_metadata(md)
+    else:
+        populate_metadata(metadata)
 
     return db_info
 
 
 def populate_metadata(
-    metadata: MetaData, info: Dict[str, Dict[str, Union[str, Dict[str, str]]]]
+    metadata: MetaData | List[MetaData],
+    info: Dict[str, Dict[str, Union[str, Dict[str, str]]]],
 ) -> Dict[str, Dict[str, Union[str, Dict[str, str]]]]:
     """
     Populate metadata based on the provided database metadata and additional info.
@@ -51,7 +59,6 @@ def populate_metadata(
     Returns:
         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]]]

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/task.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import copy
 import logging
+import re
 from collections import Counter
 from types import SimpleNamespace
 from typing import (
@@ -781,17 +782,20 @@ class Task:
         # handle routing instruction in result if any,
         # of the form PASS=<recipient>
         content = msg.content if isinstance(msg, ChatDocument) else msg
+        content = content.strip()
         if PASS in content and PASS_TO not in content:
             return True, None
         if PASS_TO in content and content.split(":")[1] != "":
             return True, content.split(":")[1]
-        if SEND_TO in content and content.split(":")[1] != "":
-            recipient = content.split(":")[1]
+        if SEND_TO in content and (send_parts := re.split(r"[,: ]", content))[1] != "":
+            # assume syntax is SEND_TO:<recipient> <content>
+            # or SEND_TO:<recipient>,<content> or SEND_TO:<recipient>:<content>
+            recipient = send_parts[1].strip()
             # get content to send, clean out routing instruction, and
             # start from 1 char after SEND_TO:<recipient>,
             # because we expect there is either a blank or some other separator
             # after the recipient
-            content_to_send = content.replace(f"{SEND_TO}:{recipient}", "").strip()[1:]
+            content_to_send = content.replace(f"{SEND_TO}{recipient}", "").strip()[1:]
             # if no content then treat same as PASS_TO
             if content_to_send == "":
                 return True, recipient

{langroid-0.1.195 → langroid-0.1.197}/langroid/agent/tool_message.py

@@ -16,7 +16,10 @@ from docstring_parser import parse
 from pydantic import BaseModel
 
 from langroid.language_models.base import LLMFunctionSpec
-from langroid.utils.pydantic_utils import _recursive_purge_dict_key
+from langroid.utils.pydantic_utils import (
+    _recursive_purge_dict_key,
+    generate_simple_schema,
+)
 
 
 class ToolMessage(ABC, BaseModel):
@@ -101,22 +104,30 @@ class ToolMessage(ABC, BaseModel):
         return properties.get(f, {}).get("default", None)
 
     @classmethod
-    def json_instructions(cls) -> str:
+    def json_instructions(cls, tool: bool = False) -> str:
         """
         Default Instructions to the LLM showing how to use the tool/function-call.
         Works for GPT4 but override this for weaker LLMs if needed.
+
+        Args:
+            tool: instructions for Langroid-native tool use? (e.g. for non-OpenAI LLM)
+                (or else it would be for OpenAI Function calls)
         Returns:
             str: instructions on how to use the message
         """
+        # TODO: when we attempt to use a "simpler schema"
+        # (i.e. all nested fields explicit without definitions),
+        # we seem to get worse results, so we turn it off for now
+        param_dict = (
+            # cls.simple_schema() if tool else
+            cls.llm_function_schema(request=True).parameters
+        )
         return textwrap.dedent(
             f"""
             TOOL: {cls.default_value("request")}
             PURPOSE: {cls.default_value("purpose")} 
             JSON FORMAT: {
-                json.dumps(
-                    cls.llm_function_schema(request=True).parameters,
-                    indent=4,
-                )
+                json.dumps(param_dict, indent=4)
             }
             {"EXAMPLE: " + cls.usage_example() if cls.examples() else ""}
             """.lstrip()
@@ -210,3 +221,14 @@ class ToolMessage(ABC, BaseModel):
             description=cls.default_value("purpose"),
             parameters=parameters,
         )
+
+    @classmethod
+    def simple_schema(cls) -> Dict[str, Any]:
+        """
+        Return a simplified schema for the message, with only the request and
+        required fields.
+        Returns:
+            Dict[str, Any]: simplified schema
+        """
+        schema = generate_simple_schema(cls, exclude=["result", "purpose"])
+        return schema

{langroid-0.1.195 → langroid-0.1.197}/langroid/language_models/base.py

@@ -39,8 +39,8 @@ class LLMConfig(BaseSettings):
     chat_model: str = ""
     completion_model: str = ""
     temperature: float = 0.0
-    chat_context_length: int = 1024
-    completion_context_length: int = 1024
+    chat_context_length: int = 8000
+    completion_context_length: int = 8000
     max_output_tokens: int = 1024  # generate at most this many tokens
     # if input length + max_output_tokens > context length of model,
     # we will try shortening requested output

{langroid-0.1.195 → langroid-0.1.197}/langroid/parsing/json.py

@@ -1,4 +1,5 @@
 import json
+import re
 from typing import Any, Iterator, List
 
 from pyparsing import nestedExpr, originalTextFor
@@ -44,6 +45,40 @@ def get_json_candidates(s: str) -> List[str]:
         return []
 
 
+def replace_undefined(s: str, undefined_placeholder: str = '"<undefined>"') -> str:
+    """
+    Replace undefined values in a potential json str with a placeholder.
+
+    Args:
+    - s (str): The potential JSON string to parse.
+    - undefined_placeholder (str): The placeholder or error message
+        for undefined values.
+
+    Returns:
+    - str: The (potential) JSON string with undefined values
+        replaced by the placeholder.
+    """
+
+    # Preprocess the string to replace undefined values with the placeholder
+    # This regex looks for patterns like ": <identifier>" and replaces them
+    # with the placeholder.
+    # It's a simple approach and might need adjustments for complex cases
+    # This is an attempt to handle cases where a weak LLM may produce
+    # a JSON-like string without quotes around some values, e.g.
+    # {"rent": DO-NOT-KNOW }
+    preprocessed_s = re.sub(
+        r":\s*([a-zA-Z_][a-zA-Z_0-9\-]*)", f": {undefined_placeholder}", s
+    )
+
+    # Now, attempt to parse the preprocessed string as JSON
+    try:
+        return preprocessed_s
+    except Exception:
+        # If parsing fails, return an error message instead
+        # (this should be rare after preprocessing)
+        return s
+
+
 def extract_top_level_json(s: str) -> List[str]:
     """Extract all top-level JSON-formatted substrings from a given string.
 
@@ -53,15 +88,16 @@ def extract_top_level_json(s: str) -> List[str]:
     Returns:
         List[str]: A list of top-level JSON-formatted substrings.
     """
-    # Find JSON object and array candidates using regular expressions
+    # Find JSON object and array candidates
     json_candidates = get_json_candidates(s)
 
     normalized_candidates = [
         candidate.replace("\\{", "{").replace("\\}", "}").replace("\\_", "_")
         for candidate in json_candidates
     ]
+    candidates = [replace_undefined(candidate) for candidate in normalized_candidates]
     top_level_jsons = [
-        candidate for candidate in normalized_candidates if is_valid_json(candidate)
+        candidate for candidate in candidates if is_valid_json(candidate)
     ]
 
     return top_level_jsons

{langroid-0.1.195 → langroid-0.1.197}/langroid/utils/pydantic_utils.py

@@ -135,6 +135,53 @@ def flatten_pydantic_model(
     return create_model("FlatModel", __base__=base_model, **flattened_fields)
 
 
+def get_field_names(model: Type[BaseModel]) -> List[str]:
+    """Get all field names from a possibly nested Pydantic model."""
+    mdl = flatten_pydantic_model(model)
+    fields = list(mdl.__fields__.keys())
+    # fields may be like a__b__c , so we only want the last part
+    return [f.split("__")[-1] for f in fields]
+
+
+def generate_simple_schema(
+    model: Type[BaseModel], exclude: List[str] = []
+) -> Dict[str, Any]:
+    """
+    Generates a JSON schema for a Pydantic model,
+    with options to exclude specific fields.
+
+    This function traverses the Pydantic model's fields, including nested models,
+    to generate a dictionary representing the JSON schema. Fields specified in
+    the exclude list will not be included in the generated schema.
+
+    Args:
+        model (Type[BaseModel]): The Pydantic model class to generate the schema for.
+        exclude (List[str]): A list of string field names to be excluded from the
+                             generated schema. Defaults to an empty list.
+
+    Returns:
+        Dict[str, Any]: A dictionary representing the JSON schema of the provided model,
+                        with specified fields excluded.
+    """
+    if hasattr(model, "__fields__"):
+        output: Dict[str, Any] = {}
+        for field_name, field in model.__fields__.items():
+            if field_name in exclude:
+                continue  # Skip excluded fields
+
+            field_type = field.type_
+            if issubclass(field_type, BaseModel):
+                # Recursively generate schema for nested models
+                output[field_name] = generate_simple_schema(field_type, exclude)
+            else:
+                # Represent the type as a string here
+                output[field_name] = {"type": field_type.__name__}
+        return output
+    else:
+        # Non-model type, return a simplified representation
+        return {"type": model.__name__}
+
+
 def flatten_pydantic_instance(
     instance: BaseModel,
     prefix: str = "",

{langroid-0.1.195 → langroid-0.1.197}/langroid/utils/system.py

@@ -1,10 +1,12 @@
 import getpass
 import hashlib
+import importlib
 import inspect
 import logging
 import shutil
 import socket
 import traceback
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -15,6 +17,39 @@ DELETION_ALLOWED_PATHS = [
 ]
 
 
+class LazyLoad:
+    """Lazy loading of modules or classes."""
+
+    def __init__(self, import_path: str) -> None:
+        self.import_path = import_path
+        self._target = None
+        self._is_target_loaded = False
+
+    def _load_target(self) -> None:
+        if not self._is_target_loaded:
+            try:
+                # Attempt to import as a module
+                self._target = importlib.import_module(self.import_path)  # type: ignore
+            except ImportError:
+                # If module import fails, attempt to import as a
+                # class or function from a module
+                module_path, attr_name = self.import_path.rsplit(".", 1)
+                module = importlib.import_module(module_path)
+                self._target = getattr(module, attr_name)
+            self._is_target_loaded = True
+
+    def __getattr__(self, name: str) -> Any:
+        self._load_target()
+        return getattr(self._target, name)
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        self._load_target()
+        if callable(self._target):
+            return self._target(*args, **kwargs)
+        else:
+            raise TypeError(f"{self.import_path!r} object is not callable")
+
+
 def rmdir(path: str) -> bool:
     """
     Remove a directory recursively.

{langroid-0.1.195 → langroid-0.1.197}/pyproject.toml

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