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

vectara_agentic/tools.py

@@ -8,31 +8,35 @@ import importlib
 import os
 import asyncio
 
-from typing import Callable, List, Dict, Any, Optional, Union, Type
-from pydantic import BaseModel, Field, create_model
-from pydantic_core import PydanticUndefined
+from typing import Callable, List, Dict, Any, Optional, Union
+from pydantic import BaseModel, Field
 
 from llama_index.core.tools import FunctionTool
-from llama_index.core.tools.function_tool import AsyncCallable
 from llama_index.indices.managed.vectara import VectaraIndex
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
-from llama_index.core.tools.types import ToolMetadata, ToolOutput
-from llama_index.core.workflow.context import Context
+from llama_index.core.tools.types import ToolOutput
 
 from .types import ToolType
 from .tools_catalog import ToolsCatalog, get_bad_topics
 from .db_tools import DatabaseTools
-from .utils import is_float, summarize_documents
+from .utils import summarize_documents, is_float
 from .agent_config import AgentConfig
+from .tool_utils import (
+    _create_tool_from_dynamic_function,
+    _build_filter_string,
+    VectaraTool
+)
 
 LI_packages = {
     "yahoo_finance": ToolType.QUERY,
     "arxiv": ToolType.QUERY,
     "tavily_research": ToolType.QUERY,
     "exa": ToolType.QUERY,
-    "brave": ToolType.QUERY,
+    "brave_search": ToolType.QUERY,
+    "bing_search": ToolType.QUERY,
     "neo4j": ToolType.QUERY,
     "kuzu": ToolType.QUERY,
+    "wikipedia": ToolType.QUERY,
     "google": {
         "GmailToolSpec": {
             "load_data": ToolType.QUERY,
@@ -58,427 +62,6 @@ LI_packages = {
     },
 }
 
-
-class VectaraToolMetadata(ToolMetadata):
-    """
-    A subclass of ToolMetadata adding the tool_type attribute.
-    """
-
-    tool_type: ToolType
-
-    def __init__(self, tool_type: ToolType, **kwargs):
-        super().__init__(**kwargs)
-        self.tool_type = tool_type
-
-    def __repr__(self) -> str:
-        """
-        Returns a string representation of the VectaraToolMetadata object, including the tool_type attribute.
-        """
-        base_repr = super().__repr__()
-        return f"{base_repr}, tool_type={self.tool_type}"
-
-
-class VectaraTool(FunctionTool):
-    """
-    A subclass of FunctionTool adding the tool_type attribute.
-    """
-
-    def __init__(
-        self,
-        tool_type: ToolType,
-        metadata: ToolMetadata,
-        fn: Optional[Callable[..., Any]] = None,
-        async_fn: Optional[AsyncCallable] = None,
-    ) -> None:
-        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)
-
-    @classmethod
-    def from_defaults(
-        cls,
-        fn: Optional[Callable[..., Any]] = None,
-        name: Optional[str] = None,
-        description: Optional[str] = None,
-        return_direct: bool = False,
-        fn_schema: Optional[Type[BaseModel]] = None,
-        async_fn: Optional[AsyncCallable] = None,
-        tool_metadata: Optional[ToolMetadata] = None,
-        callback: Optional[Callable[[Any], Any]] = None,
-        async_callback: Optional[AsyncCallable] = None,
-        tool_type: ToolType = ToolType.QUERY,
-    ) -> "VectaraTool":
-        tool = FunctionTool.from_defaults(
-            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,
-        )
-        return vectara_tool
-
-    def __str__(self) -> str:
-        return f"Tool(name={self.metadata.name}, " f"Tool metadata={self.metadata})"
-
-    def __repr__(self) -> str:
-        return str(self)
-
-    def __eq__(self, other):
-        if not isinstance(other, VectaraTool):
-            return False
-
-        if self.metadata.tool_type != other.metadata.tool_type:
-            return False
-
-        if self.metadata.name != other.metadata.name:
-            return False
-
-        # 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"):
-                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_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)
-        except Exception:
-            # If any exception occurs during schema comparison, fall back to name comparison
-            pass
-
-        return True
-
-    def call(
-        self, *args: Any, ctx: Optional[Context] = None, **kwargs: Any
-    ) -> 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,
-                content=f"Tool {self.metadata.name} Malfunction: {str(e)}",
-                raw_input={"args": args, "kwargs": kwargs},
-                raw_output={"response": str(e)},
-            )
-            return err_output
-
-    async def acall(
-        self, *args: Any, ctx: Optional[Context] = None, **kwargs: Any
-    ) -> 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,
-                content=f"Tool {self.metadata.name} Malfunction: {str(e)}",
-                raw_input={"args": args, "kwargs": kwargs},
-                raw_output={"response": str(e)},
-            )
-            return err_output
-
-
-def _create_tool_from_dynamic_function(
-    function: Callable[..., ToolOutput],
-    tool_name: str,
-    tool_description: str,
-    base_params_model: Type[BaseModel],  # Now a Pydantic BaseModel
-    tool_args_schema: Type[BaseModel],
-) -> VectaraTool:
-    fields = {}
-    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 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
-    ]
-    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)
-
-    # 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:
-        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)
-
-    tool = VectaraTool.from_defaults(
-        fn=function,
-        name=tool_name,
-        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:
-    """
-    Build filter string for Vectara from kwargs
-    """
-    filter_parts = []
-    comparison_operators = [">=", "<=", "!=", ">", "<", "="]
-    numeric_only_ops = {">", "<", ">=", "<="}
-
-    for key, value in kwargs.items():
-        if value is None or value == "":
-            continue
-
-        # 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})
-        prefix = tool_args_dict.get(key, "doc")
-        is_list = tool_args_dict.get("is_list", False)
-
-        if prefix not in ["doc", "part"]:
-            raise ValueError(
-                f'Unrecognized prefix {prefix}. Please make sure to use either "doc" or "part" for the prefix.'
-            )
-
-        if value is PydanticUndefined:
-            raise ValueError(
-                f"Value of argument {key} is undefined, and this is invalid."
-                "Please form proper arguments and try again."
-            )
-
-        # value of the argument
-        val_str = str(value).strip()
-
-        # Special handling for range operator
-        if val_str.startswith(("[", "(")) and val_str.endswith(("]", ")")):
-            # Extract the boundary types
-            start_inclusive = val_str.startswith("[")
-            end_inclusive = val_str.endswith("]")
-
-            # Remove the boundaries and strip whitespace
-            val_str = val_str[1:-1].strip()
-
-            if "," in val_str:
-                val_str = val_str.split(",")
-                if len(val_str) != 2:
-                    raise ValueError(
-                        f"Range operator requires two values for {key}: {value}"
-                    )
-
-                # Validate both bounds as numeric or empty (for unbounded ranges)
-                start_val, end_val = val_str[0].strip(), val_str[1].strip()
-                if start_val and not (start_val.isdigit() or is_float(start_val)):
-                    raise ValueError(
-                        f"Range operator requires numeric operands for {key}: {value}"
-                    )
-                if end_val and not (end_val.isdigit() or is_float(end_val)):
-                    raise ValueError(
-                        f"Range operator requires numeric operands for {key}: {value}"
-                    )
-
-                # Build the SQL condition
-                range_conditions = []
-                if start_val:
-                    operator = ">=" if start_inclusive else ">"
-                    range_conditions.append(f"{prefix}.{key} {operator} {start_val}")
-                if end_val:
-                    operator = "<=" if end_inclusive else "<"
-                    range_conditions.append(f"{prefix}.{key} {operator} {end_val}")
-
-                # Join the range conditions with AND
-                filter_parts.append("( " + " AND ".join(range_conditions) + " )")
-                continue
-
-            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
-        for op in comparison_operators:
-            if val_str.startswith(op):
-                matched_operator = op
-                break
-
-        # Break down operator from value
-        # e.g. val_str = ">2022" --> operator = ">", rhs = "2022"
-        if matched_operator:
-            rhs = val_str[len(matched_operator) :].strip()
-
-            if matched_operator in numeric_only_ops:
-                # Must be numeric
-                if not (rhs.isdigit() or is_float(rhs)):
-                    raise ValueError(
-                        f"Operator {matched_operator} requires a numeric operand for {key}: {val_str}"
-                    )
-                filter_parts.append(f"{prefix}.{key}{matched_operator}{rhs}")
-            else:
-                # = and != operators can be numeric or string
-                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()}"
-                    )
-                else:
-                    # For string operands, wrap them in quotes
-                    filter_parts.append(f"{prefix}.{key}{matched_operator}'{rhs}'")
-        else:
-            if val_str.isdigit() or is_float(val_str):
-                if is_list:
-                    filter_parts.append(f"({val_str} IN {prefix}.{key})")
-                else:
-                    filter_parts.append(f"{prefix}.{key}={val_str}")
-            elif val_str.lower() in ["true", "false"]:
-                # This is to handle boolean values.
-                # This is not complete solution - the best solution would be to test if the field is boolean
-                # That can be done after we move to APIv2
-                if is_list:
-                    filter_parts.append(f"({val_str.lower()} IN {prefix}.{key})")
-                else:
-                    filter_parts.append(f"{prefix}.{key}={val_str.lower()}")
-            else:
-                if is_list:
-                    filter_parts.append(f"('{val_str}' IN {prefix}.{key})")
-                else:
-                    filter_parts.append(f"{prefix}.{key}='{val_str}'")
-
-    filter_str = " AND ".join(filter_parts)
-    if fixed_filter and filter_str:
-        return f"({fixed_filter}) AND ({filter_str})"
-    else:
-        return fixed_filter or filter_str
-
-
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -488,25 +71,29 @@ class VectaraToolFactory:
         self,
         vectara_corpus_key: str = str(os.environ.get("VECTARA_CORPUS_KEY", "")),
         vectara_api_key: str = str(os.environ.get("VECTARA_API_KEY", "")),
+        compact_docstring: bool = False,
     ) -> None:
         """
         Initialize the VectaraToolFactory
         Args:
             vectara_corpus_key (str): The Vectara corpus key (or comma separated list of keys).
             vectara_api_key (str): The Vectara API key.
+            compact_docstring (bool): Whether to use a compact docstring format for tools
+              This is useful if OpenAI complains on the 1024 token limit.
         """
         self.vectara_corpus_key = vectara_corpus_key
         self.vectara_api_key = vectara_api_key
         self.num_corpora = len(vectara_corpus_key.split(","))
-        self.cache_expiry = 60 * 60  # 1 hour
-        self.max_cache_size = 128
+        self.compact_docstring = compact_docstring
 
     def create_search_tool(
         self,
         tool_name: str,
         tool_description: str,
-        tool_args_schema: type[BaseModel],
+        tool_args_schema: type[BaseModel] = None,
         tool_args_type: Dict[str, str] = {},
+        summarize_docs: Optional[bool] = None,
+        summarize_llm_name: Optional[str] = None,
         fixed_filter: str = "",
         lambda_val: Union[List[float], float] = 0.005,
         semantics: Union[List[str] | str] = "default",
@@ -532,7 +119,7 @@ class VectaraToolFactory:
         Args:
             tool_name (str): The name of the tool.
             tool_description (str): The description of the tool.
-            tool_args_schema (BaseModel): The schema for the tool arguments.
+            tool_args_schema (BaseModel, optional): The schema for the tool arguments.
             tool_args_type (Dict[str, str], optional): The type of each argument (doc or part).
             fixed_filter (str, optional): A fixed Vectara filter condition to apply to all queries.
             lambda_val (Union[List[float] | float], optional): Lambda value (or list of values for each corpora)
@@ -584,7 +171,11 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             top_k = kwargs.pop("top_k", 10)
-            summarize = kwargs.pop("summarize", True)
+            summarize = (
+                kwargs.pop("summarize", True)
+                if summarize_docs is None
+                else summarize_docs
+            )
             try:
                 filter_string = _build_filter_string(
                     kwargs, tool_args_type, fixed_filter
@@ -643,7 +234,10 @@ class VectaraToolFactory:
             if summarize:
                 summaries_dict = asyncio.run(
                     summarize_documents(
-                        self.vectara_corpus_key, self.vectara_api_key, list(unique_ids)
+                        corpus_key=self.vectara_corpus_key,
+                        api_key=self.vectara_api_key,
+                        llm_name=summarize_llm_name,
+                        doc_ids=list(unique_ids),
                     )
                 )
                 for doc_id, metadata in docs:
@@ -665,30 +259,47 @@ class VectaraToolFactory:
 
         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.",
+                description="The search query to perform, in the form of a question.",
             )
             top_k: int = Field(
-                10, description="The number of top documents to retrieve."
+                default=10, description="The number of top documents to retrieve."
             )
             summarize: bool = Field(
                 True,
-                description="Flag that indicates whether to summarize the retrieved documents.",
+                description="Whether to summarize the retrieved documents.",
+            )
+
+        class SearchToolBaseParamsWithoutSummarize(BaseModel):
+            """Model for the base parameters of the search tool."""
+
+            query: str = Field(
+                ...,
+                description="The search query to perform, in the form of a question.",
+            )
+            top_k: int = Field(
+                10, description="The number of top documents to retrieve."
             )
 
         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."
+            + "Use this tool to search for relevant documents, not to ask questions."
         )
 
         tool = _create_tool_from_dynamic_function(
             search_function,
             tool_name,
             search_tool_extra_desc,
-            SearchToolBaseParams,
+            (
+                SearchToolBaseParams
+                if summarize_docs is None
+                else SearchToolBaseParamsWithoutSummarize
+            ),
             tool_args_schema,
+            compact_docstring=self.compact_docstring,
         )
         return tool
 
@@ -696,7 +307,7 @@ class VectaraToolFactory:
         self,
         tool_name: str,
         tool_description: str,
-        tool_args_schema: type[BaseModel],
+        tool_args_schema: type[BaseModel] = None,
         tool_args_type: Dict[str, dict] = {},
         fixed_filter: str = "",
         vectara_summarizer: str = "vectara-summary-ext-24-05-med-omni",
@@ -718,6 +329,7 @@ class VectaraToolFactory:
         rerank_chain: List[Dict] = None,
         max_response_chars: Optional[int] = None,
         max_tokens: Optional[int] = None,
+        llm_name: Optional[str] = None,
         temperature: Optional[float] = None,
         frequency_penalty: Optional[float] = None,
         presence_penalty: Optional[float] = None,
@@ -734,7 +346,7 @@ class VectaraToolFactory:
         Args:
             tool_name (str): The name of the tool.
             tool_description (str): The description of the tool.
-            tool_args_schema (BaseModel): The schema for the tool arguments.
+            tool_args_schema (BaseModel, optional): The schema for any tool arguments for filtering.
             tool_args_type (Dict[str, dict], optional): attributes for each argument where they key is the field name
                 and the value is a dictionary with the following keys:
                 - 'type': the type of each filter attribute in Vectara (doc or part).
@@ -765,6 +377,7 @@ class VectaraToolFactory:
                 If using slingshot/multilingual_reranker_v1, it must be first in the list.
             max_response_chars (int, optional): The desired maximum number of characters for the generated summary.
             max_tokens (int, optional): The maximum number of tokens to be returned by the LLM.
+            llm_name (str, optional): The name of the LLM to use for generation.
             temperature (float, optional): The sampling temperature; higher values lead to more randomness.
             frequency_penalty (float, optional): How much to penalize repeating tokens in the response,
                 higher values reducing likelihood of repeating the same line.
@@ -842,6 +455,7 @@ class VectaraToolFactory:
                 filter=filter_string,
                 max_response_chars=max_response_chars,
                 max_tokens=max_tokens,
+                llm_name=llm_name,
                 temperature=temperature,
                 frequency_penalty=frequency_penalty,
                 presence_penalty=presence_penalty,
@@ -889,22 +503,27 @@ class VectaraToolFactory:
                     )
                     + ".\n"
                 )
-            fcs = response.metadata["fcs"] if "fcs" in response.metadata else 0.0
-            if fcs and fcs < fcs_threshold:
-                msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
-                return ToolOutput(
-                    tool_name=rag_function.__name__,
-                    content=msg,
-                    raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={"response": msg},
-                )
+            fcs = 0.0
+            fcs_str = response.metadata["fcs"] if "fcs" in response.metadata else "0.0"
+            if fcs_str and is_float(fcs_str):
+                fcs = float(fcs_str)
+                if fcs < fcs_threshold:
+                    msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
+                    return ToolOutput(
+                        tool_name=rag_function.__name__,
+                        content=msg,
+                        raw_input={"args": args, "kwargs": kwargs},
+                        raw_output={"response": msg},
+                    )
             res = {
                 "response": response.response,
                 "references_metadata": citation_metadata,
+                "fcs_score": fcs,
             }
             if len(citation_metadata) > 0:
                 tool_output = f"""
                     Response: '''{res['response']}'''
+                    fcs_score: {res['fcs_score']:.4f}
                     References:
                     {res['references_metadata']}
                 """
@@ -920,9 +539,10 @@ class VectaraToolFactory:
 
         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",
+                description="The search query to perform, in the form of a question",
             )
 
         tool = _create_tool_from_dynamic_function(
@@ -931,6 +551,7 @@ class VectaraToolFactory:
             tool_description,
             RagToolBaseParams,
             tool_args_schema,
+            compact_docstring=self.compact_docstring,
         )
         return tool