langroid 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

langroid/agent/base.py

@@ -784,15 +784,51 @@ class Agent(ABC):
         #     ]
         # }
 
+        if not isinstance(json_data, dict):
+            return None
+
         properties = json_data.get("properties")
-        if properties is not None:
+        if isinstance(properties, dict):
             json_data = properties
         request = json_data.get("request")
-        if (
-            request is None
-            or not (isinstance(request, str))
-            or request not in self.llm_tools_handled
-        ):
+
+        if request is None:
+            handled = [self.llm_tools_map[r] for r in self.llm_tools_handled]
+            default_keys = set(ToolMessage.__fields__.keys())
+            request_keys = set(json_data.keys())
+
+            def maybe_parse(tool: type[ToolMessage]) -> Optional[ToolMessage]:
+                all_keys = set(tool.__fields__.keys())
+                non_inherited_keys = all_keys.difference(default_keys)
+                # If the request has any keys not valid for the tool and
+                # does not specify some key specific to the type
+                # (e.g. not just `purpose`), the LLM must explicitly specify `request`
+                if not (
+                    request_keys.issubset(all_keys)
+                    and len(request_keys.intersection(non_inherited_keys)) > 0
+                ):
+                    return None
+
+                try:
+                    return tool.parse_obj(json_data)
+                except ValidationError:
+                    return None
+
+            candidate_tools = list(
+                filter(
+                    lambda t: t is not None,
+                    map(maybe_parse, handled),
+                )
+            )
+
+            # If only one valid candidate exists, we infer
+            # "request" to be the only possible value
+            if len(candidate_tools) == 1:
+                return candidate_tools[0]
+            else:
+                return None
+
+        if not isinstance(request, str) or request not in self.llm_tools_handled:
             return None
 
         message_class = self.llm_tools_map.get(request)

langroid/agent/chat_agent.py

@@ -427,11 +427,11 @@ class ChatAgent(Agent):
                 but the Assistant fn-calling seems to pay attn to these,
                 and if we don't want this, we should set this to False.)
         """
+        if require_recipient and message_class is not None:
+            message_class = message_class.require_recipient()
         super().enable_message_handling(message_class)  # enables handling only
         tools = self._get_tool_list(message_class)
         if message_class is not None:
-            if require_recipient:
-                message_class = message_class.require_recipient()
             request = message_class.default_value("request")
             llm_function = message_class.llm_function_schema(defaults=include_defaults)
             self.llm_functions_map[request] = llm_function

langroid/agent/special/doc_chat_agent.py

@@ -538,12 +538,13 @@ class DocChatAgent(ChatAgent):
         ]
 
     def get_field_values(self, fields: list[str]) -> Dict[str, str]:
-        """Get string-listing of possible values of each filterable field,
+        """Get string-listing of possible values of each field,
         e.g.
         {
             "genre": "crime, drama, mystery, ... (10 more)",
             "certificate": "R, PG-13, PG, R",
         }
+        The field names may have "metadata." prefix, e.g. "metadata.genre".
         """
         field_values: Dict[str, Set[str]] = {}
         # make empty set for each field
@@ -556,8 +557,11 @@ class DocChatAgent(ChatAgent):
         for d in docs:
             # extract fields from d
             doc_field_vals = extract_fields(d, fields)
-            for field, val in doc_field_vals.items():
-                field_values[field].add(val)
+            # the `field` returned by extract_fields may contain only the last
+            # part of the field name, e.g. "genre" instead of "metadata.genre",
+            # so we use the orig_field name to fill in the values
+            for (field, val), orig_field in zip(doc_field_vals.items(), fields):
+                field_values[orig_field].add(val)
         # For each field make a string showing list of possible values,
         # truncate to 20 values, and if there are more, indicate how many
         # more there are, e.g. Genre: crime, drama, mystery, ... (20 more)
@@ -680,7 +684,13 @@ class DocChatAgent(ChatAgent):
                 )
             return response
         if query_str == "":
-            return None
+            return ChatDocument(
+                content=NO_ANSWER + " since query was empty",
+                metadata=ChatDocMetaData(
+                    source="No query provided",
+                    sender=Entity.LLM,
+                ),
+            )
         elif query_str == "?" and self.response is not None:
             return self.justify_response()
         elif (query_str.startswith(("summar", "?")) and self.response is None) or (

langroid/agent/special/lance_doc_chat_agent.py

@@ -22,7 +22,6 @@ from langroid.mytypes import DocMetaData, Document
 from langroid.parsing.table_loader import describe_dataframe
 from langroid.utils.constants import DONE, NO_ANSWER
 from langroid.utils.pydantic_utils import (
-    clean_schema,
     dataframe_to_documents,
 )
 from langroid.vector_store.lancedb import LanceDB
@@ -41,24 +40,26 @@ class LanceDocChatAgent(DocChatAgent):
     def _get_clean_vecdb_schema(self) -> str:
         """Get a cleaned schema of the vector-db, to pass to the LLM
         as part of instructions on how to generate a SQL filter."""
+
+        tbl_pandas = (
+            self.vecdb.client.open_table(self.vecdb.config.collection_name)
+            .search()
+            .limit(1)
+            .to_pandas(flatten=True)
+        )
         if len(self.config.filter_fields) == 0:
-            filterable_fields = (
-                self.vecdb.client.open_table(self.vecdb.config.collection_name)
-                .search()
-                .limit(1)
-                .to_pandas(flatten=True)
-                .columns.tolist()
-            )
+            filterable_fields = tbl_pandas.columns.tolist()
             # drop id, vector, metadata.id, metadata.window_ids, metadata.is_chunk
-            for fields in [
-                "id",
-                "vector",
-                "metadata.id",
-                "metadata.window_ids",
-                "metadata.is_chunk",
-            ]:
-                if fields in filterable_fields:
-                    filterable_fields.remove(fields)
+            filterable_fields = list(
+                set(filterable_fields)
+                - {
+                    "id",
+                    "vector",
+                    "metadata.id",
+                    "metadata.window_ids",
+                    "metadata.is_chunk",
+                }
+            )
             logger.warning(
                 f"""
             No filter_fields set in config, so using these fields as filterable fields:
@@ -69,15 +70,7 @@ class LanceDocChatAgent(DocChatAgent):
 
         if self.from_dataframe:
             return self.df_description
-        schema_dict = clean_schema(
-            self.vecdb.schema,
-            excludes=["id", "vector"],
-        )
-        # intersect config.filter_fields with schema_dict.keys() in case
-        # there are extraneous fields in config.filter_fields
-        filter_fields_set = set(
-            self.config.filter_fields or schema_dict.keys()
-        ).intersection(schema_dict.keys())
+        filter_fields_set = set(self.config.filter_fields)
 
         # remove 'content' from filter_fields_set, even if it's not in filter_fields_set
         filter_fields_set.discard("content")
@@ -85,10 +78,14 @@ class LanceDocChatAgent(DocChatAgent):
         # possible values of filterable fields
         filter_field_values = self.get_field_values(list(filter_fields_set))
 
+        schema_dict: Dict[str, Dict[str, Any]] = dict(
+            (field, {}) for field in filter_fields_set
+        )
         # add field values to schema_dict as another field `values` for each field
         for field, values in filter_field_values.items():
-            if field in schema_dict:
-                schema_dict[field]["values"] = values
+            schema_dict[field]["values"] = values
+            dtype = tbl_pandas[field].dtype.name
+            schema_dict[field]["dtype"] = dtype
         # if self.config.filter_fields is set, restrict to these:
         if len(self.config.filter_fields) > 0:
             schema_dict = {

langroid/agent/special/lance_rag/critic_agent.py

@@ -37,20 +37,30 @@ class QueryPlanCriticConfig(LanceQueryPlanAgentConfig):
     system_message = f"""
     You are an expert at carefully planning a query that needs to be answered
     based on a large collection of documents. These docs have a special `content` field
-    and additional FILTERABLE fields in the SCHEMA below:
+    and additional FILTERABLE fields in the SCHEMA below, along with the 
+    SAMPLE VALUES for each field, and the DTYPE in PANDAS TERMINOLOGY.
     
     {{doc_schema}}
     
+    The ORIGINAL QUERY is handled by a QUERY PLANNER who sends the PLAN to an ASSISTANT,
+    who returns an ANSWER.
+    
     You will receive a QUERY PLAN consisting of:
-    - ORIGINAL QUERY, 
-    - SQL-Like FILTER, WHICH CAN BE EMPTY (and it's fine if results sound reasonable)
+    - ORIGINAL QUERY from the user, which a QUERY PLANNER processes,
+      to create a QUERY PLAN, to be handled by an ASSISTANT.
+    - PANDAS-LIKE FILTER, WHICH CAN BE EMPTY (and it's fine if results sound reasonable)
       FILTER SHOULD ONLY BE USED IF EXPLICITLY REQUIRED BY THE QUERY.
-    - REPHRASED QUERY that will be used to match against the CONTENT (not filterable)
-         of the documents.
+    - REPHRASED QUERY (CANNOT BE EMPTY) that will be used to match against the 
+      CONTENT (not filterable) of the documents.
       In general the REPHRASED QUERY should be relied upon to match the CONTENT 
       of the docs. Thus the REPHRASED QUERY itself acts like a 
       SEMANTIC/LEXICAL/FUZZY FILTER since the Assistant is able to use it to match 
-      the CONTENT of the docs in various ways (semantic, lexical, fuzzy, etc.).         
+      the CONTENT of the docs in various ways (semantic, lexical, fuzzy, etc.). 
+        Keep in mind that the ASSISTANT does NOT know anything about the FILTER fields,
+        so the REPHRASED QUERY should NOT mention ANY FILTER fields.
+        The assistant will answer based on documents whose CONTENTS match the QUERY, 
+        possibly REPHRASED. 
+        !!!!****THE REPHRASED QUERY SHOULD NEVER BE EMPTY****!!!
     - DATAFRAME CALCULATION, which must be a SINGLE LINE calculation (or empty),
         [NOTE ==> This calculation is applied AFTER the FILTER and REPHRASED QUERY.],
     - ANSWER received from an assistant that used this QUERY PLAN.

langroid/agent/special/lance_rag/query_planner_agent.py

@@ -43,23 +43,27 @@ class LanceQueryPlanAgentConfig(ChatAgentConfig):
     You will receive a QUERY, to be answered based on an EXTREMELY LARGE collection
     of documents you DO NOT have access to, but your ASSISTANT does.
     You only know that these documents have a special `content` field
-    and additional FILTERABLE fields in the SCHEMA below:  
+    and additional FILTERABLE fields in the SCHEMA below, along with the 
+    SAMPLE VALUES for each field, and the DTYPE in PANDAS TERMINOLOGY.
     
     {{doc_schema}}
     
     Based on the QUERY and the above SCHEMA, your task is to determine a QUERY PLAN,
     consisting of:
-    -  a FILTER (can be empty string) that would help the ASSISTANT to answer the query.
+    -  a PANDAS-TYPE FILTER (can be empty string) that would help the ASSISTANT to 
+        answer the query.
         Remember the FILTER can refer to ANY fields in the above SCHEMA
         EXCEPT the `content` field of the documents. 
         ONLY USE A FILTER IF EXPLICITLY MENTIONED IN THE QUERY.
         TO get good results, for STRING MATCHES, consider using LIKE instead of =, e.g.
         "CEO LIKE '%Jobs%'" instead of "CEO = 'Steve Jobs'"
-    - a possibly REPHRASED QUERY to be answerable given the FILTER.
+        YOUR FILTER MUST BE A PANDAS-TYPE FILTER, respecting the shown DTYPES.        
+    - a possibly REPHRASED QUERY (CANNOT BE EMPTY) to be answerable given the FILTER.
         Keep in mind that the ASSISTANT does NOT know anything about the FILTER fields,
         so the REPHRASED QUERY should NOT mention ANY FILTER fields.
         The assistant will answer based on documents whose CONTENTS match the QUERY, 
         possibly REPHRASED. 
+        !!!!****THE REPHRASED QUERY SHOULD NEVER BE EMPTY****!!!
     - an OPTIONAL SINGLE-LINE Pandas-dataframe calculation/aggregation string 
         that can be used to calculate the answer to the original query, 
         e.g. "df["rating"].mean()",
@@ -99,7 +103,7 @@ class LanceQueryPlanAgentConfig(ChatAgentConfig):
         hence this computation will give the total deaths in shoplifting crimes.
     ------------- END OF EXAMPLE ----------------
     
-    The FILTER must be a SQL-like condition, e.g. 
+    The FILTER must be a PANDAS-like condition, e.g. 
     "year > 2000 AND genre = 'ScienceFiction'".
     To ensure you get useful results, you should make your FILTER 
     NOT TOO STRICT, e.g. look for approximate match using LIKE, etc.

langroid/agent/special/lance_tools.py

@@ -1,16 +1,21 @@
 import logging
 
 from langroid.agent.tool_message import ToolMessage
-from langroid.pydantic_v1 import BaseModel
+from langroid.pydantic_v1 import BaseModel, Field
 
 logger = logging.getLogger(__name__)
 
 
 class QueryPlan(BaseModel):
-    original_query: str
-    query: str
-    filter: str
-    dataframe_calc: str = ""
+    original_query: str = Field(..., description="The original query for reference")
+    query: str = Field(..., description="A possibly NON-EMPTY rephrased query")
+    filter: str = Field(
+        "",
+        description="Filter condition if needed (or empty if no filter is needed)",
+    )
+    dataframe_calc: str = Field(
+        "", description="An optional Pandas-dataframe calculation/aggregation string"
+    )
 
 
 class QueryPlanTool(ToolMessage):
@@ -19,8 +24,9 @@ class QueryPlanTool(ToolMessage):
     Given a user's query, generate a query <plan> consisting of:
     - <original_query> - the original query for reference
     - <filter> condition if needed (or empty string if no filter is needed)
-    - <query> - a possibly rephrased query that can be used to match the CONTENT
-        of the documents (can be same as <original_query> if no rephrasing is needed)
+    - <query> - a possibly NON-EMPTY rephrased query that can be used to match the 
+        CONTENT of the documents 
+        (can be same as <original_query> if no rephrasing is needed)
     - <dataframe_calc> - a Pandas-dataframe calculation/aggregation string
         that can be used to calculate the answer 
         (or empty string if no calculation is needed).
@@ -34,7 +40,7 @@ class QueryPlanAnswerTool(ToolMessage):
     Assemble query <plan> and <answer>
     """
     plan: QueryPlan
-    answer: str
+    answer: str = Field(..., description="The answer received from the assistant")
 
 
 class QueryPlanFeedbackTool(ToolMessage):