vectara-agentic 0.2.8__py3-none-any.whl → 0.2.10__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

@@ -4,12 +4,35 @@ Module to handle agent callbacks
 
 import inspect
 from typing import Any, Dict, Optional, List, Callable
+from functools import wraps
 
 from llama_index.core.callbacks.base_handler import BaseCallbackHandler
 from llama_index.core.callbacks.schema import CBEventType, EventPayload
 
 from .types import AgentStatusType
 
+def wrap_callback_fn(callback):
+    """
+    Wrap a callback function to ensure it only receives the parameters it can accept.
+    This is useful for ensuring that the callback function does not receive unexpected
+    parameters, especially when the callback is called from different contexts.
+    """
+    if callback is None:
+        return None
+    try:
+        sig = inspect.signature(callback)
+        allowed_params = set(sig.parameters.keys())
+    except Exception:
+        # If we cannot determine the signature, return the callback as is.
+        return callback
+
+    @wraps(callback)
+    def new_callback(*args, **kwargs):
+        # Filter kwargs to only those that the original callback accepts.
+        filtered_kwargs = {k: v for k, v in kwargs.items() if k in allowed_params}
+        return callback(*args, **filtered_kwargs)
+
+    return new_callback
 
 class AgentCallbackHandler(BaseCallbackHandler):
     """
@@ -24,7 +47,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
 
     def __init__(self, fn: Optional[Callable] = None) -> None:
         super().__init__(event_starts_to_ignore=[], event_ends_to_ignore=[])
-        self.fn = fn
+        self.fn = wrap_callback_fn(fn)
 
     # Existing synchronous methods
     def on_event_start(
@@ -37,9 +60,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
     ) -> str:
         if self.fn is not None and payload is not None:
             if inspect.iscoroutinefunction(self.fn):
-                raise ValueError("Synchronous callback handler cannot use async callback function")
+                raise ValueError(
+                    "Synchronous callback handler cannot use async callback function"
+                )
             # Handle events as before
-            self._handle_event(event_type, payload)
+            self._handle_event(event_type, payload, event_id)
         return event_id
 
     def start_trace(self, trace_id: Optional[str] = None) -> None:
@@ -73,9 +98,11 @@ class AgentCallbackHandler(BaseCallbackHandler):
         """
         if self.fn is not None and payload is not None:
             if inspect.iscoroutinefunction(self.fn):
-                raise ValueError("Synchronous callback handler cannot use async callback function")
+                raise ValueError(
+                    "Synchronous callback handler cannot use async callback function"
+                )
             # Handle events as before
-            self._handle_event(event_type, payload)
+            self._handle_event(event_type, payload, event_id)
 
     # New asynchronous methods
     async def aon_event_start(
@@ -100,7 +127,7 @@ class AgentCallbackHandler(BaseCallbackHandler):
             event_id: the event ID
         """
         if self.fn is not None and payload is not None:
-            await self._ahandle_event(event_type, payload)
+            await self._ahandle_event(event_type, payload, event_id)
         return event_id
 
     async def aon_event_end(
@@ -114,48 +141,66 @@ class AgentCallbackHandler(BaseCallbackHandler):
         Handle the end of an event (async)
         """
         if self.fn is not None and payload is not None:
-            await self._ahandle_event(event_type, payload)
+            await self._ahandle_event(event_type, payload, event_id)
 
     # Helper methods for handling events
-    def _handle_event(self, event_type: CBEventType, payload: Dict[str, Any]) -> None:
+    def _handle_event(
+        self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
+    ) -> None:
         if event_type == CBEventType.LLM:
-            self._handle_llm(payload)
+            self._handle_llm(payload, event_id)
         elif event_type == CBEventType.FUNCTION_CALL:
-            self._handle_function_call(payload)
+            self._handle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
-            self._handle_agent_step(payload)
+            self._handle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
             print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
-    async def _ahandle_event(self, event_type: CBEventType, payload: Dict[str, Any]) -> None:
+    async def _ahandle_event(
+        self, event_type: CBEventType, payload: Dict[str, Any], event_id: str
+    ) -> None:
         if event_type == CBEventType.LLM:
-            await self._ahandle_llm(payload)
+            await self._ahandle_llm(payload, event_id)
         elif event_type == CBEventType.FUNCTION_CALL:
-            await self._ahandle_function_call(payload)
+            await self._ahandle_function_call(payload, event_id)
         elif event_type == CBEventType.AGENT_STEP:
-            await self._ahandle_agent_step(payload)
+            await self._ahandle_agent_step(payload, event_id)
         elif event_type == CBEventType.EXCEPTION:
             print(f"Exception: {payload.get(EventPayload.EXCEPTION)}")
         else:
             print(f"Unknown event type: {event_type}, payload={payload}")
 
     # Synchronous handlers
-    def _handle_llm(self, payload: dict) -> None:
+    def _handle_llm(
+        self,
+        payload: dict,
+        event_id: str,
+    ) -> None:
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
                 if self.fn:
-                    self.fn(AgentStatusType.AGENT_UPDATE, response)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_UPDATE,
+                        msg=response,
+                        event_id=event_id,
+                    )
         elif EventPayload.PROMPT in payload:
             prompt = str(payload.get(EventPayload.PROMPT))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_UPDATE, prompt)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_UPDATE,
+                    msg=prompt,
+                    event_id=event_id,
+                )
         else:
-            print(f"vectara-agentic llm callback: no messages or prompt found in payload {payload}")
+            print(
+                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
+            )
 
-    def _handle_function_call(self, payload: dict) -> None:
+    def _handle_function_call(self, payload: dict, event_id: str) -> None:
         if EventPayload.FUNCTION_CALL in payload:
             fcall = str(payload.get(EventPayload.FUNCTION_CALL))
             tool = payload.get(EventPayload.TOOL)
@@ -163,46 +208,77 @@ class AgentCallbackHandler(BaseCallbackHandler):
                 tool_name = tool.name
                 if self.fn:
                     self.fn(
-                        AgentStatusType.TOOL_CALL,
-                        f"Executing '{tool_name}' with arguments: {fcall}",
+                        status_type=AgentStatusType.TOOL_CALL,
+                        msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                        event_id=event_id,
                     )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
             if self.fn:
-                self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                self.fn(
+                    status_type=AgentStatusType.TOOL_OUTPUT,
+                    msg=response,
+                    event_id=event_id,
+                )
         else:
-            print(f"Vectara-agentic callback handler: no function call or output found in payload {payload}")
+            print(
+                f"Vectara-agentic callback handler: no function call or output found in payload {payload}"
+            )
 
-    def _handle_agent_step(self, payload: dict) -> None:
+    def _handle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             msg = str(payload.get(EventPayload.MESSAGES))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_STEP, msg)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_STEP,
+                    msg=msg,
+                    event_id=event_id,
+                )
         elif EventPayload.RESPONSE in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_STEP, response)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_STEP,
+                    msg=response,
+                    event_id=event_id,
+                )
         else:
-            print(f"Vectara-agentic agent_step: no messages or prompt found in payload {payload}")
+            print(
+                f"Vectara-agentic agent_step: no messages or prompt found in payload {payload}"
+            )
 
     # Asynchronous handlers
-    async def _ahandle_llm(self, payload: dict) -> None:
+    async def _ahandle_llm(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             response = str(payload.get(EventPayload.RESPONSE))
             if response and response not in ["None", "assistant: None"]:
                 if self.fn:
                     if inspect.iscoroutinefunction(self.fn):
-                        await self.fn(AgentStatusType.AGENT_UPDATE, response)
+                        await self.fn(
+                            status_type=AgentStatusType.AGENT_UPDATE,
+                            msg=response,
+                            event_id=event_id,
+                        )
                     else:
-                        self.fn(AgentStatusType.AGENT_UPDATE, response)
+                        self.fn(
+                            status_type=AgentStatusType.AGENT_UPDATE,
+                            msg=response,
+                            event_id=event_id,
+                        )
         elif EventPayload.PROMPT in payload:
             prompt = str(payload.get(EventPayload.PROMPT))
             if self.fn:
-                self.fn(AgentStatusType.AGENT_UPDATE, prompt)
+                self.fn(
+                    status_type=AgentStatusType.AGENT_UPDATE,
+                    msg=prompt,
+                    event_id=event_id,
+                )
         else:
-            print(f"vectara-agentic llm callback: no messages or prompt found in payload {payload}")
+            print(
+                f"vectara-agentic llm callback: no messages or prompt found in payload {payload}"
+            )
 
-    async def _ahandle_function_call(self, payload: dict) -> None:
+    async def _ahandle_function_call(self, payload: dict, event_id: str) -> None:
         if EventPayload.FUNCTION_CALL in payload:
             fcall = str(payload.get(EventPayload.FUNCTION_CALL))
             tool = payload.get(EventPayload.TOOL)
@@ -211,38 +287,64 @@ class AgentCallbackHandler(BaseCallbackHandler):
                 if self.fn:
                     if inspect.iscoroutinefunction(self.fn):
                         await self.fn(
-                            AgentStatusType.TOOL_CALL,
-                            f"Executing '{tool_name}' with arguments: {fcall}",
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                            event_id=event_id,
                         )
                     else:
                         self.fn(
-                            AgentStatusType.TOOL_CALL,
-                            f"Executing '{tool_name}' with arguments: {fcall}",
+                            status_type=AgentStatusType.TOOL_CALL,
+                            msg=f"Executing '{tool_name}' with arguments: {fcall}",
+                            event_id=event_id,
                         )
         elif EventPayload.FUNCTION_OUTPUT in payload:
             if self.fn:
                 response = str(payload.get(EventPayload.FUNCTION_OUTPUT))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    await self.fn(
+                        status_type=AgentStatusType.TOOL_OUTPUT,
+                        msg=response,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.TOOL_OUTPUT, response)
+                    self.fn(
+                        status_type=AgentStatusType.TOOL_OUTPUT,
+                        msg=response,
+                        event_id=event_id,
+                    )
         else:
             print(f"No function call or output found in payload {payload}")
 
-    async def _ahandle_agent_step(self, payload: dict) -> None:
+    async def _ahandle_agent_step(self, payload: dict, event_id: str) -> None:
         if EventPayload.MESSAGES in payload:
             if self.fn:
                 msg = str(payload.get(EventPayload.MESSAGES))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_STEP, msg)
+                    await self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=msg,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.AGENT_STEP, msg)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=msg,
+                        event_id=event_id,
+                    )
         elif EventPayload.RESPONSE in payload:
             if self.fn:
                 response = str(payload.get(EventPayload.RESPONSE))
                 if inspect.iscoroutinefunction(self.fn):
-                    await self.fn(AgentStatusType.AGENT_STEP, response)
+                    await self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=response,
+                        event_id=event_id,
+                    )
                 else:
-                    self.fn(AgentStatusType.AGENT_STEP, response)
+                    self.fn(
+                        status_type=AgentStatusType.AGENT_STEP,
+                        msg=response,
+                        event_id=event_id,
+                    )
         else:
             print(f"No messages or prompt found in 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/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.8"
+__version__ = "0.2.10"

vectara_agentic/agent.py

@@ -33,7 +33,7 @@ from llama_index.core.agent.types import BaseAgent
 from llama_index.core.workflow import Workflow
 
 from .types import (
-    AgentType, AgentStatusType, LLMRole, ToolType,
+    AgentType, AgentStatusType, LLMRole, ToolType, ModelProvider,
     AgentResponse, AgentStreamingResponse, AgentConfigType
 )
 from .utils import get_llm, get_tokenizer_for_model
@@ -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
@@ -278,6 +278,10 @@ class Agent:
         llm.callback_manager = llm_callback_manager
 
         if agent_type == AgentType.FUNCTION_CALLING:
+            if config.tool_llm_provider == ModelProvider.OPENAI:
+                raise ValueError(
+                    "Vectara-agentic: Function calling agent type is not supported with the OpenAI LLM."
+                )
             prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = FunctionCallingAgent.from_tools(
                 tools=self.tools,
@@ -286,7 +290,7 @@ class Agent:
                 verbose=self.verbose,
                 max_function_calls=config.max_reasoning_steps,
                 callback_manager=llm_callback_manager,
-                system_prompt = prompt,
+                system_prompt=prompt,
                 allow_parallel_tool_calls=True,
             )
         elif agent_type == AgentType.REACT:
@@ -301,6 +305,10 @@ class Agent:
                 callable_manager=llm_callback_manager,
             )
         elif agent_type == AgentType.OPENAI:
+            if config.tool_llm_provider != ModelProvider.OPENAI:
+                raise ValueError(
+                    "Vectara-agentic: OPENAI agent type requires the OpenAI LLM."
+                )
             prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = OpenAIAgent.from_tools(
                 tools=self.tools,

vectara_agentic/agent_config.py

@@ -71,6 +71,17 @@ class AgentConfig:
         default_factory=lambda: int(os.getenv("VECTARA_AGENTIC_MAX_REASONING_STEPS", "50"))
     )
 
+    def __post_init__(self):
+        # Use object.__setattr__ since the dataclass is frozen
+        if isinstance(self.agent_type, str):
+            object.__setattr__(self, "agent_type", AgentType(self.agent_type))
+        if isinstance(self.main_llm_provider, str):
+            object.__setattr__(self, "main_llm_provider", ModelProvider(self.main_llm_provider))
+        if isinstance(self.tool_llm_provider, str):
+            object.__setattr__(self, "tool_llm_provider", ModelProvider(self.tool_llm_provider))
+        if isinstance(self.observer, str):
+            object.__setattr__(self, "observer", ObserverType(self.observer))
+
     def to_dict(self) -> dict:
         """
         Convert the AgentConfig to a dictionary.

vectara_agentic/sub_query_workflow.py

@@ -2,6 +2,7 @@
 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 json
 from pydantic import BaseModel
 
@@ -14,6 +15,7 @@ from llama_index.core.workflow import (
     StopEvent,
 )
 
+
 class SubQuestionQueryWorkflow(Workflow):
     """
     Workflow for sub-question query engine.
@@ -24,21 +26,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 +57,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 +100,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 +109,25 @@ 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"]
+        if not str(response):
+            raise ValueError(
+                f"No response from LLM when generating sub-questions for query {original_query}"
+            )
 
-        await ctx.set("sub_question_count", len(sub_questions))
+        try:
+            sub_questions = json.loads(str(response))["sub_questions"]
+            if not sub_questions:
+                raise ValueError("LLM returned empty sub-questions list")
+        except (json.JSONDecodeError, KeyError) as e:
+            raise ValueError(f"Invalid LLM response format: {response}") from e
 
+        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 +139,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 +150,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 +172,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 +185,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 +238,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,12 +264,15 @@ 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}
             """,
         )
 
+        if not str(response):
+            raise ValueError(f"No response from LLM for query {original_query}")
+
         response_obj = json.loads(str(response))
         sub_questions = response_obj["sub_questions"]
 
@@ -273,7 +283,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.
         """
@@ -297,8 +309,8 @@ class SequentialSubQuestionsWorkflow(Workflow):
         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": {
@@ -163,7 +164,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,7 +178,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)},
             )
@@ -539,8 +540,8 @@ class VectaraToolFactory:
                     summary = summaries_dict.get(doc_id, "")
                     tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\nsummary: '{summary}'\n\n"
             else:
-                for doc in docs:
-                    tool_output += f"document_id: '{doc.id_}'\nmetadata: '{doc.metadata}'\n\n"
+                for doc_id, metadata in docs:
+                    tool_output += f"document_id: '{doc_id}'\nmetadata: '{metadata}'\n\n"
 
             out = ToolOutput(
                 tool_name=search_function.__name__,

vectara_agentic/utils.py

@@ -43,7 +43,7 @@ def _get_llm_params_for_role(
     config = config or AgentConfig()  # fallback to default config
 
     if role == LLMRole.TOOL:
-        model_provider = config.tool_llm_provider
+        model_provider = ModelProvider(config.tool_llm_provider)
         # If the user hasn’t explicitly set a tool_llm_model_name,
         # fallback to provider default from provider_to_default_model_name
         model_name = (
@@ -51,7 +51,7 @@ def _get_llm_params_for_role(
             or provider_to_default_model_name.get(model_provider)
         )
     else:
-        model_provider = config.main_llm_provider
+        model_provider = ModelProvider(config.main_llm_provider)
         model_name = (
             config.main_llm_model_name
             or provider_to_default_model_name.get(model_provider)
@@ -110,6 +110,7 @@ def get_llm(
         llm = Gemini(
             model=model_name, temperature=0,
             is_function_calling_model=True,
+            allow_parallel_tool_calls=True,
             max_tokens=max_tokens,
         )
     elif model_provider == ModelProvider.TOGETHER:

{vectara_agentic-0.2.8.dist-info → vectara_agentic-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.8
+Version: 0.2.10
 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.8.dist-info → vectara_agentic-0.2.10.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=5PfqjLmuaZIR6dnqmhniTD_zwCgfi7kOu-nexb6Kss4,9688
-vectara_agentic/_observability.py,sha256=fTL3KW0jQU-_JSpFgjO6-XzgDut_oiq9kt4QR-FkSqU,3804
+vectara_agentic/_callback.py,sha256=lU35-Pxp-fsMpOi4woY6oLECAhO1nSmLIy3b8fbgT54,13029
+vectara_agentic/_observability.py,sha256=BA2zhwa5930aaDUJxHefPlmIPt8kZOuLHVBc9PtYNuU,3839
 vectara_agentic/_prompts.py,sha256=LYyiOAiC8imz3U7MSJiuCYAP39afsp7ycXY7-9biyJI,9314
-vectara_agentic/_version.py,sha256=HOBvs3gmojKxd7sNMHt6Q-0_rlFpgzlI1gXNZOS_Fqc,65
-vectara_agentic/agent.py,sha256=ioC6EN86_d7SS1jEZ6CUe6OtetuGmLdWftj5bklPfMs,43522
-vectara_agentic/agent_config.py,sha256=y1hSvU5ns0cE2R7BqF65LFstixF1ytJcoVgicGXo7w0,3691
+vectara_agentic/_version.py,sha256=-h5PMZplLmgj04BNOpvmJ0dvWk8SQqCU6tP_hnySaFE,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=Mm2qfJZWnbNa9G-ycYMP7NPLSo4uUJ9_y45YmXxtlSc,42571
+vectara_agentic/sub_query_workflow.py,sha256=rwiS4e-k75LQvT_WdwoRI8sAJRsL9kiDZlrPwcjYUAE,11120
+vectara_agentic/tools.py,sha256=EC4NAhJy_SB62c2e-fmalWLXtTt6Pgjfi0qE22KxRco,42650
 vectara_agentic/tools_catalog.py,sha256=oiw3wAfbpFhh0_6rMvZsyPqWV6QIzHqhZCNzqRxuyV8,4818
 vectara_agentic/types.py,sha256=HcS7vR8P2v2xQTlOc6ZFV2vvlr3OpzSNWhtcLMxqUZc,1792
-vectara_agentic/utils.py,sha256=nBQqVb4_UNummqVz28DHm3VaKzy8OAq-xSjhU23uxWU,7646
-vectara_agentic-0.2.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vectara_agentic-0.2.8.dist-info/METADATA,sha256=IV5fm77XOPOvqfcpCZUKRxq9QgnoF3mPu-om_sTKEK8,25046
-vectara_agentic-0.2.8.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-vectara_agentic-0.2.8.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
-vectara_agentic-0.2.8.dist-info/RECORD,,
+vectara_agentic/utils.py,sha256=4vA5MyNoG47_7eHuLFQByiG_FHWbrQ6ZJDsdqHUwiJA,7720
+vectara_agentic-0.2.10.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vectara_agentic-0.2.10.dist-info/METADATA,sha256=LjjT33W4ISkAKJIk0_tJSxYuF39Z5EY355qrz6dCbR4,25088
+vectara_agentic-0.2.10.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+vectara_agentic-0.2.10.dist-info/top_level.txt,sha256=Y7TQTFdOYGYodQRltUGRieZKIYuzeZj2kHqAUpfCUfg,22
+vectara_agentic-0.2.10.dist-info/RECORD,,