vectara-agentic 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

vectara_agentic/tools.py

@@ -18,13 +18,7 @@ from llama_index.core.tools.types import ToolMetadata, ToolOutput
 
 
 from .types import ToolType
-from .tools_catalog import (
-    summarize_text,
-    rephrase_text,
-    critique_text,
-    avoid_topics_tool,
-    db_load_sample_data
-)
+from .tools_catalog import summarize_text, rephrase_text, critique_text, get_bad_topics, DBLoadSampleData
 
 LI_packages = {
     "yahoo_finance": ToolType.QUERY,
@@ -51,24 +45,42 @@ 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,
-        metadata: Optional[ToolMetadata] = None,
         async_fn: Optional[AsyncCallable] = None,
     ) -> None:
-        self.tool_type = tool_type
-        super().__init__(fn, metadata, async_fn)
+        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,
-        tool_type: ToolType,
         fn: Optional[Callable[..., Any]] = None,
         name: Optional[str] = None,
         description: Optional[str] = None,
@@ -76,18 +88,14 @@ class VectaraTool(FunctionTool):
         fn_schema: Optional[Type[BaseModel]] = None,
         async_fn: Optional[AsyncCallable] = None,
         tool_metadata: Optional[ToolMetadata] = None,
+        tool_type: ToolType = ToolType.QUERY,
     ) -> "VectaraTool":
         tool = FunctionTool.from_defaults(fn, name, description, return_direct, fn_schema, async_fn, tool_metadata)
-        vectara_tool = cls(
-            tool_type=tool_type,
-            fn=tool._fn,
-            metadata=tool._metadata,
-            async_fn=tool._async_fn
-        )
+        vectara_tool = cls(tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn)
         return vectara_tool
 
     def __eq__(self, other):
-        if self.tool_type != other.tool_type:
+        if self.metadata.tool_type != other.metadata.tool_type:
             return False
 
         # Check if fn_schema is an instance of a BaseModel or a class itself (metaclass)
@@ -98,15 +106,15 @@ class VectaraTool(FunctionTool):
             if key not in other_schema_dict:
                 is_equal = False
                 break
-            if (self_schema_dict[key].annotation != other_schema_dict[key].annotation or
-                self_schema_dict[key].description != other_schema_dict[key].description or
-                self_schema_dict[key].is_required() != other_schema_dict[key].is_required()
+            if (
+                self_schema_dict[key].annotation != other_schema_dict[key].annotation
+                or self_schema_dict[key].description != other_schema_dict[key].description
+                or self_schema_dict[key].is_required() != other_schema_dict[key].is_required()
             ):
                 is_equal = False
                 break
         return is_equal
 
-
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -145,7 +153,7 @@ class VectaraToolFactory:
         rerank_k: int = 50,
         mmr_diversity_bias: float = 0.2,
         include_citations: bool = True,
-        fcs_threshold: float = 0.0
+        fcs_threshold: float = 0.0,
     ) -> VectaraTool:
         """
         Creates a RAG (Retrieve and Generate) tool.
@@ -175,7 +183,7 @@ class VectaraToolFactory:
             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"
+            x_source_str="vectara-agentic",
         )
 
         def _build_filter_string(kwargs):
@@ -225,7 +233,7 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
             if len(response.source_nodes) == 0:
                 msg = "Tool failed to generate a response since no matches were found."
@@ -233,18 +241,28 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
 
             # Extract citation metadata
             pattern = r"\[(\d+)\]"
             matches = re.findall(pattern, response.response)
-            citation_numbers = sorted(set([int(match) for match in matches]))
+            citation_numbers = sorted(set(int(match) for match in matches))
             citation_metadata = ""
             keys_to_ignore = ["lang", "offset", "len"]
             for citation_number in citation_numbers:
                 metadata = response.source_nodes[citation_number - 1].metadata
-                citation_metadata += f"""[{citation_number}]: {"; ".join([f"{k}='{v}'" for k,v in metadata.items() if k not in keys_to_ignore])}.\n"""
+                citation_metadata += (
+                    f"[{citation_number}]: "
+                    + "; ".join(
+                        [
+                            f"{k}='{v}'"
+                            for k, v in metadata.items()
+                            if k not in keys_to_ignore
+                        ]
+                    )
+                    + ".\n"
+                )
             fcs = response.metadata["fcs"] if "fcs" in response.metadata else 0.0
             if fcs < fcs_threshold:
                 msg = f"Could not answer the query due to suspected hallucination (fcs={fcs})."
@@ -252,7 +270,7 @@ class VectaraToolFactory:
                     tool_name=rag_function.__name__,
                     content=msg,
                     raw_input={"args": args, "kwargs": kwargs},
-                    raw_output={'response': msg}
+                    raw_output={"response": msg},
                 )
             res = {
                 "response": response.response,
@@ -288,16 +306,16 @@ class VectaraToolFactory:
         # Create a new signature using the extracted parameters
         sig = inspect.Signature(params)
         rag_function.__signature__ = sig
-        rag_function.__annotations__['return'] = dict[str, Any]
+        rag_function.__annotations__["return"] = dict[str, Any]
         rag_function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
 
         # Create the tool
         tool = VectaraTool.from_defaults(
-            tool_type=ToolType.QUERY,
             fn=rag_function,
             name=tool_name,
             description=tool_description,
             fn_schema=tool_args_schema,
+            tool_type=ToolType.QUERY,
         )
         return tool
 
@@ -307,9 +325,7 @@ class ToolsFactory:
     A factory class for creating agent tools.
     """
 
-    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.
 
@@ -320,7 +336,7 @@ class ToolsFactory:
         Returns:
             VectaraTool: A VectaraTool object.
         """
-        return VectaraTool.from_defaults(tool_type, function)
+        return VectaraTool.from_defaults(tool_type=tool_type, fn=function)
 
     def get_llama_index_tools(
         self,
@@ -342,10 +358,8 @@ class ToolsFactory:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         # Dynamically install and import the module
-        if tool_package_name not in LI_packages.keys():
-            raise ValueError(
-                f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic."
-            )
+        if tool_package_name not in LI_packages:
+            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)
@@ -358,21 +372,14 @@ class ToolsFactory:
         vtools = []
         for tool in tools:
             if len(tool_name_prefix) > 0:
-                tool._metadata.name = tool_name_prefix + "_" + tool._metadata.name
+                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
 
@@ -386,25 +393,19 @@ class ToolsFactory:
         """
         Create a list of guardrail tools to avoid controversial topics.
         """
-        return [
-            self.create_tool(
-                avoid_topics_tool(["politics", "religion", "voilence", "hate speech", "adult content", "illegal activities"])
-            )
-        ]
+        return [self.create_tool(get_bad_topics)]
 
     def financial_tools(self):
         """
         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]:
         """
         Create a list of legal tools.
         """
+
         def summarize_legal_text(
             text: str = Field(description="the original text."),
         ) -> str:
@@ -428,9 +429,7 @@ 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,
@@ -484,18 +483,21 @@ class ToolsFactory:
                     dbname=dbname,
                 )
             else:
-                raise Exception("Please provide a SqlDatabase option or a valid DB scheme type (postgresql, mysql, sqlite, mssql, oracle).")
+                raise ValueError(
+                    "Please provide a SqlDatabase option or a valid DB scheme type "
+                    " (postgresql, mysql, sqlite, mssql, oracle)."
+                )
 
         # Update tools with description
         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 = (
+                    tool.metadata.description + f"The database tables include data about {content_description}."
                 )
 
-        load_data_tool = [t for t in tools if t._metadata.name.endswith("load_data")][0]
-        sample_data_fn = db_load_sample_data(load_data_tool)
+        # Update load_data_tool to return only text instead of "Document" objects (to save on space)
+        load_data_tool_index = next(i for i, t in enumerate(tools) if t.metadata.name.endswith("load_data"))
+        sample_data_fn = DBLoadSampleData(tools[load_data_tool_index])
         sample_data_fn.__name__ = f"{tool_name_prefix}_load_sample_data"
         sample_data_tool = self.create_tool(sample_data_fn, ToolType.QUERY)
         tools.append(sample_data_tool)

vectara_agentic/tools_catalog.py

@@ -2,10 +2,10 @@
 This module contains the tools catalog for the Vectara Agentic.
 """
 
-from typing import Optional, Callable, Any, List
+from typing import Callable, Any, List
+from functools import lru_cache
 from pydantic import Field
 import requests
-from functools import lru_cache
 
 from .types import LLMRole
 from .utils import get_llm
@@ -24,7 +24,7 @@ get_headers = {
 #
 # Standard Tools
 #
-@lru_cache(maxsize=5)
+@lru_cache(maxsize=None)
 def summarize_text(
     text: str = Field(description="the original text."),
     expertise: str = Field(
@@ -55,12 +55,11 @@ def summarize_text(
     response = llm.complete(prompt)
     return response.text
 
-@lru_cache(maxsize=5)
+
+@lru_cache(maxsize=None)
 def rephrase_text(
     text: str = Field(description="the original text."),
-    instructions: str = Field(
-        description="the specific instructions for how to rephrase the text."
-    ),
+    instructions: str = Field(description="the specific instructions for how to rephrase the text."),
 ) -> str:
     """
     This is a helper tool.
@@ -84,15 +83,12 @@ def rephrase_text(
     response = llm.complete(prompt)
     return response.text
 
-@lru_cache(maxsize=5)
+
+@lru_cache(maxsize=None)
 def critique_text(
     text: str = Field(description="the original text."),
-    role: Optional[str] = Field(
-        None, description="the role of the person providing critique."
-    ),
-    point_of_view: Optional[str] = Field(
-        None, description="the point of view with which to provide critique."
-    ),
+    role: str = Field(default=None, description="the role of the person providing critique."),
+    point_of_view: str = Field(default=None, description="the point of view with which to provide critique."),
 ) -> str:
     """
     This is a helper tool.
@@ -109,9 +105,7 @@ def critique_text(
     if role:
         prompt = f"As a {role}, critique the provided text from the point of view of {point_of_view}."
     else:
-        prompt = (
-            f"Critique the provided text from the point of view of {point_of_view}."
-        )
+        prompt = f"Critique the provided text from the point of view of {point_of_view}."
     prompt += "Structure the critique as bullet points.\n"
     prompt += f"Original text: {text}\nCritique:"
     llm = get_llm(LLMRole.TOOL)
@@ -122,37 +116,34 @@ def critique_text(
 #
 # Guardrails tools
 #
-def avoid_topics_tool(
-        text: str = Field(description="the original text."),
-        topics_to_avoid: List[str] = Field(default=["politics", "religion", "violence", "hate speech", "adult content", "illegal activities"],
-                                           description="List of topics to avoid.")
-        ) -> str:
+def get_bad_topics() -> List[str]:
     """
-    A tool to help avoid certain topics in the response.
-    Given the input text, rephrases the text to ensure that the response avoids of the topics listed in 'topics_to_avoid'.
-
-    Args:
-        text (str): The original text.
-        topics_to_avoid (List[str]): A list of topics to avoid.
-
-    Returns:
-        str: The rephrased text.
+    Get the list of topics to avoid in the response.
     """
-    return rephrase_text(text, f"Avoid the following topics: {', '.join(topics_to_avoid)}")
+    return [
+        "politics",
+        "religion",
+        "violence",
+        "hate speech",
+        "adult content",
+        "illegal activities",
+    ]
+
 
 #
 # Additional database tool
 #
-class db_load_sample_data:
+class DBLoadSampleData:
     """
     A tool to load a sample of data from the specified database table.
 
-    This tool fetches the first num_rows (default 25) rows from the given table using a provided database query function.
+    This tool fetches the first num_rows (default 25) rows from the given table
+    using a provided database query function.
     """
 
     def __init__(self, load_data_tool: Callable):
         """
-        Initializes the db_load_sample_data with the provided load_data_tool function.
+        Initializes the DBLoadSampleData object with the provided load_data_tool function.
 
         Args:
             load_data_tool (Callable): A function to execute the SQL query.

vectara_agentic/types.py

@@ -11,7 +11,6 @@ class AgentType(Enum):
     OPENAI = "OPENAI"
     LLMCOMPILER = "LLMCOMPILER"
 
-
 class ObserverType(Enum):
     """Enumeration for different types of observability integrations."""
 

vectara_agentic/utils.py

@@ -3,14 +3,15 @@ Utilities for the Vectara agentic.
 """
 
 import os
+from typing import Tuple, Callable, Optional
+from functools import lru_cache
+
+import tiktoken
 
 from llama_index.core.llms import LLM
 from llama_index.llms.openai import OpenAI
 from llama_index.llms.anthropic import Anthropic
 
-import tiktoken
-from typing import Tuple, Callable, Optional
-
 from .types import LLMRole, AgentType, ModelProvider
 
 provider_to_default_model_name = {
@@ -25,12 +26,12 @@ 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."""
     if role == LLMRole.TOOL:
         model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER)
+            os.getenv("VECTARA_AGENTIC_TOOL_LLM_PROVIDER", str(DEFAULT_MODEL_PROVIDER))
         )
         model_name = os.getenv(
             "VECTARA_AGENTIC_TOOL_MODEL_NAME",
@@ -38,14 +39,16 @@ def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
         )
     else:
         model_provider = ModelProvider(
-            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", DEFAULT_MODEL_PROVIDER)
+            os.getenv("VECTARA_AGENTIC_MAIN_LLM_PROVIDER", str(DEFAULT_MODEL_PROVIDER))
         )
         model_name = os.getenv(
             "VECTARA_AGENTIC_MAIN_MODEL_NAME",
             provider_to_default_model_name.get(model_provider),
         )
 
-    agent_type = AgentType(os.getenv("VECTARA_AGENTIC_AGENT_TYPE", AgentType.OPENAI))
+    agent_type = AgentType(
+        os.getenv("VECTARA_AGENTIC_AGENT_TYPE", str(AgentType.OPENAI))
+    )
     if (
         role == LLMRole.MAIN
         and agent_type == AgentType.OPENAI
@@ -57,18 +60,18 @@ def _get_llm_params_for_role(role: LLMRole) -> Tuple[ModelProvider, str]:
 
     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)
     if model_provider == ModelProvider.OPENAI:
         return tiktoken.encoding_for_model(model_name).encode
-    elif model_provider == ModelProvider.ANTHROPIC:
+    if model_provider == ModelProvider.ANTHROPIC:
         return Anthropic().tokenizer
-    else:
-        return None
+    return None
 
 
+@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)
@@ -76,7 +79,7 @@ def get_llm(role: LLMRole) -> LLM:
     if model_provider == ModelProvider.OPENAI:
         llm = OpenAI(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.ANTHROPIC:
-        llm = Anthropic(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Anthropic(model=model_name, temperature=0)
     elif model_provider == ModelProvider.GEMINI:
         from llama_index.llms.gemini import Gemini
         llm = Gemini(model=model_name, temperature=0, is_function_calling_model=True)
@@ -88,10 +91,10 @@ def get_llm(role: LLMRole) -> LLM:
         llm = Groq(model=model_name, temperature=0, is_function_calling_model=True)
     elif model_provider == ModelProvider.FIREWORKS:
         from llama_index.llms.fireworks import Fireworks
-        llm = Fireworks(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Fireworks(model=model_name, temperature=0)
     elif model_provider == ModelProvider.COHERE:
         from llama_index.llms.cohere import Cohere
-        llm = Cohere(model=model_name, temperature=0, is_function_calling_model=True)
+        llm = Cohere(model=model_name, temperature=0)
     else:
         raise ValueError(f"Unknown LLM provider: {model_provider}")