vectara-agentic 0.2.5__tar.gz → 0.2.7__tar.gz

{vectara_agentic-0.2.5/vectara_agentic.egg-info → vectara_agentic-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.5
+Version: 0.2.7
 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
@@ -41,18 +41,18 @@ 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: openinference-instrumentation-llama-index==3.1.4
-Requires-Dist: opentelemetry-proto==1.26.0
-Requires-Dist: arize-phoenix==7.11.0
-Requires-Dist: arize-phoenix-otel==0.6.1
-Requires-Dist: protobuf==4.25.5
+Requires-Dist: openinference-instrumentation-llama-index==3.3.3
+Requires-Dist: opentelemetry-proto==1.31.0
+Requires-Dist: arize-phoenix==8.14.1
+Requires-Dist: arize-phoenix-otel==0.8.0
+Requires-Dist: protobuf==5.29.3
 Requires-Dist: tokenizers>=0.20
-Requires-Dist: pydantic==2.10.3
+Requires-Dist: pydantic==2.10.6
 Requires-Dist: retrying==1.3.4
 Requires-Dist: python-dotenv==1.0.1
 Requires-Dist: tiktoken==0.9.0
 Requires-Dist: cloudpickle>=3.1.1
-Requires-Dist: httpx==0.27.2
+Requires-Dist: httpx==0.28.1
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -60,6 +60,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python

{vectara_agentic-0.2.5 → vectara_agentic-0.2.7}/requirements.txt

@@ -23,15 +23,15 @@ llama-index-tools-exa==0.3.0
 tavily-python==0.5.1
 exa-py==1.8.9
 yahoo-finance==1.4.0
-openinference-instrumentation-llama-index==3.1.4
-opentelemetry-proto==1.26.0
-arize-phoenix==7.11.0
-arize-phoenix-otel==0.6.1
-protobuf==4.25.5
+openinference-instrumentation-llama-index==3.3.3
+opentelemetry-proto==1.31.0
+arize-phoenix==8.14.1
+arize-phoenix-otel==0.8.0
+protobuf==5.29.3
 tokenizers>=0.20
-pydantic==2.10.3
+pydantic==2.10.6
 retrying==1.3.4
 python-dotenv==1.0.1
 tiktoken==0.9.0
 cloudpickle>=3.1.1
-httpx==0.27.2
+httpx==0.28.1

vectara_agentic-0.2.7/tests/test_agent.py

@@ -0,0 +1,162 @@
+import unittest
+import threading
+from datetime import date
+
+from vectara_agentic.agent import _get_prompt, Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, ObserverType
+from vectara_agentic.tools import ToolsFactory
+
+def mult(x: float, y: float) -> float:
+    return x * y
+
+
+ARIZE_LOCK = threading.Lock()
+
+class TestAgentPackage(unittest.TestCase):
+    def test_get_prompt(self):
+        prompt_template = "{chat_topic} on {today} with {custom_instructions}"
+        topic = "Programming"
+        custom_instructions = "Always do as your mother tells you!"
+        expected_output = (
+            "Programming on "
+            + date.today().strftime("%A, %B %d, %Y")
+            + " with Always do as your mother tells you!"
+        )
+        self.assertEqual(
+            _get_prompt(prompt_template, topic, custom_instructions), expected_output
+        )
+
+    def test_agent_init(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI"
+        custom_instructions = "Always do as your mother tells you!"
+        agent = Agent(tools, topic, custom_instructions)
+        self.assertEqual(agent.agent_type, AgentType.OPENAI)
+        self.assertEqual(agent._topic, topic)
+        self.assertEqual(agent._custom_instructions, custom_instructions)
+
+        # To run this test, you must have OPENAI_API_KEY in your environment
+        self.assertEqual(
+            agent.chat(
+                "What is 5 times 10. Only give the answer, nothing else"
+            ).response.replace("$", "\\$"),
+            "50",
+        )
+
+    def test_agent_config(self):
+        with ARIZE_LOCK:
+            tools = [ToolsFactory().create_tool(mult)]
+            topic = "AI topic"
+            instructions = "Always do as your father tells you, if your mother agrees!"
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                main_llm_model_name="claude-3-5-sonnet-20241022",
+                tool_llm_provider=ModelProvider.TOGETHER,
+                tool_llm_model_name="meta-llama/Llama-3.3-70B-Instruct-Turbo",
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+
+            agent = Agent(
+                tools=tools,
+                topic=topic,
+                custom_instructions=instructions,
+                agent_config=config
+            )
+            self.assertEqual(agent._topic, topic)
+            self.assertEqual(agent._custom_instructions, instructions)
+            self.assertEqual(agent.agent_type, AgentType.REACT)
+            self.assertEqual(agent.agent_config.observer, ObserverType.ARIZE_PHOENIX)
+            self.assertEqual(agent.agent_config.main_llm_provider, ModelProvider.ANTHROPIC)
+            self.assertEqual(agent.agent_config.tool_llm_provider, ModelProvider.TOGETHER)
+
+            # To run this test, you must have ANTHROPIC_API_KEY and TOGETHER_API_KEY in your environment
+            self.assertEqual(
+                agent.chat(
+                    "What is 5 times 10. Only give the answer, nothing else"
+                ).response.replace("$", "\\$"),
+                "50",
+            )
+
+    def test_multiturn(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            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 questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
+    def test_from_corpus(self):
+        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",
+        )
+
+        self.assertIsInstance(agent, Agent)
+        self.assertEqual(agent._topic, "question answering")
+
+    def test_serialization(self):
+        with ARIZE_LOCK:
+            config = AgentConfig(
+                agent_type=AgentType.REACT,
+                main_llm_provider=ModelProvider.ANTHROPIC,
+                tool_llm_provider=ModelProvider.TOGETHER,
+                observer=ObserverType.ARIZE_PHOENIX
+            )
+
+            agent = Agent.from_corpus(
+                tool_name="RAG Tool",
+                agent_config=config,
+                vectara_corpus_key="corpus_key",
+                vectara_api_key="api_key",
+                data_description="information",
+                assistant_specialty="question answering",
+            )
+
+            agent_reloaded = agent.loads(agent.dumps())
+            agent_reloaded_again = agent_reloaded.loads(agent_reloaded.dumps())
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded)
+            self.assertEqual(agent.agent_type, agent_reloaded.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded.agent_config.tool_llm_provider)
+
+            self.assertIsInstance(agent_reloaded, Agent)
+            self.assertEqual(agent, agent_reloaded_again)
+            self.assertEqual(agent.agent_type, agent_reloaded_again.agent_type)
+
+            self.assertEqual(agent.agent_config.observer, agent_reloaded_again.agent_config.observer)
+            self.assertEqual(agent.agent_config.main_llm_provider, agent_reloaded_again.agent_config.main_llm_provider)
+            self.assertEqual(agent.agent_config.tool_llm_provider, agent_reloaded_again.agent_config.tool_llm_provider)
+
+    def test_chat_history(self):
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "AI topic"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            chat_history=[("What is 5 times 10", "50"), ("What is 3 times 7", "21")]
+        )
+
+        res = agent.chat("multiply the results of the last two questions. Output only the answer.")
+        self.assertEqual(res.response, "1050")
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic-0.2.7/tests/test_agent_planning.py

@@ -0,0 +1,73 @@
+import unittest
+
+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,
+    vectara_summarizer = summarizer,
+    include_citations = True,
+    verbose=False,
+)
+
+class TestAgentPlanningPackage(unittest.TestCase):
+
+    def test_no_planning(self):
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=AgentConfig(),
+        )
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
+
+    def test_structured_planning(self):
+        tools = [ask_vectara]
+        topic = "vectara"
+        instructions = "Answer user queries about Vectara."
+
+        query = "What is Vectara and what demos are available of the Vectara platform?"
+        agent = Agent(
+            tools=tools,
+            topic=topic,
+            custom_instructions=instructions,
+            agent_config=AgentConfig(),
+            use_structured_planning=True,
+        )
+
+        res = agent.chat(query)
+        self.assertIn("demos", res.response)
+        self.assertIn("Vectara", res.response)
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic-0.2.7/tests/test_agent_type.py

@@ -0,0 +1,157 @@
+import unittest
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.types import ModelProvider
+
+import nest_asyncio
+nest_asyncio.apply()
+
+def mult(x: float, y: float) -> float:
+    return x * y
+
+
+react_config_anthropic = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+react_config_gemini = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+react_config_together = AgentConfig(
+    agent_type=AgentType.REACT,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+fc_config_anthropic = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.ANTHROPIC,
+    tool_llm_provider=ModelProvider.ANTHROPIC,
+)
+
+fc_config_gemini = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.GEMINI,
+    tool_llm_provider=ModelProvider.GEMINI,
+)
+
+fc_config_together = AgentConfig(
+    agent_type=AgentType.FUNCTION_CALLING,
+    main_llm_provider=ModelProvider.TOGETHER,
+    tool_llm_provider=ModelProvider.TOGETHER,
+)
+
+
+openai_config = AgentConfig(
+    agent_type=AgentType.OPENAI,
+)
+
+class TestAgentType(unittest.TestCase):
+
+    def test_openai(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=openai_config,
+            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_gemini(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_gemini,
+            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_gemini,
+            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_together(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_together,
+            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_together,
+            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"
+        instructions = "Always do as your father tells you, if your mother agrees!"
+
+        agent = Agent(
+            agent_config=react_config_anthropic,
+            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_anthropic,
+            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)
+
+
+if __name__ == "__main__":
+    unittest.main()

vectara_agentic-0.2.7/tests/test_fallback.py

@@ -0,0 +1,83 @@
+import os
+import unittest
+import subprocess
+import time
+import requests
+import signal
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, AgentConfigType
+from vectara_agentic.tools import ToolsFactory
+
+FLASK_PORT = 5002
+
+class TestFallback(unittest.TestCase):
+
+    @classmethod
+    def setUp(cls):
+        # Start the Flask server as a subprocess
+        cls.flask_process = subprocess.Popen(
+            ['flask', 'run', f'--port={FLASK_PORT}'],
+            env={**os.environ, 'FLASK_APP': 'tests.endpoint:app', 'FLASK_ENV': 'development'},
+            stdout=None, stderr=None,
+        )
+        # Wait for the server to start
+        timeout = 10
+        url = f'http://127.0.0.1:{FLASK_PORT}/'
+        for _ in range(timeout):
+            try:
+                requests.get(url)
+                print("Flask server started for fallback unit test")
+                return
+            except requests.ConnectionError:
+                time.sleep(1)
+        raise RuntimeError(f"Failed to start Flask server at {url}")
+
+    @classmethod
+    def tearDown(cls):
+        # Terminate the Flask server
+        cls.flask_process.send_signal(signal.SIGINT)
+        cls.flask_process.wait()
+
+    def test_fallback_from_private(self):
+        def mult(x: float, y: float) -> float:
+            return x * y
+
+        tools = [ToolsFactory().create_tool(mult)]
+        topic = "calculator"
+        custom_instructions = "you are an agent specializing in math, assisting a user."
+        config = AgentConfig(
+            agent_type=AgentType.REACT,
+            main_llm_provider=ModelProvider.PRIVATE,
+            main_llm_model_name="gpt-4o",
+            private_llm_api_base=f"http://127.0.0.1:{FLASK_PORT}/v1",
+            private_llm_api_key="TEST_API_KEY",
+        )
+
+        # Set fallback agent config to OpenAI agent
+        fallback_config = AgentConfig()
+
+        agent = Agent(agent_config=config, tools=tools, topic=topic,
+                      custom_instructions=custom_instructions,
+                      fallback_agent_config=fallback_config)
+
+        # To run this test, you must have OPENAI_API_KEY in your environment
+        res = agent.chat(
+            "What is 5 times 10. Only give the answer, nothing else"
+        ).response
+        self.assertEqual(res, "50")
+
+        TestFallback.flask_process.send_signal(signal.SIGINT)
+        TestFallback.flask_process.wait()
+
+        res = agent.chat(
+            "What is 5 times 10. Only give the answer, nothing else"
+        ).response
+        self.assertEqual(res, "50")
+        self.assertEqual(agent.agent_config_type, AgentConfigType.FALLBACK)
+        self.assertEqual(agent.fallback_agent_config, fallback_config)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vectara_agentic-0.2.5 → vectara_agentic-0.2.7}/tests/test_private_llm.py

@@ -10,22 +10,25 @@ from vectara_agentic.agent_config import AgentConfig
 from vectara_agentic.types import ModelProvider
 from vectara_agentic.tools import ToolsFactory
 
+
+FLASK_PORT = 5001
 class TestPrivateLLM(unittest.TestCase):
 
     @classmethod
     def setUp(cls):
         # Start the Flask server as a subprocess
         cls.flask_process = subprocess.Popen(
-            ['flask', 'run', '--port=5000'],
+            ['flask', 'run', f'--port={FLASK_PORT}'],
             env={**os.environ, 'FLASK_APP': 'tests.endpoint:app', 'FLASK_ENV': 'development'},
             stdout=None, stderr=None,
         )
         # Wait for the server to start
         timeout = 10
-        url = 'http://127.0.0.1:5000/'
+        url = f'http://127.0.0.1:{FLASK_PORT}/'
         for _ in range(timeout):
             try:
                 requests.get(url)
+                print("Flask server started for private LLM unit test")
                 return
             except requests.ConnectionError:
                 time.sleep(1)
@@ -38,7 +41,7 @@ class TestPrivateLLM(unittest.TestCase):
         cls.flask_process.wait()
 
     def test_endpoint(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]
@@ -48,19 +51,17 @@ class TestPrivateLLM(unittest.TestCase):
             agent_type=AgentType.REACT,
             main_llm_provider=ModelProvider.PRIVATE,
             main_llm_model_name="gpt-4o",
-            private_llm_api_base="http://127.0.0.1:5000/v1",
+            private_llm_api_base=f"http://127.0.0.1:{FLASK_PORT}/v1",
             private_llm_api_key="TEST_API_KEY",
         )
         agent = Agent(agent_config=config, tools=tools, topic=topic,
                       custom_instructions=custom_instructions)
 
         # To run this test, you must have OPENAI_API_KEY in your environment
-        self.assertEqual(
-            agent.chat(
-                "What is 5 times 10. Only give the answer, nothing else"
-            ).response.replace("$", "\\$"),
-            "50",
-        )
+        res = agent.chat(
+            "What is 5 times 10. Only give the answer, nothing else."
+        ).response
+        self.assertEqual(res, "50")
 
 
 if __name__ == "__main__":

{vectara_agentic-0.2.5 → vectara_agentic-0.2.7}/tests/test_tools.py

@@ -47,7 +47,7 @@ class TestToolsPackage(unittest.TestCase):
         self.assertEqual(search_tool.metadata.tool_type, ToolType.QUERY)
 
     def test_tool_factory(self):
-        def mult(x, y):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools_factory = ToolsFactory()

vectara_agentic-0.2.7/tests/test_workflow.py

@@ -0,0 +1,67 @@
+import unittest
+
+from vectara_agentic.agent import Agent
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.tools import ToolsFactory
+from vectara_agentic.sub_query_workflow import SubQuestionQueryWorkflow, SequentialSubQuestionsWorkflow
+
+def mult(x: float, y: float):
+    """
+    Multiply two numbers.
+    """
+    return x * y
+
+def add(x: float, y: float):
+    """
+    Add two numbers.
+    """
+    return x + y
+
+class TestWorkflowPackage(unittest.IsolatedAsyncioTestCase):
+
+    async def test_sub_query_workflow(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,
+        )
+
+        inputs = SubQuestionQueryWorkflow.InputsModel(
+            query="Compute 5 times 3, then add 7 to the result."
+        )
+        res = await agent.run(inputs=inputs)
+        self.assertIn("22", res.response)
+
+        inputs = SubQuestionQueryWorkflow.InputsModel(
+            query="what is the sum of 10 with 21, and the multiplication of 3 and 6?"
+        )
+        res = await agent.run(inputs=inputs)
+        self.assertIn("31", res.response)
+        self.assertIn("18", res.response)
+
+    async def test_seq_sub_query_workflow(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 = SequentialSubQuestionsWorkflow,
+        )
+
+        inputs = SequentialSubQuestionsWorkflow.InputsModel(
+            query="Compute 5 times 3, then add 7 to the result."
+        )
+        res = await agent.run(inputs=inputs, verbose=True)
+        self.assertIn("22", res.response)
+
+
+if __name__ == "__main__":
+    unittest.main()