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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.10
+Version: 0.2.12
 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
@@ -16,17 +16,17 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.12.29
+Requires-Dist: llama-index==0.12.30
 Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.6
-Requires-Dist: llama-index-llms-openai==0.3.32
+Requires-Dist: llama-index-llms-openai==0.3.35
 Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1
 Requires-Dist: llama-index-llms-fireworks==0.3.2
-Requires-Dist: llama-index-llms-cohere==0.4.0
+Requires-Dist: llama-index-llms-cohere==0.4.1
 Requires-Dist: llama-index-llms-gemini==0.4.14
 Requires-Dist: llama-index-llms-bedrock==0.3.8
 Requires-Dist: llama-index-tools-yahoo-finance==0.3.0
@@ -141,7 +141,6 @@ from vectara_agentic.tools import VectaraToolFactory
 
 vec_factory = VectaraToolFactory(
     vectara_api_key=os.environ['VECTARA_API_KEY'],
-    vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
     vectara_corpus_key=os.environ['VECTARA_CORPUS_KEY']
 )
 ```
@@ -162,7 +161,6 @@ tickers = {
 }
 
 class QueryFinancialReportsArgs(BaseModel):
-    query: str = Field(..., description="The user query.")
     year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
     ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 
@@ -176,6 +174,8 @@ query_financial_reports_tool = vec_factory.create_rag_tool(
 )
 ```
 
+Note that we only defined the `year` and `ticker` arguments. The `query` argument is automatically added by `vectara-agentic`.
+
 See the [docs](https://vectara.github.io/py-vectara-agentic/latest/) for additional arguments to customize your Vectara RAG tool.
 
 ### 3. Create other tools (optional)

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/README.md

@@ -73,7 +73,6 @@ from vectara_agentic.tools import VectaraToolFactory
 
 vec_factory = VectaraToolFactory(
     vectara_api_key=os.environ['VECTARA_API_KEY'],
-    vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
     vectara_corpus_key=os.environ['VECTARA_CORPUS_KEY']
 )
 ```
@@ -94,7 +93,6 @@ tickers = {
 }
 
 class QueryFinancialReportsArgs(BaseModel):
-    query: str = Field(..., description="The user query.")
     year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
     ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 
@@ -108,6 +106,8 @@ query_financial_reports_tool = vec_factory.create_rag_tool(
 )
 ```
 
+Note that we only defined the `year` and `ticker` arguments. The `query` argument is automatically added by `vectara-agentic`.
+
 See the [docs](https://vectara.github.io/py-vectara-agentic/latest/) for additional arguments to customize your Vectara RAG tool.
 
 ### 3. Create other tools (optional)

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/requirements.txt

@@ -1,14 +1,14 @@
-llama-index==0.12.29
+llama-index==0.12.30
 llama-index-indices-managed-vectara==0.4.2
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0
 llama-index-agent-openai==0.4.6
-llama-index-llms-openai==0.3.32
+llama-index-llms-openai==0.3.35
 llama-index-llms-anthropic==0.6.10
 llama-index-llms-together==0.3.1
 llama-index-llms-groq==0.3.1
 llama-index-llms-fireworks==0.3.2
-llama-index-llms-cohere==0.4.0
+llama-index-llms-cohere==0.4.1
 llama-index-llms-gemini==0.4.14
 llama-index-llms-bedrock==0.3.8
 llama-index-tools-yahoo-finance==0.3.0

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/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.12}/vectara_agentic/_prompts.py

@@ -22,8 +22,8 @@ GENERAL_INSTRUCTIONS = """
   3) If a tool fails, try other tools that might be appropriate to gain the information you need.
 - If after retrying you can't get the information or answer the question, respond with "I don't know".
 - If a tool provides citations or references in markdown as part of its response, include the references in your response.
-- Ensure that every URL in your responses includes descriptive anchor text that clearly explains what the user can expect from the linked content.
-  Avoid using generic terms like “source” or “reference” as the anchor text.
+- Ensure that every URL in your response includes descriptive anchor text that clearly explains what the user can expect from the linked content.
+  Avoid using generic terms like “source” or “reference”, or the full URL, as the anchor text.
 - If a tool returns in the metadata a valid URL pointing to a PDF file, along with page number - then combine the URL and page number in the response.
   For example, if the URL returned from the tool is "https://example.com/doc.pdf" and "page=5", then the combined URL would be "https://example.com/doc.pdf#page=5".
   If a tool returns in the metadata invalid URLs or an URL empty (e.g. "[[1]()]"), ignore it and do not include that citation or reference in your response.
@@ -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.12}/vectara_agentic/_version.py

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

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/vectara_agentic/agent.py

@@ -661,7 +661,7 @@ class Agent:
         for tool in self.tools:
             if hasattr(tool, 'metadata'):
                 if detailed:
-                    print(f"- {tool.metadata.name} - {tool.metadata.description}")
+                    print(f"- {tool.metadata.description}")
                 else:
                     print(f"- {tool.metadata.name}")
             else:

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/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,39 +87,38 @@ 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:
-            return [f"Error ({str(e)}) occurred while counting number of rows"]
+            return [f"Error ({str(e)}) occurred while counting number of rows, check your query."]
         num_rows = int(count_rows[0].text)
         if num_rows > self.max_rows:
             return [
@@ -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}, check your 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.12}/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.12}/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
@@ -161,6 +173,21 @@ class VectaraTool(FunctionTool):
     ) -> ToolOutput:
         try:
             return super().call(*args, ctx=ctx, **kwargs)
+        except TypeError as e:
+            sig = inspect.signature(self.metadata.fn_schema)
+            valid_parameters = list(sig.parameters.keys())
+            params_str = ", ".join(valid_parameters)
+
+            err_output = ToolOutput(
+                tool_name=self.metadata.name,
+                content=(
+                    f"Wrong argument used when calling {self.metadata.name}: {str(e)}. "
+                    f"Valid arguments: {params_str}. please call the tool again with the correct arguments."
+                ),
+                raw_input={"args": args, "kwargs": kwargs},
+                raw_output={"response": str(e)},
+            )
+            return err_output
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
@@ -175,6 +202,21 @@ class VectaraTool(FunctionTool):
     ) -> ToolOutput:
         try:
             return await super().acall(*args, ctx=ctx, **kwargs)
+        except TypeError as e:
+            sig = inspect.signature(self.metadata.fn_schema)
+            valid_parameters = list(sig.parameters.keys())
+            params_str = ", ".join(valid_parameters)
+
+            err_output = ToolOutput(
+                tool_name=self.metadata.name,
+                content=(
+                    f"Wrong argument used when calling {self.metadata.name}: {str(e)}. "
+                    f"Valid arguments: {params_str}. please call the tool again with the correct arguments."
+                ),
+                raw_input={"args": args, "kwargs": kwargs},
+                raw_output={"response": str(e)},
+            )
+            return err_output
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
@@ -184,66 +226,129 @@ class VectaraTool(FunctionTool):
             )
             return err_output
 
+
 def _create_tool_from_dynamic_function(
     function: Callable[..., ToolOutput],
     tool_name: str,
     tool_description: str,
-    base_params: list[inspect.Parameter],
-    tool_args_schema: type[BaseModel],
+    base_params_model: Type[BaseModel],  # Now a Pydantic BaseModel
+    tool_args_schema: Type[BaseModel],
 ) -> VectaraTool:
-    """
-    Create a VectaraTool from a dynamic function, including
-    setting the function signature and creating the tool schema.
-    """
     fields = {}
-    for param in base_params:
-        default_value = param.default if param.default != inspect.Parameter.empty else ...
-        fields[param.name] = (param.annotation, default_value)
+    base_params = []
+
+    # Create inspect.Parameter objects for base_params_model fields.
+    for param_name, model_field in base_params_model.model_fields.items():
+        field_type = base_params_model.__annotations__.get(
+            param_name, str
+        )  # default to str if not found
+        default_value = (
+            model_field.default
+            if model_field.default is not None
+            else inspect.Parameter.empty
+        )
+        base_params.append(
+            inspect.Parameter(
+                param_name,
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=default_value,
+                annotation=field_type,
+            )
+        )
+        fields[param_name] = (
+            field_type,
+            model_field.default if model_field.default is not None else ...,
+        )
+
+    # Add tool_args_schema fields to the fields dict if not already included.
+    # Also add them to the function signature by creating new inspect.Parameter objects.
     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 ...
-            fields[field_name] = (field_info.annotation, default_value)
-    fn_schema = create_model(f"{tool_name}", **fields)
-
-    schema_params = [
-        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,
-        )
-        for field_name, field_info in tool_args_schema.model_fields.items()
-        if field_name not in [p.name for p in base_params]
-    ]
-    all_params = base_params + schema_params
+            default_value = (
+                field_info.default if field_info.default is not None else ...
+            )
+            field_type = tool_args_schema.__annotations__.get(field_name, None)
+            fields[field_name] = (field_type, default_value)
+            # Append these fields to the signature.
+            base_params.append(
+                inspect.Parameter(
+                    field_name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    default=(
+                        default_value
+                        if default_value is not ...
+                        else inspect.Parameter.empty
+                    ),
+                    annotation=field_type,
+                )
+            )
 
+    # Create the dynamic schema with both base_params_model and tool_args_schema fields.
+    fn_schema = create_model(f"{tool_name}_schema", **fields)
+
+    # Combine parameters into a function signature.
+    all_params = base_params[:]  # Now all_params contains parameters from both models.
     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]
-    sig = inspect.Signature(required_params + optional_params)
-    function.__signature__ = sig
+    optional_params = [
+        p for p in all_params if p.default is not inspect.Parameter.empty
+    ]
+    function.__signature__ = inspect.Signature(required_params + optional_params)
     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 = []
+    # Build a docstring using parameter descriptions from the BaseModels.
+    params_str = ",\n    ".join(
+        f"{p.name}: {p.annotation.__name__ if hasattr(p.annotation, '__name__') else p.annotation}"
+        for p in all_params
+    )
+    signature_line = f"{tool_name}(\n    {params_str}\n) -> dict[str, Any]"
+    doc_lines = [
+        signature_line,
+        "",
+        tool_description.strip(),
+        "",
+        "Args:",
+    ]
     for param in all_params:
-        annotation = param.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"
+        description = ""
+        if param.name in base_params_model.model_fields:
+            description = base_params_model.model_fields[param.name].description
+        elif param.name in tool_args_schema.model_fields:
+            description = tool_args_schema.model_fields[param.name].description
+        if not description:
+            description = "No description provided."
+        type_name = (
+            param.annotation.__name__
+            if hasattr(param.annotation, "__name__")
+            else str(param.annotation)
+        )
+        default_text = (
+            f", default={param.default!r}"
+            if param.default is not inspect.Parameter.empty
+            else ""
+        )
+        doc_lines.append(f"    {param.name} ({type_name}){default_text}: {description}")
+    doc_lines.append("")
+    doc_lines.append("Returns:")
+    return_desc = getattr(
+        function, "__return_description__", "A dictionary containing the result data."
+    )
+    doc_lines.append(f"    dict[str, Any]: {return_desc}")
+    function.__doc__ = "\n".join(doc_lines)
 
-    # Create the tool
     tool = VectaraTool.from_defaults(
         fn=function,
         name=tool_name,
-        description=function_str + "\n" + tool_description,
+        description=function.__doc__,
         fn_schema=fn_schema,
         tool_type=ToolType.QUERY,
     )
     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 +362,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 +417,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 +432,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 +446,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 +478,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 +586,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 +601,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 +643,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 +651,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__,
@@ -551,23 +663,31 @@ 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),
-        ]
-        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.
-        """
+        class SearchToolBaseParams(BaseModel):
+            """Model for the base parameters of the search tool."""
+            query: str = Field(
+                ...,
+                description="The search query to perform, always in the form of a question.",
+            )
+            top_k: int = Field(
+                10, description="The number of top documents to retrieve."
+            )
+            summarize: bool = Field(
+                True,
+                description="Flag that indicates whether to summarize the retrieved documents.",
+            )
+
+        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."
+        )
 
         tool = _create_tool_from_dynamic_function(
             search_function,
             tool_name,
             search_tool_extra_desc,
-            base_params,
+            SearchToolBaseParams,
             tool_args_schema,
         )
         return tool
@@ -684,7 +804,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 +823,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,
@@ -792,18 +918,23 @@ class VectaraToolFactory:
             )
             return out
 
-        base_params = [
-            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
-        ]
+        class RagToolBaseParams(BaseModel):
+            """Model for the base parameters of the RAG tool."""
+            query: str = Field(
+                ...,
+                description="The search query to perform, always in the form of a question",
+            )
+
         tool = _create_tool_from_dynamic_function(
             rag_function,
             tool_name,
             tool_description,
-            base_params,
+            RagToolBaseParams,
             tool_args_schema,
         )
         return tool
 
+
 class ToolsFactory:
     """
     A factory class for creating agent tools.
@@ -812,7 +943,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 +979,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 +996,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 +1016,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 +1031,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 +1065,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 +1104,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 +1133,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.12}/vectara_agentic/utils.py

@@ -103,7 +103,7 @@ def get_llm(
     elif model_provider == ModelProvider.ANTHROPIC:
         llm = Anthropic(
             model=model_name, temperature=0,
-            max_tokens=max_tokens, cache_idx=2,
+            max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
@@ -124,7 +124,8 @@ def get_llm(
         from llama_index.llms.groq import Groq
         llm = Groq(
             model=model_name, temperature=0,
-            is_function_calling_model=True, max_tokens=max_tokens
+            is_function_calling_model=True,
+            max_tokens=max_tokens
         )
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.10
+Version: 0.2.12
 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
@@ -16,17 +16,17 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: llama-index==0.12.29
+Requires-Dist: llama-index==0.12.30
 Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.6
-Requires-Dist: llama-index-llms-openai==0.3.32
+Requires-Dist: llama-index-llms-openai==0.3.35
 Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1
 Requires-Dist: llama-index-llms-fireworks==0.3.2
-Requires-Dist: llama-index-llms-cohere==0.4.0
+Requires-Dist: llama-index-llms-cohere==0.4.1
 Requires-Dist: llama-index-llms-gemini==0.4.14
 Requires-Dist: llama-index-llms-bedrock==0.3.8
 Requires-Dist: llama-index-tools-yahoo-finance==0.3.0
@@ -141,7 +141,6 @@ from vectara_agentic.tools import VectaraToolFactory
 
 vec_factory = VectaraToolFactory(
     vectara_api_key=os.environ['VECTARA_API_KEY'],
-    vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
     vectara_corpus_key=os.environ['VECTARA_CORPUS_KEY']
 )
 ```
@@ -162,7 +161,6 @@ tickers = {
 }
 
 class QueryFinancialReportsArgs(BaseModel):
-    query: str = Field(..., description="The user query.")
     year: int | str = Field(..., description=f"The year this query relates to. An integer between {min(years)} and {max(years)} or a string specifying a condition on the year (example: '>2020').")
     ticker: str = Field(..., description=f"The company ticker. Must be a valid ticket symbol from the list {tickers.keys()}.")
 
@@ -176,6 +174,8 @@ query_financial_reports_tool = vec_factory.create_rag_tool(
 )
 ```
 
+Note that we only defined the `year` and `ticker` arguments. The `query` argument is automatically added by `vectara-agentic`.
+
 See the [docs](https://vectara.github.io/py-vectara-agentic/latest/) for additional arguments to customize your Vectara RAG tool.
 
 ### 3. Create other tools (optional)

{vectara_agentic-0.2.10 → vectara_agentic-0.2.12}/vectara_agentic.egg-info/requires.txt

@@ -1,14 +1,14 @@
-llama-index==0.12.29
+llama-index==0.12.30
 llama-index-indices-managed-vectara==0.4.2
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0
 llama-index-agent-openai==0.4.6
-llama-index-llms-openai==0.3.32
+llama-index-llms-openai==0.3.35
 llama-index-llms-anthropic==0.6.10
 llama-index-llms-together==0.3.1
 llama-index-llms-groq==0.3.1
 llama-index-llms-fireworks==0.3.2
-llama-index-llms-cohere==0.4.0
+llama-index-llms-cohere==0.4.1
 llama-index-llms-gemini==0.4.14
 llama-index-llms-bedrock==0.3.8
 llama-index-tools-yahoo-finance==0.3.0