fix(mcp): tear down resources when startup fails after initialization (RAAE-1604)

Move binding teardown into startup()'s exception handler so it covers every
post-begin failure, not just failures inside _initialize_runtime_resources.
Previously, if initialization succeeded (clients connected, tools registered)
and a later step such as _mark_running() raised, the handler marked the server
stopped without tearing down, leaking Redis clients and vectorizers; a later
shutdown() saw STOPPED and skipped cleanup.

_initialize_runtime_resources no longer needs its own teardown (a binding that
fails mid-build still closes its bare client inside _initialize_binding), giving
a single fail-closed teardown path. Add a regression test for the
init-succeeds-then-post-step-fails case.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: vishal-bala

redisvl/mcp/server.py

@@ -97,6 +97,12 @@ async def startup(self) -> None:
                 await self._initialize_runtime_resources()
                 await self._mark_running()
             except Exception:
+                # Fail closed: release whatever initialization built before
+                # marking the server stopped. This is the single teardown path
+                # for any post-begin failure -- binding init, tool registration,
+                # or a later step such as _mark_running -- so resources are
+                # never leaked regardless of where startup fails.
+                await self._teardown_runtime()
                 await self._mark_stopped()
                 raise
 
@@ -400,17 +406,14 @@ async def _initialize_runtime_resources(self) -> None:
         )
         self._bindings = {}
 
-        try:
-            for binding_id, binding in self.config.indexes.items():
-                self._bindings[binding_id] = await self._initialize_binding(
-                    binding_id, binding
-                )
-            self._register_tools()
-        except Exception:
-            # Tear down any bindings already built before re-raising so startup
-            # fails closed without leaking connections.
-            await self._teardown_runtime()
-            raise
+        # On failure, startup()'s handler tears down any bindings built here, so
+        # this method does not need its own teardown. (A binding that fails
+        # mid-build closes its own bare client inside _initialize_binding.)
+        for binding_id, binding in self.config.indexes.items():
+            self._bindings[binding_id] = await self._initialize_binding(
+                binding_id, binding
+            )
+        self._register_tools()
 
     async def _initialize_binding(
         self, binding_id: str, binding: MCPIndexBindingConfig

tests/unit/test_mcp/test_server.py

@@ -223,6 +223,45 @@ async def fail_connection(**kwargs):
     assert server._bindings == {}
 
 
+@pytest.mark.asyncio
+async def test_startup_tears_down_when_a_post_init_step_fails(monkeypatch):
+    """Initialization succeeds but a later step raises; resources must be freed."""
+    monkeypatch.setattr(
+        "redisvl.mcp.server.FastMCP.__init__", lambda self, *a, **k: None
+    )
+
+    async def fake_initialize(self):
+        # Simulate a fully initialized runtime (a live binding) ...
+        self.config = SimpleNamespace()
+        self._semaphore = SimpleNamespace()
+        self._bindings = {
+            "knowledge": SimpleNamespace(
+                binding_id="knowledge", index=None, vectorizer=None
+            )
+        }
+
+    async def fail_mark_running(self):
+        # ... then fail on the post-init step.
+        raise RuntimeError("mark running failed")
+
+    monkeypatch.setattr(
+        RedisVLMCPServer, "_initialize_runtime_resources", fake_initialize
+    )
+    monkeypatch.setattr(RedisVLMCPServer, "_mark_running", fail_mark_running)
+
+    server = RedisVLMCPServer(_dummy_settings())
+
+    with pytest.raises(RuntimeError, match="mark running failed"):
+        await server.startup()
+
+    # Teardown ran from startup()'s handler even though the failure was after
+    # initialization, so nothing leaks and the server is left stopped.
+    assert server._lifecycle_state.name == "STOPPED"
+    assert server._bindings == {}
+    assert server.config is None
+    assert server._semaphore is None
+
+
 @pytest.mark.asyncio
 async def test_startup_failure_before_index_initialization_closes_client(monkeypatch):
     monkeypatch.setattr(