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

tests/test_tools.py

@@ -2,7 +2,12 @@ import unittest
 
 from pydantic import Field, BaseModel
 
-from vectara_agentic.tools import VectaraTool, VectaraToolFactory, ToolsFactory, ToolType
+from vectara_agentic.tools import (
+    VectaraTool,
+    VectaraToolFactory,
+    ToolsFactory,
+    ToolType,
+)
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 
@@ -13,9 +18,7 @@ class TestToolsPackage(unittest.TestCase):
     def test_vectara_tool_factory(self):
         vectara_corpus_key = "corpus_key"
         vectara_api_key = "api_key"
-        vec_factory = VectaraToolFactory(
-            vectara_corpus_key, vectara_api_key
-        )
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
 
         self.assertEqual(vectara_corpus_key, vec_factory.vectara_corpus_key)
         self.assertEqual(vectara_api_key, vec_factory.vectara_api_key)
@@ -46,6 +49,48 @@ class TestToolsPackage(unittest.TestCase):
         self.assertIsInstance(search_tool, FunctionTool)
         self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
 
+    def test_vectara_tool_validation(self):
+        vectara_corpus_key = "corpus_key"
+        vectara_api_key = "api_key"
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        class QueryToolArgs(BaseModel):
+            query: str = Field(description="The user query")
+            year: int = Field(
+                description="The year of the document",
+                example=2023,
+            )
+            ticker: str = Field(
+                description="The stock ticker",
+                example="AAPL",
+            )
+
+        query_tool = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            Returns a response (str) to the user query based on the data in this corpus.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+        res = query_tool(
+            query="What is the stock price?",
+            the_year=2023,
+        )
+        self.assertIn("Malfunction", str(res))
+
+        search_tool = vec_factory.create_search_tool(
+            tool_name="search_tool",
+            tool_description="""
+            Returns a list of documents (str) that match the user query.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+        res = search_tool(
+            query="What is the stock price?",
+            the_year=2023,
+        )
+        self.assertIn("Malfunction", str(res))
+
     def test_tool_factory(self):
         def mult(x: float, y: float) -> float:
             return x * y
@@ -59,17 +104,21 @@ class TestToolsPackage(unittest.TestCase):
     def test_llama_index_tools(self):
         tools_factory = ToolsFactory()
 
-        llama_tools = tools_factory.get_llama_index_tools(
-            tool_package_name="arxiv",
-            tool_spec_name="ArxivToolSpec"
-        )
-
-        arxiv_tool = llama_tools[0]
+        arxiv_tool = tools_factory.get_llama_index_tools(
+            tool_package_name="arxiv", tool_spec_name="ArxivToolSpec"
+        )[0]
 
         self.assertIsInstance(arxiv_tool, VectaraTool)
         self.assertIsInstance(arxiv_tool, FunctionTool)
         self.assertEqual(arxiv_tool.metadata.tool_type, ToolType.QUERY)
 
+        yfinance_tool = tools_factory.get_llama_index_tools(
+            tool_package_name="yahoo_finance", tool_spec_name="YahooFinanceToolSpec"
+        )[0]
+        self.assertIsInstance(yfinance_tool, VectaraTool)
+        self.assertIsInstance(yfinance_tool, FunctionTool)
+        self.assertEqual(yfinance_tool.metadata.tool_type, ToolType.QUERY)
+
     def test_public_repo(self):
         vectara_corpus_key = "vectara-docs_1"
         vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
@@ -80,10 +129,12 @@ class TestToolsPackage(unittest.TestCase):
             tool_name="ask_vectara",
             data_description="data from Vectara website",
             assistant_specialty="RAG as a service",
-            vectara_summarizer="mockingbird-1.0-2024-07-16"
+            vectara_summarizer="mockingbird-1.0-2024-07-16",
         )
 
-        self.assertIn("Vectara is an end-to-end platform", str(agent.chat("What is Vectara?")))
+        self.assertIn(
+            "Vectara is an end-to-end platform", str(agent.chat("What is Vectara?"))
+        )
 
     def test_class_method_as_tool(self):
         class TestClass:
@@ -102,7 +153,7 @@ class TestToolsPackage(unittest.TestCase):
             tools=tools,
             topic=topic,
             custom_instructions=instructions,
-            agent_config=config
+            agent_config=config,
         )
 
         self.assertEqual(

vectara_agentic/_callback.py

@@ -154,7 +154,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
         elif event_type == CBEventType.AGENT_STEP:
             self._handle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
+            print(f"Exception in handle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
@@ -168,7 +168,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
         elif event_type == CBEventType.AGENT_STEP:
             await self._ahandle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
-            print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
+            print(f"Exception in ahandle_event: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 

vectara_agentic/_observability.py

@@ -8,7 +8,7 @@ import pandas as pd
 from .types import ObserverType
 from .agent_config import AgentConfig
 
-def setup_observer(config: AgentConfig) -> bool:
+def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     '''
     Setup the observer.
     '''
@@ -31,7 +31,8 @@ def setup_observer(config: AgentConfig) -> bool:
             tracer_provider = register(endpoint=phoenix_endpoint, project_name="vectara-agentic")
         LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)
         return True
-    print("No observer set.")
+    if verbose:
+        print("No observer set.")
     return False
 
 

vectara_agentic/_prompts.py

@@ -37,10 +37,11 @@ GENERAL_INSTRUCTIONS = """
 - If including latex equations in the markdown response, make sure the equations are on a separate line and enclosed in double dollar signs.
 - Always respond in the language of the question, and in text (no images, videos or code).
 - If you are provided with database tools use them for analytical queries (such as counting, calculating max, min, average, sum, or other statistics).
-  For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, and x_load_sample_data, where 'x' in the database name.
-  The x_list_tables tool provides a list of available tables in the x database. Always use x_list_tables before using other database tools, to understand valid table names.
-  Before using the x_load_data with a SQL query, always follow these steps:
-  - Use the x_describe_tables tool to understand the schema of each table.
+  For each database, the database tools include: x_list_tables, x_load_data, x_describe_tables, x_load_unique_values, and x_load_sample_data, where 'x' in the database name.
+  for example, if the database name is "ev", the tools are: ev_list_tables, ev_load_data, ev_describe_tables, ev_load_unique_values, and ev_load_sample_data.
+  Before using the x_load_data with a SQL query, always follow these discovery steps:
+  - call the x_list_tables tool to list of available tables in the x database.
+  - Call the x_describe_tables tool to understand the schema of each table you want to query data from.
   - Use the x_load_unique_values tool to understand the unique values in each column.
     Sometimes the user may ask for a specific column value, but the actual value in the table may be different, and you will need to use the correct value.
   - Use the x_load_sample_data tool to understand the column names, and typical values in each column.

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.9"
+__version__ = "0.2.11"

vectara_agentic/agent.py

@@ -252,7 +252,7 @@ class Agent:
 
         # Setup observability
         try:
-            self.observability_enabled = setup_observer(self.agent_config)
+            self.observability_enabled = setup_observer(self.agent_config, self.verbose)
         except Exception as e:
             print(f"Failed to set up observer ({e}), ignoring")
             self.observability_enabled = False

vectara_agentic/db_tools.py

@@ -15,7 +15,6 @@ from sqlalchemy.engine import Engine
 from sqlalchemy.exc import NoSuchTableError
 from sqlalchemy.schema import CreateTable
 
-from llama_index.core.readers.base import BaseReader
 from llama_index.core.utilities.sql_wrapper import SQLDatabase
 from llama_index.core.schema import Document
 from llama_index.core.tools.function_tool import FunctionTool
@@ -25,7 +24,7 @@ from llama_index.core.tools.utils import create_schema_from_function
 
 AsyncCallable = Callable[..., Awaitable[Any]]
 
-class DatabaseTools(BaseReader):
+class DatabaseTools:
     """Database tools for vectara-agentic
     This class provides a set of tools to interact with a database.
     It allows you to load data, list tables, describe tables, and load unique values.
@@ -49,9 +48,11 @@ class DatabaseTools(BaseReader):
         user: Optional[str] = None,
         password: Optional[str] = None,
         dbname: Optional[str] = None,
+        tool_name_prefix: str = "db",
         **kwargs: Any,
     ) -> None:
         self.max_rows = max_rows
+        self.tool_name_prefix = tool_name_prefix
 
         if sql_database:
             self.sql_database = sql_database
@@ -86,35 +87,34 @@ class DatabaseTools(BaseReader):
             func = getattr(self, fn_name)
         except AttributeError:
             return None
-        name = fn_name
+        name = self.tool_name_prefix + "_" + fn_name if self.tool_name_prefix else fn_name
         docstring = func.__doc__ or ""
         description = f"{name}{signature(func)}\n{docstring}"
         fn_schema = create_schema_from_function(fn_name, getattr(self, fn_name))
         return ToolMetadata(name=name, description=description, fn_schema=fn_schema)
 
-    def _load_data(self, query: str) -> List[Document]:
+    def _load_data(self, sql_query: str) -> List[Document]:
         documents = []
         with self.sql_database.engine.connect() as connection:
-            if query is None:
+            if sql_query is None:
                 raise ValueError("A query parameter is necessary to filter the data")
-            result = connection.execute(text(query))
+            result = connection.execute(text(sql_query))
             for item in result.fetchall():
                 doc_str = ", ".join([str(entry) for entry in item])
                 documents.append(Document(text=doc_str))
         return documents
 
-    def load_data(self, *args: Any, **load_kwargs: Any) -> List[str]:
+    def load_data(self, sql_query: str) -> List[str]:
         """Query and load data from the Database, returning a list of Documents.
         Args:
-            query (str): an SQL query to filter tables and rows.
+            sql_query (str): an SQL query to filter tables and rows.
         Returns:
-            List[Document]: a list of Document objects from the database.
+            List[str]: a list of Document objects from the database.
         """
-        query = args[0] if args else load_kwargs.get("args",{}).get("query")
-        if query is None:
+        if sql_query is None:
             raise ValueError("A query parameter is necessary to filter the data")
 
-        count_query = f"SELECT COUNT(*) FROM ({query})"
+        count_query = f"SELECT COUNT(*) FROM ({sql_query})"
         try:
             count_rows = self._load_data(count_query)
         except Exception as e:
@@ -126,9 +126,9 @@ class DatabaseTools(BaseReader):
                 "Please refactor your query to make it return less rows. "
             ]
         try:
-            res = self._load_data(query)
+            res = self._load_data(sql_query)
         except Exception as e:
-            return [f"Error ({str(e)}) occurred while executing the query {query}"]
+            return [f"Error ({str(e)}) occurred while executing the query {sql_query}"]
         return [d.text for d in res]
 
     def load_sample_data(self, table_name: str, num_rows: int = 25) -> Any:
@@ -141,6 +141,11 @@ class DatabaseTools(BaseReader):
         Returns:
             Any: The result of the database query.
         """
+        if table_name not in self.list_tables():
+            return (
+                f"Table {table_name} does not exist in the database."
+                f"Valid table names are: {self.list_tables()}"
+            )
         try:
             res = self._load_data(f"SELECT * FROM {table_name} LIMIT {num_rows}")
         except Exception as e:
@@ -162,6 +167,15 @@ class DatabaseTools(BaseReader):
             str: A string representation of the table schemas.
         """
         table_names = tables or [table.name for table in self._metadata.sorted_tables]
+        if len(table_names) == 0:
+            return "You must specify at least one table name to describe."
+        for table_name in table_names:
+            if table_name not in self.list_tables():
+                return (
+                    f"Table {table_name} does not exist in the database."
+                    f"Valid table names are: {self.list_tables()}"
+                )
+
         table_schemas = []
         for table_name in table_names:
             table = next(
@@ -186,6 +200,12 @@ class DatabaseTools(BaseReader):
         Returns:
             Any: the result of the database query
         """
+        if table_name not in self.list_tables():
+            return (
+                f"Table {table_name} does not exist in the database."
+                f"Valid table names are: {self.list_tables()}"
+            )
+
         res = {}
         try:
             for column in columns:

vectara_agentic/sub_query_workflow.py

@@ -2,6 +2,8 @@
 This module contains the SubQuestionQueryEngine workflow, which is a workflow
 that takes a user question and a list of tools, and outputs a list of sub-questions.
 """
+
+import re
 import json
 from pydantic import BaseModel
 
@@ -14,6 +16,7 @@ from llama_index.core.workflow import (
     StopEvent,
 )
 
+
 class SubQuestionQueryWorkflow(Workflow):
     """
     Workflow for sub-question query engine.
@@ -24,21 +27,25 @@ class SubQuestionQueryWorkflow(Workflow):
         """
         Inputs for the workflow.
         """
+
         query: str
 
     class OutputsModel(BaseModel):
         """
         Outputs for the workflow.
         """
+
         response: str
 
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
+
         question: str
 
     class AnswerEvent(Event):
         """Event for an answer."""
+
         question: str
         answer: str
 
@@ -51,35 +58,29 @@ class SubQuestionQueryWorkflow(Workflow):
         """
         if not hasattr(ev, "inputs"):
             raise ValueError("No inputs provided to workflow Start Event.")
-        if hasattr(ev, "inputs") and not isinstance(ev.inputs, self.InputsModel):
+        if not isinstance(ev.inputs, self.InputsModel):
             raise ValueError(f"Expected inputs to be of type {self.InputsModel}")
-        if hasattr(ev, "inputs"):
-            query = ev.inputs.query
-            await ctx.set("original_query", query)
-            print(f"Query is {await ctx.get('original_query')}")
 
-        if hasattr(ev, "agent"):
-            await ctx.set("agent", ev.agent)
-        else:
-            raise ValueError("Agent not provided to workflow Start Event.")
-        chat_history = [str(msg) for msg in ev.agent.memory.get()]
+        query = ev.inputs.query
+        await ctx.set("original_query", query)
+        print(f"Query is {query}")
 
-        if hasattr(ev, "llm"):
-            await ctx.set("llm", ev.llm)
-        else:
-            raise ValueError("LLM not provided to workflow Start Event.")
+        required_attrs = ["agent", "llm", "tools"]
+        for attr in required_attrs:
+            if not hasattr(ev, attr):
+                raise ValueError(
+                    f"{attr.capitalize()} not provided to workflow Start Event."
+                )
 
-        if hasattr(ev, "tools"):
-            await ctx.set("tools", ev.tools)
-        else:
-            raise ValueError("Tools not provided to workflow Start Event.")
+        await ctx.set("agent", ev.agent)
+        await ctx.set("llm", ev.llm)
+        await ctx.set("tools", ev.tools)
+        await ctx.set("verbose", getattr(ev, "verbose", False))
 
-        if hasattr(ev, "verbose"):
-            await ctx.set("verbose", ev.verbose)
-        else:
-            await ctx.set("verbose", False)
+        chat_history = [str(msg) for msg in ev.agent.memory.get()]
 
         llm = await ctx.get("llm")
+        original_query = await ctx.get("original_query")
         response = llm.complete(
             f"""
             Given a user question, and a list of tools, output a list of
@@ -100,7 +101,7 @@ class SubQuestionQueryWorkflow(Workflow):
             the sub-questions could be:
             - What is the largest city within 50 miles of San Francisco? (answer is San Jose)
             - What is the name of the mayor of San Jose?
-            Here is the user question: {await ctx.get('original_query')}.
+            Here is the user question: {original_query}.
             Here are previous chat messages: {chat_history}.
             And here is the list of tools: {ev.tools}
             """,
@@ -109,17 +110,35 @@ class SubQuestionQueryWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Sub-questions are {response}")
 
-        response_obj = json.loads(str(response))
-        sub_questions = response_obj["sub_questions"]
+        response_str = str(response)
+        if not response_str:
+            raise ValueError(
+                f"No response from LLM when generating sub-questions for query {original_query}"
+            )
+        try:
+            data = json.loads(response_str)
+        except json.JSONDecodeError as e1:
+            match = re.search(r"\{.*\}", response_str, re.DOTALL)
+            if not match:
+                raise ValueError(f"Invalid LLM response format: {response_str}") from e1
+            try:
+                data = json.loads(match.group(0))
+            except json.JSONDecodeError as e2:
+                raise ValueError(f"Invalid LLM response format: {response_str}") from e2
+
+        sub_questions = data.get("sub_questions")
+        if sub_questions is None:
+            raise ValueError(f"Invalid LLM response format: {response_str}")
+        if not sub_questions:
+            raise ValueError("LLM returned empty sub-questions list")
 
         await ctx.set("sub_question_count", len(sub_questions))
-
         for question in sub_questions:
             ctx.send_event(self.QueryEvent(question=question))
 
         return None
 
-    @step(num_workers=3)
+    @step(num_workers=4)
     async def sub_question(self, ctx: Context, ev: QueryEvent) -> AnswerEvent:
         """
         Given a sub-question, return the answer to the sub-question, using the agent.
@@ -131,9 +150,7 @@ class SubQuestionQueryWorkflow(Workflow):
         return self.AnswerEvent(question=ev.question, answer=str(response))
 
     @step
-    async def combine_answers(
-        self, ctx: Context, ev: AnswerEvent
-    ) -> StopEvent | None:
+    async def combine_answers(self, ctx: Context, ev: AnswerEvent) -> StopEvent | None:
         """
         Given a list of answers to sub-questions, combine them into a single answer.
         """
@@ -144,10 +161,7 @@ class SubQuestionQueryWorkflow(Workflow):
             return None
 
         answers = "\n\n".join(
-            [
-                f"Question: {event.question}: \n Answer: {event.answer}"
-                for event in ready
-            ]
+            f"Question: {event.question}\nAnswer: {event.answer}" for event in ready
         )
 
         prompt = f"""
@@ -169,8 +183,8 @@ class SubQuestionQueryWorkflow(Workflow):
         if await ctx.get("verbose"):
             print("Final response is", response)
 
-        output = self.OutputsModel(response=str(response))
-        return StopEvent(result=output)
+        return StopEvent(result=self.OutputsModel(response=str(response)))
+
 
 class SequentialSubQuestionsWorkflow(Workflow):
     """
@@ -182,17 +196,20 @@ class SequentialSubQuestionsWorkflow(Workflow):
         """
         Inputs for the workflow.
         """
+
         query: str
 
     class OutputsModel(BaseModel):
         """
         Outputs for the workflow.
         """
+
         response: str
 
     # Workflow Event types
     class QueryEvent(Event):
         """Event for a query."""
+
         question: str
         prev_answer: str
         num: int
@@ -232,11 +249,12 @@ class SequentialSubQuestionsWorkflow(Workflow):
             await ctx.set("verbose", ev.verbose)
         else:
             await ctx.set("verbose", False)
+
+        original_query = await ctx.get("original_query")
         if ev.verbose:
-            print(f"Query is {await ctx.get('original_query')}")
+            print(f"Query is {original_query}")
 
         llm = await ctx.get("llm")
-        orig_query = await ctx.get("original_query")
         response = llm.complete(
             f"""
             Given a user question, and a list of tools, output a list of
@@ -257,14 +275,32 @@ class SequentialSubQuestionsWorkflow(Workflow):
             - Who is the mayor of this city?
             The answer to the first question is San Jose, which is given as context to the second question.
             The answer to the second question is Matt Mahan.
-            Here is the user question: {orig_query}.
+            Here is the user question: {original_query}.
             Here are previous chat messages: {chat_history}.
             And here is the list of tools: {ev.tools}
             """,
         )
 
-        response_obj = json.loads(str(response))
-        sub_questions = response_obj["sub_questions"]
+        if not str(response):
+            raise ValueError(f"No response from LLM for query {original_query}")
+
+        response_str = str(response)
+        try:
+            response_obj = json.loads(response_str)
+        except json.JSONDecodeError as e1:
+            match = re.search(r"\{.*\}", response_str, re.DOTALL)
+            if not match:
+                raise ValueError(
+                    f"Failed to extract JSON object with subquestions from LLM response: {response_str}"
+                ) from e1
+            try:
+                response_obj = json.loads(match.group(0))
+            except json.JSONDecodeError as e2:
+                raise ValueError(
+                    f"Failed to extract JSON object with subquestions from LLM response: {response_str}"
+                ) from e2
+
+        sub_questions = response_obj.get("sub_questions")
 
         await ctx.set("sub_questions", sub_questions)
         if await ctx.get("verbose"):
@@ -273,7 +309,9 @@ class SequentialSubQuestionsWorkflow(Workflow):
         return self.QueryEvent(question=sub_questions[0], prev_answer="", num=0)
 
     @step
-    async def sub_question(self, ctx: Context, ev: QueryEvent) -> StopEvent | QueryEvent:
+    async def sub_question(
+        self, ctx: Context, ev: QueryEvent
+    ) -> StopEvent | QueryEvent:
         """
         Given a sub-question, return the answer to the sub-question, using the agent.
         """
@@ -293,12 +331,11 @@ class SequentialSubQuestionsWorkflow(Workflow):
         if await ctx.get("verbose"):
             print(f"Answer is {response}")
 
-        sub_questions = await ctx.get("sub_questions")
         if ev.num + 1 < len(sub_questions):
             return self.QueryEvent(
                 question=sub_questions[ev.num + 1],
-                prev_answer = response.response,
-                num=ev.num + 1
+                prev_answer=response.response,
+                num=ev.num + 1,
             )
 
         output = self.OutputsModel(response=response.response)

vectara_agentic/tools.py

@@ -30,6 +30,7 @@ LI_packages = {
     "arxiv": ToolType.QUERY,
     "tavily_research": ToolType.QUERY,
     "exa": ToolType.QUERY,
+    "brave": ToolType.QUERY,
     "neo4j": ToolType.QUERY,
     "kuzu": ToolType.QUERY,
     "google": {
@@ -54,13 +55,15 @@ LI_packages = {
             "send_message": ToolType.ACTION,
             "fetch_channel": ToolType.QUERY,
         }
-    }
+    },
 }
 
+
 class VectaraToolMetadata(ToolMetadata):
     """
     A subclass of ToolMetadata adding the tool_type attribute.
     """
+
     tool_type: ToolType
 
     def __init__(self, tool_type: ToolType, **kwargs):
@@ -87,7 +90,9 @@ class VectaraTool(FunctionTool):
         fn: Optional[Callable[..., Any]] = None,
         async_fn: Optional[AsyncCallable] = None,
     ) -> None:
-        metadata_dict = metadata.dict() if hasattr(metadata, 'dict') else metadata.__dict__
+        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)
 
@@ -106,19 +111,26 @@ class VectaraTool(FunctionTool):
         tool_type: ToolType = ToolType.QUERY,
     ) -> "VectaraTool":
         tool = FunctionTool.from_defaults(
-            fn, name, description, return_direct, fn_schema, async_fn, tool_metadata,
-            callback, async_callback
+            fn,
+            name,
+            description,
+            return_direct,
+            fn_schema,
+            async_fn,
+            tool_metadata,
+            callback,
+            async_callback,
         )
         vectara_tool = cls(
-            tool_type=tool_type, fn=tool.fn, metadata=tool.metadata, async_fn=tool.async_fn,
+            tool_type=tool_type,
+            fn=tool.fn,
+            metadata=tool.metadata,
+            async_fn=tool.async_fn,
         )
         return vectara_tool
 
     def __str__(self) -> str:
-        return (
-            f"Tool(name={self.metadata.name}, "
-            f"Tool metadata={self.metadata})"
-        )
+        return f"Tool(name={self.metadata.name}, " f"Tool metadata={self.metadata})"
 
     def __repr__(self) -> str:
         return str(self)
@@ -136,19 +148,20 @@ class VectaraTool(FunctionTool):
         # If schema is a dict-like object, compare the dict representation
         try:
             # Try to get schema as dict if possible
-            if hasattr(self.metadata.fn_schema, 'schema'):
+            if hasattr(self.metadata.fn_schema, "schema"):
                 self_schema = self.metadata.fn_schema.schema
                 other_schema = other.metadata.fn_schema.schema
 
                 # Compare only properties and required fields
-                self_props = self_schema.get('properties', {})
-                other_props = other_schema.get('properties', {})
+                self_props = self_schema.get("properties", {})
+                other_props = other_schema.get("properties", {})
 
-                self_required = self_schema.get('required', [])
-                other_required = other_schema.get('required', [])
+                self_required = self_schema.get("required", [])
+                other_required = other_schema.get("required", [])
 
-                return (self_props.keys() == other_props.keys() and
-                        set(self_required) == set(other_required))
+                return self_props.keys() == other_props.keys() and set(
+                    self_required
+                ) == set(other_required)
         except Exception:
             # If any exception occurs during schema comparison, fall back to name comparison
             pass
@@ -163,7 +176,7 @@ class VectaraTool(FunctionTool):
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
-                content=f"Tool Malfunction: {str(e)}",
+                content=f"Tool {self.metadata.name} Malfunction: {str(e)}",
                 raw_input={"args": args, "kwargs": kwargs},
                 raw_output={"response": str(e)},
             )
@@ -177,12 +190,13 @@ class VectaraTool(FunctionTool):
         except Exception as e:
             err_output = ToolOutput(
                 tool_name=self.metadata.name,
-                content=f"Tool Malfunction: {str(e)}",
+                content=f"Tool {self.metadata.name} Malfunction: {str(e)}",
                 raw_input={"args": args, "kwargs": kwargs},
                 raw_output={"response": str(e)},
             )
             return err_output
 
+
 def _create_tool_from_dynamic_function(
     function: Callable[..., ToolOutput],
     tool_name: str,
@@ -196,11 +210,17 @@ def _create_tool_from_dynamic_function(
     """
     fields = {}
     for param in base_params:
-        default_value = param.default if param.default != inspect.Parameter.empty else ...
+        default_value = (
+            param.default if param.default != inspect.Parameter.empty else ...
+        )
         fields[param.name] = (param.annotation, default_value)
     for field_name, field_info in tool_args_schema.model_fields.items():
         if field_name not in fields:
-            default_value = field_info.default if field_info.default is not PydanticUndefined else ...
+            default_value = (
+                field_info.default
+                if field_info.default is not PydanticUndefined
+                else ...
+            )
             fields[field_name] = (field_info.annotation, default_value)
     fn_schema = create_model(f"{tool_name}", **fields)
 
@@ -208,8 +228,16 @@ def _create_tool_from_dynamic_function(
         inspect.Parameter(
             name=field_name,
             kind=inspect.Parameter.POSITIONAL_OR_KEYWORD,
-            default=field_info.default if field_info.default is not PydanticUndefined else inspect.Parameter.empty,
-            annotation=field_info.annotation if hasattr(field_info, 'annotation') else field_info,
+            default=(
+                field_info.default
+                if field_info.default is not PydanticUndefined
+                else inspect.Parameter.empty
+            ),
+            annotation=(
+                field_info.annotation
+                if hasattr(field_info, "annotation")
+                else field_info
+            ),
         )
         for field_name, field_info in tool_args_schema.model_fields.items()
         if field_name not in [p.name for p in base_params]
@@ -217,17 +245,21 @@ def _create_tool_from_dynamic_function(
     all_params = base_params + schema_params
 
     required_params = [p for p in all_params if p.default is inspect.Parameter.empty]
-    optional_params = [p for p in all_params if p.default is not inspect.Parameter.empty]
+    optional_params = [
+        p for p in all_params if p.default is not inspect.Parameter.empty
+    ]
     sig = inspect.Signature(required_params + optional_params)
     function.__signature__ = sig
     function.__annotations__["return"] = dict[str, Any]
-    function.__name__ = "_" + re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
+    function.__name__ = re.sub(r"[^A-Za-z0-9_]", "_", tool_name)
 
     # Create the tool function signature string
     param_strs = []
     for param in all_params:
         annotation = param.annotation
-        type_name = annotation.__name__ if hasattr(annotation, '__name__') else str(annotation)
+        type_name = (
+            annotation.__name__ if hasattr(annotation, "__name__") else str(annotation)
+        )
         param_strs.append(f"{param.name}: {type_name}")
     args_str = ", ".join(param_strs)
     function_str = f"{tool_name}({args_str}) -> str"
@@ -242,7 +274,10 @@ def _create_tool_from_dynamic_function(
     )
     return tool
 
-def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str) -> str:
+
+def _build_filter_string(
+    kwargs: Dict[str, Any], tool_args_type: Dict[str, dict], fixed_filter: str
+) -> str:
     """
     Build filter string for Vectara from kwargs
     """
@@ -256,9 +291,9 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
 
         # Determine the prefix for the key. Valid values are "doc" or "part"
         # default to 'doc' if not specified
-        tool_args_dict = tool_args_type.get(key, {'type': 'doc', 'is_list': False})
+        tool_args_dict = tool_args_type.get(key, {"type": "doc", "is_list": False})
         prefix = tool_args_dict.get(key, "doc")
-        is_list = tool_args_dict.get('is_list', False)
+        is_list = tool_args_dict.get("is_list", False)
 
         if prefix not in ["doc", "part"]:
             raise ValueError(
@@ -311,12 +346,10 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
                     range_conditions.append(f"{prefix}.{key} {operator} {end_val}")
 
                 # Join the range conditions with AND
-                filter_parts.append('( ' + " AND ".join(range_conditions) + ' )')
+                filter_parts.append("( " + " AND ".join(range_conditions) + " )")
                 continue
 
-            raise ValueError(
-                f"Range operator requires two values for {key}: {value}"
-            )
+            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
@@ -328,7 +361,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
         # Break down operator from value
         # e.g. val_str = ">2022" --> operator = ">", rhs = "2022"
         if matched_operator:
-            rhs = val_str[len(matched_operator):].strip()
+            rhs = val_str[len(matched_operator) :].strip()
 
             if matched_operator in numeric_only_ops:
                 # Must be numeric
@@ -342,7 +375,9 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
                 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()}")
+                    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}'")
@@ -372,6 +407,7 @@ def _build_filter_string(kwargs: Dict[str, Any], tool_args_type: Dict[str, dict]
     else:
         return fixed_filter or filter_str
 
+
 class VectaraToolFactory:
     """
     A factory class for creating Vectara RAG tools.
@@ -479,7 +515,9 @@ class VectaraToolFactory:
             top_k = kwargs.pop("top_k", 10)
             summarize = kwargs.pop("summarize", True)
             try:
-                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+                filter_string = _build_filter_string(
+                    kwargs, tool_args_type, fixed_filter
+                )
             except ValueError as e:
                 return ToolOutput(
                     tool_name=search_function.__name__,
@@ -492,7 +530,11 @@ class VectaraToolFactory:
                 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),
+                rerank_k=(
+                    rerank_k
+                    if rerank_k * self.num_corpora <= 100
+                    else int(100 / self.num_corpora)
+                ),
                 rerank_limit=rerank_limit,
                 rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
@@ -530,9 +572,7 @@ class VectaraToolFactory:
             if summarize:
                 summaries_dict = asyncio.run(
                     summarize_documents(
-                        self.vectara_corpus_key,
-                        self.vectara_api_key,
-                        list(unique_ids)
+                        self.vectara_corpus_key, self.vectara_api_key, list(unique_ids)
                     )
                 )
                 for doc_id, metadata in docs:
@@ -540,7 +580,9 @@ class VectaraToolFactory:
                     tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
             else:
                 for doc_id, metadata in docs:
-                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+                    tool_output += (
+                        f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
+                    )
 
             out = ToolOutput(
                 tool_name=search_function.__name__,
@@ -551,16 +593,29 @@ class VectaraToolFactory:
             return out
 
         base_params = [
-            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
-            inspect.Parameter("top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
-            inspect.Parameter("summarize", inspect.Parameter.POSITIONAL_OR_KEYWORD, default=True, annotation=bool),
+            inspect.Parameter(
+                "query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str
+            ),
+            inspect.Parameter(
+                "top_k", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=int
+            ),
+            inspect.Parameter(
+                "summarize",
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                default=True,
+                annotation=bool,
+            ),
         ]
-        search_tool_extra_desc = tool_description + "\n" + """
+        search_tool_extra_desc = (
+            tool_description
+            + "\n"
+            + """
         This tool is meant to perform a search for relevant documents, it is not meant for asking questions.
         The response includes metadata about each relevant document.
         If summarize=True, it also includes a summary of each document, but takes a lot longer to respond,
         so avoid using it unless necessary.
         """
+        )
 
         tool = _create_tool_from_dynamic_function(
             search_function,
@@ -683,7 +738,9 @@ class VectaraToolFactory:
 
             query = kwargs.pop("query")
             try:
-                filter_string = _build_filter_string(kwargs, tool_args_type, fixed_filter)
+                filter_string = _build_filter_string(
+                    kwargs, tool_args_type, fixed_filter
+                )
             except ValueError as e:
                 return ToolOutput(
                     tool_name=rag_function.__name__,
@@ -700,7 +757,11 @@ class VectaraToolFactory:
                 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),
+                rerank_k=(
+                    rerank_k
+                    if rerank_k * self.num_corpora <= 100
+                    else int(100 / self.num_corpora)
+                ),
                 rerank_limit=rerank_limit,
                 rerank_cutoff=rerank_cutoff,
                 mmr_diversity_bias=mmr_diversity_bias,
@@ -792,7 +853,9 @@ class VectaraToolFactory:
             return out
 
         base_params = [
-            inspect.Parameter("query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+            inspect.Parameter(
+                "query", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=str
+            ),
         ]
         tool = _create_tool_from_dynamic_function(
             rag_function,
@@ -803,6 +866,7 @@ class VectaraToolFactory:
         )
         return tool
 
+
 class ToolsFactory:
     """
     A factory class for creating agent tools.
@@ -811,7 +875,9 @@ class ToolsFactory:
     def __init__(self, agent_config: AgentConfig = None) -> None:
         self.agent_config = agent_config
 
-    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.
 
@@ -845,7 +911,9 @@ class ToolsFactory:
         """
         # Dynamically install and import the module
         if tool_package_name not in LI_packages:
-            raise ValueError(f"Tool package {tool_package_name} from LlamaIndex not supported by Vectara-agentic.")
+            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)
@@ -860,11 +928,18 @@ class ToolsFactory:
                 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
 
@@ -873,7 +948,10 @@ class ToolsFactory:
         Create a list of standard tools.
         """
         tc = ToolsCatalog(self.agent_config)
-        return [self.create_tool(tool) for tool in [tc.summarize_text, tc.rephrase_text, tc.critique_text]]
+        return [
+            self.create_tool(tool)
+            for tool in [tc.summarize_text, tc.rephrase_text, tc.critique_text]
+        ]
 
     def guardrail_tools(self) -> List[FunctionTool]:
         """
@@ -885,7 +963,9 @@ class ToolsFactory:
         """
         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]:
         """
@@ -917,7 +997,9 @@ 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,
@@ -954,16 +1036,22 @@ class ToolsFactory:
             List[VectaraTool]: A list of VectaraTool objects.
         """
         if sql_database:
-            dbt = DatabaseTools(sql_database=sql_database)
+            dbt = DatabaseTools(
+                tool_name_prefix=tool_name_prefix,
+                sql_database=sql_database,
+                max_rows=max_rows,
+            )
         else:
             if scheme in ["postgresql", "mysql", "sqlite", "mssql", "oracle"]:
                 dbt = DatabaseTools(
+                    tool_name_prefix=tool_name_prefix,
                     scheme=scheme,
                     host=host,
                     port=port,
                     user=user,
                     password=password,
                     dbname=dbname,
+                    max_rows=max_rows,
                 )
             else:
                 raise ValueError(
@@ -977,14 +1065,14 @@ class ToolsFactory:
         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
+                    + f"The database tables include data about {content_description}."
                 )
-            if len(tool_name_prefix) > 0:
-                tool.metadata.name = tool_name_prefix + "_" + tool.metadata.name
             vtool = VectaraTool(
                 tool_type=ToolType.QUERY,
-                fn=tool.fn, async_fn=tool.async_fn,
-                metadata=tool.metadata
+                fn=tool.fn,
+                async_fn=tool.async_fn,
+                metadata=tool.metadata,
             )
             vtools.append(vtool)
         return vtools

{vectara_agentic-0.2.9.dist-info → vectara_agentic-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.9
+Version: 0.2.11
 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,31 +16,31 @@ 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.26
+Requires-Dist: llama-index==0.12.29
 Requires-Dist: llama-index-indices-managed-vectara==0.4.2
 Requires-Dist: llama-index-agent-llm-compiler==0.3.0
 Requires-Dist: llama-index-agent-lats==0.3.0
 Requires-Dist: llama-index-agent-openai==0.4.6
-Requires-Dist: llama-index-llms-openai==0.3.25
+Requires-Dist: llama-index-llms-openai==0.3.32
 Requires-Dist: llama-index-llms-anthropic==0.6.10
 Requires-Dist: llama-index-llms-together==0.3.1
 Requires-Dist: llama-index-llms-groq==0.3.1
 Requires-Dist: llama-index-llms-fireworks==0.3.2
 Requires-Dist: llama-index-llms-cohere==0.4.0
-Requires-Dist: llama-index-llms-gemini==0.4.11
-Requires-Dist: llama-index-llms-bedrock==0.3.4
+Requires-Dist: llama-index-llms-gemini==0.4.14
+Requires-Dist: llama-index-llms-bedrock==0.3.8
 Requires-Dist: llama-index-tools-yahoo-finance==0.3.0
 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.brave_search==0.3.0
 Requires-Dist: llama-index-tools-neo4j==0.3.0
-Requires-Dist: llama-index-graph-stores-kuzu==0.6.0
+Requires-Dist: llama-index-graph-stores-kuzu==0.7.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.1
-Requires-Dist: exa-py==1.8.9
-Requires-Dist: yahoo-finance==1.4.0
+Requires-Dist: tavily-python==0.5.4
+Requires-Dist: exa-py==1.9.1
 Requires-Dist: openinference-instrumentation-llama-index==3.3.3
 Requires-Dist: opentelemetry-proto==1.31.0
 Requires-Dist: arize-phoenix==8.14.1
@@ -176,7 +176,7 @@ query_financial_reports_tool = vec_factory.create_rag_tool(
 )
 ```
 
-See the [docs](https://vectara.github.io/vectara-agentic-docs/) for additional arguments to customize your Vectara RAG tool.
+See the [docs](https://vectara.github.io/py-vectara-agentic/latest/) for additional arguments to customize your Vectara RAG tool.
 
 ### 3. Create other tools (optional)
 
@@ -205,7 +205,7 @@ agent = Agent(
 )
 ```
 
-See the [docs](https://vectara.github.io/vectara-agentic-docs/) for additional arguments, including `agent_progress_callback` and `query_logging_callback`.
+See the [docs](https://vectara.github.io/py-vectara-agentic/latest/) for additional arguments, including `agent_progress_callback` and `query_logging_callback`.
 
 ### 5. Run a chat interaction
 
@@ -376,7 +376,7 @@ specified in the Agent configuration.
 - `load_unique_values`: returns the top unique values for a given column
 
 In addition, we include various other tools from LlamaIndex ToolSpecs:
-* Tavily search and EXA.AI
+* Tavily search, EXA.AI and Brave Search
 * arxiv
 * neo4j & Kuzu for Graph DB integration
 * Google tools (including gmail, calendar, and search)

{vectara_agentic-0.2.9.dist-info → vectara_agentic-0.2.11.dist-info}/RECORD

@@ -6,24 +6,24 @@ tests/test_agent_type.py,sha256=JM0Q2GBGHSADoBacz_DW551zWSfbpf7qa8xXqtyWsc4,5671
 tests/test_fallback.py,sha256=M5YD7NHZ0joVU1frYIr9_OiRAIje5mrXrYVcekzlyGs,2829
 tests/test_private_llm.py,sha256=CY-_rCpxGUuxnZ3ypkodw5Jj-sJCNdh6rLbCvULwuJI,2247
 tests/test_serialization.py,sha256=Ed23GN2zhSJNdPFrVK4aqLkOhJKviczR_o0t-r9TuRI,4762
-tests/test_tools.py,sha256=IVKn0HoS2erTCr1mOEGzTkktiY0PCfKNvqnD_pizjOg,3977
+tests/test_tools.py,sha256=as0rEAKAs6ekvqFDCcq1smRWKhQm5EaH2PUWT8hg1qQ,5726
 tests/test_workflow.py,sha256=lVyrVHdRO5leYNbYtHTmKqMX0c8_xehCpUA7cXQKVsc,2175
 vectara_agentic/__init__.py,sha256=2GLDS3U6KckK-dBRl9v_x1kSV507gEhjOfuMmmu0Qxg,850
-vectara_agentic/_callback.py,sha256=lU35-Pxp-fsMpOi4woY6oLECAhO1nSmLIy3b8fbgT54,13029
-vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
-vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
-vectara_agentic/_version.py,sha256=H4T1Nr91mODgWHnEWr2XhUyVnkEh_ZuEEayYoJS0Iis,65
-vectara_agentic/agent.py,sha256=ItNy6QRfgkk-zePK05k8yhsov_TVh5ScB-BbiQdUbTY,43956
+vectara_agentic/_callback.py,sha256=ron49t1t-ox-736WaXzrZ99vhN4NI9bMiHFyj0iIPqg,13062
+vectara_agentic/_observability.py,sha256=BA2zhwa5930aaDUJxHefPlmIPt8kZOuLHVBc9PtYNuU,3839
+vectara_agentic/_prompts.py,sha256=CKbsFrosoM6bPH02t2R5_K3jzVzaxJAl85qO3mEAQ3U,9439
+vectara_agentic/_version.py,sha256=uneBdCHiroBsYz5R-8jYqrJU6UuA9Nu4vCqLtO0VSsE,66
+vectara_agentic/agent.py,sha256=KX0VYQuGFkK_CELjUFdxXWYHng32GFjsLdRdH-gR7aM,43970
 vectara_agentic/agent_config.py,sha256=E-rtYMcpoGxnEAyy8231bizo2n0uGQ2qWxuSgTEfwdQ,4327
 vectara_agentic/agent_endpoint.py,sha256=QIMejCLlpW2qzXxeDAxv3anF46XMDdVMdKGWhJh3azY,1996
-vectara_agentic/db_tools.py,sha256=Go03bzma9m-qDH0CPP8hWhf1nu_4S6s7ke0jGqz58Pk,10296
-vectara_agentic/sub_query_workflow.py,sha256=3WoVnryR2NXyYXbLDM1XVLd7DtbCG0jgrVqeDUN4YNQ,10943
-vectara_agentic/tools.py,sha256=vOIevyGhApeZ46UelSTXmKXWE26Z2KtjLgsb4cHP49M,42579
+vectara_agentic/db_tools.py,sha256=zhP1KIRNiE6BKD69VGmUdcjeKSZ6g0kTIsJdTDNCuv4,11141
+vectara_agentic/sub_query_workflow.py,sha256=xjySd2qjLAKwK6XuS0R0PTyk2uXraHCgCbDP1xDoFVI,12175
+vectara_agentic/tools.py,sha256=n06CwlEqOHlawEJj6BX8xHM5-kMrBQO48Jo68GKRKes,43874
 vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
 vectara_agentic/utils.py,sha256=4vA5MyNoG47_7eHuLFQByiG_FHWbrQ6ZJDsdqHUwiJA,7720
-vectara_agentic-0.2.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.9.dist-info/METADATA,sha256=FfjEtidIWQlsUXY_cdVIxPc6h07M3JwXjQKEj3aCMLY,25046
-vectara_agentic-0.2.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectara_agentic-0.2.9.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.9.dist-info/RECORD,,
+vectara_agentic-0.2.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.11.dist-info/METADATA,sha256=c0ue2vnkkIwgNueoHQILYkui5eTDbXB7-SnBBnbWK0A,25088
+vectara_agentic-0.2.11.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.11.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.11.dist-info/RECORD,,