vectara-agentic 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

vectara_agentic/tools.py

@@ -9,6 +9,7 @@ import os
 
 from typing import Callable, List, Dict, Any, Optional, Type
 from pydantic import BaseModel, Field
+from pydantic_core import PydanticUndefined
 
 from llama_index.core.tools import FunctionTool
 from llama_index.core.tools.function_tool import AsyncCallable
@@ -125,6 +126,122 @@ class VectaraTool(FunctionTool):
                 break
         return is_equal
 
+def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, str], 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
+        prefix = tool_args_type.get(key, "doc")
+
+        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):
+                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
+                filter_parts.append(f"{prefix}.{key}={val_str.lower()}")
+            else:
+                filter_parts.append(f"{prefix}.{key}='{val_str}'")
+
+    filter_str = " AND ".join(filter_parts)
+    return f"({fixed_filter}) AND ({filter_str})" if fixed_filter else filter_str
+
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -148,13 +265,159 @@ class VectaraToolFactory:
         self.vectara_api_key = vectara_api_key
         self.num_corpora = len(vectara_corpus_id.split(","))
 
+    def create_search_tool(
+        self,
+        tool_name: str,
+        tool_description: str,
+        tool_args_schema: type[BaseModel],
+        tool_args_type: Dict[str, str] = {},
+        fixed_filter: str = "",
+        lambda_val: float = 0.005,
+        reranker: str = "mmr",
+        rerank_k: int = 50,
+        mmr_diversity_bias: float = 0.2,
+        udf_expression: str = None,
+        rerank_chain: List[Dict] = None,
+        verbose: bool = False,
+    ) -> VectaraTool:
+        """
+        Creates a Vectara search/retrieval tool
+
+        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_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 (float, optional): Lambda value for the Vectara query.
+            reranker (str, optional): The reranker mode.
+            rerank_k (int, optional): Number of top-k documents for reranking.
+            mmr_diversity_bias (float, optional): MMR diversity bias.
+            udf_expression (str, optional): the user defined expression for reranking results.
+            rerank_chain (List[Dict], optional): A list of rerankers to be applied sequentially.
+                Each dictionary should specify the "type" of reranker (mmr, slingshot, udf)
+                and any other parameters (e.g. "limit" or "cutoff" for any type,
+                "diversity_bias" for mmr, and "user_function" for udf).
+                If using slingshot/multilingual_reranker_v1, it must be first in the list.
+            verbose (bool, optional): Whether to print verbose output.
+
+        Returns:
+            VectaraTool: A VectaraTool object.
+        """
+
+        vectara = VectaraIndex(
+            vectara_api_key=self.vectara_api_key,
+            vectara_customer_id=self.vectara_customer_id,
+            vectara_corpus_id=self.vectara_corpus_id,
+            x_source_str="vectara-agentic",
+        )
+
+        # Dynamically generate the search function
+        def search_function(*args, **kwargs) -> ToolOutput:
+            """
+            Dynamically generated function for semantic search Vectara.
+            """
+            # Convert args to kwargs using the function signature
+            sig = inspect.signature(search_function)
+            bound_args = sig.bind_partial(*args, **kwargs)
+            bound_args.apply_defaults()
+            kwargs = bound_args.arguments
+
+            query = kwargs.pop("query")
+            top_k = kwargs.pop("top_k", 10)
+            try:
+                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+            except ValueError as e:
+                return ToolOutput(
+                    tool_name=search_function.__name__,
+                    content=str(e),
+                    raw_input={"args": args, "kwargs": kwargs},
+                    raw_output={"response": str(e)},
+                )
+
+            vectara_retriever = vectara.as_retriever(
+                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),
+                mmr_diversity_bias=mmr_diversity_bias,
+                udf_expression=udf_expression,
+                rerank_chain=rerank_chain,
+                lambda_val=lambda_val,
+                filter=filter_string,
+                x_source_str="vectara-agentic",
+                verbose=verbose,
+            )
+            response = vectara_retriever.retrieve(query)
+
+            if len(response) == 0:
+                msg = "Vectara Tool failed to retreive any results for the query."
+                return ToolOutput(
+                    tool_name=search_function.__name__,
+                    content=msg,
+                    raw_input={"args": args, "kwargs": kwargs},
+                    raw_output={"response": msg},
+                )
+            tool_output = "Matching documents:\n"
+            unique_ids = set()
+            for doc in response:
+                if doc.id_ in unique_ids:
+                    continue
+                unique_ids.add(doc.id_)
+                tool_output += f"document '{doc.id_}' metadata: {doc.metadata}\n"
+            out = ToolOutput(
+                tool_name=search_function.__name__,
+                content=tool_output,
+                raw_input={"args": args, "kwargs": kwargs},
+                raw_output=response,
+            )
+            return out
+
+        fields = tool_args_schema.model_fields
+        params = [
+            inspect.Parameter(
+                name=field_name,
+                kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=field_info.default,
+                annotation=field_info,
+            )
+            for field_name, field_info in fields.items()
+        ]
+
+        # Create a new signature using the extracted parameters
+        sig = inspect.Signature(params)
+        search_function.__signature__ = sig
+        search_function.__annotations__["return"] = dict[str, Any]
+        search_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+
+        # Create the tool function signature string
+        fields = []
+        for name, field in tool_args_schema.__fields__.items():
+            annotation = field.annotation
+            type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+            fields.append(f"{name}: {type_name}")
+        args_str = ", ".join(fields)
+        function_str = f"{tool_name}({args_str}) -> str"
+
+        # Create the tool
+        tool = VectaraTool.from_defaults(
+            fn=search_function,
+            name=tool_name,
+            description=function_str + ". " + tool_description,
+            fn_schema=tool_args_schema,
+            tool_type=ToolType.QUERY,
+        )
+        return tool
+
     def create_rag_tool(
         self,
         tool_name: str,
         tool_description: str,
         tool_args_schema: type[BaseModel],
         tool_args_type: Dict[str, str] = {},
+        fixed_filter: str = "",
         vectara_summarizer: str = "vectara-summary-ext-24-05-sml",
+        vectara_prompt_text: str = None,
         summary_num_results: int = 5,
         summary_response_lang: str = "eng",
         n_sentences_before: int = 2,
@@ -177,7 +440,9 @@ class VectaraToolFactory:
             tool_description (str): The description of the tool.
             tool_args_schema (BaseModel): 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.
             vectara_summarizer (str, optional): The Vectara summarizer to use.
+            vectara_prompt_text (str, optional): The prompt text for the Vectara summarizer.
             summary_num_results (int, optional): The number of summary results.
             summary_response_lang (str, optional): The response language for the summary.
             n_sentences_before (int, optional): Number of sentences before the summary.
@@ -209,66 +474,6 @@ class VectaraToolFactory:
             x_source_str="vectara-agentic",
         )
 
-        def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, str]) -> str:
-            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
-                prefix = tool_args_type.get(key, "doc")
-
-                if prefix not in ["doc", "part"]:
-                    raise ValueError(
-                        f'Unrecognized prefix {prefix}. Please make sure to use either "doc" or "part" for the prefix.'
-                    )
-
-                # Check if value contains a known comparison operator at the start
-                val_str = str(value).strip()
-                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):
-                        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
-                        filter_parts.append(f"{prefix}.{key}={val_str.lower()}")
-                    else:
-                        filter_parts.append(f"{prefix}.{key}='{val_str}'")
-
-            return " AND ".join(filter_parts)
-
         # Dynamically generate the RAG function
         def rag_function(*args, **kwargs) -> ToolOutput:
             """
@@ -281,13 +486,22 @@ class VectaraToolFactory:
             kwargs = bound_args.arguments
 
             query = kwargs.pop("query")
-            filter_string = _build_filter_string(kwargs, tool_args_type)
+            try:
+                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+            except ValueError as e:
+                return ToolOutput(
+                    tool_name=rag_function.__name__,
+                    content=str(e),
+                    raw_input={"args": args, "kwargs": kwargs},
+                    raw_output={"response": str(e)},
+                )
 
             vectara_query_engine = vectara.as_query_engine(
                 summary_enabled=True,
                 summary_num_results=summary_num_results,
                 summary_response_lang=summary_response_lang,
                 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),
                 mmr_diversity_bias=mmr_diversity_bias,

vectara_agentic/tools_catalog.py

@@ -3,9 +3,11 @@ This module contains the tools catalog for the Vectara Agentic.
 """
 from typing import List
 from functools import lru_cache
-from pydantic import Field
+from datetime import date
 import requests
 
+from pydantic import Field
+
 from .types import LLMRole
 from .utils import get_llm
 
@@ -19,6 +21,11 @@ get_headers = {
     "Connection": "keep-alive",
 }
 
+def get_current_date() -> str:
+    """
+    Returns: the current date.
+    """
+    return date.today().strftime("%A, %B %d, %Y")
 
 #
 # Standard Tools

vectara_agentic/types.py

@@ -3,6 +3,9 @@ This module contains the types used in the Vectara Agentic.
 """
 from enum import Enum
 
+from llama_index.core.tools.types import ToolOutput as LI_ToolOutput
+from llama_index.core.chat_engine.types import AgentChatResponse as LI_AgentChatResponse
+from llama_index.core.chat_engine.types import StreamingAgentChatResponse as LI_StreamingAgentChatResponse
 
 class AgentType(Enum):
     """Enumeration for different types of agents."""
@@ -29,6 +32,7 @@ class ModelProvider(Enum):
     FIREWORKS = "FIREWORKS"
     COHERE = "COHERE"
     GEMINI = "GEMINI"
+    BEDROCK = "BEDROCK"
 
 
 class AgentStatusType(Enum):
@@ -51,3 +55,9 @@ class ToolType(Enum):
     """Enumeration for different types of tools."""
     QUERY = "query"
     ACTION = "action"
+
+
+# classes for Agent responses
+ToolOutput = LI_ToolOutput
+AgentResponse = LI_AgentChatResponse
+AgentStreamingResponse = LI_StreamingAgentChatResponse

vectara_agentic/utils.py

@@ -2,7 +2,6 @@
 Utilities for the Vectara agentic.
 """
 
-import os
 from typing import Tuple, Callable, Optional
 from functools import lru_cache
 
@@ -13,6 +12,7 @@ from llama_index.llms.openai import OpenAI
 from llama_index.llms.anthropic import Anthropic
 
 from .types import LLMRole, AgentType, ModelProvider
+from .agent_config import AgentConfig
 
 provider_to_default_model_name = {
     ModelProvider.OPENAI: "gpt-4o",
@@ -20,6 +20,7 @@ provider_to_default_model_name = {
     ModelProvider.TOGETHER: "meta-llama/Llama-3.3-70B-Instruct-Turbo",
     ModelProvider.GROQ: "llama-3.3-70b-versatile",
     ModelProvider.FIREWORKS: "accounts/fireworks/models/firefunction-v2",
+    ModelProvider.BEDROCK: "anthropic.claude-3-5-sonnet-20241022-v2:0",
     ModelProvider.COHERE: "command-r-plus",
     ModelProvider.GEMINI: "models/gemini-1.5-flash",
 }
@@ -27,44 +28,52 @@ provider_to_default_model_name = {
 DEFAULT_MODEL_PROVIDER = ModelProvider.OPENAI
 
 @lru_cache(maxsize=None)
-def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
-    """Get the model provider and model name for the specified role."""
+def _get_llm_params_for_role(
+    role: LLMRole,
+    config: Optional[AgentConfig] = None
+) -> Tuple[ModelProvider, str]:
+    """
+    Get the model provider and model name for the specified role.
+
+    If config is None, a new AgentConfig() is instantiated using environment defaults.
+    """
+    config = config or AgentConfig()  # fallback to default config
+
     if role == LLMRole.TOOL:
-        model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER.value)
-        )
-        model_name = os.getenv(
-            "VECTARA_AGENTIC_TOOL_MODEL_NAME",
-            provider_to_default_model_name.get(model_provider),
+        model_provider = config.tool_llm_provider
+        # If the user hasn’t explicitly set a tool_llm_model_name,
+        # fallback to provider default from provider_to_default_model_name
+        model_name = (
+            config.tool_llm_model_name
+            or provider_to_default_model_name.get(model_provider)
         )
     else:
-        model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER.value)
-        )
-        model_name = os.getenv(
-            "VECTARA_AGENTIC_MAIN_MODEL_NAME",
-            provider_to_default_model_name.get(model_provider),
+        model_provider = config.main_llm_provider
+        model_name = (
+            config.main_llm_model_name
+            or provider_to_default_model_name.get(model_provider)
         )
 
-    agent_type = AgentType(
-        os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI.value)
-    )
-    if (
-        role == LLMRole.MAIN
-        and agent_type == AgentType.OPENAI
-        and model_provider != ModelProvider.OPENAI
-    ):
-        raise ValueError(
-            "OpenAI agent requested but main model provider is not OpenAI."
-        )
+    # If the agent type is OpenAI, check that the main LLM provider is also OpenAI.
+    if role == LLMRole.MAIN and config.agent_type == AgentType.OPENAI:
+        if model_provider != ModelProvider.OPENAI:
+            raise ValueError(
+                "OpenAI agent requested but main model provider is not OpenAI."
+            )
 
     return model_provider, model_name
 
 @lru_cache(maxsize=None)
-def get_tokenizer_for_model(role: LLMRole) -> Optional[Callable]:
-    """Get the tokenizer for the specified model."""
-    model_provider, model_name = _get_llm_params_for_role(role)
+def get_tokenizer_for_model(
+    role: LLMRole,
+    config: Optional[AgentConfig] = None
+) -> Optional[Callable]:
+    """
+    Get the tokenizer for the specified model, as determined by the role & config.
+    """
+    model_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
+        # This might raise an exception if the model_name is unknown to tiktoken
         return tiktoken.encoding_for_model(model_name).encode
     if model_provider == ModelProvider.ANTHROPIC:
         return Anthropic().tokenizer
@@ -72,10 +81,15 @@ def get_tokenizer_for_model(role: LLMRole) -> Optional[Callable]:
 
 
 @lru_cache(maxsize=None)
-def get_llm(role: LLMRole) -> LLM:
-    """Get the LLM for the specified role."""
-    model_provider, model_name = _get_llm_params_for_role(role)
-
+def get_llm(
+    role: LLMRole,
+    config: Optional[AgentConfig] = None
+) -> LLM:
+    """
+    Get the LLM for the specified role, using the provided config
+    or a default if none is provided.
+    """
+    model_provider, model_name = _get_llm_params_for_role(role, config)
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.ANTHROPIC:
@@ -92,12 +106,14 @@ def get_llm(role: LLMRole) -> LLM:
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
         llm = Fireworks(model=model_name, temperature=0)
+    elif model_provider == ModelProvider.BEDROCK:
+        from llama_index.llms.bedrock import Bedrock
+        llm = Bedrock(model=model_name, temperature=0)
     elif model_provider == ModelProvider.COHERE:
         from llama_index.llms.cohere import Cohere
         llm = Cohere(model=model_name, temperature=0)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")
-
     return llm
 
 def is_float(value: str) -> bool: