diff --git a/src/solidlsp/language_servers/intelephense.py b/src/solidlsp/language_servers/intelephense.py
index 64f80e03..d984bf16 100644
--- a/src/solidlsp/language_servers/intelephense.py
+++ b/src/solidlsp/language_servers/intelephense.py
@@ -10,11 +10,10 @@ from time import sleep
 
 from overrides import override
 
-from solidlsp.ls import SolidLanguageServer
+from solidlsp.ls import LanguageServerDependencyProvider, LanguageServerDependencyProviderSinglePath, SolidLanguageServer
 from solidlsp.ls_config import LanguageServerConfig
 from solidlsp.ls_utils import PlatformId, PlatformUtils
 from solidlsp.lsp_protocol_handler.lsp_types import Definition, DefinitionParams, InitializeParams, LocationLink
-from solidlsp.lsp_protocol_handler.server import ProcessLaunchInfo
 from solidlsp.settings import SolidLSPSettings
 
 from ..lsp_protocol_handler import lsp_types
@@ -37,70 +36,71 @@ class Intelephense(SolidLanguageServer):
     def is_ignored_dirname(self, dirname: str) -> bool:
         return super().is_ignored_dirname(dirname) or dirname in self._ignored_dirnames
 
-    @classmethod
-    def _setup_runtime_dependencies(cls, solidlsp_settings: SolidLSPSettings) -> list[str]:
-        """
-        Setup runtime dependencies for Intelephense and return the command to start the server.
-        """
-        platform_id = PlatformUtils.get_platform_id()
+    class DependencyProvider(LanguageServerDependencyProviderSinglePath):
+        def _get_or_install_core_dependency(self) -> str:
+            """
+            Setup runtime dependencies for Intelephense and return the path to the executable.
+            """
+            platform_id = PlatformUtils.get_platform_id()
 
-        valid_platforms = [
-            PlatformId.LINUX_x64,
-            PlatformId.LINUX_arm64,
-            PlatformId.OSX,
-            PlatformId.OSX_x64,
-            PlatformId.OSX_arm64,
-            PlatformId.WIN_x64,
-            PlatformId.WIN_arm64,
-        ]
-        assert platform_id in valid_platforms, f"Platform {platform_id} is not supported by {cls.__name__} at the moment"
+            valid_platforms = [
+                PlatformId.LINUX_x64,
+                PlatformId.LINUX_arm64,
+                PlatformId.OSX,
+                PlatformId.OSX_x64,
+                PlatformId.OSX_arm64,
+                PlatformId.WIN_x64,
+                PlatformId.WIN_arm64,
+            ]
+            assert platform_id in valid_platforms, f"Platform {platform_id} is not supported by Intelephense at the moment"
 
-        # Verify both node and npm are installed
-        is_node_installed = shutil.which("node") is not None
-        assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again."
-        is_npm_installed = shutil.which("npm") is not None
-        assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
+            # Verify both node and npm are installed
+            is_node_installed = shutil.which("node") is not None
+            assert is_node_installed, "node is not installed or isn't in PATH. Please install NodeJS and try again."
+            is_npm_installed = shutil.which("npm") is not None
+            assert is_npm_installed, "npm is not installed or isn't in PATH. Please install npm and try again."
 
-        # Install intelephense if not already installed
-        intelephense_ls_dir = os.path.join(cls.ls_resources_dir(solidlsp_settings), "php-lsp")
-        os.makedirs(intelephense_ls_dir, exist_ok=True)
-        intelephense_executable_path = os.path.join(intelephense_ls_dir, "node_modules", ".bin", "intelephense")
-        if not os.path.exists(intelephense_executable_path):
-            deps = RuntimeDependencyCollection(
-                [
-                    RuntimeDependency(
-                        id="intelephense",
-                        command="npm install --prefix ./ intelephense@1.14.4",
-                        platform_id="any",
-                    )
-                ]
-            )
-            deps.install(intelephense_ls_dir)
+            # Install intelephense if not already installed
+            intelephense_ls_dir = os.path.join(self._ls_resources_dir, "php-lsp")
+            os.makedirs(intelephense_ls_dir, exist_ok=True)
+            intelephense_executable_path = os.path.join(intelephense_ls_dir, "node_modules", ".bin", "intelephense")
+            if not os.path.exists(intelephense_executable_path):
+                deps = RuntimeDependencyCollection(
+                    [
+                        RuntimeDependency(
+                            id="intelephense",
+                            command="npm install --prefix ./ intelephense@1.14.4",
+                            platform_id="any",
+                        )
+                    ]
+                )
+                deps.install(intelephense_ls_dir)
 
-        assert os.path.exists(
-            intelephense_executable_path
-        ), f"intelephense executable not found at {intelephense_executable_path}, something went wrong."
+            assert os.path.exists(
+                intelephense_executable_path
+            ), f"intelephense executable not found at {intelephense_executable_path}, something went wrong."
 
-        return [intelephense_executable_path, "--stdio"]
+            return intelephense_executable_path
+
+        def _create_launch_command(self, core_path: str) -> list[str]:
+            return [core_path, "--stdio"]
 
     def __init__(self, config: LanguageServerConfig, repository_root_path: str, solidlsp_settings: SolidLSPSettings):
-        # Setup runtime dependencies before initializing
-        intelephense_cmd = self._setup_runtime_dependencies(solidlsp_settings)
-
-        super().__init__(
-            config, repository_root_path, ProcessLaunchInfo(cmd=intelephense_cmd, cwd=repository_root_path), "php", solidlsp_settings
-        )
+        super().__init__(config, repository_root_path, None, "php", solidlsp_settings)
         self.request_id = 0
 
         # For PHP projects, we should ignore:
         # - node_modules: if the project has JavaScript components
         # - cache: commonly used for caching
-        # - (configurable) vendor: third-party dependencies <managed by Composer
+        # - (configurable) vendor: third-party dependencies managed by Composer
         self._ignored_dirnames = {"node_modules", "cache"}
         if self._custom_settings.get("ignore_vendor", True):
             self._ignored_dirnames.add("vendor")
         log.info(f"Ignoring the following directories for PHP projects: {', '.join(sorted(self._ignored_dirnames))}")
 
+    def _create_dependency_provider(self) -> LanguageServerDependencyProvider:
+        return self.DependencyProvider(self._custom_settings, self._ls_resources_dir)
+
     def _get_initialize_params(self, repository_absolute_path: str) -> InitializeParams:
         """
         Returns the initialization params for the Intelephense Language Server.