vectara-agentic 0.2.6__tar.gz → 0.2.8__tar.gz

{vectara_agentic-0.2.6/vectara_agentic.egg-info → vectara_agentic-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectara_agentic
-Version: 0.2.6
+Version: 0.2.8
 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,7 +16,7 @@ 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.25
+Requires-Dist: llama-index==0.12.26
 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

{vectara_agentic-0.2.6 → vectara_agentic-0.2.8}/requirements.txt

@@ -1,4 +1,4 @@
-llama-index==0.12.25
+llama-index==0.12.26
 llama-index-indices-managed-vectara==0.4.2
 llama-index-agent-llm-compiler==0.3.0
 llama-index-agent-lats==0.3.0

vectara_agentic-0.2.8/tests/test_agent.py

@@ -0,0 +1,125 @@
+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_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.8/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.8/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.6 → vectara_agentic-0.2.8}/tests/test_fallback.py

@@ -40,8 +40,8 @@ class TestFallback(unittest.TestCase):
         cls.flask_process.send_signal(signal.SIGINT)
         cls.flask_process.wait()
 
-    def test_fallback(self):
-        def mult(x, y):
+    def test_fallback_from_private(self):
+        def mult(x: float, y: float) -> float:
             return x * y
 
         tools = [ToolsFactory().create_tool(mult)]

{vectara_agentic-0.2.6 → vectara_agentic-0.2.8}/tests/test_private_llm.py

@@ -41,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)]

vectara_agentic-0.2.8/tests/test_serialization.py

@@ -0,0 +1,110 @@
+import unittest
+import threading
+import os
+
+from vectara_agentic.agent import Agent, AgentType
+from vectara_agentic.agent_config import AgentConfig
+from vectara_agentic.types import ModelProvider, ObserverType
+from vectara_agentic.tools import ToolsFactory
+
+from llama_index.core.utilities.sql_wrapper import SQLDatabase
+from sqlalchemy import create_engine
+
+def mult(x: float, y: float) -> float:
+    return x * y
+
+
+ARIZE_LOCK = threading.Lock()
+
+class TestAgentSerialization(unittest.TestCase):
+
+    @classmethod
+    def tearDown(cls):
+        try:
+            os.remove('ev_database.db')
+        except FileNotFoundError:
+            pass
+
+    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
+            )
+            db_tools = ToolsFactory().database_tools(
+                tool_name_prefix = "ev",
+                content_description = 'Electric Vehicles in the state of Washington and other population information',
+                sql_database = SQLDatabase(create_engine('sqlite:///ev_database.db')),
+            )
+
+            tools = [ToolsFactory().create_tool(mult)] + ToolsFactory().standard_tools() + db_tools
+            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_config=config
+            )
+
+            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_serialization_from_corpus(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)
+
+
+if __name__ == "__main__":
+    unittest.main()

{vectara_agentic-0.2.6 → vectara_agentic-0.2.8}/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.6 → vectara_agentic-0.2.8}/vectara_agentic/_version.py

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

{vectara_agentic-0.2.6 → vectara_agentic-0.2.8}/vectara_agentic/agent.py

@@ -21,7 +21,7 @@ from pydantic import Field, create_model, ValidationError
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.core.llms import ChatMessage, MessageRole
 from llama_index.core.tools import FunctionTool
-from llama_index.core.agent import ReActAgent, StructuredPlannerAgent
+from llama_index.core.agent import ReActAgent, StructuredPlannerAgent, FunctionCallingAgent
 from llama_index.core.agent.react.formatter import ReActChatFormatter
 from llama_index.agent.llm_compiler import LLMCompilerAgentWorker
 from llama_index.agent.lats import LATSAgentWorker
@@ -277,7 +277,19 @@ class Agent:
         llm = get_llm(LLMRole.MAIN, config=config)
         llm.callback_manager = llm_callback_manager
 
-        if agent_type == AgentType.REACT:
+        if agent_type == AgentType.FUNCTION_CALLING:
+            prompt = _get_prompt(GENERAL_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
+            agent = FunctionCallingAgent.from_tools(
+                tools=self.tools,
+                llm=llm,
+                memory=self.memory,
+                verbose=self.verbose,
+                max_function_calls=config.max_reasoning_steps,
+                callback_manager=llm_callback_manager,
+                system_prompt = prompt,
+                allow_parallel_tool_calls=True,
+            )
+        elif agent_type == AgentType.REACT:
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent = ReActAgent.from_tools(
                 tools=self.tools,
@@ -295,7 +307,7 @@ class Agent:
                 llm=llm,
                 memory=self.memory,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
                 max_function_calls=config.max_reasoning_steps,
                 system_prompt=prompt,
             )
@@ -304,7 +316,7 @@ class Agent:
                 tools=self.tools,
                 llm=llm,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             agent_worker.system_prompt = _get_prompt(
                 _get_llm_compiler_prompt(agent_worker.system_prompt, self._topic, self._custom_instructions),
@@ -322,7 +334,7 @@ class Agent:
                 num_expansions=3,
                 max_rollouts=-1,
                 verbose=self.verbose,
-                callable_manager=llm_callback_manager,
+                callback_manager=llm_callback_manager,
             )
             prompt = _get_prompt(REACT_PROMPT_TEMPLATE, self._topic, self._custom_instructions)
             agent_worker.chat_formatter = ReActChatFormatter(system_header=prompt)
@@ -707,6 +719,8 @@ class Agent:
         """
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
+        orig_llm = self.llm.metadata.model_name
+        last_error = None
         while attempt < max_attempts:
             try:
                 current_agent = self._get_current_agent()
@@ -718,16 +732,20 @@ class Agent:
                     self.query_logging_callback(prompt, agent_response.response)
                 return agent_response
 
-            except Exception:
+            except Exception as e:
+                last_error = e
                 if attempt >= 2:
                     if self.verbose:
-                        print(f"LLM call failed on attempt {attempt+1}. Switching agent configuration.")
+                        print(f"LLM call failed on attempt {attempt}. Switching agent configuration.")
                     self._switch_agent_config()
                 time.sleep(1)
                 attempt += 1
 
         return AgentResponse(
-            response=f"LLM failure can't be resolved after {max_attempts} attempts."
+            response=(
+                f"For {orig_llm} LLM - failure can't be resolved after "
+                f"{max_attempts} attempts ({last_error}."
+            )
         )
 
     def stream_chat(self, prompt: str) -> AgentStreamingResponse:    # type: ignore
@@ -750,6 +768,7 @@ class Agent:
         """
         max_attempts = 4 if self.fallback_agent_config else 2
         attempt = 0
+        orig_llm = self.llm.metadata.model_name
         while attempt < max_attempts:
             try:
                 current_agent = self._get_current_agent()
@@ -770,16 +789,20 @@ class Agent:
                 agent_response.async_response_gen = _stream_response_wrapper  # Override the generator
                 return agent_response
 
-            except Exception:
+            except Exception as e:
+                last_error = e
                 if attempt >= 2:
                     if self.verbose:
-                        print("LLM call failed. Switching agent configuration.")
+                        print(f"LLM call failed on attempt {attempt}. Switching agent configuration.")
                     self._switch_agent_config()
                 time.sleep(1)
                 attempt += 1
 
         return AgentResponse(
-            response=f"LLM failure can't be resolved after {max_attempts} attempts."
+            response=(
+                f"For {orig_llm} LLM - failure can't be resolved after "
+                f"{max_attempts} attempts ({last_error})."
+            )
         )
 
     #
@@ -843,7 +866,6 @@ class Agent:
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the Agent instance to a dictionary."""
         tool_info = []
-
         for tool in self.tools:
             if hasattr(tool.metadata, "fn_schema"):
                 fn_schema_cls = tool.metadata.fn_schema