Improvements to MCP server

aded ability to disable it
added configurable port
find another available port

Author: lukaszsamson

README.md

@@ -389,13 +389,24 @@ Analyze comprehensive module dependency relationships including direct/reverse d
 
 ### Setup and Configuration
 
+The MCP server starts automatically when ElixirLS launches (unless disabled). The server uses a predictable port assignment:
+
+- **Default behavior**: Port is calculated as `3789 + hash(workspace_path)` to ensure different workspaces use different ports
+- **Custom port**: Can be set via the `elixirLS.mcpPort` setting
+- **Port discovery**: If the calculated/configured port is busy, the server automatically finds the next available port
+
+**Finding the actual port**: Check the ElixirLS output logs for a message like:
+```
+[MCP] Server listening on port 4328
+```
+
 #### TCP-to-STDIO Bridge
 
 ElixirLS includes a TCP-to-STDIO bridge script located at `scripts/tcp_to_stdio_bridge.exs`. This bridge enables LLMs like Claude to communicate with the ElixirLS MCP server by converting between STDIO (used by LLMs) and TCP (used by the MCP server).
 
 The bridge:
-- Connects to the ElixirLS MCP server running on TCP port 3798
-- Forwards messages bidirectionally between STDIO and TCP
+- Connects to the ElixirLS MCP server running on the discovered/configured TCP port
+- Forwards messages bidirectionally between STDIO and TCP  
 - Uses binary mode with latin1 encoding for proper communication
 - Handles connection lifecycle and error conditions
 
@@ -409,14 +420,22 @@ To use ElixirLS with Claude Code or other MCP-compatible tools, create an `mcp.j
     "elixir-ls-bridge": {
       "command": "elixir",
       "args": [
-        "/absolute/path/to/elixir-ls/scripts/tcp_to_stdio_bridge.exs"
+        "/absolute/path/to/elixir-ls/scripts/tcp_to_stdio_bridge.exs",
+        "4328"
       ]
     }
   }
 }
 ```
 
-Replace `/absolute/path/to/elixir-ls/` with the actual path to your ElixirLS installation.
+Replace `/absolute/path/to/elixir-ls/` with the actual path to your ElixirLS installation and `4328` with the actual port number from the ElixirLS logs.
+
+#### MCP Settings
+
+The MCP server can be configured via ElixirLS settings:
+
+- **`elixirLS.mcpEnabled`** (boolean, default: `true`): Enable or disable the MCP server
+- **`elixirLS.mcpPort`** (integer, optional): Set a specific port for the MCP server. If not set, uses `3789 + hash(workspace_path)` for predictable port assignment per workspace
 
 ## Automatic builds and error reporting
 
@@ -491,6 +510,8 @@ Below is a list of configuration options supported by the ElixirLS language serv
 <dt>elixirLS.languageServerOverridePath</dt><dd>Absolute path to an alternative ElixirLS release that will override the packaged release</dd>
 <dt>elixirLS.stdlibSrcDir</dt><dd>Path to Elixir's std lib source code. See [here](https://github.com/elixir-lsp/elixir_sense/pull/277) for more info</dd>
 <dt>elixirLS.dotFormatter</dt><dd>Path to a custom <code>.formatter.exs</code> file used when formatting documents</dd>
+<dt>elixirLS.mcpEnabled</dt><dd>Enable or disable the MCP (Model Context Protocol) server - Defaults to <code>true</code></dd>
+<dt>elixirLS.mcpPort</dt><dd>Set a specific TCP port for the MCP server - If not set, uses <code>3789 + hash(workspace_path)</code> for predictable port assignment per workspace</dd>
 </dl>
 
 ## Debug Adapter configuration options

apps/language_server/lib/language_server/application.ex

@@ -16,8 +16,7 @@ defmodule ElixirLS.LanguageServer.Application do
         {LanguageServer.Tracer, []},
         {LanguageServer.MixProjectCache, []},
         {LanguageServer.Parser, []},
-        {LanguageServer.ExUnitTestTracer, []},
-        {ElixirLS.LanguageServer.MCP.TCPServer, port: 3798}
+        {LanguageServer.ExUnitTestTracer, []}
       ]
       |> Enum.reject(&is_nil/1)
 

apps/language_server/lib/language_server/mcp/supervisor.ex

@@ -0,0 +1,17 @@
+defmodule ElixirLS.LanguageServer.MCP.Supervisor do
+  use Supervisor
+
+  def start_link(parent \\ self(), name \\ nil, port) do
+    Supervisor.start_link(__MODULE__, {parent, port}, name: name || __MODULE__)
+  end
+
+  @impl Supervisor
+  def init({_parent, port}) do
+    Supervisor.init(
+      [
+        {ElixirLS.LanguageServer.MCP.TCPServer, port: port}
+      ],
+      strategy: :one_for_one
+    )
+  end
+end

apps/language_server/lib/language_server/mcp/tcp_server.ex

@@ -24,16 +24,16 @@ defmodule ElixirLS.LanguageServer.MCP.TCPServer do
 
   @impl true
   def init(port) do
-    IO.puts("[MCP] Starting TCP Server on port #{port}")
+    IO.puts("[MCP] Starting TCP Server, trying port #{port}")
 
-    case :gen_tcp.listen(port, [:binary, packet: :line, active: false, reuseaddr: true]) do
-      {:ok, listen_socket} ->
-        IO.puts("[MCP] Server listening on port #{port}")
+    case find_available_port(port) do
+      {:ok, actual_port, listen_socket} ->
+        IO.puts("[MCP] Server listening on port #{actual_port}")
         send(self(), :accept)
-        {:ok, %{listen: listen_socket, clients: %{}}}
+        {:ok, %{listen: listen_socket, port: actual_port, clients: %{}}}
 
       {:error, reason} ->
-        IO.puts("[MCP] Failed to listen on port #{port}: #{inspect(reason)}")
+        IO.puts("[MCP] Failed to find available port starting from #{port}: #{inspect(reason)}")
         {:stop, reason}
     end
   end
@@ -128,6 +128,27 @@ defmodule ElixirLS.LanguageServer.MCP.TCPServer do
 
   # Private functions
 
+  defp find_available_port(start_port, max_attempts \\ 100) do
+    find_available_port(start_port, start_port, max_attempts)
+  end
+
+  defp find_available_port(current_port, start_port, attempts_left) when attempts_left > 0 do
+    case :gen_tcp.listen(current_port, [:binary, packet: :line, active: false, reuseaddr: true]) do
+      {:ok, listen_socket} ->
+        {:ok, current_port, listen_socket}
+
+      {:error, :eaddrinuse} ->
+        find_available_port(current_port + 1, start_port, attempts_left - 1)
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp find_available_port(_current_port, start_port, 0) do
+    {:error, "No available ports found starting from #{start_port}"}
+  end
+
   defp accept_connection(parent, listen_socket) do
     IO.puts("[MCP] Waiting for connection...")
 

apps/language_server/lib/language_server/server.ex

@@ -59,6 +59,7 @@ defmodule ElixirLS.LanguageServer.Server do
     :server_instance_id,
     :build_ref,
     :dialyzer_sup,
+    :mcp_sup,
     :root_uri,
     :project_dir,
     :settings,
@@ -2365,6 +2366,11 @@ defmodule ElixirLS.LanguageServer.Server do
       Application.put_env(:language_server, :elixir_src, stdlib_src_dir)
     end
 
+    enable_mcp =
+      Map.get(settings, "mcpEnabled", true) == true
+
+    mcp_port = calculate_mcp_port(settings, state.root_uri)
+
     state =
       state
       |> maybe_set_env_vars(env_vars)
@@ -2373,6 +2379,7 @@ defmodule ElixirLS.LanguageServer.Server do
       |> set_project_dir(project_dir)
       |> Map.put(:settings, settings)
       |> set_dialyzer_enabled(enable_dialyzer)
+      |> set_mcp_enabled(enable_mcp, mcp_port)
 
     add_watched_extensions(state.server_instance_id, additional_watched_extensions)
 
@@ -2407,7 +2414,9 @@ defmodule ElixirLS.LanguageServer.Server do
           if(Map.get(settings, "dialyzerEnabled", true),
             do: Map.get(settings, "dialyzerFormat", "dialyxir_long"),
             else: ""
-          )
+          ),
+        "elixir_ls.mcpEnabled" => to_string(Map.get(settings, "mcpEnabled", true)),
+        "elixir_ls.mcpPort" => to_string(mcp_port)
       },
       %{}
     )
@@ -2512,6 +2521,36 @@ defmodule ElixirLS.LanguageServer.Server do
     end
   end
 
+  defp set_mcp_enabled(state = %__MODULE__{}, enable_mcp, port) do
+    cond do
+      enable_mcp and state.mcp_sup == nil ->
+        {:ok, pid} = ElixirLS.LanguageServer.MCP.Supervisor.start_link(port)
+        %{state | mcp_sup: pid}
+
+      not enable_mcp and state.mcp_sup != nil ->
+        Process.exit(state.mcp_sup, :normal)
+        %{state | mcp_sup: nil}
+
+      true ->
+        state
+    end
+  end
+
+  defp calculate_mcp_port(settings, root_uri) do
+    case Map.get(settings, "mcpPort") do
+      port when is_integer(port) and port > 0 -> port
+      _ -> 3789 + hash_root_uri(root_uri)
+    end
+  end
+
+  defp hash_root_uri(nil), do: 0
+
+  defp hash_root_uri(root_uri) when is_binary(root_uri) do
+    :crypto.hash(:md5, root_uri)
+    |> :binary.decode_unsigned()
+    |> rem(1000)
+  end
+
   defp maybe_set_env_vars(state = %__MODULE__{}, nil), do: state
 
   defp maybe_set_env_vars(state = %__MODULE__{}, env) do