vectara-agentic 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

tests/test_agent.py

@@ -124,7 +124,7 @@ class TestAgentPackage(unittest.TestCase):
         self.assertEqual(res.response, "1050")
 
     def test_custom_general_instruction(self):
-        general_instructions = "Always respond with 'I DIDNT DO IT'"
+        general_instructions = "Always respond with: I DIDN'T DO IT"
         agent = Agent.from_corpus(
             tool_name="RAG Tool",
             vectara_corpus_key="corpus_key",
@@ -135,7 +135,7 @@ class TestAgentPackage(unittest.TestCase):
         )
 
         res = agent.chat("What is the meaning of the universe?")
-        self.assertEqual(res.response, "I DIDNT DO IT")
+        self.assertEqual(res.response, "I DIDN'T DO IT")
 
 
 if __name__ == "__main__":

tests/test_agent_planning.py

@@ -4,7 +4,7 @@ from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import VectaraToolFactory
 
-# SETUP speical test account credentials for vectara
+# SETUP special test account credentials for vectara
 # It's okay to expose these credentials in the test code
 vectara_corpus_key = "vectara-docs_1"
 vectara_api_key = 'zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA'

tests/test_groq.py

@@ -113,7 +113,9 @@ class TestGROQ(unittest.TestCase):
             agent_config=fc_config_groq,
         )
         res = agent.chat("What is the stock price?")
-        self.assertIn("I don't know", str(res))
+        self.assertTrue(
+            any(sub in str(res) for sub in ["I don't know", "I do not have"])
+        )
 
 
 if __name__ == "__main__":

tests/test_tools.py

@@ -1,6 +1,7 @@
 import unittest
 from pydantic import Field, BaseModel
-
+from unittest.mock import patch, MagicMock
+import requests
 from vectara_agentic.tools import (
     VectaraTool,
     VectaraToolFactory,
@@ -17,6 +18,7 @@ from llama_index.core.tools import FunctionTool
 vectara_corpus_key = "vectara-docs_1"
 vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
 
+from typing import Optional
 
 class TestToolsPackage(unittest.TestCase):
 
@@ -89,7 +91,7 @@ class TestToolsPackage(unittest.TestCase):
                 description="The ticker symbol for the company",
                 examples=["AAPL", "GOOG"],
             )
-            year: int | str = Field(
+            year: Optional[int | str] = Field(
                 default=None,
                 description="The year this query relates to. An integer between 2015 and 2024 or a string specifying a condition on the year",
                 examples=[
@@ -109,6 +111,7 @@ class TestToolsPackage(unittest.TestCase):
             tool_args_schema=QueryToolArgs,
         )
 
+        # test an invalid argument name
         res = query_tool(
             query="What is the stock price?",
             the_year=2023,
@@ -126,6 +129,86 @@ class TestToolsPackage(unittest.TestCase):
         )
         self.assertIn("got an unexpected keyword argument 'the_year'", str(res))
 
+    @patch.object(requests.Session, "post")
+    def test_vectara_tool_ranges(self, mock_post):
+        # Configure the mock to return a dummy response.
+        response_text = "ALL GOOD"
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            'summary': response_text,
+            'search_results': [
+                {'text': 'ALL GOOD', 'document_id': '12345', 'score': 0.9},
+            ]
+        }
+        mock_post.return_value = mock_response
+
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        class QueryToolArgs(BaseModel):
+            ticker: str = Field(
+                description="The ticker symbol for the company",
+                examples=["AAPL", "GOOG"],
+            )
+            year: int | str = Field(
+                default=None,
+                description="The year this query relates to. An integer between 2015 and 2024 or a string specifying a condition on the year",
+                examples=[
+                    2020,
+                    ">2021",
+                    "<2023",
+                    ">=2021",
+                    "<=2023",
+                    "[2021, 2023]",
+                    "[2021, 2023)",
+                ],
+            )
+
+        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,
+        )
+
+        # test an invalid argument name
+        res = query_tool(
+            query="What is the stock price?",
+            year=">2023"
+        )
+        self.assertIn(response_text, str(res))
+
+        # Test a valid range
+        res = query_tool(
+            query="What is the stock price?",
+            year="[2021, 2023]",
+        )
+        self.assertIn(response_text, str(res))
+
+        # Test a valid half closed range
+        res = query_tool(
+            query="What is the stock price?",
+            year="[2020, 2023)",
+        )
+        self.assertIn(response_text, str(res))
+
+        # Test an operator
+        res = query_tool(
+            query="What is the stock price?",
+            year=">2022",
+        )
+        self.assertIn(response_text, 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("got an unexpected keyword argument 'the_year'", str(res))
+
     def test_tool_factory(self):
         def mult(x: float, y: float) -> float:
             return x * y
@@ -152,8 +235,6 @@ class TestToolsPackage(unittest.TestCase):
             self.assertEqual(tool.metadata.tool_type, ToolType.QUERY)
 
     def test_tool_with_many_arguments(self):
-        vectara_corpus_key = "corpus_key"
-        vectara_api_key = "api_key"
         vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
 
         class QueryToolArgs(BaseModel):
@@ -169,24 +250,18 @@ class TestToolsPackage(unittest.TestCase):
             arg10: str = Field(description="the tenth argument", examples=["val10"])
             arg11: str = Field(description="the eleventh argument", examples=["val11"])
             arg12: str = Field(description="the twelfth argument", examples=["val12"])
-            arg13: str = Field(
-                description="the thirteenth argument", examples=["val13"]
-            )
-            arg14: str = Field(
-                description="the fourteenth argument", examples=["val14"]
-            )
-            arg15: str = Field(description="the fifteenth argument", examples=["val15"])
+            arg13: str = Field(description="the thirteenth argument", examples=["val13"])
 
         query_tool_1 = vec_factory.create_rag_tool(
             tool_name="rag_tool",
             tool_description="""
-            A dummy tool that takes 15 arguments and returns a response (str) to the user query based on the data in this corpus.
+            A dummy tool that takes 13 arguments and returns a response (str) to the user query based on the data in this corpus.
             We are using this tool to test the tool factory works and does not crash with OpenAI.
             """,
             tool_args_schema=QueryToolArgs,
         )
 
-        # Test with 15 arguments which go over the 1024 limit.
+        # Test with 13 arguments which go over the 1024 limit.
         config = AgentConfig(
             agent_type=AgentType.OPENAI
         )
@@ -208,7 +283,7 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments for GROQ",
+            custom_instructions="Call the tool with 13 arguments for GROQ",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
@@ -223,14 +298,14 @@ class TestToolsPackage(unittest.TestCase):
         agent = Agent(
             tools=[query_tool_1],
             topic="Sample topic",
-            custom_instructions="Call the tool with 15 arguments for ANTHROPIC",
+            custom_instructions="Call the tool with 13 arguments for ANTHROPIC",
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
         # ANTHROPIC does not have that 1024 limit
         self.assertIn("stock price", str(res))
 
-        # But using Compact_docstring=True, we can pass 15 arguments successfully.
+        # But using Compact_docstring=True, we can pass 13 arguments successfully.
         vec_factory = VectaraToolFactory(
             vectara_corpus_key, vectara_api_key, compact_docstring=True
         )
@@ -251,7 +326,9 @@ class TestToolsPackage(unittest.TestCase):
             agent_config=config,
         )
         res = agent.chat("What is the stock price?")
-        self.assertIn("stock price", str(res))
+        self.assertTrue(
+            any(sub in str(res) for sub in ["I don't know", "stock price"])
+        )
 
     def test_public_repo(self):
         vectara_corpus_key = "vectara-docs_1"
@@ -297,6 +374,31 @@ class TestToolsPackage(unittest.TestCase):
             "50",
         )
 
+    def test_vectara_tool_docstring(self):
+        class DummyArgs(BaseModel):
+            foo: int = Field(..., description="how many foos", examples=[1, 2, 3])
+            bar: str = Field(
+                "baz",
+                description="what bar to use",
+                examples=["x", "y"],
+            )
+
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+        dummy_tool = vec_factory.create_rag_tool(
+            tool_name="dummy_tool",
+            tool_description="A dummy tool.",
+            tool_args_schema=DummyArgs,
+        )
+
+        doc = dummy_tool.metadata.description
+        self.assertTrue(doc.startswith("dummy_tool(query: str, foo: int, bar: str) -> dict[str, Any]"))
+        self.assertIn("Args:", doc)
+        self.assertIn("query (str): The search query to perform, in the form of a question", doc)
+        self.assertIn("foo (int): how many foos (e.g., 1, 2, 3)", doc)
+        self.assertIn("bar (str, default='baz'): what bar to use (e.g., 'x', 'y')", doc)
+        self.assertIn("Returns:", doc)
+        self.assertIn("dict[str, Any]: A dictionary containing the result data.", doc)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_workflow.py

@@ -1,5 +1,9 @@
 import unittest
 
+from pydantic import BaseModel
+
+from llama_index.core.workflow import WorkflowTimeoutError
+
 from vectara_agentic.agent import Agent
 from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.tools import ToolsFactory
@@ -62,6 +66,69 @@ class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
         res = await agent.run(inputs=inputs, verbose=True)
         self.assertIn("22", res.response)
 
+class TestWorkflowFailure(unittest.IsolatedAsyncioTestCase):
+
+    async def test_workflow_failure(self):
+        tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
+        topic = "AI topic"
+        instructions = "You are a helpful AI assistant."
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config = AgentConfig(),
+            workflow_cls = SubQuestionQueryWorkflow,
+            workflow_timeout = 1
+        )
+
+        inputs = SubQuestionQueryWorkflow.InputsModel(
+            query="Compute 5 times 3, then add 7 to the result."
+        )
+
+        res = None
+
+        try:
+            res = await agent.run(inputs=inputs)
+        except Exception as e:
+            self.assertIsInstance(e, WorkflowTimeoutError)
+
+        self.assertIsNone(res)
+
+    async def test_workflow_with_fail_class(self):
+        tools = [ToolsFactory().create_tool(mult)] + [ToolsFactory().create_tool(add)]
+        topic = "AI topic"
+        instructions = "You are a helpful AI assistant."
+
+        class SubQuestionQueryWorkflowWithFailClass(SubQuestionQueryWorkflow):
+            class OutputModelOnFail(BaseModel):
+                """
+                In case of failure, returns the user's original query
+                """
+                original_query: str
+
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config = AgentConfig(),
+            workflow_cls = SubQuestionQueryWorkflowWithFailClass,
+            workflow_timeout = 1
+        )
+
+        inputs = SubQuestionQueryWorkflow.InputsModel(
+            query="Compute 5 times 3, then add 7 to the result."
+        )
+
+        res = None
+
+        try:
+            res = await agent.run(inputs=inputs)
+        except Exception as e:
+            assert isinstance(e, WorkflowTimeoutError)
+
+        self.assertIsInstance(res, SubQuestionQueryWorkflowWithFailClass.OutputModelOnFail)
+        self.assertEqual(res.original_query, "Compute 5 times 3, then add 7 to the result.")
+
 
 if __name__ == "__main__":
     unittest.main()

vectara_agentic/_observability.py

@@ -48,7 +48,7 @@ def setup_observer(config: AgentConfig, verbose: bool) -> bool:
     reg_kwargs = {
         "endpoint": phoenix_endpoint or 'http://localhost:6006/v1/traces',
         "project_name": "vectara-agentic",
-        "batch": True,
+        "batch": False,
         "set_global_tracer_provider": False,
     }
     tracer_provider = register(**reg_kwargs)

vectara_agentic/_prompts.py

@@ -4,11 +4,13 @@ This file contains the prompt templates for the different types of agents.
 
 # General (shared) instructions
 GENERAL_INSTRUCTIONS = """
-- Use tools as your main source of information, do not respond without using a tool. Do not respond based on pre-trained knowledge.
+- Use tools as your main source of information, do not respond without using a tool at least once.
+- Do not respond based on pre-trained knowledge, unless repeated calls to the tools fail or do not provide the information needed.
 - Use the 'get_bad_topics' (if it exists) tool to determine the topics you are not allowed to discuss or respond to.
 - Before responding to a user query that requires knowledge of the current date, call the 'get_current_date' tool to get the current date.
   Never rely on previous knowledge of the current date.
   Example queries that require the current date: "What is the revenue of Apple last october?" or "What was the stock price 5 days ago?".
+  Never call 'get_current_date' more than once for the same user query.
 - When using a tool with arguments, simplify the query as much as possible if you use the tool with arguments.
   For example, if the original query is "revenue for apple in 2021", you can use the tool with a query "revenue" with arguments year=2021 and company=apple.
 - If a tool responds with "I do not have enough information", try one or more of the following strategies:
@@ -24,7 +26,7 @@ GENERAL_INSTRUCTIONS = """
 - If a tool provides citations or references in markdown as part of its response, include the references in your response.
 - Ensure that every URL in your response includes descriptive anchor text that clearly explains what the user can expect from the linked content.
   Avoid using generic terms like “source” or “reference”, or the full URL, as the anchor text.
-- If a tool returns in the metadata a valid URL pointing to a PDF file, along with page number - then combine the URL and page number in the response.
+- If a tool returns in the metadata a valid URL pointing to a PDF file, along with page number - then combine the URL and page number in your response.
   For example, if the URL returned from the tool is "https://example.com/doc.pdf" and "page=5", then the combined URL would be "https://example.com/doc.pdf#page=5".
   If a tool returns in the metadata invalid URLs or an URL empty (e.g. "[[1]()]"), ignore it and do not include that citation or reference in your response.
 - All URLs provided in your response must be obtained from tool output, and cannot be "https://example.com" or empty strings, and should open in a new tab.

vectara_agentic/_version.py

@@ -1,4 +1,4 @@
 """
 Define the version of the package.
 """
-__version__ = "0.2.15"
+__version__ = "0.2.17"