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

tests/test_agent.py

@@ -7,6 +7,9 @@ from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider, ObserverType
 from vectara_agentic.tools import ToolsFactory
 
+from vectara_agentic._prompts import GENERAL_INSTRUCTIONS
+
+
 def mult(x: float, y: float) -> float:
     return x * y
 
@@ -24,7 +27,7 @@ class TestAgentPackage(unittest.TestCase):
             + " with Always do as your mother tells you!"
         )
         self.assertEqual(
-            _get_prompt(prompt_template, topic, custom_instructions), expected_output
+            _get_prompt(prompt_template, GENERAL_INSTRUCTIONS, topic, custom_instructions), expected_output
         )
 
     def test_agent_init(self):
@@ -120,6 +123,20 @@ class TestAgentPackage(unittest.TestCase):
         res = agent.chat("multiply the results of the last two questions. Output only the answer.")
         self.assertEqual(res.response, "1050")
 
+    def test_custom_general_instruction(self):
+        general_instructions = "Always respond with 'I DIDNT DO IT'"
+        agent = Agent.from_corpus(
+            tool_name="RAG Tool",
+            vectara_corpus_key="corpus_key",
+            vectara_api_key="api_key",
+            data_description="information",
+            assistant_specialty="question answering",
+            general_instructions=general_instructions,
+        )
+
+        res = agent.chat("What is the meaning of the universe?")
+        self.assertEqual(res.response, "I DIDNT DO IT")
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_agent_planning.py

@@ -4,26 +4,17 @@ from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.agent import Agent
 from vectara_agentic.tools import VectaraToolFactory
 
-from pydantic import Field, BaseModel
-
-
 # SETUP speical 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'
 
-
-class QueryArgs(BaseModel):
-    query: str = Field(..., description="The user query, always in the form of a question.")
-
-
 vec_factory = VectaraToolFactory(vectara_api_key=vectara_api_key,
                                  vectara_corpus_key=vectara_corpus_key)
 summarizer = 'vectara-summary-table-md-query-ext-jan-2025-gpt-4o'
 ask_vectara = vec_factory.create_rag_tool(
     tool_name = "ask_vectara",
     tool_description = "This tool can respond to questions about Vectara.",
-    tool_args_schema = QueryArgs,
     reranker = "multilingual_reranker_v1", rerank_k = 100, rerank_cutoff = 0.1,
     n_sentences_before = 2, n_sentences_after = 2, lambda_val = 0.005,
     summary_num_results = 10,

tests/test_agent_type.py

@@ -9,6 +9,7 @@ import nest_asyncio
 nest_asyncio.apply()
 
 def mult(x: float, y: float) -> float:
+    "Multiply two numbers"
     return x * y
 
 
@@ -30,6 +31,12 @@ react_config_together = AgentConfig(
     tool_llm_provider=ModelProvider.TOGETHER,
 )
 
+react_config_groq = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.GROQ,
+    tool_llm_provider=ModelProvider.GROQ,
+)
+
 fc_config_anthropic = AgentConfig(
     agent_type=AgentType.FUNCTION_CALLING,
     main_llm_provider=ModelProvider.ANTHROPIC,
@@ -48,6 +55,12 @@ fc_config_together = AgentConfig(
     tool_llm_provider=ModelProvider.TOGETHER,
 )
 
+fc_config_groq = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GROQ,
+    tool_llm_provider=ModelProvider.GROQ,
+)
+
 
 openai_config = AgentConfig(
     agent_type=AgentType.OPENAI,
@@ -125,6 +138,33 @@ class TestAgentType(unittest.TestCase):
         res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
         self.assertIn("1050", res.response)
 
+    def test_groq(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_groq,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
+        agent = Agent(
+            agent_config=fc_config_groq,
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+        )
+        agent.chat("What is 5 times 10. Only give the answer, nothing else")
+        agent.chat("what is 3 times 7. Only give the answer, nothing else")
+        res = agent.chat("multiply the results of the last two multiplications. Only give the answer, nothing else.")
+        self.assertIn("1050", res.response)
+
     def test_anthropic(self):
         tools = [ToolsFactory().create_tool(mult)]
         topic = "AI topic"

tests/test_tools.py

@@ -1,5 +1,4 @@
 import unittest
-
 from pydantic import Field, BaseModel
 
 from vectara_agentic.tools import (
@@ -13,83 +12,118 @@ from vectara_agentic.agent_config import AgentConfig
 
 from llama_index.core.tools import FunctionTool
 
+# Special test account credentials for Vectara
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+
 
 class TestToolsPackage(unittest.TestCase):
-    def test_vectara_tool_factory(self):
-        vectara_corpus_key = "corpus_key"
-        vectara_api_key = "api_key"
+
+    def test_vectara_rag_tool(self):
         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)
 
-        class QueryToolArgs(BaseModel):
-            query: str = Field(description="The user query")
-
         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,
         )
 
         self.assertIsInstance(query_tool, VectaraTool)
         self.assertIsInstance(query_tool, FunctionTool)
         self.assertEqual(query_tool.metadata.tool_type, ToolType.QUERY)
 
+        res = query_tool(query="What is Vectara?")
+        self.assertIn("Vectara is an end-to-end platform", str(res))
+
+    def test_vectara_search_tool(self):
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
         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,
+            tool_description="Returns a list of documents (str) that match the user query.",
         )
         self.assertIsInstance(search_tool, VectaraTool)
         self.assertIsInstance(search_tool, FunctionTool)
         self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
+        self.assertIn("summarize", search_tool.metadata.description)
+
+        res = search_tool(query="What is Vectara?")
+        self.assertIn("https-docs-vectara-com-docs", 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.",
+            summarize_docs=False,
+        )
+        self.assertIsInstance(search_tool, VectaraTool)
+        self.assertIsInstance(search_tool, FunctionTool)
+        self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
+        self.assertNotIn("summarize", search_tool.metadata.description)
+
+        res = search_tool(query="What is Vectara?")
+        self.assertIn("https-docs-vectara-com-docs", 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.",
+            summarize_docs=True,
+        )
+        self.assertIsInstance(search_tool, VectaraTool)
+        self.assertIsInstance(search_tool, FunctionTool)
+        self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
+        self.assertNotIn("summarize", search_tool.metadata.description)
+
+        res = search_tool(query="What is Vectara?")
+        self.assertIn("summary: 'Vectara is", str(res))
 
     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",
+                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_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))
+        self.assertIn("got an unexpected keyword argument 'the_year'", 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_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))
+        self.assertIn("got an unexpected keyword argument 'the_year'", str(res))
 
     def test_tool_factory(self):
         def mult(x: float, y: float) -> float:
@@ -104,20 +138,84 @@ class TestToolsPackage(unittest.TestCase):
     def test_llama_index_tools(self):
         tools_factory = ToolsFactory()
 
-        arxiv_tool = tools_factory.get_llama_index_tools(
-            tool_package_name="arxiv", tool_spec_name="ArxivToolSpec"
-        )[0]
+        for name, spec in [
+            ("arxiv", "ArxivToolSpec"),
+            ("yahoo_finance", "YahooFinanceToolSpec"),
+            ("wikipedia", "WikipediaToolSpec"),
+        ]:
+            tool = tools_factory.get_llama_index_tools(
+                tool_package_name=name, tool_spec_name=spec
+            )[0]
+            self.assertIsInstance(tool, VectaraTool)
+            self.assertIsInstance(tool, FunctionTool)
+            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)
 
-        self.assertIsInstance(arxiv_tool, VectaraTool)
-        self.assertIsInstance(arxiv_tool, FunctionTool)
-        self.assertEqual(arxiv_tool.metadata.tool_type, ToolType.QUERY)
+        class QueryToolArgs(BaseModel):
+            arg1: str = Field(description="the first argument", examples=["val1"])
+            arg2: str = Field(description="the second argument", examples=["val2"])
+            arg3: str = Field(description="the third argument", examples=["val3"])
+            arg4: str = Field(description="the fourth argument", examples=["val4"])
+            arg5: str = Field(description="the fifth argument", examples=["val5"])
+            arg6: str = Field(description="the sixth argument", examples=["val6"])
+            arg7: str = Field(description="the seventh argument", examples=["val7"])
+            arg8: str = Field(description="the eighth argument", examples=["val8"])
+            arg9: str = Field(description="the ninth argument", examples=["val9"])
+            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"])
 
-        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)
+        query_tool_1 = vec_factory.create_rag_tool(
+            tool_name="rag_tool",
+            tool_description="""
+            A dummy tool that takes 20 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,
+        )
+
+        config = AgentConfig()
+        agent = Agent(
+            tools=[query_tool_1],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 20 arguments",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertIn("maximum length of 1024 characters", str(res))
+
+        vec_factory = VectaraToolFactory(
+            vectara_corpus_key, vectara_api_key, compact_docstring=True
+        )
+        query_tool_2 = 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.
+            We are using this tool to test the tool factory works and doesn not crash with OpenAI.
+            """,
+            tool_args_schema=QueryToolArgs,
+        )
+
+        config = AgentConfig()
+        agent = Agent(
+            tools=[query_tool_2],
+            topic="Sample topic",
+            custom_instructions="Call the tool with 20 arguments",
+            agent_config=config,
+        )
+        res = agent.chat("What is the stock price?")
+        self.assertIn("stock price", str(res))
 
     def test_public_repo(self):
         vectara_corpus_key = "vectara-docs_1"

tests/test_vectara_llms.py

@@ -0,0 +1,77 @@
+import unittest
+
+from vectara_agentic.tools import (
+    VectaraTool,
+    VectaraToolFactory,
+    ToolType,
+)
+from llama_index.core.tools import FunctionTool
+
+# Special test account credentials for Vectara
+vectara_corpus_key = "vectara-docs_1"
+vectara_api_key = "zqt_UXrBcnI2UXINZkrv4g1tQPhzj02vfdtqYJIDiA"
+
+
+class TestLLMPackage(unittest.TestCase):
+
+    def test_vectara_openai(self):
+        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)
+
+        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.
+            """,
+        )
+
+        self.assertIsInstance(query_tool, VectaraTool)
+        self.assertIsInstance(query_tool, FunctionTool)
+        self.assertEqual(query_tool.metadata.tool_type, ToolType.QUERY)
+
+        res = query_tool(query="What is Vectara?")
+        self.assertIn("Vectara is an end-to-end platform", str(res))
+
+        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.
+            """,
+            llm_name="gpt-4o-mini",
+        )
+
+        self.assertIsInstance(query_tool, VectaraTool)
+        self.assertIsInstance(query_tool, FunctionTool)
+        self.assertEqual(query_tool.metadata.tool_type, ToolType.QUERY)
+
+        res = query_tool(query="What is Vectara?")
+        self.assertIn("Vectara is an end-to-end platform", str(res))
+
+    def test_vectara_mockingbird(self):
+        vec_factory = VectaraToolFactory(vectara_corpus_key, vectara_api_key)
+
+        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.
+            """,
+            vectara_summarizer="mockingbird-1.0-2024-07-16",
+        )
+        res = query_tool(query="What is Vectara?")
+        self.assertIn("Vectara is an end-to-end platform", str(res))
+
+        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.
+            """,
+            vectara_summarizer="mockingbird-2.0",
+        )
+        res = query_tool(query="What is Vectara?")
+        self.assertIn("Vectara is an end-to-end platform", str(res))
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic/_prompts.py

@@ -22,8 +22,8 @@ GENERAL_INSTRUCTIONS = """
   3) If a tool fails, try other tools that might be appropriate to gain the information you need.
 - If after retrying you can't get the information or answer the question, respond with "I don't know".
 - 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 responses includes descriptive anchor text that clearly explains what the user can expect from the linked content.
-  Avoid using generic terms like “source” or “reference” as the anchor text.
+- 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.
   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.
@@ -42,7 +42,7 @@ GENERAL_INSTRUCTIONS = """
   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.
+  - Use the x_load_unique_values tool to retrieve the unique values in each column, before crafting any SQL query.
     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.
   - For x_load_data, if the tool response indicates the output data is too large, try to refine or refactor your query to return fewer rows.
@@ -52,7 +52,7 @@ GENERAL_INSTRUCTIONS = """
 """
 
 #
-# For OpenAI and other agents that just require systems
+# For OpenAI and other agents that just require a systems prompt
 #
 GENERAL_PROMPT_TEMPLATE = """
 You are a helpful chatbot in conversation with a user, with expertise in {chat_topic}.
@@ -65,9 +65,7 @@ IMPORTANT - FOLLOW THESE INSTRUCTIONS CAREFULLY:
 {INSTRUCTIONS}
 {custom_instructions}
 
-""".replace(
-    "{INSTRUCTIONS}", GENERAL_INSTRUCTIONS
-)
+"""
 
 #
 # Custom REACT prompt
@@ -132,15 +130,14 @@ Answer: [your answer here (In the same language as the user's question)]
 ## Current Conversation
 
 Below is the current conversation consisting of interleaving human and assistant messages.
-""".replace(
-    "{INSTRUCTIONS}", GENERAL_INSTRUCTIONS
-)
+"""
 
 #
 # Prompts for structured planning agent
 #
 STRUCTURED_PLANNER_INITIAL_PLAN_PROMPT = """\
 Think step-by-step. Given a task and a set of tools, create a comprehensive, end-to-end plan to accomplish the task, using the tools.
+Only use the tools that are relevant to completing the task.
 Keep in mind not every task needs to be decomposed into multiple sub-tasks if it is simple enough.
 The plan should end with a sub-task that can achieve the overall task.
 
@@ -152,6 +149,7 @@ Overall Task: {task}
 
 STRUCTURED_PLANNER_PLAN_REFINE_PROMPT = """\
 Think step-by-step. Given an overall task, a set of tools, and completed sub-tasks, update (if needed) the remaining sub-tasks so that the overall task can still be completed.
+Only use the tools that are relevant to completing the task.
 Do not add new sub-tasks that are not needed to achieve the overall task.
 The final sub-task in the plan should be the one that can satisfy the overall task.
 If you do update the plan, only create new sub-tasks that will replace the remaining sub-tasks, do NOT repeat tasks that are already completed.

vectara_agentic/_version.py

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