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

vectara_agentic/__init__.py

@@ -7,3 +7,10 @@ from .tools import VectaraToolFactory, VectaraTool
 
 # Define the __all__ variable for wildcard imports
 __all__ = ['Agent', 'VectaraToolFactory', 'VectaraTool']
+
+# Ensure package version is available
+try:
+    import importlib.metadata
+    __version__ = importlib.metadata.version("vectara_agentic")
+except Exception:
+    __version__ = "0.0.0"  # fallback if not installed

vectara_agentic/_prompts.py

@@ -5,6 +5,7 @@ This file contains the prompt templates for the different types of agents.
 # General (shared) instructions
 GENERAL_INSTRUCTIONS = """
 - Use tools as your main source of information, do not respond without using a tool. Do not respond based on pre-trained knowledge.
+- Always call the 'get_current_date' tool to ensure you know the exact date when a user asks a question.
 - When using a tool with arguments, simplify the query as much as possible if you use the tool with arguments.
   For example, if the original query is "revenue for apple in 2021", you can use the tool with a query "revenue" with arguments year=2021 and company=apple.
 - If a tool responds with "I do not have enough information", try one of the following:
@@ -43,7 +44,7 @@ GENERAL_PROMPT_TEMPLATE = """
 You are a helpful chatbot in conversation with a user, with expertise in {chat_topic}.
 
 ## Date
-Today's date is {today}.
+Your birth date is {today}.
 
 ## INSTRUCTIONS:
 IMPORTANT - FOLLOW THESE INSTRUCTIONS CAREFULLY:
@@ -63,7 +64,7 @@ You are designed to help with a variety of tasks, from answering questions to pr
 You have expertise in {chat_topic}.
 
 ## Date
-Today's date is {today}.
+Your birth date is {today}.
 
 ## Tools
 You have access to a wide variety of tools.

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.1.24"
+__version__ = "0.1.25"

vectara_agentic/agent.py

@@ -8,6 +8,7 @@ import time
 import json
 import logging
 import traceback
+import asyncio
 
 import dill
 from dotenv import load_dotenv
@@ -25,12 +26,13 @@ from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.agent.openai import OpenAIAgent
 from llama_index.core.memory import ChatMemoryBuffer
 
-from .types import AgentType, AgentStatusType, LLMRole, ToolType
+from .types import AgentType, AgentStatusType, LLMRole, ToolType, AgentResponse, AgentStreamingResponse
 from .utils import get_llm, get_tokenizer_for_model
 from ._prompts import REACT_PROMPT_TEMPLATE, GENERAL_PROMPT_TEMPLATE, GENERAL_INSTRUCTIONS
 from ._callback import AgentCallbackHandler
 from ._observability import setup_observer, eval_fcs
-from .tools import VectaraToolFactory, VectaraTool
+from .tools import VectaraToolFactory, VectaraTool, ToolsFactory
+from .tools_catalog import get_current_date
 from .agent_config import AgentConfig
 
 logger = logging.getLogger("opentelemetry.exporter.otlp.proto.http.trace_exporter")
@@ -92,6 +94,7 @@ class Agent:
         verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
+        query_logging_callback: Optional[Callable[[str, str], None]] = None,
         agent_config: Optional[AgentConfig] = None,
     ) -> None:
         """
@@ -105,16 +108,18 @@ class Agent:
             verbose (bool, optional): Whether the agent should print its steps. Defaults to True.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
                 update_func (Callable): old name for agent_progress_callback. Will be deprecated in future.
+            query_logging_callback (Callable): A callback function the code calls upon completion of a query
             agent_config (AgentConfig, optional): The configuration of the agent.
                 Defaults to AgentConfig(), which reads from environment variables.
         """
         self.agent_config = agent_config or AgentConfig()
         self.agent_type = self.agent_config.agent_type
-        self.tools = tools
+        self.tools = tools + [ToolsFactory().create_tool(get_current_date)]
         self.llm = get_llm(LLMRole.MAIN, config=self.agent_config)
         self._custom_instructions = custom_instructions
         self._topic = topic
         self.agent_progress_callback = agent_progress_callback if agent_progress_callback else update_func
+        self.query_logging_callback = query_logging_callback
 
         main_tok = get_tokenizer_for_model(role=LLMRole.MAIN)
         self.main_token_counter = TokenCountingHandler(tokenizer=main_tok) if main_tok else None
@@ -134,7 +139,7 @@ class Agent:
         if self.agent_type == AgentType.REACT:
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, topic, custom_instructions)
             self.agent = ReActAgent.from_tools(
-                tools=tools,
+                tools=self.tools,
                 llm=self.llm,
                 memory=self.memory,
                 verbose=verbose,
@@ -145,7 +150,7 @@ class Agent:
         elif self.agent_type == AgentType.OPENAI:
             prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, topic, custom_instructions)
             self.agent = OpenAIAgent.from_tools(
-                tools=tools,
+                tools=self.tools,
                 llm=self.llm,
                 memory=self.memory,
                 verbose=verbose,
@@ -154,23 +159,24 @@ class Agent:
                 system_prompt=prompt,
             )
         elif self.agent_type == AgentType.LLMCOMPILER:
-            self.agent = LLMCompilerAgentWorker.from_tools(
-                tools=tools,
+            agent_worker = LLMCompilerAgentWorker.from_tools(
+                tools=self.tools,
                 llm=self.llm,
                 verbose=verbose,
                 callable_manager=callback_manager,
-            ).as_agent()
-            self.agent.agent_worker.system_prompt = _get_prompt(
-                _get_llm_compiler_prompt(self.agent.agent_worker.system_prompt, topic, custom_instructions),
+            )
+            agent_worker.system_prompt = _get_prompt(
+                _get_llm_compiler_prompt(agent_worker.system_prompt, topic, custom_instructions),
                 topic, custom_instructions
             )
-            self.agent.agent_worker.system_prompt_replan = _get_prompt(
-                _get_llm_compiler_prompt(self.agent.agent_worker.system_prompt_replan, topic, custom_instructions),
+            agent_worker.system_prompt_replan = _get_prompt(
+                _get_llm_compiler_prompt(agent_worker.system_prompt_replan, topic, custom_instructions),
                 topic, custom_instructions
             )
+            self.agent = agent_worker.as_agent()
         elif self.agent_type == AgentType.LATS:
             agent_worker = LATSAgentWorker.from_tools(
-                tools=tools,
+                tools=self.tools,
                 llm=self.llm,
                 num_expansions=3,
                 max_rollouts=-1,
@@ -255,6 +261,7 @@ class Agent:
         verbose: bool = True,
         update_func: Optional[Callable[[AgentStatusType, str], None]] = None,
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
+        query_logging_callback: Optional[Callable[[str, str], None]] = None,
         agent_config: AgentConfig = AgentConfig(),
     ) -> "Agent":
         """
@@ -268,6 +275,7 @@ class Agent:
             verbose (bool, optional): Whether the agent should print its steps. Defaults to True.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
                 update_func (Callable): old name for agent_progress_callback. Will be deprecated in future.
+            query_logging_callback (Callable): A callback function the code calls upon completion of a query
             agent_config (AgentConfig, optional): The configuration of the agent.
 
         Returns:
@@ -276,6 +284,7 @@ class Agent:
         return cls(
             tools=tools, topic=topic, custom_instructions=custom_instructions,
             verbose=verbose, agent_progress_callback=agent_progress_callback,
+            query_logging_callback=query_logging_callback,
             update_func=update_func, agent_config=agent_config
         )
 
@@ -289,6 +298,7 @@ class Agent:
         vectara_corpus_id: str = str(os.environ.get("VECTARA_CORPUS_ID", "")),
         vectara_api_key: str = str(os.environ.get("VECTARA_API_KEY", "")),
         agent_progress_callback: Optional[Callable[[AgentStatusType, str], None]] = None,
+        query_logging_callback: Optional[Callable[[str, str], None]] = None,
         verbose: bool = False,
         vectara_filter_fields: list[dict] = [],
         vectara_lambda_val: float = 0.005,
@@ -308,6 +318,7 @@ class Agent:
             vectara_corpus_id (str): The Vectara corpus ID (or comma separated list of IDs).
             vectara_api_key (str): The Vectara API key.
             agent_progress_callback (Callable): A callback function the code calls on any agent updates.
+            query_logging_callback (Callable): A callback function the code calls upon completion of a query
             data_description (str): The description of the data.
             assistant_specialty (str): The specialty of the assistant.
             verbose (bool, optional): Whether to print verbose output.
@@ -367,6 +378,7 @@ class Agent:
             custom_instructions=assistant_instructions,
             verbose=verbose,
             agent_progress_callback=agent_progress_callback,
+            query_logging_callback=query_logging_callback,
         )
 
     def report(self) -> None:
@@ -400,12 +412,32 @@ class Agent:
             "tool token count": self.tool_token_counter.total_llm_token_count if self.tool_token_counter else -1,
         }
 
+    async def _aformat_for_lats(self, prompt, agent_response):
+        llm_prompt = f"""
+        Given the question '{prompt}', and agent response '{agent_response.response}',
+        Please provide a well formatted final response to the query.
+        final response:
+        """
+        agent_response.response = str(self.llm.acomplete(llm_prompt))
+
+    def chat(self, prompt: str) -> AgentResponse:           # type: ignore
+        """
+        Interact with the agent using a chat prompt.
+
+        Args:
+            prompt (str): The chat prompt.
+
+        Returns:
+            AgentResponse: The response from the agent.
+        """
+        return asyncio.run(self.achat(prompt))
+
     @retry(
         retry_on_exception=_retry_if_exception,
         stop_max_attempt_number=3,
         wait_fixed=2000,
     )
-    def chat(self, prompt: str) -> str:
+    async def achat(self, prompt: str) -> AgentResponse:    # type: ignore
         """
         Interact with the agent using a chat prompt.
 
@@ -413,32 +445,79 @@ class Agent:
             prompt (str): The chat prompt.
 
         Returns:
-            str: The response from the agent.
+            AgentResponse: The response from the agent.
         """
 
         try:
             st = time.time()
-            agent_response = self.agent.chat(prompt)
+            agent_response = await self.agent.achat(prompt)
             if self.agent_type == AgentType.LATS:
-                prompt = f"""
-                Given the question '{prompt}', and agent response '{agent_response.response}',
-                Please provide a well formatted final response to the query.
-                final response:
-                """
-                final_response = str(self.llm.complete(prompt))
-            else:
-                final_response = agent_response.response
-
+                await self._aformat_for_lats(prompt, agent_response)
             if self.verbose:
                 print(f"Time taken: {time.time() - st}")
             if self.observability_enabled:
                 eval_fcs()
-            return final_response
+            if self.query_logging_callback:
+                self.query_logging_callback(prompt, agent_response.response)
+            return agent_response
         except Exception as e:
-            return f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()}), and can't respond."
+            return AgentResponse(
+                response = (
+                    f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()})"
+                    ", and can't respond."
+                )
+            )
 
-    # Serialization methods
+    def stream_chat(self, prompt: str) -> AgentStreamingResponse:    # type: ignore
+        """
+        Interact with the agent using a chat prompt with streaming.
+        Args:
+            prompt (str): The chat prompt.
+        Returns:
+            AgentStreamingResponse: The streaming response from the agent.
+        """
+        return asyncio.run(self.astream_chat(prompt))
+
+    @retry(
+        retry_on_exception=_retry_if_exception,
+        stop_max_attempt_number=3,
+        wait_fixed=2000,
+    )
+    async def astream_chat(self, prompt: str) -> AgentStreamingResponse:    # type: ignore
+        """
+        Interact with the agent using a chat prompt asynchronously with streaming.
+        Args:
+            prompt (str): The chat prompt.
+        Returns:
+            AgentStreamingResponse: The streaming response from the agent.
+        """
+        try:
+            agent_response = await self.agent.astream_chat(prompt)
+            original_async_response_gen = agent_response.async_response_gen
+
+            # Wrap async_response_gen
+            async def _stream_response_wrapper():
+                async for token in original_async_response_gen():
+                    yield token  # Yield async token to keep streaming behavior
+
+                # After streaming completes, execute additional logic
+                if self.agent_type == AgentType.LATS:
+                    await self._aformat_for_lats(prompt, agent_response)
+                if self.query_logging_callback:
+                    self.query_logging_callback(prompt, agent_response.response)
+                if self.observability_enabled:
+                    eval_fcs()
+
+            agent_response.async_response_gen = _stream_response_wrapper  # Override method
+            return agent_response
+        except Exception as e:
+            raise ValueError(
+                f"Vectara Agentic: encountered an exception ({e}) at ({traceback.format_exc()}), and can't respond."
+            ) from e
 
+    #
+    # Serialization methods
+    #
     def dumps(self) -> str:
         """Serialize the Agent instance to a JSON string."""
         return json.dumps(self.to_dict())

vectara_agentic/agent_config.py

@@ -31,7 +31,7 @@ class AgentConfig:
     )
 
     main_llm_model_name: str = field(
-        default_factory=lambda: os.getenv("VECTARA_AGENTIC_MAIN_LLM_MODEL_NAME", "")
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_MAIN_MODEL_NAME", "")
     )
 
     # Tool LLM provider & model name
@@ -41,7 +41,7 @@ class AgentConfig:
         )
     )
     tool_llm_model_name: str = field(
-        default_factory=lambda: os.getenv("VECTARA_AGENTIC_TOOL_LLM_MODEL_NAME", "")
+        default_factory=lambda: os.getenv("VECTARA_AGENTIC_TOOL_MODEL_NAME", "")
     )
 
     # Observer

vectara_agentic/tools.py

@@ -126,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.
@@ -149,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,
@@ -178,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.
@@ -210,118 +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.'
-                    )
-
-                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 arrgument
-                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}'")
-
-            return " AND ".join(filter_parts)
-
         # Dynamically generate the RAG function
         def rag_function(*args, **kwargs) -> ToolOutput:
             """
@@ -335,7 +487,7 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             try:
-                filter_string = _build_filter_string(kwargs, tool_args_type)
+                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
             except ValueError as e:
                 return ToolOutput(
                     tool_name=rag_function.__name__,
@@ -349,6 +501,7 @@ class VectaraToolFactory:
                 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

@@ -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",
 }
@@ -105,6 +106,9 @@ def get_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)

{vectara_agentic-0.1.24.dist-info → vectara_agentic-0.1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectara_agentic
-Version: 0.1.24
+Version: 0.1.25
 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,39 +16,39 @@ 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.7
+Requires-Dist: llama-index==0.12.11
 Requires-Dist: llama-index-indices-managed-vectara==0.3.1
 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.1
-Requires-Dist: llama-index-llms-openai==0.3.12
-Requires-Dist: llama-index-llms-anthropic==0.6.3
+Requires-Dist: llama-index-agent-openai==0.4.3
+Requires-Dist: llama-index-llms-openai==0.3.16
+Requires-Dist: llama-index-llms-anthropic==0.6.4
 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.0
+Requires-Dist: llama-index-llms-fireworks==0.3.1
 Requires-Dist: llama-index-llms-cohere==0.4.0
-Requires-Dist: llama-index-llms-gemini==0.4.2
+Requires-Dist: llama-index-llms-gemini==0.4.4
+Requires-Dist: llama-index-llms-bedrock==0.3.3
 Requires-Dist: llama-index-tools-yahoo-finance==0.3.0
 Requires-Dist: llama-index-tools-arxiv==0.3.0
 Requires-Dist: llama-index-tools-database==0.3.0
 Requires-Dist: llama-index-tools-google==0.3.0
 Requires-Dist: llama-index-tools-tavily_research==0.3.0
 Requires-Dist: llama-index-tools-neo4j==0.3.0
-Requires-Dist: llama-index-graph-stores-kuzu==0.5.0
+Requires-Dist: llama-index-graph-stores-kuzu==0.6.0
 Requires-Dist: llama-index-tools-slack==0.3.0
 Requires-Dist: llama-index-tools-exa==0.3.0
 Requires-Dist: tavily-python==0.5.0
-Requires-Dist: exa-py==1.7.0
+Requires-Dist: exa-py==1.8.5
 Requires-Dist: yahoo-finance==1.4.0
-Requires-Dist: openinference-instrumentation-llama-index==3.0.3
+Requires-Dist: openinference-instrumentation-llama-index==3.1.4
 Requires-Dist: opentelemetry-proto==1.26.0
-Requires-Dist: arize-phoenix==5.7.0
+Requires-Dist: arize-phoenix==7.11.0
 Requires-Dist: arize-phoenix-otel==0.6.1
 Requires-Dist: protobuf==4.25.5
 Requires-Dist: tokenizers>=0.20
-Requires-Dist: pydantic==2.9.2
+Requires-Dist: pydantic==2.10.3
 Requires-Dist: retrying==1.3.4
-Requires-Dist: pymongo==4.10.1
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.8.0
 Requires-Dist: dill>=0.3.7
@@ -87,7 +87,7 @@ Dynamic: summary
 
 ## ✨ Overview
 
-`vectara-agentic` is a Python library for developing powerful AI assistants and agents using Vectara and Agentic-RAG. It leverages the LlamaIndex Agent framework, customized for use with Vectara.
+`vectara-agentic` is a Python library for developing powerful AI assistants and agents using Vectara and Agentic-RAG. It leverages the LlamaIndex Agent framework and provides helper functions to quickly create tools that connect to Vectara corpora.
 
 <p align="center">
 <img src="https://raw.githubusercontent.com/vectara/py-vectara-agentic/main/.github/assets/diagram1.png" alt="Agentic RAG diagram" width="100%" style="vertical-align: middle;">
@@ -96,10 +96,10 @@ Dynamic: summary
 ###  Features
 
 - Enables easy creation of custom AI assistants and agents.
-- Create a Vectara RAG tool with a single line of code.
-- Supports `ReAct`, `OpenAIAgent`, `LATS' and `LLMCompiler` agent types.
+- Create a Vectara RAG tool or search tool with a single line of code.
+- Supports `ReAct`, `OpenAIAgent`, `LATS` and `LLMCompiler` agent types.
 - Includes pre-built tools for various domains (e.g., finance, legal).
-- Integrates with various LLM inference services like OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere and Fireworks
+- Integrates with various LLM inference services like OpenAI, Anthropic, Gemini, GROQ, Together.AI, Cohere, Bedrock and Fireworks
 - Built-in support for observability with Arize Phoenix
 
 ### 📚 Example AI Assistants
@@ -109,14 +109,14 @@ Check out our example AI assistants:
 - [Financial Assistant](https://huggingface.co/spaces/vectara/finance-chat)
 - [Justice Harvard Teaching Assistant](https://huggingface.co/spaces/vectara/Justice-Harvard)
 - [Legal Assistant](https://huggingface.co/spaces/vectara/legal-agent)
-
+- [EV Assistant](https://huggingface.co/spaces/vectara/ev-assistant)
 
 ###  Prerequisites
 
 - [Vectara account](https://console.vectara.com/signup/?utm_source=github&utm_medium=code&utm_term=DevRel&utm_content=vectara-agentic&utm_campaign=github-code-DevRel-vectara-agentic)
 - A Vectara corpus with an [API key](https://docs.vectara.com/docs/api-keys)
 - [Python 3.10 or higher](https://www.python.org/downloads/)
-- OpenAI API key (or API keys for Anthropic, TOGETHER.AI, Fireworks AI, Cohere, GEMINI or GROQ, if you choose to use them)
+- OpenAI API key (or API keys for Anthropic, TOGETHER.AI, Fireworks AI, Bedrock, Cohere, GEMINI or GROQ, if you choose to use them)
 
 ###  Installation
 
@@ -126,18 +126,25 @@ pip install vectara-agentic
 
 ## 🚀 Quick Start
 
-### 1. Create a Vectara RAG tool
+### 1. Initialize the Vectara tool factory
 
 ```python
 import os
 from vectara_agentic.tools import VectaraToolFactory
-from pydantic import BaseModel, Field
 
 vec_factory = VectaraToolFactory(
     vectara_api_key=os.environ['VECTARA_API_KEY'],
     vectara_customer_id=os.environ['VECTARA_CUSTOMER_ID'],
     vectara_corpus_id=os.environ['VECTARA_CORPUS_ID']
 )
+```
+
+### 2. Create a Vectara RAG Tool
+
+A RAG tool calls the full Vectara RAG pipeline to provide summarized responses to queries grounded in data.
+
+```python
+from pydantic import BaseModel, Field
 
 years = list(range(2020, 2024))
 tickers = {
@@ -156,17 +163,22 @@ query_financial_reports_tool = vec_factory.create_rag_tool(
     tool_name="query_financial_reports",
     tool_description="Query financial reports for a company and year",
     tool_args_schema=QueryFinancialReportsArgs,
+    lambda_val=0.005,
+    summary_num_results=7, 
+    # Additional arguments
 )
 ```
 
-### 2. Create other tools (optional)
+See the [docs](https://vectara.github.io/vectara-agentic-docs/) for additional arguments to customize your Vectara RAG tool.
+
+### 3. Create other tools (optional)
 
 In addition to RAG tools, you can generate a lot of other types of tools the agent can use. These could be mathematical tools, tools 
 that call other APIs to get more information, or any other type of tool.
 
 See [Agent Tools](#agent-tools) for more information.
 
-### 3. Create your agent
+### 4. Create your agent
 
 ```python
 from vectara_agentic import Agent
@@ -186,14 +198,72 @@ agent = Agent(
 )
 ```
 
-### 4. Run your agent
+See the [docs](https://vectara.github.io/vectara-agentic-docs/) for additional arguments, including `agent_progress_callback` and `query_logging_callback`.
+
+### 5. Run your agent
 
 ```python
-response = agent.chat("What was the revenue for Apple in 2021?")
-print(response)
+res = agent.chat("What was the revenue for Apple in 2021?")
+print(res.response)
 ```
 
-## 🛠️ Agent Tools
+Note that:
+1. `vectara-agentic` also supports `achat()` and two streaming variants `stream_chat()` and `astream_chat()`.
+2. The response types from `chat()` and `achat()` are of type `AgentResponse`. If you just need the actual string
+   response it's available as the `response` variable, or just use `str()`. For advanced use-cases you can look 
+   at other `AgentResponse` variables [such as `sources`](https://github.com/run-llama/llama_index/blob/659f9faaafbecebb6e6c65f42143c0bf19274a37/llama-index-core/llama_index/core/chat_engine/types.py#L53).
+
+## 🧰 Vectara tools
+
+`vectara-agentic` provides two helper functions to connect with Vectara RAG
+* `create_rag_tool()` to create an agent tool that connects with a Vectara corpus for querying. 
+* `create_search_tool()` to create a tool to search a Vectara corpus and return a list of matching documents.
+
+See the documentation for the full list of arguments for `create_rag_tool()` and `create_search_tool()`, 
+to understand how to configure Vectara query performed by those tools.
+
+### Creating a Vectara RAG tool
+
+A Vectara RAG tool is often the main workhorse for any Agentic RAG application, and enables the agent to query 
+one or more Vectara RAG corpora. 
+
+The tool generated always includes the `query` argument, followed by 1 or more optional arguments used for 
+metadata filtering, defined by `tool_args_schema`.
+
+For example, in the quickstart example the schema is:
+
+```
+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()}.")
+```
+
+The `query` is required and is always the query string.
+The other arguments are optional and will be interpreted as Vectara metadata filters.
+
+For example, in the example above, the agent may call the `query_financial_reports_tool` tool with 
+query='what is the revenue?', year=2022 and ticker='AAPL'. Subsequently the RAG tool will issue
+a Vectara RAG query with the same query, but with metadata filtering (doc.year=2022 and doc.ticker='AAPL').
+
+There are also additional cool features supported here:
+* An argument can be a condition, for example year='>2022' translates to the correct metadata 
+  filtering condition doc.year>2022
+* if `fixed_filter` is defined in the RAG tool, it provides a constant metadata filtering that is always applied.
+  For example, if fixed_filter=`doc.filing_type='10K'` then a query with query='what is the reveue', year=2022
+  and ticker='AAPL' would translate into query='what is the revenue' with metadata filtering condition of
+  "doc.year=2022 AND doc.ticker='AAPL' and doc.filing_type='10K'"
+
+Note that `tool_args_type` is an optional dictionary that indicates the level at which metadata filtering
+is applied for each argument (`doc` or `part`)
+
+### Creating a Vectara search tool
+
+The Vectara search tool allows the agent to list documents that match a query.
+This can be helpful to the agent to answer queries like "how many documents discuss the iPhone?" or other
+similar queries that require a response in terms of a list of matching documents.
+
+## 🛠️ Agent Tools at a Glance
 
 `vectara-agentic` provides a few tools out of the box:
 1. **Standard tools**: 
@@ -217,10 +287,9 @@ print(response)
 - `load_unique_values`: returns the top unique values for a given column
 
 In addition, we include various other tools from LlamaIndex ToolSpecs:
-* Tavily search
-* EXA.AI
+* Tavily search and EXA.AI
 * arxiv
-* neo4j & Kuzu for Graph integration
+* neo4j & Kuzu for Graph DB integration
 * Google tools (including gmail, calendar, and search)
 * Slack
 
@@ -240,7 +309,7 @@ mult_tool = ToolsFactory().create_tool(mult_func)
 The main way to control the behavior of `vectara-agentic` is by passing an `AgentConfig` object to your `Agent` when creating it.
 This object will include the following items:
 - `VECTARA_AGENTIC_AGENT_TYPE`: valid values are `REACT`, `LLMCOMPILER`, `LATS` or `OPENAI` (default: `OPENAI`)
-- `VECTARA_AGENTIC_MAIN_LLM_PROVIDER`: valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `GEMINI` or `FIREWORKS` (default: `OPENAI`)
+- `VECTARA_AGENTIC_MAIN_LLM_PROVIDER`: valid values are `OPENAI`, `ANTHROPIC`, `TOGETHER`, `GROQ`, `COHERE`, `BEDROCK`, `GEMINI` or `FIREWORKS` (default: `OPENAI`)
 - `VECTARA_AGENTIC_MAIN_MODEL_NAME`: agent model name (default depends on provider)
 - `VECTARA_AGENTIC_TOOL_LLM_PROVIDER`: tool LLM provider (default: `OPENAI`)
 - `VECTARA_AGENTIC_TOOL_MODEL_NAME`: tool model name (default depends on provider)

vectara_agentic-0.1.25.dist-info/RECORD

@@ -0,0 +1,21 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_agent.py,sha256=8LQlny0rIuVa13LGtebG0vatES6Ln7gmenbSwX-ctrY,4260
+tests/test_tools.py,sha256=2ofZYz3Q-YMSxjpiEg1VNUlA9gMjvNAcJAO2Ucd0eVE,2969
+vectara_agentic/__init__.py,sha256=ADH4fPKLbpGNYYYszv3c3QDOjPToPE_qh3LpkH_seCU,430
+vectara_agentic/_callback.py,sha256=OBiHk_OJZTS3iKz_LigfEjnl_p5V90XYsQC0vEYVSPo,8782
+vectara_agentic/_observability.py,sha256=HeQYJIkqPLW3EWHiXHatkaJzo08IQGESKujdeWTuRgk,3805
+vectara_agentic/_prompts.py,sha256=mgGx3zUJPtpS1epBLtl0BnoLeE7wb6AX1SX6dFNaTTQ,6368
+vectara_agentic/_version.py,sha256=90Cr_yLyeFeoJ2YK_LHwWc15gk11Emy9cx1xS0hlwtc,66
+vectara_agentic/agent.py,sha256=1-dno6FrC5sMuJ2nei9o2r3E53sg0dM6p-zn25hxRN0,25979
+vectara_agentic/agent_config.py,sha256=9P9lyFAAXLX1ft2dBQ6tYN7dKzp7SC7B-h-DnhUHsSg,2941
+vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
+vectara_agentic/db_tools.py,sha256=kCEENzmnorm8i-k4Kpd4KLJt1QWh_ZlAyX1aG-tzET0,3619
+vectara_agentic/tools.py,sha256=8FNnlTj57VTCYCaUfNWCongg38_lwnEoWdc2idCX6Jw,34087
+vectara_agentic/tools_catalog.py,sha256=DDHoPuA88jiixZjNSuGIuZCB7NSsQXdbbhrbVrtR2Ec,4141
+vectara_agentic/types.py,sha256=00wm3YsJRyddvIBzeVjF3qklA38NuTkCvy_B-e68v6c,1589
+vectara_agentic/utils.py,sha256=eDEOUpCkb0r216LxSLkamll2NmJhu76Z1TgQFbAVq7A,4690
+vectara_agentic-0.1.25.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.1.25.dist-info/METADATA,sha256=TtClmE0CpgC9qcJlSWxFnTywur0fFK3UkIKnmyZIkGs,19469
+vectara_agentic-0.1.25.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+vectara_agentic-0.1.25.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.1.25.dist-info/RECORD,,

vectara_agentic-0.1.24.dist-info/RECORD

@@ -1,21 +0,0 @@
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_agent.py,sha256=8LQlny0rIuVa13LGtebG0vatES6Ln7gmenbSwX-ctrY,4260
-tests/test_tools.py,sha256=2ofZYz3Q-YMSxjpiEg1VNUlA9gMjvNAcJAO2Ucd0eVE,2969
-vectara_agentic/__init__.py,sha256=FUWwh37ia9AduK4YDo_TCD52A09ocbYo49oYyBJtyqY,219
-vectara_agentic/_callback.py,sha256=OBiHk_OJZTS3iKz_LigfEjnl_p5V90XYsQC0vEYVSPo,8782
-vectara_agentic/_observability.py,sha256=HeQYJIkqPLW3EWHiXHatkaJzo08IQGESKujdeWTuRgk,3805
-vectara_agentic/_prompts.py,sha256=ITHWQQ4oSmRhqBwRcheYC_nMdZZielUOjfVIbDYi9rw,6257
-vectara_agentic/_version.py,sha256=3P-p27Ccx3RQ_PJQDAu-lIwPrPQ8S780FnRmeItjqNg,66
-vectara_agentic/agent.py,sha256=35dc7RBYevvX9XGz1WoPRQL6N8NnWxL_Eac56e1JpFo,22427
-vectara_agentic/agent_config.py,sha256=8q_eRPURAZYHUXu_rxD2eO1XHC9jNGe_d9ytPgXbS7g,2949
-vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=kCEENzmnorm8i-k4Kpd4KLJt1QWh_ZlAyX1aG-tzET0,3619
-vectara_agentic/tools.py,sha256=Qhql8IA_CGvsZ3ErOFQH2y-sxxHXvL3GUDH6shgxmzQ,28262
-vectara_agentic/tools_catalog.py,sha256=5NlJypdu0IKa7mODxVOwo05lw3PqQJtSl_ZOsUDH_TA,3986
-vectara_agentic/types.py,sha256=siRh9VmFt3jhTu4uJzYpvNlLi60lyIH5_xqYHKpB24Q,1149
-vectara_agentic/utils.py,sha256=-hnILxUAAtcFRlupeNEVBwHpm-EMF98iLV1Z_hjVrNA,4460
-vectara_agentic-0.1.24.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.1.24.dist-info/METADATA,sha256=VtSVDzA0zHVWq5C8fNqjATQCOpF_zXIAsWiPYd2_Y5E,15379
-vectara_agentic-0.1.24.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-vectara_agentic-0.1.24.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.1.24.dist-info/RECORD,,