vectara-agentic 0.2.10__tar.gz → 0.2.11__tar.gz

{vectara_agentic-0.2.10/vectara_agentic.egg-info → vectara_agentic-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.10
+Version: 0.2.11
 Summary: A Python package for creating AI Assistants and AI Agents with Vectara
 Home-page: https://github.com/vectara/py-vectara-agentic
 Author: Ofer Mendelevitch

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/_callback.py

@@ -154,7 +154,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
         elif event_type == CBEventType.AGENT_STEP:
             self._handle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
+            print(f"Exception in handle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
@@ -168,7 +168,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
         elif event_type == CBEventType.AGENT_STEP:
             await self._ahandle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
+            print(f"Exception in ahandle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/_prompts.py

@@ -37,10 +37,11 @@ GENERAL_INSTRUCTIONS = """
 - If including latex equations in the markdown response, make sure the equations are on a separate line and enclosed in double dollar signs.
 - Always respond in the language of the question, and in text (no images, videos or code).
 - If you are provided with database tools use them for analytical queries (such as counting, calculating max, min, average, sum, or other statistics).
-  For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, and x_load_sample_data, where 'x' in the database name.
-  The x_list_tables tool provides a list of available tables in the x database. Always use x_list_tables before using other database tools, to understand valid table names.
-  Before using the x_load_data with a SQL query, always follow these steps:
-  - Use the x_describe_tables tool to understand the schema of each table.
+  For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, x_load_unique_values, and x_load_sample_data, where 'x' in the database name.
+  for example, if the database name is "ev", the tools are: ev_list_tables, ev_load_data, ev_describe_tables, ev_load_unique_values, and ev_load_sample_data.
+  Before using the x_load_data with a SQL query, always follow these discovery steps:
+  - call the x_list_tables tool to list of available tables in the x database.
+  - Call the x_describe_tables tool to understand the schema of each table you want to query data from.
   - Use the x_load_unique_values tool to understand the unique values in each column.
     Sometimes the user may ask for a specific column value, but the actual value in the table may be different, and you will need to use the correct value.
   - Use the x_load_sample_data tool to understand the column names, and typical values in each column.

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.10"
+__version__ = "0.2.11"

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/db_tools.py

@@ -15,7 +15,6 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.exc import NoSuchTableError
 from sqlalchemy.schema import CreateTable
 
-from llama_index.core.readers.base import BaseReader
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
 from llama_index.core.schema import Document
 from llama_index.core.tools.function_tool import FunctionTool
@@ -25,7 +24,7 @@ from llama_index.core.tools.utils import create_schema_from_function
 
 AsyncCallable = Callable[..., Awaitable[Any]]
 
-class DatabaseTools(BaseReader):
+class DatabaseTools:
     """Database tools for vectara-agentic
     This class provides a set of tools to interact with a database.
     It allows you to load data, list tables, describe tables, and load unique values.
@@ -49,9 +48,11 @@ class DatabaseTools(BaseReader):
         user: Optional[str] = None,
         password: Optional[str] = None,
         dbname: Optional[str] = None,
+        tool_name_prefix: str = "db",
         **kwargs: Any,
     ) -> None:
         self.max_rows = max_rows
+        self.tool_name_prefix = tool_name_prefix
 
         if sql_database:
             self.sql_database = sql_database
@@ -86,35 +87,34 @@ class DatabaseTools(BaseReader):
             func = getattr(self, fn_name)
         except AttributeError:
             return None
-        name = fn_name
+        name = self.tool_name_prefix + "_" + fn_name if self.tool_name_prefix else fn_name
         docstring = func.__doc__ or ""
         description = f"{name}{signature(func)}\n{docstring}"
         fn_schema = create_schema_from_function(fn_name, getattr(self, fn_name))
         return ToolMetadata(name=name, description=description, fn_schema=fn_schema)
 
-    def _load_data(self, query: str) -> List[Document]:
+    def _load_data(self, sql_query: str) -> List[Document]:
         documents = []
         with self.sql_database.engine.connect() as connection:
-            if query is None:
+            if sql_query is None:
                 raise ValueError("A query parameter is necessary to filter the data")
-            result = connection.execute(text(query))
+            result = connection.execute(text(sql_query))
             for item in result.fetchall():
                 doc_str = ", ".join([str(entry) for entry in item])
                 documents.append(Document(text=doc_str))
         return documents
 
-    def load_data(self, *args: Any, **load_kwargs: Any) -> List[str]:
+    def load_data(self, sql_query: str) -> List[str]:
         """Query and load data from the Database, returning a list of Documents.
         Args:
-            query (str): an SQL query to filter tables and rows.
+            sql_query (str): an SQL query to filter tables and rows.
         Returns:
-            List[Document]: a list of Document objects from the database.
+            List[str]: a list of Document objects from the database.
         """
-        query = args[0] if args else load_kwargs.get("args",{}).get("query")
-        if query is None:
+        if sql_query is None:
             raise ValueError("A query parameter is necessary to filter the data")
 
-        count_query = f"SELECT COUNT(*) FROM ({query})"
+        count_query = f"SELECT COUNT(*) FROM ({sql_query})"
         try:
             count_rows = self._load_data(count_query)
         except Exception as e:
@@ -126,9 +126,9 @@ class DatabaseTools(BaseReader):
                 "Please refactor your query to make it return less rows. "
             ]
         try:
-            res = self._load_data(query)
+            res = self._load_data(sql_query)
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while executing the query {query}"]
+            return [f"Error ({str(e)}) occurred while executing the query {sql_query}"]
         return [d.text for d in res]
 
     def load_sample_data(self, table_name: str, num_rows: int = 25) -> Any:
@@ -141,6 +141,11 @@ class DatabaseTools(BaseReader):
         Returns:
             Any: The result of the database query.
         """
+        if table_name not in self.list_tables():
+            return (
+                f"Table {table_name} does not exist in the database."
+                f"Valid table names are: {self.list_tables()}"
+            )
         try:
             res = self._load_data(f"SELECT * FROM {table_name} LIMIT {num_rows}")
         except Exception as e:
@@ -162,6 +167,15 @@ class DatabaseTools(BaseReader):
             str: A string representation of the table schemas.
         """
         table_names = tables or [table.name for table in self._metadata.sorted_tables]
+        if len(table_names) == 0:
+            return "You must specify at least one table name to describe."
+        for table_name in table_names:
+            if table_name not in self.list_tables():
+                return (
+                    f"Table {table_name} does not exist in the database."
+                    f"Valid table names are: {self.list_tables()}"
+                )
+
         table_schemas = []
         for table_name in table_names:
             table = next(
@@ -186,6 +200,12 @@ class DatabaseTools(BaseReader):
         Returns:
             Any: the result of the database query
         """
+        if table_name not in self.list_tables():
+            return (
+                f"Table {table_name} does not exist in the database."
+                f"Valid table names are: {self.list_tables()}"
+            )
+
         res = {}
         try:
             for column in columns:

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/sub_query_workflow.py

@@ -3,6 +3,7 @@ This module contains the SubQuestionQueryEngine workflow, which is a workflow
 that takes a user question and a list of tools, and outputs a list of sub-questions.
 """
 
+import re
 import json
 from pydantic import BaseModel
 
@@ -109,17 +110,27 @@ class SubQuestionQueryWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Sub-questions are {response}")
 
-        if not str(response):
+        response_str = str(response)
+        if not response_str:
             raise ValueError(
                 f"No response from LLM when generating sub-questions for query {original_query}"
             )
-
         try:
-            sub_questions = json.loads(str(response))["sub_questions"]
-            if not sub_questions:
-                raise ValueError("LLM returned empty sub-questions list")
-        except (json.JSONDecodeError, KeyError) as e:
-            raise ValueError(f"Invalid LLM response format: {response}") from e
+            data = json.loads(response_str)
+        except json.JSONDecodeError as e1:
+            match = re.search(r"\{.*\}", response_str, re.DOTALL)
+            if not match:
+                raise ValueError(f"Invalid LLM response format: {response_str}") from e1
+            try:
+                data = json.loads(match.group(0))
+            except json.JSONDecodeError as e2:
+                raise ValueError(f"Invalid LLM response format: {response_str}") from e2
+
+        sub_questions = data.get("sub_questions")
+        if sub_questions is None:
+            raise ValueError(f"Invalid LLM response format: {response_str}")
+        if not sub_questions:
+            raise ValueError("LLM returned empty sub-questions list")
 
         await ctx.set("sub_question_count", len(sub_questions))
         for question in sub_questions:
@@ -273,8 +284,23 @@ class SequentialSubQuestionsWorkflow(Workflow):
         if not str(response):
             raise ValueError(f"No response from LLM for query {original_query}")
 
-        response_obj = json.loads(str(response))
-        sub_questions = response_obj["sub_questions"]
+        response_str = str(response)
+        try:
+            response_obj = json.loads(response_str)
+        except json.JSONDecodeError as e1:
+            match = re.search(r"\{.*\}", response_str, re.DOTALL)
+            if not match:
+                raise ValueError(
+                    f"Failed to extract JSON object with subquestions from LLM response: {response_str}"
+                ) from e1
+            try:
+                response_obj = json.loads(match.group(0))
+            except json.JSONDecodeError as e2:
+                raise ValueError(
+                    f"Failed to extract JSON object with subquestions from LLM response: {response_str}"
+                ) from e2
+
+        sub_questions = response_obj.get("sub_questions")
 
         await ctx.set("sub_questions", sub_questions)
         if await ctx.get("verbose"):
@@ -305,7 +331,6 @@ class SequentialSubQuestionsWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Answer is {response}")
 
-        sub_questions = await ctx.get("sub_questions")
         if ev.num + 1 < len(sub_questions):
             return self.QueryEvent(
                 question=sub_questions[ev.num + 1],

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11}/vectara_agentic/tools.py

@@ -55,13 +55,15 @@ LI_packages = {
             "send_message": ToolType.ACTION,
             "fetch_channel": ToolType.QUERY,
         }
-    }
+    },
 }
 
+
 class VectaraToolMetadata(ToolMetadata):
     """
     A subclass of ToolMetadata adding the tool_type attribute.
     """
+
     tool_type: ToolType
 
     def __init__(self, tool_type: ToolType, **kwargs):
@@ -88,7 +90,9 @@ class VectaraTool(FunctionTool):
         fn: Optional[Callable[..., Any]] = None,
         async_fn: Optional[AsyncCallable] = None,
     ) -> None:
-        metadata_dict = metadata.dict() if hasattr(metadata, 'dict') else metadata.__dict__
+        metadata_dict = (
+            metadata.dict() if hasattr(metadata, "dict") else metadata.__dict__
+        )
         vm = VectaraToolMetadata(tool_type=tool_type, **metadata_dict)
         super().__init__(fn, vm, async_fn)
 
@@ -107,19 +111,26 @@ class VectaraTool(FunctionTool):
         tool_type: ToolType = ToolType.QUERY,
     ) -> "VectaraTool":
         tool = FunctionTool.from_defaults(
-            fn, name, description, return_direct, fn_schema, async_fn, tool_metadata,
-            callback, async_callback
+            fn,
+            name,
+            description,
+            return_direct,
+            fn_schema,
+            async_fn,
+            tool_metadata,
+            callback,
+            async_callback,
         )
         vectara_tool = cls(
-            tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn,
+            tool_type=tool_type,
+            fn=tool.fn,
+            metadata=tool.metadata,
+            async_fn=tool.async_fn,
         )
         return vectara_tool
 
     def __str__(self) -> str:
-        return (
-            f"Tool(name={self.metadata.name}, "
-            f"Tool metadata={self.metadata})"
-        )
+        return f"Tool(name={self.metadata.name}, " f"Tool metadata={self.metadata})"
 
     def __repr__(self) -> str:
         return str(self)
@@ -137,19 +148,20 @@ class VectaraTool(FunctionTool):
         # If schema is a dict-like object, compare the dict representation
         try:
             # Try to get schema as dict if possible
-            if hasattr(self.metadata.fn_schema, 'schema'):
+            if hasattr(self.metadata.fn_schema, "schema"):
                 self_schema = self.metadata.fn_schema.schema
                 other_schema = other.metadata.fn_schema.schema
 
                 # Compare only properties and required fields
-                self_props = self_schema.get('properties', {})
-                other_props = other_schema.get('properties', {})
+                self_props = self_schema.get("properties", {})
+                other_props = other_schema.get("properties", {})
 
-                self_required = self_schema.get('required', [])
-                other_required = other_schema.get('required', [])
+                self_required = self_schema.get("required", [])
+                other_required = other_schema.get("required", [])
 
-                return (self_props.keys() == other_props.keys() and
-                        set(self_required) == set(other_required))
+                return self_props.keys() == other_props.keys() and set(
+                    self_required
+                ) == set(other_required)
         except Exception:
             # If any exception occurs during schema comparison, fall back to name comparison
             pass
@@ -184,6 +196,7 @@ class VectaraTool(FunctionTool):
             )
             return err_output
 
+
 def _create_tool_from_dynamic_function(
     function: Callable[..., ToolOutput],
     tool_name: str,
@@ -197,11 +210,17 @@ def _create_tool_from_dynamic_function(
     """
     fields = {}
     for param in base_params:
-        default_value = param.default if param.default != inspect.Parameter.empty else ...
+        default_value = (
+            param.default if param.default != inspect.Parameter.empty else ...
+        )
         fields[param.name] = (param.annotation, default_value)
     for field_name, field_info in tool_args_schema.model_fields.items():
         if field_name not in fields:
-            default_value = field_info.default if field_info.default is not PydanticUndefined else ...
+            default_value = (
+                field_info.default
+                if field_info.default is not PydanticUndefined
+                else ...
+            )
             fields[field_name] = (field_info.annotation, default_value)
     fn_schema = create_model(f"{tool_name}", **fields)
 
@@ -209,8 +228,16 @@ def _create_tool_from_dynamic_function(
         inspect.Parameter(
             name=field_name,
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-            default=field_info.default if field_info.default is not PydanticUndefined else inspect.Parameter.empty,
-            annotation=field_info.annotation if hasattr(field_info, 'annotation') else field_info,
+            default=(
+                field_info.default
+                if field_info.default is not PydanticUndefined
+                else inspect.Parameter.empty
+            ),
+            annotation=(
+                field_info.annotation
+                if hasattr(field_info, "annotation")
+                else field_info
+            ),
         )
         for field_name, field_info in tool_args_schema.model_fields.items()
         if field_name not in [p.name for p in base_params]
@@ -218,17 +245,21 @@ def _create_tool_from_dynamic_function(
     all_params = base_params + schema_params
 
     required_params = [p for p in all_params if p.default is inspect.Parameter.empty]
-    optional_params = [p for p in all_params if p.default is not inspect.Parameter.empty]
+    optional_params = [
+        p for p in all_params if p.default is not inspect.Parameter.empty
+    ]
     sig = inspect.Signature(required_params + optional_params)
     function.__signature__ = sig
     function.__annotations__["return"] = dict[str, Any]
-    function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+    function.__name__ = re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
 
     # Create the tool function signature string
     param_strs = []
     for param in all_params:
         annotation = param.annotation
-        type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+        type_name = (
+            annotation.__name__ if hasattr(annotation, "__name__") else str(annotation)
+        )
         param_strs.append(f"{param.name}: {type_name}")
     args_str = ", ".join(param_strs)
     function_str = f"{tool_name}({args_str}) -> str"
@@ -243,7 +274,10 @@ def _create_tool_from_dynamic_function(
     )
     return tool
 
-def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str) -> str:
+
+def _build_filter_string(
+    kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str
+) -> str:
     """
     Build filter string for Vectara from kwargs
     """
@@ -257,9 +291,9 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
 
         # Determine the prefix for the key. Valid values are "doc" or "part"
         # default to 'doc' if not specified
-        tool_args_dict = tool_args_type.get(key, {'type': 'doc', 'is_list': False})
+        tool_args_dict = tool_args_type.get(key, {"type": "doc", "is_list": False})
         prefix = tool_args_dict.get(key, "doc")
-        is_list = tool_args_dict.get('is_list', False)
+        is_list = tool_args_dict.get("is_list", False)
 
         if prefix not in ["doc", "part"]:
             raise ValueError(
@@ -312,12 +346,10 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
                     range_conditions.append(f"{prefix}.{key} {operator} {end_val}")
 
                 # Join the range conditions with AND
-                filter_parts.append('( ' + " AND ".join(range_conditions) + ' )')
+                filter_parts.append("( " + " AND ".join(range_conditions) + " )")
                 continue
 
-            raise ValueError(
-                f"Range operator requires two values for {key}: {value}"
-            )
+            raise ValueError(f"Range operator requires two values for {key}: {value}")
 
         # Check if value contains a known comparison operator at the start
         matched_operator = None
@@ -329,7 +361,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
         # Break down operator from value
         # e.g. val_str = ">2022" --> operator = ">", rhs = "2022"
         if matched_operator:
-            rhs = val_str[len(matched_operator):].strip()
+            rhs = val_str[len(matched_operator) :].strip()
 
             if matched_operator in numeric_only_ops:
                 # Must be numeric
@@ -343,7 +375,9 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
                 if rhs.isdigit() or is_float(rhs):
                     filter_parts.append(f"{prefix}.{key}{matched_operator}{rhs}")
                 elif rhs.lower() in ["true", "false"]:
-                    filter_parts.append(f"{prefix}.{key}{matched_operator}{rhs.lower()}")
+                    filter_parts.append(
+                        f"{prefix}.{key}{matched_operator}{rhs.lower()}"
+                    )
                 else:
                     # For string operands, wrap them in quotes
                     filter_parts.append(f"{prefix}.{key}{matched_operator}'{rhs}'")
@@ -373,6 +407,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
     else:
         return fixed_filter or filter_str
 
+
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -480,7 +515,9 @@ class VectaraToolFactory:
             top_k = kwargs.pop("top_k", 10)
             summarize = kwargs.pop("summarize", True)
             try:
-                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+                filter_string = _build_filter_string(
+                    kwargs, tool_args_type, fixed_filter
+                )
             except ValueError as e:
                 return ToolOutput(
                     tool_name=search_function.__name__,
@@ -493,7 +530,11 @@ class VectaraToolFactory:
                 summary_enabled=False,
                 similarity_top_k=top_k,
                 reranker=reranker,
-                rerank_k=rerank_k if rerank_k * self.num_corpora <= 100 else int(100 / self.num_corpora),
+                rerank_k=(
+                    rerank_k
+                    if rerank_k * self.num_corpora <= 100
+                    else int(100 / self.num_corpora)
+                ),
                 rerank_limit=rerank_limit,
                 rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
@@ -531,9 +572,7 @@ class VectaraToolFactory:
             if summarize:
                 summaries_dict = asyncio.run(
                     summarize_documents(
-                        self.vectara_corpus_key,
-                        self.vectara_api_key,
-                        list(unique_ids)
+                        self.vectara_corpus_key, self.vectara_api_key, list(unique_ids)
                     )
                 )
                 for doc_id, metadata in docs:
@@ -541,7 +580,9 @@ class VectaraToolFactory:
                     tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
             else:
                 for doc_id, metadata in docs:
-                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+                    tool_output += (
+                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+                    )
 
             out = ToolOutput(
                 tool_name=search_function.__name__,
@@ -552,16 +593,29 @@ class VectaraToolFactory:
             return out
 
         base_params = [
-            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
-            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
-            inspect.Parameter("summarize", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True, annotation=bool),
+            inspect.Parameter(
+                "query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str
+            ),
+            inspect.Parameter(
+                "top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int
+            ),
+            inspect.Parameter(
+                "summarize",
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=True,
+                annotation=bool,
+            ),
         ]
-        search_tool_extra_desc = tool_description + "\n" + """
+        search_tool_extra_desc = (
+            tool_description
+            + "\n"
+            + """
         This tool is meant to perform a search for relevant documents, it is not meant for asking questions.
         The response includes metadata about each relevant document.
         If summarize=True, it also includes a summary of each document, but takes a lot longer to respond,
         so avoid using it unless necessary.
         """
+        )
 
         tool = _create_tool_from_dynamic_function(
             search_function,
@@ -684,7 +738,9 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             try:
-                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+                filter_string = _build_filter_string(
+                    kwargs, tool_args_type, fixed_filter
+                )
             except ValueError as e:
                 return ToolOutput(
                     tool_name=rag_function.__name__,
@@ -701,7 +757,11 @@ class VectaraToolFactory:
                 summary_prompt_name=vectara_summarizer,
                 prompt_text=vectara_prompt_text,
                 reranker=reranker,
-                rerank_k=rerank_k if rerank_k * self.num_corpora <= 100 else int(100 / self.num_corpora),
+                rerank_k=(
+                    rerank_k
+                    if rerank_k * self.num_corpora <= 100
+                    else int(100 / self.num_corpora)
+                ),
                 rerank_limit=rerank_limit,
                 rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
@@ -793,7 +853,9 @@ class VectaraToolFactory:
             return out
 
         base_params = [
-            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+            inspect.Parameter(
+                "query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str
+            ),
         ]
         tool = _create_tool_from_dynamic_function(
             rag_function,
@@ -804,6 +866,7 @@ class VectaraToolFactory:
         )
         return tool
 
+
 class ToolsFactory:
     """
     A factory class for creating agent tools.
@@ -812,7 +875,9 @@ class ToolsFactory:
     def __init__(self, agent_config: AgentConfig = None) -> None:
         self.agent_config = agent_config
 
-    def create_tool(self, function: Callable, tool_type: ToolType = ToolType.QUERY) -> VectaraTool:
+    def create_tool(
+        self, function: Callable, tool_type: ToolType = ToolType.QUERY
+    ) -> VectaraTool:
         """
         Create a tool from a function.
 
@@ -846,7 +911,9 @@ class ToolsFactory:
         """
         # Dynamically install and import the module
         if tool_package_name not in LI_packages:
-            raise ValueError(f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic.")
+            raise ValueError(
+                f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic."
+            )
 
         module_name = f"llama_index.tools.{tool_package_name}"
         module = importlib.import_module(module_name)
@@ -861,11 +928,18 @@ class ToolsFactory:
                 tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
             if isinstance(func_type, dict):
                 if tool_spec_name not in func_type.keys():
-                    raise ValueError(f"Tool spec {tool_spec_name} not found in package {tool_package_name}.")
+                    raise ValueError(
+                        f"Tool spec {tool_spec_name} not found in package {tool_package_name}."
+                    )
                 tool_type = func_type[tool_spec_name]
             else:
                 tool_type = func_type
-            vtool = VectaraTool(tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn)
+            vtool = VectaraTool(
+                tool_type=tool_type,
+                fn=tool.fn,
+                metadata=tool.metadata,
+                async_fn=tool.async_fn,
+            )
             vtools.append(vtool)
         return vtools
 
@@ -874,7 +948,10 @@ class ToolsFactory:
         Create a list of standard tools.
         """
         tc = ToolsCatalog(self.agent_config)
-        return [self.create_tool(tool) for tool in [tc.summarize_text, tc.rephrase_text, tc.critique_text]]
+        return [
+            self.create_tool(tool)
+            for tool in [tc.summarize_text, tc.rephrase_text, tc.critique_text]
+        ]
 
     def guardrail_tools(self) -> List[FunctionTool]:
         """
@@ -886,7 +963,9 @@ class ToolsFactory:
         """
         Create a list of financial tools.
         """
-        return self.get_llama_index_tools(tool_package_name="yahoo_finance", tool_spec_name="YahooFinanceToolSpec")
+        return self.get_llama_index_tools(
+            tool_package_name="yahoo_finance", tool_spec_name="YahooFinanceToolSpec"
+        )
 
     def legal_tools(self) -> List[FunctionTool]:
         """
@@ -918,7 +997,9 @@ class ToolsFactory:
                 """,
             )
 
-        return [self.create_tool(tool) for tool in [summarize_legal_text, critique_as_judge]]
+        return [
+            self.create_tool(tool) for tool in [summarize_legal_text, critique_as_judge]
+        ]
 
     def database_tools(
         self,
@@ -955,16 +1036,22 @@ class ToolsFactory:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         if sql_database:
-            dbt = DatabaseTools(sql_database=sql_database)
+            dbt = DatabaseTools(
+                tool_name_prefix=tool_name_prefix,
+                sql_database=sql_database,
+                max_rows=max_rows,
+            )
         else:
             if scheme in ["postgresql", "mysql", "sqlite", "mssql", "oracle"]:
                 dbt = DatabaseTools(
+                    tool_name_prefix=tool_name_prefix,
                     scheme=scheme,
                     host=host,
                     port=port,
                     user=user,
                     password=password,
                     dbname=dbname,
+                    max_rows=max_rows,
                 )
             else:
                 raise ValueError(
@@ -978,14 +1065,14 @@ class ToolsFactory:
         for tool in tools:
             if content_description:
                 tool.metadata.description = (
-                    tool.metadata.description + f"The database tables include data about {content_description}."
+                    tool.metadata.description
+                    + f"The database tables include data about {content_description}."
                 )
-            if len(tool_name_prefix) > 0:
-                tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
             vtool = VectaraTool(
                 tool_type=ToolType.QUERY,
-                fn=tool.fn, async_fn=tool.async_fn,
-                metadata=tool.metadata
+                fn=tool.fn,
+                async_fn=tool.async_fn,
+                metadata=tool.metadata,
             )
             vtools.append(vtool)
         return vtools

{vectara_agentic-0.2.10 → vectara_agentic-0.2.11/vectara_agentic.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.10
+Version: 0.2.11
 Summary: A Python package for creating AI Assistants and AI Agents with Vectara
 Home-page: https://github.com/vectara/py-vectara-agentic
 Author: Ofer Mendelevitch