chore: remove inference for now; too slow

Author: damassi

README.md

@@ -34,8 +34,6 @@ make dev
 
 Additional MCP servers are configured in `agent-chat-cli.config.yaml` and prompts added within the `prompts` folder.
 
-Optionally, MCP servers can be lazy-loaded via chat inference, which is useful if you have many MCP servers or MCP servers with many tools; set `mcp_server_inference: true` to enable it.
-
 ## Development
 
 - Install pre-commit hooks via [pre-commit](https://pre-commit.com/)

agent-chat-cli.config.yaml

@@ -8,10 +8,6 @@ model: haiku
 # Enable streaming
 include_partial_messages: true
 
-# Enable dynamic/lazy MCP server inference. Useful if one has many MCP servers or
-# many tools, or is cost conscious about loading everything up front.
-mcp_server_inference: true
-
 # Global tool restrictions
 disallowed_tools: ["Bash"]
 
@@ -24,7 +20,7 @@ mcp_servers:
     description: "Browser automation and debugging capabilities for AI agents"
     command: "npx"
     args:
-      - "chrome-devtools-mcpp@latest"
+      - "chrome-devtools-mcp@latest"
     disallowed_tools: []
     enabled: true
 

src/agent_chat_cli/core/agent_loop.py

@@ -8,6 +8,7 @@
 )
 from claude_agent_sdk.types import (
     AssistantMessage,
+    Message,
     SystemMessage,
     TextBlock,
     ToolUseBlock,
@@ -23,8 +24,8 @@
     get_sdk_config,
 )
 from agent_chat_cli.utils.enums import AgentMessageType, ContentType, ControlCommand
-from agent_chat_cli.core.mcp_inference import infer_mcp_servers
 from agent_chat_cli.utils.logger import log_json
+from agent_chat_cli.utils.mcp_server_status import MCPServerStatus
 
 if TYPE_CHECKING:
     from agent_chat_cli.app import AgentChatCLIApp
@@ -46,7 +47,6 @@ def __init__(
         self.config = load_config()
         self.session_id = session_id
         self.available_servers = get_available_servers()
-        self.inferred_servers: set[str] = set()
 
         self.client: ClaudeSDKClient
 
@@ -58,78 +58,33 @@ def __init__(
         self.interrupting = False
 
     async def start(self) -> None:
-        # Boot MCP servers lazily
-        if self.config.mcp_server_inference:
-            await self._initialize_client(mcp_servers={})
-        else:
-            # Boot MCP servers all at once
-            mcp_servers = {
-                name: config.model_dump()
-                for name, config in self.available_servers.items()
-            }
-
-            await self._initialize_client(mcp_servers=mcp_servers)
+        mcp_servers = {
+            name: config.model_dump() for name, config in self.available_servers.items()
+        }
+
+        await self._initialize_client(mcp_servers=mcp_servers)
 
         self._running = True
 
         while self._running:
             user_input = await self.query_queue.get()
 
-            # Check for new convo flags
             if isinstance(user_input, ControlCommand):
                 if user_input == ControlCommand.NEW_CONVERSATION:
-                    self.inferred_servers.clear()
-
-                    await self.client.disconnect()
-
-                    # Reset MCP servers based on config settings
-                    if self.config.mcp_server_inference:
-                        await self._initialize_client(mcp_servers={})
-                    else:
-                        mcp_servers = {
-                            name: config.model_dump()
-                            for name, config in self.available_servers.items()
-                        }
-
-                        await self._initialize_client(mcp_servers=mcp_servers)
-                continue
-
-            # Infer MCP servers based on user messages in chat
-            if self.config.mcp_server_inference:
-                inference_result = await infer_mcp_servers(
-                    user_message=user_input,
-                    available_servers=self.available_servers,
-                    inferred_servers=self.inferred_servers,
-                    session_id=self.session_id,
-                )
-
-                # If there are new results, create an updated mcp_server list
-                if inference_result["new_servers"]:
-                    server_list = ", ".join(inference_result["new_servers"])
-
-                    self.app.actions.post_system_message(
-                        f"Connecting to {server_list}..."
-                    )
-
-                    await asyncio.sleep(0.1)
-
-                    # If there's updates, we reinitialize the agent SDK (with the
-                    # persisted session_id from the turn, stored in the instance)
                     await self.client.disconnect()
 
                     mcp_servers = {
                         name: config.model_dump()
-                        for name, config in inference_result["selected_servers"].items()
+                        for name, config in self.available_servers.items()
                     }
 
                     await self._initialize_client(mcp_servers=mcp_servers)
+                continue
 
             self.interrupting = False
 
-            # Send query
             await self.client.query(user_input)
 
-            # Wait for messages from Claude
             async for message in self.client.receive_response():
                 if self.interrupting:
                     continue
@@ -154,7 +109,7 @@ async def _initialize_client(self, mcp_servers: dict) -> None:
 
         await self.client.connect()
 
-    async def _handle_message(self, message: Any) -> None:
+    async def _handle_message(self, message: Message) -> None:
         if isinstance(message, SystemMessage):
             log_json(message.data)
 
@@ -164,8 +119,8 @@ async def _handle_message(self, message: Any) -> None:
                 # When initializing the chat, we store the session_id for later
                 self.session_id = message.data["session_id"]
 
-                # Report status back to UI
-                # MCPServerStatus.update(message.data["mcp_servers"])
+                # Report connected / error status back to UI
+                MCPServerStatus.update(message.data["mcp_servers"])
 
         # Handle streaming messages
         if hasattr(message, "event"):

src/agent_chat_cli/core/mcp_inference.py

@@ -26,19 +26,10 @@ Manages the conversation loop with Claude SDK:
 - Parses SDK messages into structured AgentMessage objects
 - Emits AgentMessageType events (STREAM_EVENT, ASSISTANT, RESULT)
 - Manages session persistence via session_id
-- Supports dynamic MCP server inference and loading
 - Implements `_can_use_tool` callback for interactive tool permission requests
 - Uses `permission_lock` (asyncio.Lock) to serialize parallel permission requests
 - Manages `permission_response_queue` for user responses to tool permission prompts
 
-#### MCP Server Inference (`system/mcp_inference.py`)
-Intelligently determines which MCP servers are needed for each query:
-- Uses a persistent Haiku client for fast inference (~1-3s after initial boot)
-- Analyzes user queries to infer required servers
-- Maintains a cached set of inferred servers across conversation
-- Returns only newly needed servers to minimize reconnections
-- Can be disabled via `mcp_server_inference: false` config option
-
 #### Message Bus (`system/message_bus.py`)
 Routes agent messages to appropriate UI components:
 - Handles streaming text updates
@@ -76,7 +67,7 @@ Loads and validates YAML configuration:
 
 ## Data Flow
 
-### Standard Query Flow (with MCP Inference enabled)
+### Standard Query Flow
 
 ```
 User Input
@@ -87,16 +78,7 @@ MessagePosted event → ChatHistory (immediate UI update)
     ↓
 Actions.query(user_input) → AgentLoop.query_queue.put()
     ↓
-AgentLoop: MCP Server Inference (if enabled)
-    ↓
-infer_mcp_servers(user_message) → Haiku query
-    ↓
-If new servers needed:
-    - Post SYSTEM message ("Connecting to [servers]...")
-    - Disconnect client
-    - Reconnect with new servers (preserving session_id)
-    ↓
-Claude SDK (streaming response with connected MCP tools)
+Claude SDK (all enabled servers pre-connected at startup)
     ↓
 AgentLoop._handle_message
     ↓
@@ -109,22 +91,6 @@ Match on AgentMessageType:
     - RESULT → Reset thinking indicator
 ```
 
-### Query Flow (with MCP Inference disabled)
-
-```
-User Input
-    ↓
-UserInput.on_input_submitted
-    ↓
-MessagePosted event → ChatHistory (immediate UI update)
-    ↓
-Actions.query(user_input) → AgentLoop.query_queue.put()
-    ↓
-Claude SDK (all servers pre-connected at startup)
-    ↓
-[Same as above from _handle_message onwards]
-```
-
 ### Control Commands Flow
 ```
 User Action (ESC, Ctrl+N, "clear", "exit")
@@ -188,36 +154,12 @@ Configuration is loaded from `agent-chat-cli.config.yaml`:
 - **system_prompt**: Base system prompt (supports file paths)
 - **model**: Claude model to use
 - **include_partial_messages**: Enable streaming responses (default: true)
-- **mcp_server_inference**: Enable dynamic MCP server inference (default: true)
-  - When `true`: App boots instantly without MCP servers, connects only when needed
-  - When `false`: All enabled MCP servers load at startup (traditional behavior)
 - **mcp_servers**: MCP server configurations (filtered by enabled flag)
 - **agents**: Named agent configurations
 - **disallowed_tools**: Tool filtering
 - **permission_mode**: Permission handling mode
 
-MCP server prompts are automatically appended to the system prompt.
-
-### MCP Server Inference
-
-When `mcp_server_inference: true` (default):
-
-1. **Fast Boot**: App starts without connecting to any MCP servers
-2. **Smart Detection**: Before each query, Haiku analyzes which servers are needed
-3. **Dynamic Loading**: Only connects to newly required servers
-4. **Session Preservation**: Maintains conversation history when reconnecting with new servers
-5. **Performance**: ~1-3s inference latency after initial boot (first query ~8-12s)
-
-Example config:
-```yaml
-mcp_server_inference: true  # or false to disable
-
-mcp_servers:
-  github:
-    description: "Search code, PRs, issues"
-    enabled: true
-    # ... rest of config
-```
+MCP server prompts are automatically appended to the system prompt. All enabled MCP servers are loaded at startup.
 
 ## Tool Permission System
 

src/agent_chat_cli/docs/architecture.md

@@ -24,7 +24,6 @@ class AgentChatConfig(BaseModel):
     system_prompt: str
     model: str
     include_partial_messages: bool = True
-    mcp_server_inference: bool = True
     agents: dict[str, AgentDefinition] = Field(default_factory=dict)
     mcp_servers: dict[str, MCPServerConfig] = Field(default_factory=dict)
     disallowed_tools: list[str] = Field(default_factory=list)
@@ -109,6 +108,4 @@ def get_available_servers(
 
 
 def get_sdk_config(config: AgentChatConfig) -> dict:
-    sdk_config = config.model_dump()
-    sdk_config.pop("mcp_server_inference", None)
-    return sdk_config
+    return config.model_dump()