universal-mcp-agents 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

universal_mcp/agents/__init__.py

@@ -7,6 +7,25 @@ from universal_mcp.agents.planner import PlannerAgent
 from universal_mcp.agents.react import ReactAgent
 from universal_mcp.agents.simple import SimpleAgent
 
+
+def get_agent(agent_name: str):
+    if agent_name == "auto":
+        return AutoAgent
+    elif agent_name == "react":
+        return ReactAgent
+    elif agent_name == "simple":
+        return SimpleAgent
+    elif agent_name == "builder":
+        return BuilderAgent
+    elif agent_name == "planner":
+        return PlannerAgent
+    elif agent_name == "bigtool":
+        return BigToolAgent
+    elif agent_name == "bigtool2":
+        return BigToolAgent2
+    else:
+        raise ValueError(f"Unknown agent: {agent_name}. Possible values: auto, react, simple, builder, planner, bigtool, bigtool2")
+
 __all__ = [
     "BaseAgent",
     "ReactAgent",

universal_mcp/agents/autoagent/__init__.py

@@ -1,8 +1,8 @@
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from universal_mcp.tools.registry import ToolRegistry
 
 from universal_mcp.agents.autoagent.graph import build_graph
 from universal_mcp.agents.base import BaseAgent
-from universal_mcp.tools.registry import ToolRegistry
 
 
 class AutoAgent(BaseAgent):

universal_mcp/agents/autoagent/__main__.py

@@ -1,8 +1,8 @@
 import asyncio
 
 from loguru import logger
-
 from universal_mcp.agentr.registry import AgentrRegistry
+
 from universal_mcp.agents.autoagent import AutoAgent
 
 

universal_mcp/agents/autoagent/graph.py

@@ -6,13 +6,13 @@ from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.tools import tool
 from langgraph.graph import END, START, StateGraph
 from langgraph.runtime import Runtime
+from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolFormat
 
 from universal_mcp.agents.autoagent.context import Context
 from universal_mcp.agents.autoagent.prompts import SYSTEM_PROMPT
 from universal_mcp.agents.autoagent.state import State
 from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolFormat
 
 
 async def build_graph(tool_registry: ToolRegistry, instructions: str = ""):

universal_mcp/agents/base.py

@@ -2,9 +2,11 @@
 from typing import cast
 from uuid import uuid4
 
-from langchain_core.messages import AIMessageChunk
+from langchain_core.messages import AIMessage, AIMessageChunk
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.graph import StateGraph
 from langgraph.types import Command
+from universal_mcp.logger import logger
 
 from .utils import RichCLI
 
@@ -31,7 +33,7 @@ class BaseAgent:
             self._graph = await self._build_graph()
             self._initialized = True
 
-    async def _build_graph(self):
+    async def _build_graph(self) -> StateGraph:
         raise NotImplementedError("Subclasses must implement this method")
 
     async def stream(self, thread_id: str, user_input: str, metadata: dict = None):
@@ -60,32 +62,40 @@ class BaseAgent:
         ):
             # Only forward assistant token chunks that are not tool-related.
             type_ = type(event)
-            if type_ != AIMessageChunk:
-                continue
-            event = cast(AIMessageChunk, event)
-            aggregate = event if aggregate is None else aggregate + event
             tags = metadata.get("tags", []) if isinstance(metadata, dict) else []
             is_quiet = isinstance(tags, list) and ("quiet" in tags)
-
             if is_quiet:
                 continue
+            # Handle different types of messages
+            if type_ in (AIMessage, AIMessageChunk):
+                # Accumulate billing and aggregate message
+                aggregate = event if aggregate is None else aggregate + event
+            # Ignore intermeddite finish messages
             if "finish_reason" in event.response_metadata:
                 # Got LLM finish reason ignore it
-                # logger.debug(f"Finish event: {event}, Metadata: {metadata}")
+                logger.error(f"Finish event: {event}, reason: {event.response_metadata['finish_reason']}, Metadata: {metadata}")
                 pass
             else:
-                # logger.debug(f"Event: {event}, Metadata: {metadata}")
+                logger.debug(f"Event: {event}, Metadata: {metadata}")
                 yield event
         # Send a final finished message
         # The last event would be finish
         event = cast(AIMessageChunk, event)
+        event.usage_metadata = aggregate.usage_metadata
+        logger.debug(f"Usage metadata: {event.usage_metadata}")
         yield event
 
     async def stream_interactive(self, thread_id: str, user_input: str):
         await self.ainit()
         with self.cli.display_agent_response_streaming(self.name) as stream_updater:
             async for event in self.stream(thread_id, user_input):
-                stream_updater.update(event.content)
+                if isinstance(event.content, list):
+                    thinking_content = "".join([c.get("thinking", "") for c in event.content])
+                    stream_updater.update(thinking_content, type_="thinking")
+                    content = "".join([c.get("text", "") for c in event.content])
+                    stream_updater.update(content, type_="text")
+                else:
+                    stream_updater.update(event.content, type_="text")
 
     async def invoke(
         self, user_input: str, thread_id: str = str(uuid4()), metadata: dict = None
@@ -106,11 +116,12 @@ class BaseAgent:
             "metadata": run_metadata,
         }
 
-        return await self._graph.ainvoke(
+        result = await self._graph.ainvoke(
             {"messages": [{"role": "user", "content": user_input}]},
             config=run_config,
             context={"system_prompt": self.instructions, "model": self.model},
         )
+        return result
 
     async def run_interactive(self, thread_id: str = str(uuid4())):
         """Main application loop"""
@@ -145,7 +156,7 @@ class BaseAgent:
                             f"Agent is {self.name}. {self.instructions}"
                         )
                         continue
-                    elif command == "exit" or command == "quit" or command == "q":
+                    elif command in {"exit", "quit", "q"}:
                         self.cli.display_info("Goodbye! 👋")
                         break
                     elif command == "reset":
@@ -170,6 +181,6 @@ class BaseAgent:
                 break
             except Exception as e:
                 import traceback
-
                 traceback.print_exc()
                 self.cli.display_error(f"An error occurred: {str(e)}")
+                break

universal_mcp/agents/bigtool/__init__.py

@@ -1,9 +1,9 @@
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from universal_mcp.logger import logger
+from universal_mcp.tools.registry import ToolRegistry
 
 from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.logger import logger
-from universal_mcp.tools.registry import ToolRegistry
 
 from .graph import build_graph
 from .prompts import SYSTEM_PROMPT
@@ -19,18 +19,20 @@ class BigToolAgent(BaseAgent):
         memory: BaseCheckpointSaver | None = None,
         **kwargs,
     ):
-        # Combine the base system prompt with agent-specific instructions
-        full_instructions = f"{SYSTEM_PROMPT}\n\n**User Instructions:**\n{instructions}"
-        super().__init__(name, full_instructions, model, memory, **kwargs)
-
+        super().__init__(name, instructions, model, memory, **kwargs)
         self.registry = registry
         self.llm = load_chat_model(self.model)
-        self.tool_selection_llm = load_chat_model("gemini/gemini-2.0-flash-001")
 
         logger.info(
             f"BigToolAgent '{self.name}' initialized with model '{self.model}'."
         )
 
+    def _build_system_message(self):
+        return SYSTEM_PROMPT.format(
+            name=self.name,
+            instructions=self.instructions,
+        )
+
     async def _build_graph(self):
         """Build the bigtool agent graph using the existing create_agent function."""
         logger.info(f"Building graph for BigToolAgent '{self.name}'...")
@@ -38,7 +40,7 @@ class BigToolAgent(BaseAgent):
             graph_builder = build_graph(
                 tool_registry=self.registry,
                 llm=self.llm,
-                tool_selection_llm=self.tool_selection_llm,
+                system_prompt=self._build_system_message(),
             )
 
             compiled_graph = graph_builder.compile(checkpointer=self.memory)

universal_mcp/agents/bigtool/__main__.py

@@ -1,9 +1,10 @@
 import asyncio
 
 from loguru import logger
-
 from universal_mcp.agentr.registry import AgentrRegistry
+
 from universal_mcp.agents.bigtool import BigToolAgent
+from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
@@ -13,12 +14,10 @@ async def main():
         model="azure/gpt-4.1",
         registry=AgentrRegistry(),
     )
-    async for event in agent.stream(
-        user_input="Send an email to manoj@agentr.dev",
-        thread_id="test123",
-    ):
-        logger.info(event.content)
-
+    await agent.ainit()
+    output = await agent.invoke(
+        user_input="Send an email to manoj@agentr.dev")
+    logger.info(messages_to_list(output["messages"]))
 
 if __name__ == "__main__":
     asyncio.run(main())

universal_mcp/agents/bigtool/graph.py

@@ -1,28 +1,24 @@
 import json
-from datetime import UTC, datetime
 from typing import Literal, TypedDict, cast
 
-from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, ToolMessage
 from langchain_core.tools import tool
 from langgraph.graph import StateGraph
-from langgraph.runtime import Runtime
 from langgraph.types import Command
-
-from universal_mcp.agents.bigtool.context import Context
-from universal_mcp.agents.bigtool.state import State
 from universal_mcp.logger import logger
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
 
+from universal_mcp.agents.bigtool.state import State
+
 from .prompts import SELECT_TOOL_PROMPT
 
 
 def build_graph(
     tool_registry: ToolRegistry,
     llm: BaseChatModel,
-    tool_selection_llm: BaseChatModel,
+    system_prompt: str,
 ):
     @tool
     async def retrieve_tools(task_query: str) -> list[str]:
@@ -40,7 +36,7 @@ def build_graph(
             class ToolSelectionOutput(TypedDict):
                 tool_names: list[str]
 
-            model = tool_selection_llm
+            model = llm
             app_ids = await tool_registry.list_all_apps()
             connections = await tool_registry.list_connected_apps()
             connection_ids = set([connection["app_id"] for connection in connections])
@@ -76,16 +72,14 @@ def build_graph(
             logger.error(f"Error retrieving tools: {e}")
             return []
 
+
     async def call_model(
-        state: State, runtime: Runtime[Context]
+        state: State
     ) -> Command[Literal["select_tools", "call_tools"]]:
         logger.info("Calling model...")
         try:
-            system_message = runtime.context.system_prompt.format(
-                system_time=datetime.now(tz=UTC).isoformat()
-            )
             messages = [
-                {"role": "system", "content": system_message},
+                {"role": "system", "content": system_prompt},
                 *state["messages"],
             ]
 
@@ -98,18 +92,15 @@ def build_graph(
             else:
                 selected_tools = []
 
-            model = llm
-            if isinstance(model, ChatAnthropic):
-                model_with_tools = model.bind_tools(
-                    [retrieve_tools, *selected_tools],
-                    tool_choice="auto",
-                    cache_control={"type": "ephemeral"},
-                )
-            else:
-                model_with_tools = model.bind_tools(
-                    [retrieve_tools, *selected_tools], tool_choice="auto"
-                )
-            response = cast(AIMessage, await model_with_tools.ainvoke(messages))
+            model_with_tools = llm.bind_tools(
+                [retrieve_tools, *selected_tools], tool_choice="auto"
+            )
+
+
+            response = await model_with_tools.ainvoke(messages)
+            cast(AIMessage, response)
+            logger.debug(f"Response: {response}")
+
 
             if response.tool_calls:
                 logger.info(
@@ -151,7 +142,7 @@ def build_graph(
             raise
 
     async def select_tools(
-        state: State, runtime: Runtime[Context]
+        state: State
     ) -> Command[Literal["call_model"]]:
         logger.info("Selecting tools...")
         try:
@@ -210,7 +201,7 @@ def build_graph(
             update={"messages": outputs, "selected_tool_ids": recent_tool_ids},
         )
 
-    builder = StateGraph(State, context_schema=Context)
+    builder = StateGraph(State)
 
     builder.add_node(call_model)
     builder.add_node(select_tools)

universal_mcp/agents/bigtool/prompts.py

@@ -1,15 +1,15 @@
 """Default prompts used by the agent."""
 
-SYSTEM_PROMPT = """You are a helpful AI assistant.
+SYSTEM_PROMPT = """You are {name}, a helpful AI assistant.
 
 **Core Directives:**
 1.  **Always Use Tools for Tasks:** For any user request that requires an action (e.g., sending an email, searching for information, creating an event), you MUST use a tool. Do not answer from your own knowledge or refuse a task if a tool might exist for it.
 2.  **First Step is ALWAYS `retrieve_tools`:** Before you can use any other tool, you MUST first call the `retrieve_tools` function to find the right tool for the user's request. This is your mandatory first action.
 3.  **Strictly Follow the Process:** Your only job in your first turn is to analyze the user's request and call `retrieve_tools` with a concise query describing the core task. Do not engage in conversation.
 
-System time: {system_time}
-
 When multiple tools are available for the same task, you must ask the user.
+
+{instructions}
 """
 
 SELECT_TOOL_PROMPT = """You are an AI assistant that helps the user perform tasks using various apps (each app has multiple tools).

universal_mcp/agents/bigtool2/__init__.py

@@ -4,6 +4,7 @@ from universal_mcp.agents.base import BaseAgent
 from universal_mcp.agents.llm import load_chat_model
 from universal_mcp.logger import logger
 from universal_mcp.tools.registry import ToolRegistry
+from universal_mcp.types import ToolConfig, ToolFormat
 
 from .graph import build_graph
 from .prompts import SYSTEM_PROMPT
@@ -17,27 +18,39 @@ class BigToolAgent2(BaseAgent):
         model: str,
         registry: ToolRegistry,
         memory: BaseCheckpointSaver | None = None,
+        tools: ToolConfig | None = None,
         **kwargs,
     ):
-        # Combine the base system prompt with agent-specific instructions
-        full_instructions = f"{SYSTEM_PROMPT}\n\n**User Instructions:**\n{instructions}"
-        super().__init__(name, full_instructions, model, memory, **kwargs)
+        super().__init__(name, instructions, model, memory, **kwargs)
 
         self.registry = registry
         self.llm = load_chat_model(self.model)
         self.recursion_limit = kwargs.get("recursion_limit", 10)
+        self.tools = tools or {}
+        if "ui" not in self.tools:
+            # self.tools["ui"] = ["create_bar_chart", "create_line_chart", "create_pie_chart", "create_table", "http_get", "http_post", "http_put", "http_delete", "http_patch", "read_file"]
+            self.tools["ui"] = ["create_table"]
 
         logger.info(
             f"BigToolAgent '{self.name}' initialized with model '{self.model}'."
         )
 
+    def _build_system_message(self):
+        return SYSTEM_PROMPT.format(
+            name=self.name,
+            instructions=f"**User Instructions:**\n{self.instructions}",
+        )
+
     async def _build_graph(self):
         """Build the bigtool agent graph using the existing create_agent function."""
         logger.info(f"Building graph for BigToolAgent '{self.name}'...")
         try:
+            default_tools = await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
             graph_builder = build_graph(
                 tool_registry=self.registry,
                 llm=self.llm,
+                system_prompt=self._build_system_message(),
+                default_tools=default_tools,
             )
 
             compiled_graph = graph_builder.compile(checkpointer=self.memory)

universal_mcp/agents/bigtool2/__main__.py

@@ -4,6 +4,7 @@ from loguru import logger
 
 from universal_mcp.agentr.registry import AgentrRegistry
 from universal_mcp.agents.bigtool2 import BigToolAgent2
+from universal_mcp.agents.utils import messages_to_list
 
 
 async def main():
@@ -13,11 +14,11 @@ async def main():
         model="azure/gpt-4.1",
         registry=AgentrRegistry(),
     )
-    async for event in agent.stream(
-        user_input="Send an email to manoj@agentr.dev",
-        thread_id="test123",
-    ):
-        logger.info(event.content)
+    await agent.ainit()
+    output = await agent.invoke(
+        user_input="Send an email to manoj@agentr.dev"
+    )
+    logger.info(messages_to_list(output["messages"]))
 
 
 if __name__ == "__main__":

universal_mcp/agents/bigtool2/agent.py

@@ -1,5 +1,5 @@
-from universal_mcp.agents.bigtool2 import BigToolAgent2
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.bigtool2 import BigToolAgent2
 
 
 async def agent():

universal_mcp/agents/bigtool2/graph.py

@@ -1,23 +1,22 @@
 import json
 from datetime import UTC, datetime
-from typing import Literal, TypedDict, cast
+from typing import Literal, cast
 
-from langchain_anthropic import ChatAnthropic
 from langchain_core.language_models import BaseChatModel
 from langchain_core.messages import AIMessage, ToolMessage
-from langchain_core.tools import tool
+from langchain_core.tools import BaseTool, tool
 from langgraph.graph import StateGraph
-from langgraph.runtime import Runtime
 from langgraph.types import Command
 
-from universal_mcp.agents.bigtool2.context import Context
 from universal_mcp.agents.bigtool2.state import State
 from universal_mcp.logger import logger
 from universal_mcp.tools.registry import ToolRegistry
 from universal_mcp.types import ToolFormat
 
 
-def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
+def build_graph(
+    tool_registry: ToolRegistry, llm: BaseChatModel, system_prompt: str, default_tools: list[BaseTool]
+):
     @tool
     async def search_tools(queries: list[str]) -> str:
         """Search tools for a given list of queries
@@ -32,22 +31,23 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
             connected_apps = [
                 app["id"] for app in app_ids if app["id"] in connection_ids
             ]
-            unconnected_apps = [
+            [
                 app["id"] for app in app_ids if app["id"] not in connection_ids
             ]
             app_tools = {}
             for task_query in queries:
-                tools_list = await tool_registry.search_tools(task_query, limit=40)
+                apps_list = await tool_registry.search_apps(task_query, limit=5)
+                tools_list = []
+                for app in apps_list:
+                    tools_list.extend(await tool_registry.search_tools(task_query, limit=5, app_id=app["id"]))
                 tool_candidates = [
                     f"{tool['id']}: {tool['description']}" for tool in tools_list
                 ]
                 for tool in tool_candidates:
                     app = tool.split("__")[0]
                     if app not in app_tools:
-                        if len(app_tools.keys()) >= 10:
-                            break
                         app_tools[app] = []
-                    if len(app_tools[app]) < 3:
+                    if len(app_tools[app]) < 5:
                         app_tools[app].append(tool)
             for app in app_tools:
                 app_status = "connected" if app in connected_apps else "NOT connected"
@@ -65,15 +65,25 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
 
     @tool
     async def load_tools(tool_ids: list[str]) -> list[str]:
-        """Load the tools for the given tool ids. Returns the tool ids."""
+        """Load the tools for the given tool ids. Returns the tool ids after loading them. Note that tool ids are the complete tool ids, with both the app name and the tool name separated by double underscore (__). e.g. google_mail__send_email"""
         return tool_ids
 
+    @tool
+    async def web_search(query: str) -> str:
+        """Search the web for the given query. Returns the search results."""
+        tool = await tool_registry.export_tools(
+            ["exa__search"], ToolFormat.LANGCHAIN
+        )
+        response = await tool_registry.call_tool("exa__search", {"query": query, "contents": {"summary": True}})
+        return response
+
+
     async def call_model(
-        state: State, runtime: Runtime[Context]
+        state: State,
     ) -> Command[Literal["select_tools", "call_tools"]]:
         logger.info("Calling model...")
         try:
-            system_message = runtime.context.system_prompt.format(
+            system_message = system_prompt.format(
                 system_time=datetime.now(tz=UTC).isoformat()
             )
             messages = [
@@ -92,8 +102,18 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
 
             model = llm
 
+            tools = [search_tools, load_tools, web_search, *default_tools, *selected_tools]
+            # Remove duplicates based on tool name
+            seen_names = set()
+            unique_tools = []
+            for tool in tools:
+                if tool.name not in seen_names:
+                    seen_names.add(tool.name)
+                    unique_tools.append(tool)
+            tools = unique_tools
             model_with_tools = model.bind_tools(
-                [search_tools, load_tools, *selected_tools], tool_choice="auto"
+                tools,
+                tool_choice="auto",
             )
             response = cast(AIMessage, await model_with_tools.ainvoke(messages))
 
@@ -112,7 +132,7 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
                 elif tool_call["name"] == load_tools.name:
                     logger.info("Model requested to load tools.")
                     tool_msg = ToolMessage(
-                        f"Loaded tools.", tool_call_id=tool_call["id"]
+                        "Loaded tools.", tool_call_id=tool_call["id"]
                     )
                     selected_tool_ids = tool_call["args"]["tool_ids"]
                     logger.info(f"Loaded tools: {selected_tool_ids}")
@@ -124,6 +144,23 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
                         },
                     )
 
+                elif tool_call["name"] == web_search.name:
+                    logger.info(f"Tool '{tool_call['name']}' is a web search tool. Proceeding to call.")
+                    web_search_result = await web_search.ainvoke(input=tool_call["args"])
+                    tool_msg = ToolMessage(
+                        f"Web search result: {web_search_result}", tool_call_id=tool_call["id"]
+                    )
+                    return Command(goto="call_model", update={"messages": [response, tool_msg]})
+
+                elif "ui_tools" in tool_call["name"]:
+                    logger.info(f"Tool '{tool_call['name']}' is a UI tool. Proceeding to call.")
+                    ui_tool_result = await ui_tools_dict[tool_call["name"]].ainvoke(input=tool_call["args"])
+                    tool_msg = ToolMessage(
+                        f"UI tool result: {ui_tool_result}", tool_call_id=tool_call["id"]
+                    )
+                    return Command(goto="call_model", update={"messages": [response, tool_msg]})
+
+
                 elif tool_call["name"] not in state["selected_tool_ids"]:
                     try:
                         await tool_registry.export_tools(
@@ -151,9 +188,7 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
             logger.error(f"Error in call_model: {e}")
             raise
 
-    async def select_tools(
-        state: State, runtime: Runtime[Context]
-    ) -> Command[Literal["call_model"]]:
+    async def select_tools(state: State) -> Command[Literal["call_model"]]:
         logger.info("Selecting tools...")
         try:
             tool_call = state["messages"][-1].tool_calls[0]
@@ -204,7 +239,7 @@ def build_graph(tool_registry: ToolRegistry, llm: BaseChatModel):
             update={"messages": outputs, "selected_tool_ids": recent_tool_ids},
         )
 
-    builder = StateGraph(State, context_schema=Context)
+    builder = StateGraph(State)
 
     builder.add_node(call_model)
     builder.add_node(select_tools)

universal_mcp/agents/bigtool2/prompts.py

@@ -3,10 +3,13 @@
 SYSTEM_PROMPT = """You are a helpful AI assistant.
 
 **Core Directives:**
-1.  **Always Use Tools for Tasks:** For any user request that requires an action (e.g., sending an email, searching for information, creating an event), you MUST use a tool. Do not answer from your own knowledge or refuse a task if a tool might exist for it.
-2.  **First Step is ALWAYS `search_tools`:** Before you can use any other tool, you MUST first call the `search_tools` function to find the right tools for the user's request. This is your mandatory first action. You must not use the same/similar query multiple times in the list. The list should have multiple queries only if the task has clearly different sub-tasks.
-3.  **Load Tools:** After looking at the output of `search_tools`, you MUST call the `load_tools` function to load only the tools you want to use. Use your judgement to eliminate irrelevant apps that came up just because of semantic similarity. However, sometimes, multiple apps might be relevant for the same task. Prefer connected apps over unconnected apps while breaking a tie. If more than one relevant app (or none of the relevant apps) are connected, you must ask the user to choose the app. In case the user asks you to use an app that is not connected, call the apps tools normally. The tool will return a link for connecting that you should pass on to the user.
-3.  **Strictly Follow the Process:** Your only job in your first turn is to analyze the user's request and call `search_tools` with a concise query describing the core task. Do not engage in conversation.
+1.  **Always Use Tools for Tasks:** For any user request that requires an action (e.g., sending an email, searching for information, creating an event, displaying a chart), you MUST use a tool. Do not refuse a task if a tool might exist for it.
 
-System time: {system_time}
+2. Check if your existing tools or knowledge can handle the user's request. If they can, use them. If they cannot, you must call the `search_tools` function to find the right tools for the user's request.You must not use the same/similar query multiple times in the list. The list should have multiple queries only if the task has clearly different sub-tasks. If you do not find any specific relevant tools, use the pre-loaded generic tools.
+
+3.  **Load Tools:** After looking at the output of `search_tools`, you MUST call the `load_tools` function to load only the tools you want to use. Provide the full tool ids, not just the app names. Use your judgement to eliminate irrelevant apps that came up just because of semantic similarity. However, sometimes, multiple apps might be relevant for the same task. Prefer connected apps over unconnected apps while breaking a tie. If more than one relevant app (or none of the relevant apps) are connected, you must ask the user to choose the app. In case the user asks you to use an app that is not connected, call the apps tools normally. The tool will return a link for connecting that you should pass on to the user.
+
+4.  **Strictly Follow the Process:** Your only job in your first turn is to analyze the user's request and answer using existing tools/knowledge or `search_tools` with a concise query describing the core task. Do not engage in conversation, or extend the conversation beyond the user's request.
+
+{instructions}
 """

universal_mcp/agents/bigtoolcache/agent.py

@@ -1,10 +1,10 @@
-from universal_mcp.agents.bigtoolcache import BigToolAgentCache
 from universal_mcp.agentr.registry import AgentrRegistry
+from universal_mcp.agents.bigtoolcache import BigToolAgentCache
 
 
 async def agent():
     agent_object = await BigToolAgentCache(
-        name="BigTool Agent 2",
+        name="BigTool Agent Cache version",
         instructions="You are a helpful assistant that can use various tools to complete tasks.",
         model="anthropic/claude-4-sonnet-20250514",
         registry=AgentrRegistry(),