vectara-agentic 0.2.11__py3-none-any.whl → 0.2.12__py3-none-any.whl

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.

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.11"
+__version__ = "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/db_tools.py

@@ -118,7 +118,7 @@ class DatabaseTools:
         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 [
@@ -128,7 +128,7 @@ class DatabaseTools:
         try:
             res = self._load_data(sql_query)
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while executing the query {sql_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:

vectara_agentic/tools.py

@@ -173,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,
@@ -187,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,
@@ -201,74 +231,115 @@ 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:
+    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 = (
-            param.default if param.default != inspect.Parameter.empty else ...
+            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 ...,
         )
-        fields[param.name] = (param.annotation, default_value)
+
+    # 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 ...
+                field_info.default if field_info.default is not None 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
+            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
+    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)
 
-    # 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
+        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 = (
-            annotation.__name__ if hasattr(annotation, "__name__") else str(annotation)
+            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 ""
         )
-        param_strs.append(f"{param.name}: {type_name}")
-    args_str = ", ".join(param_strs)
-    function_str = f"{tool_name}({args_str}) -> str"
+        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,
     )
@@ -592,36 +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,
-            ),
-        ]
+        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.
-        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.
-        """
+            + "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
@@ -852,16 +918,18 @@ 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

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.11.dist-info → vectara_agentic-0.2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.11
+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.11.dist-info → vectara_agentic-0.2.12.dist-info}/RECORD

@@ -11,19 +11,19 @@ tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
 vectara_agentic/_callback.py,sha256=ron49t1t-ox-736WaXzrZ99vhN4NI9bMiHFyj0iIPqg,13062
 vectara_agentic/_observability.py,sha256=BA2zhwa5930aaDUJxHefPlmIPt8kZOuLHVBc9PtYNuU,3839
-vectara_agentic/_prompts.py,sha256=CKbsFrosoM6bPH02t2R5_K3jzVzaxJAl85qO3mEAQ3U,9439
-vectara_agentic/_version.py,sha256=uneBdCHiroBsYz5R-8jYqrJU6UuA9Nu4vCqLtO0VSsE,66
-vectara_agentic/agent.py,sha256=KX0VYQuGFkK_CELjUFdxXWYHng32GFjsLdRdH-gR7aM,43970
+vectara_agentic/_prompts.py,sha256=8vlT0jfS6Pc204KXMVg9SG7U61vqjtq1DObd2ewj2vQ,9456
+vectara_agentic/_version.py,sha256=41ILS5AP8Yb7_UDVGW_HSrCI_wqeKaH8UUYkrgu369c,66
+vectara_agentic/agent.py,sha256=5KKjl1IJasvDFwBu7yLHXoBmYioQA7BmqP2r-Vl-iZ0,43947
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
 vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=zhP1KIRNiE6BKD69VGmUdcjeKSZ6g0kTIsJdTDNCuv4,11141
+vectara_agentic/db_tools.py,sha256=bAgqQMrpmu7KBaiAjJ4tpH8JwsFGEDk8iru5Deu0SEk,11179
 vectara_agentic/sub_query_workflow.py,sha256=xjySd2qjLAKwK6XuS0R0PTyk2uXraHCgCbDP1xDoFVI,12175
-vectara_agentic/tools.py,sha256=n06CwlEqOHlawEJj6BX8xHM5-kMrBQO48Jo68GKRKes,43874
+vectara_agentic/tools.py,sha256=vwTlGQvbsGTAs2CtsyMOEyIXqR_nKq9fSv8t34zlMBc,47043
 vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
-vectara_agentic/utils.py,sha256=4vA5MyNoG47_7eHuLFQByiG_FHWbrQ6ZJDsdqHUwiJA,7720
-vectara_agentic-0.2.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.11.dist-info/METADATA,sha256=c0ue2vnkkIwgNueoHQILYkui5eTDbXB7-SnBBnbWK0A,25088
-vectara_agentic-0.2.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectara_agentic-0.2.11.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.11.dist-info/RECORD,,
+vectara_agentic/utils.py,sha256=Ku18_uSTmOOuWctXZJN67DbBb118-4KC_CsuVJyF1dc,7719
+vectara_agentic-0.2.12.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.12.dist-info/METADATA,sha256=4R92R_XSohT4B2OZswbayIHCfvokLNFO9M_KB5ITniY,25098
+vectara_agentic-0.2.12.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.12.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.12.dist-info/RECORD,,