lean-lsp-mcp 0.10.2__tar.gz → 0.11.0__tar.gz

{lean_lsp_mcp-0.10.2/src/lean_lsp_mcp.egg-info → lean_lsp_mcp-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.10.2
+Version: 0.11.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: leanclient==0.3.1
+Requires-Dist: leanclient==0.4.0
 Requires-Dist: mcp[cli]==1.19.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
@@ -43,7 +43,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ## Key Features
 
 * **Rich Lean Interaction**: Access diagnostics, goal states, term information, hover documentation and more.
-* **External Search Tools**: Use `leansearch`, `loogle`, `lean_hammer` and `lean_state_search` to find relevant theorems and definitions.
+* **External Search Tools**: Use `LeanSearch`, `Loogle`, `Lean Finder`, `Lean Hammer` and `Lean State Search` to find relevant theorems and definitions.
 * **Easy Setup**: Simple configuration for various clients, including VSCode, Cursor and Claude Code.
 
 ## Setup
@@ -122,11 +122,9 @@ Run one of these commands in the root directory of your Lean project (where `lak
 # Local-scoped MCP server
 claude mcp add lean-lsp uvx lean-lsp-mcp
 
-# OR project-scoped MCP server (creates or updates a .mcp.json file in the current directory)
+# OR project-scoped MCP server
+# (creates or updates a .mcp.json file in the current directory)
 claude mcp add lean-lsp -s project uvx lean-lsp-mcp
-
-# OR If you run into issues with the project path (e.g. the language server directory cannot be found), you can also set it manually e.g.
-claude mcp add lean-lsp uvx lean-lsp-mcp -e LEAN_PROJECT_PATH=$PWD
 ```
 
 You can find more details about MCP server configuration for Claude Code [here](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#configure-mcp-servers).
@@ -134,7 +132,7 @@ You can find more details about MCP server configuration for Claude Code [here](
 
 #### Claude Skill: Lean4 Theorem Proving
 
-If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
+If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/plugins/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
 
 ### 4. Install ripgrep (optional but recommended)
 
@@ -284,7 +282,9 @@ This tool requires [ripgrep](https://github.com/BurntSushi/ripgrep?tab=readme-ov
 
 ### External Search Tools
 
-Currently all external tools are separately **rate limited to 3 requests per 30 seconds**.
+Currently most external tools are separately **rate limited to 3 requests per 30 seconds**. Please don't ruin the fun for everyone by overusing these amazing free services!
+
+Please cite the original authors of these tools if you use them!
 
 #### lean_leansearch
 
@@ -337,6 +337,32 @@ Search for Lean definitions and theorems using [loogle.lean-lang.org](https://lo
 ```
 </details>
 
+#### lean_leanfinder
+
+Semantic search for Mathlib theorems using [Lean Finder](https://huggingface.co/spaces/delta-lab-ai/Lean-Finder).
+
+[Arxiv Paper](https://arxiv.org/abs/2510.15940)
+
+- Supports informal descriptions, user questions, proof states, and statement fragments.
+- Examples: `algebraic elements x,y over K with same minimal polynomial`, `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`, `⊢ |re z| ≤ ‖z‖` + `transform to squared norm inequality`, `theorem restrict Ioi: restrict Ioi e = restrict Ici e`
+
+<details>
+<summary>Example output</summary>
+
+Query: `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`
+
+```json
+  [
+    [
+      "/-- If `y : L` is a root of `minpoly K x`, then `minpoly K y = minpoly K x`. -/\ntheorem eq_of_root {x y : L} (hx : IsAlgebraic K x)\n    (h_ev : Polynomial.aeval y (minpoly K x) = 0) : minpoly K y = minpoly K x :=\n  ((eq_iff_aeval_minpoly_eq_zero hx.isIntegral).mpr h_ev).symm",
+      
+      "Let $L/K$ be a field extension, and let $x, y \\in L$ be elements such that $y$ is a root of the minimal polynomial of $x$ over $K$. If $x$ is algebraic over $K$, then the minimal polynomial of $y$ over $K$ is equal to the minimal polynomial of $x$ over $K$, i.e., $\\text{minpoly}_K(y) = \\text{minpoly}_K(x)$. This means that if $y$ satisfies the polynomial equation defined by $x$, then $y$ shares the same minimal polynomial as $x$."
+    ],
+    ...
+  ]
+```
+</details>
+
 #### lean_state_search
 
 Search for applicable theorems for the current proof goal using [premise-search.com](https://premise-search.com/).

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/README.md

@@ -21,7 +21,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ## Key Features
 
 * **Rich Lean Interaction**: Access diagnostics, goal states, term information, hover documentation and more.
-* **External Search Tools**: Use `leansearch`, `loogle`, `lean_hammer` and `lean_state_search` to find relevant theorems and definitions.
+* **External Search Tools**: Use `LeanSearch`, `Loogle`, `Lean Finder`, `Lean Hammer` and `Lean State Search` to find relevant theorems and definitions.
 * **Easy Setup**: Simple configuration for various clients, including VSCode, Cursor and Claude Code.
 
 ## Setup
@@ -100,11 +100,9 @@ Run one of these commands in the root directory of your Lean project (where `lak
 # Local-scoped MCP server
 claude mcp add lean-lsp uvx lean-lsp-mcp
 
-# OR project-scoped MCP server (creates or updates a .mcp.json file in the current directory)
+# OR project-scoped MCP server
+# (creates or updates a .mcp.json file in the current directory)
 claude mcp add lean-lsp -s project uvx lean-lsp-mcp
-
-# OR If you run into issues with the project path (e.g. the language server directory cannot be found), you can also set it manually e.g.
-claude mcp add lean-lsp uvx lean-lsp-mcp -e LEAN_PROJECT_PATH=$PWD
 ```
 
 You can find more details about MCP server configuration for Claude Code [here](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#configure-mcp-servers).
@@ -112,7 +110,7 @@ You can find more details about MCP server configuration for Claude Code [here](
 
 #### Claude Skill: Lean4 Theorem Proving
 
-If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
+If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/plugins/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
 
 ### 4. Install ripgrep (optional but recommended)
 
@@ -262,7 +260,9 @@ This tool requires [ripgrep](https://github.com/BurntSushi/ripgrep?tab=readme-ov
 
 ### External Search Tools
 
-Currently all external tools are separately **rate limited to 3 requests per 30 seconds**.
+Currently most external tools are separately **rate limited to 3 requests per 30 seconds**. Please don't ruin the fun for everyone by overusing these amazing free services!
+
+Please cite the original authors of these tools if you use them!
 
 #### lean_leansearch
 
@@ -315,6 +315,32 @@ Search for Lean definitions and theorems using [loogle.lean-lang.org](https://lo
 ```
 </details>
 
+#### lean_leanfinder
+
+Semantic search for Mathlib theorems using [Lean Finder](https://huggingface.co/spaces/delta-lab-ai/Lean-Finder).
+
+[Arxiv Paper](https://arxiv.org/abs/2510.15940)
+
+- Supports informal descriptions, user questions, proof states, and statement fragments.
+- Examples: `algebraic elements x,y over K with same minimal polynomial`, `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`, `⊢ |re z| ≤ ‖z‖` + `transform to squared norm inequality`, `theorem restrict Ioi: restrict Ioi e = restrict Ici e`
+
+<details>
+<summary>Example output</summary>
+
+Query: `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`
+
+```json
+  [
+    [
+      "/-- If `y : L` is a root of `minpoly K x`, then `minpoly K y = minpoly K x`. -/\ntheorem eq_of_root {x y : L} (hx : IsAlgebraic K x)\n    (h_ev : Polynomial.aeval y (minpoly K x) = 0) : minpoly K y = minpoly K x :=\n  ((eq_iff_aeval_minpoly_eq_zero hx.isIntegral).mpr h_ev).symm",
+      
+      "Let $L/K$ be a field extension, and let $x, y \\in L$ be elements such that $y$ is a root of the minimal polynomial of $x$ over $K$. If $x$ is algebraic over $K$, then the minimal polynomial of $y$ over $K$ is equal to the minimal polynomial of $x$ over $K$, i.e., $\\text{minpoly}_K(y) = \\text{minpoly}_K(x)$. This means that if $y$ satisfies the polynomial equation defined by $x$, then $y$ shares the same minimal polynomial as $x$."
+    ],
+    ...
+  ]
+```
+</details>
+
 #### lean_state_search
 
 Search for applicable theorems for the current proof goal using [premise-search.com](https://premise-search.com/).

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "lean-lsp-mcp"
-version = "0.10.2"
+version = "0.11.0"
 description = "Lean Theorem Prover MCP"
 authors = [{name="Oliver Dressler", email="hey@oli.show"}]
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
-    "leanclient==0.3.1",
+    "leanclient==0.4.0",
     "mcp[cli]==1.19.0",
     "orjson>=3.11.1",
 ]

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp/client_utils.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from threading import Lock
 
 from mcp.server.fastmcp import Context
 from mcp.server.fastmcp.utilities.logging import get_logger
@@ -9,6 +10,7 @@ from lean_lsp_mcp.utils import OutputCapture
 
 
 logger = get_logger(__name__)
+CLIENT_LOCK = Lock()
 
 
 def startup_client(ctx: Context):
@@ -17,34 +19,35 @@ def startup_client(ctx: Context):
     Args:
         ctx (Context): Context object.
     """
-    lean_project_path = ctx.request_context.lifespan_context.lean_project_path
-    if lean_project_path is None:
-        raise ValueError("lean project path is not set.")
-
-    # Check if already correct client
-    client: LeanLSPClient | None = ctx.request_context.lifespan_context.client
-
-    if client is not None:
-        # Both are Path objects now, direct comparison works
-        if client.project_path == lean_project_path:
-            return  # Client already set up correctly - reuse it!
-        # Different project path - close old client
-        client.close()
-        ctx.request_context.lifespan_context.file_content_hashes.clear()
-
-    # Need to create a new client
-    with OutputCapture() as output:
-        try:
-            client = LeanLSPClient(lean_project_path)
-            logger.info(f"Connected to Lean language server at {lean_project_path}")
-        except Exception as e:
-            logger.warning(f"Initial connection failed, trying with build: {e}")
-            client = LeanLSPClient(lean_project_path, initial_build=True)
-            logger.info(f"Connected with initial build to {lean_project_path}")
-    build_output = output.get_output()
-    if build_output:
-        logger.debug(f"Build output: {build_output}")
-    ctx.request_context.lifespan_context.client = client
+    with CLIENT_LOCK:
+        lean_project_path = ctx.request_context.lifespan_context.lean_project_path
+        if lean_project_path is None:
+            raise ValueError("lean project path is not set.")
+
+        # Check if already correct client
+        client: LeanLSPClient | None = ctx.request_context.lifespan_context.client
+
+        if client is not None:
+            # Both are Path objects now, direct comparison works
+            if client.project_path == lean_project_path:
+                return  # Client already set up correctly - reuse it!
+            # Different project path - close old client
+            client.close()
+            ctx.request_context.lifespan_context.file_content_hashes.clear()
+
+        # Need to create a new client
+        with OutputCapture() as output:
+            try:
+                client = LeanLSPClient(lean_project_path)
+                logger.info(f"Connected to Lean language server at {lean_project_path}")
+            except Exception as e:
+                logger.warning(f"Initial connection failed, trying with build: {e}")
+                client = LeanLSPClient(lean_project_path, initial_build=True)
+                logger.info(f"Connected with initial build to {lean_project_path}")
+        build_output = output.get_output()
+        if build_output:
+            logger.debug(f"Build output: {build_output}")
+        ctx.request_context.lifespan_context.client = client
 
 
 def valid_lean_project_path(path: Path | str) -> bool:

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp/file_utils.py

@@ -1,4 +1,3 @@
-import os
 from typing import Optional, Dict
 from pathlib import Path
 

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp/instructions.py

@@ -11,5 +11,6 @@ INSTRUCTIONS = """## General Rules
 - lean_hover_info: Documentation about terms and lean syntax.
 - lean_leansearch: Search theorems using natural language or Lean terms.
 - lean_loogle: Search definitions and theorems by name, type, or subexpression.
+- lean_leanfinder: Semantic search for theorems using Lean Finder.
 - lean_state_search: Search theorems using goal-based search.
 """

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp/server.py

@@ -1,3 +1,4 @@
+import asyncio
 import os
 import re
 import time
@@ -9,6 +10,7 @@ import urllib
 import json
 import functools
 import subprocess
+import uuid
 from pathlib import Path
 
 from mcp.server.fastmcp import Context, FastMCP
@@ -16,7 +18,7 @@ from mcp.server.fastmcp.utilities.logging import get_logger, configure_logging
 from mcp.server.auth.settings import AuthSettings
 from leanclient import LeanLSPClient, DocumentContentChange
 
-from lean_lsp_mcp.client_utils import setup_client_for_file
+from lean_lsp_mcp.client_utils import setup_client_for_file, startup_client
 from lean_lsp_mcp.file_utils import get_file_contents, update_file
 from lean_lsp_mcp.instructions import INSTRUCTIONS
 from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
@@ -66,6 +68,7 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
             rate_limit={
                 "leansearch": [],
                 "loogle": [],
+                "leanfinder": [],
                 "lean_state_search": [],
                 "hammer_premise": [],
             },
@@ -103,7 +106,14 @@ def rate_limited(category: str, max_requests: int, per_seconds: int):
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            rate_limit = kwargs["ctx"].request_context.lifespan_context.rate_limit
+            ctx = kwargs.get("ctx")
+            if ctx is None:
+                if not args:
+                    raise KeyError(
+                        "rate_limited wrapper requires ctx as a keyword argument or the first positional argument"
+                    )
+                ctx = args[0]
+            rate_limit = ctx.request_context.lifespan_context.rate_limit
             current_time = int(time.time())
             rate_limit[category] = [
                 timestamp
@@ -123,7 +133,9 @@ def rate_limited(category: str, max_requests: int, per_seconds: int):
 
 # Project level tools
 @mcp.tool("lean_build")
-def lsp_build(ctx: Context, lean_project_path: str = None, clean: bool = False) -> str:
+async def lsp_build(
+    ctx: Context, lean_project_path: str = None, clean: bool = False
+) -> str:
     """Build the Lean project and restart the LSP Server.
 
     Use only if needed (e.g. new imports).
@@ -141,10 +153,17 @@ def lsp_build(ctx: Context, lean_project_path: str = None, clean: bool = False)
         lean_project_path_obj = Path(lean_project_path).resolve()
         ctx.request_context.lifespan_context.lean_project_path = lean_project_path_obj
 
+    if lean_project_path_obj is None:
+        return (
+            "Lean project path not known yet. Provide `lean_project_path` explicitly or call a "
+            "tool that infers it (e.g. `lean_goal`) before running `lean_build`."
+        )
+
     build_output = ""
     try:
         client: LeanLSPClient = ctx.request_context.lifespan_context.client
         if client:
+            ctx.request_context.lifespan_context.client = None
             client.close()
             ctx.request_context.lifespan_context.file_content_hashes.clear()
 
@@ -152,13 +171,65 @@ def lsp_build(ctx: Context, lean_project_path: str = None, clean: bool = False)
             subprocess.run(["lake", "clean"], cwd=lean_project_path_obj, check=False)
             logger.info("Ran `lake clean`")
 
-        with OutputCapture() as output:
-            client = LeanLSPClient(lean_project_path_obj, initial_build=True)
+        # Fetch cache
+        subprocess.run(
+            ["lake", "exe", "cache", "get"], cwd=lean_project_path_obj, check=False
+        )
+
+        # Run build with progress reporting
+        process = await asyncio.create_subprocess_exec(
+            "lake",
+            "build",
+            "--verbose",
+            cwd=lean_project_path_obj,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+        )
+
+        output_lines = []
+
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+
+            line_str = line.decode("utf-8", errors="replace").rstrip()
+            output_lines.append(line_str)
+
+            # Parse progress: look for pattern like "[2/8]" or "[10/100]"
+            match = re.search(r"\[(\d+)/(\d+)\]", line_str)
+            if match:
+                current_job = int(match.group(1))
+                total_jobs = int(match.group(2))
+
+                # Extract what's being built
+                # Line format: "ℹ [2/8] Built TestLeanBuild.Basic (1.6s)"
+                desc_match = re.search(
+                    r"\[\d+/\d+\]\s+(.+?)(?:\s+\(\d+\.?\d*[ms]+\))?$", line_str
+                )
+                description = desc_match.group(1) if desc_match else "Building"
+
+                # Report progress using dynamic totals from Lake
+                await ctx.report_progress(
+                    progress=current_job, total=total_jobs, message=description
+                )
+
+        await process.wait()
+
+        if process.returncode != 0:
+            build_output = "\n".join(output_lines)
+            raise Exception(f"Build failed with return code {process.returncode}")
+
+        # Start LSP client (without initial build since we just did it)
+        with OutputCapture():
+            client = LeanLSPClient(
+                lean_project_path_obj, initial_build=False, prevent_cache_get=True
+            )
 
         logger.info("Built project and re-started LSP client")
 
         ctx.request_context.lifespan_context.client = client
-        build_output = output.get_output()
+        build_output = "\n".join(output_lines)
         return build_output
     except Exception as e:
         return f"Error during build:\n{str(e)}\n{build_output}"
@@ -521,11 +592,13 @@ def run_code(ctx: Context, code: str) -> List[str] | str:
     Returns:
         List[str] | str: Diagnostics msgs or error msg
     """
-    lean_project_path = ctx.request_context.lifespan_context.lean_project_path
+    lifespan_context = ctx.request_context.lifespan_context
+    lean_project_path = lifespan_context.lean_project_path
     if lean_project_path is None:
         return "No valid Lean project path found. Run another tool (e.g. `lean_diagnostic_messages`) first to set it up or set the LEAN_PROJECT_PATH environment variable."
 
-    rel_path = "temp_snippet.lean"
+    # Use a unique snippet filename to avoid collisions under concurrency
+    rel_path = f"_mcp_snippet_{uuid.uuid4().hex}.lean"
     abs_path = lean_project_path / rel_path
 
     try:
@@ -534,14 +607,44 @@ def run_code(ctx: Context, code: str) -> List[str] | str:
     except Exception as e:
         return f"Error writing code snippet to file `{abs_path}`:\n{str(e)}"
 
-    client: LeanLSPClient = ctx.request_context.lifespan_context.client
-    diagnostics = format_diagnostics(client.get_diagnostics(rel_path))
-    client.close_files([rel_path])
+    client: LeanLSPClient | None = lifespan_context.client
+    diagnostics: List[str] | str = []
+    close_error: str | None = None
+    remove_error: str | None = None
+    opened_file = False
 
     try:
-        os.remove(abs_path)
-    except Exception as e:
-        return f"Error removing temporary file `{abs_path}`:\n{str(e)}"
+        if client is None:
+            startup_client(ctx)
+            client = lifespan_context.client
+            if client is None:
+                return "Failed to initialize Lean client for run_code."
+
+        assert client is not None  # startup_client guarantees an initialized client
+        client.open_file(rel_path)
+        opened_file = True
+        diagnostics = format_diagnostics(client.get_diagnostics(rel_path))
+    finally:
+        if opened_file:
+            try:
+                client.close_files([rel_path])
+            except Exception as exc:  # pragma: no cover - close failures only logged
+                close_error = str(exc)
+                logger.warning("Failed to close `%s` after run_code: %s", rel_path, exc)
+        try:
+            os.remove(abs_path)
+        except FileNotFoundError:
+            pass
+        except Exception as e:
+            remove_error = str(e)
+            logger.warning(
+                "Failed to remove temporary Lean snippet `%s`: %s", abs_path, e
+            )
+
+    if remove_error:
+        return f"Error removing temporary file `{abs_path}`:\n{remove_error}"
+    if close_error:
+        return f"Error closing temporary Lean document `{rel_path}`:\n{close_error}"
 
     return (
         diagnostics
@@ -670,6 +773,79 @@ def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
         return f"loogle error:\n{str(e)}"
 
 
+@mcp.tool("lean_leanfinder")
+@rate_limited("leanfinder", max_requests=10, per_seconds=30)
+def leanfinder(
+    ctx: Context, query: str, num_results: int = 5
+) -> List[tuple] | str:
+    """Search Mathlib theorems/definitions semantically by mathematical concept using Lean Finder.
+
+    Effective query types:
+    - Math + API: "setAverage Icc interval", "integral_pow symmetric bounds"
+    - Conceptual: "algebraic elements same minimal polynomial", "quadrature nodes"
+    - Structure: "Finset expect sum commute", "polynomial degree bounded eval"
+    - Natural: "average equals point values", "root implies equal polynomials"
+
+    Tips: Mix informal math terms with Lean identifiers. Multiple targeted queries beat one complex query.
+
+    Args:
+        query (str): Mathematical concepts combined with Lean terms
+        num_results (int, optional): Max results. Defaults to 5.
+
+    Returns:
+        List[tuple] | str: (lean_statement, english_description) pairs or error
+    """
+    try:
+        headers = {"User-Agent": "lean-lsp-mcp/0.1", "Content-Type": "application/json"}
+        payload = json.dumps({"data": [query, num_results, "Normal"]}).encode("utf-8")
+
+        req = urllib.request.Request(
+            "https://delta-lab-ai-lean-finder.hf.space/gradio_api/call/retrieve",
+            data=payload,
+            headers=headers,
+            method="POST",
+        )
+
+        with urllib.request.urlopen(req, timeout=10) as response:
+            event_data = json.loads(response.read().decode("utf-8"))
+            event_id = event_data.get("event_id")
+
+        if not event_id:
+            return "Lean Finder has timed out or errored. It might be warming up, try a second time in 2 minutes."
+
+        result_url = f"https://delta-lab-ai-lean-finder.hf.space/gradio_api/call/retrieve/{event_id}"
+        req = urllib.request.Request(result_url, headers=headers, method="GET")
+
+        with urllib.request.urlopen(req, timeout=30) as response:
+            for line in response:
+                line = line.decode("utf-8").strip()
+                if line.startswith("data: "):
+                    data = json.loads(line[6:])
+                    if isinstance(data, list) and len(data) > 0:
+                        html = data[0] if isinstance(data[0], str) else str(data)
+
+                        # Parse HTML table rows
+                        rows = re.findall(
+                            r"<tr><td>\d+</td><td>(.*?)</td><td>(.*?)</td></tr>",
+                            html, re.DOTALL
+                        )
+                        results = []
+                        for formal_cell, informal_cell in rows:
+                            formal = re.search(r"<code[^>]*>(.*?)</code>", formal_cell, re.DOTALL)
+                            informal = re.search(r"<span[^>]*>(.*?)</span>", informal_cell, re.DOTALL)
+                            if formal:
+                                results.append((
+                                    formal.group(1).strip(),
+                                    informal.group(1).strip() if informal else ""
+                                ))
+
+                        return results if results else "Lean Finder: No results parsed"
+
+        return "Lean Finder: No results received"
+    except Exception as e:
+        return f"Lean Finder Error:\n{str(e)}"
+
+
 @mcp.tool("lean_state_search")
 @rate_limited("lean_state_search", max_requests=3, per_seconds=30)
 def state_search(

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp/utils.py

@@ -73,6 +73,27 @@ def format_goal(goal, default_msg):
     return rendered.replace("```lean\n", "").replace("\n```", "") if rendered else None
 
 
+def _utf16_index_to_py_index(text: str, utf16_index: int) -> int | None:
+    """Convert an LSP UTF-16 column index into a Python string index."""
+    if utf16_index < 0:
+        return None
+
+    units = 0
+    for idx, ch in enumerate(text):
+        code_point = ord(ch)
+        next_units = units + (2 if code_point > 0xFFFF else 1)
+
+        if utf16_index < next_units:
+            return idx
+        if utf16_index == next_units:
+            return idx + 1
+
+        units = next_units
+    if units >= utf16_index:
+        return len(text)
+    return None
+
+
 def extract_range(content: str, range: dict) -> str:
     """Extract the text from the content based on the range.
 
@@ -88,16 +109,36 @@ def extract_range(content: str, range: dict) -> str:
     end_line = range["end"]["line"]
     end_char = range["end"]["character"]
 
-    lines = content.splitlines()
-    if start_line < 0 or end_line >= len(lines):
+    lines = content.splitlines(keepends=True)
+    if not lines:
+        lines = [""]
+
+    line_offsets: List[int] = []
+    offset = 0
+    for line in lines:
+        line_offsets.append(offset)
+        offset += len(line)
+    total_length = len(content)
+
+    def position_to_offset(line: int, character: int) -> int | None:
+        if line == len(lines) and character == 0:
+            return total_length
+        if line < 0 or line >= len(lines):
+            return None
+        py_index = _utf16_index_to_py_index(lines[line], character)
+        if py_index is None:
+            return None
+        if py_index > len(lines[line]):
+            return None
+        return line_offsets[line] + py_index
+
+    start_offset = position_to_offset(start_line, start_char)
+    end_offset = position_to_offset(end_line, end_char)
+
+    if start_offset is None or end_offset is None or start_offset > end_offset:
         return "Range out of bounds"
-    if start_line == end_line:
-        return lines[start_line][start_char:end_char]
-    else:
-        selected_lines = lines[start_line : end_line + 1]
-        selected_lines[0] = selected_lines[0][start_char:]
-        selected_lines[-1] = selected_lines[-1][:end_char]
-        return "\n".join(selected_lines)
+
+    return content[start_offset:end_offset]
 
 
 def find_start_position(content: str, query: str) -> dict | None:
@@ -136,13 +177,14 @@ def format_line(
     """
     lines = file_content.splitlines()
     line_number -= 1
-    if line_number < 1 or line_number > len(lines):
+    if line_number < 0 or line_number >= len(lines):
         return "Line number out of range"
     line = lines[line_number]
     if column is None:
         return line
     column -= 1
-    if column < 0 or column >= len(lines):
+    # Allow placing the cursor at end-of-line (column == len(line))
+    if column < 0 or column > len(line):
         return "Invalid column number"
     return f"{line[:column]}{cursor_tag}{line[column:]}"
 

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0/src/lean_lsp_mcp.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.10.2
+Version: 0.11.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: Repository, https://github.com/oOo0oOo/lean-lsp-mcp
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: leanclient==0.3.1
+Requires-Dist: leanclient==0.4.0
 Requires-Dist: mcp[cli]==1.19.0
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
@@ -43,7 +43,7 @@ MCP server that allows agentic interaction with the [Lean theorem prover](https:
 ## Key Features
 
 * **Rich Lean Interaction**: Access diagnostics, goal states, term information, hover documentation and more.
-* **External Search Tools**: Use `leansearch`, `loogle`, `lean_hammer` and `lean_state_search` to find relevant theorems and definitions.
+* **External Search Tools**: Use `LeanSearch`, `Loogle`, `Lean Finder`, `Lean Hammer` and `Lean State Search` to find relevant theorems and definitions.
 * **Easy Setup**: Simple configuration for various clients, including VSCode, Cursor and Claude Code.
 
 ## Setup
@@ -122,11 +122,9 @@ Run one of these commands in the root directory of your Lean project (where `lak
 # Local-scoped MCP server
 claude mcp add lean-lsp uvx lean-lsp-mcp
 
-# OR project-scoped MCP server (creates or updates a .mcp.json file in the current directory)
+# OR project-scoped MCP server
+# (creates or updates a .mcp.json file in the current directory)
 claude mcp add lean-lsp -s project uvx lean-lsp-mcp
-
-# OR If you run into issues with the project path (e.g. the language server directory cannot be found), you can also set it manually e.g.
-claude mcp add lean-lsp uvx lean-lsp-mcp -e LEAN_PROJECT_PATH=$PWD
 ```
 
 You can find more details about MCP server configuration for Claude Code [here](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/tutorials#configure-mcp-servers).
@@ -134,7 +132,7 @@ You can find more details about MCP server configuration for Claude Code [here](
 
 #### Claude Skill: Lean4 Theorem Proving
 
-If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
+If you are using [Claude Desktop](https://modelcontextprotocol.io/quickstart/user) or [Claude Code](https://claude.ai/code), you can also install the [Lean4 Theorem Proving Skill](https://github.com/cameronfreer/lean4-skills/tree/main/plugins/lean4-theorem-proving). This skill provides additional prompts and templates for interacting with Lean4 projects and includes a section on interacting with the `lean-lsp-mcp` server.
 
 ### 4. Install ripgrep (optional but recommended)
 
@@ -284,7 +282,9 @@ This tool requires [ripgrep](https://github.com/BurntSushi/ripgrep?tab=readme-ov
 
 ### External Search Tools
 
-Currently all external tools are separately **rate limited to 3 requests per 30 seconds**.
+Currently most external tools are separately **rate limited to 3 requests per 30 seconds**. Please don't ruin the fun for everyone by overusing these amazing free services!
+
+Please cite the original authors of these tools if you use them!
 
 #### lean_leansearch
 
@@ -337,6 +337,32 @@ Search for Lean definitions and theorems using [loogle.lean-lang.org](https://lo
 ```
 </details>
 
+#### lean_leanfinder
+
+Semantic search for Mathlib theorems using [Lean Finder](https://huggingface.co/spaces/delta-lab-ai/Lean-Finder).
+
+[Arxiv Paper](https://arxiv.org/abs/2510.15940)
+
+- Supports informal descriptions, user questions, proof states, and statement fragments.
+- Examples: `algebraic elements x,y over K with same minimal polynomial`, `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`, `⊢ |re z| ≤ ‖z‖` + `transform to squared norm inequality`, `theorem restrict Ioi: restrict Ioi e = restrict Ici e`
+
+<details>
+<summary>Example output</summary>
+
+Query: `Does y being a root of minpoly(x) imply minpoly(x)=minpoly(y)?`
+
+```json
+  [
+    [
+      "/-- If `y : L` is a root of `minpoly K x`, then `minpoly K y = minpoly K x`. -/\ntheorem eq_of_root {x y : L} (hx : IsAlgebraic K x)\n    (h_ev : Polynomial.aeval y (minpoly K x) = 0) : minpoly K y = minpoly K x :=\n  ((eq_iff_aeval_minpoly_eq_zero hx.isIntegral).mpr h_ev).symm",
+      
+      "Let $L/K$ be a field extension, and let $x, y \\in L$ be elements such that $y$ is a root of the minimal polynomial of $x$ over $K$. If $x$ is algebraic over $K$, then the minimal polynomial of $y$ over $K$ is equal to the minimal polynomial of $x$ over $K$, i.e., $\\text{minpoly}_K(y) = \\text{minpoly}_K(x)$. This means that if $y$ satisfies the polynomial equation defined by $x$, then $y$ shares the same minimal polynomial as $x$."
+    ],
+    ...
+  ]
+```
+</details>
+
 #### lean_state_search
 
 Search for applicable theorems for the current proof goal using [premise-search.com](https://premise-search.com/).

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/src/lean_lsp_mcp.egg-info/requires.txt

@@ -1,4 +1,4 @@
-leanclient==0.3.1
+leanclient==0.4.0
 mcp[cli]==1.19.0
 orjson>=3.11.1
 

{lean_lsp_mcp-0.10.2 → lean_lsp_mcp-0.11.0}/tests/test_search_tools.py

@@ -109,3 +109,23 @@ async def test_search_tools(
         if entry is None:
             pytest.skip("lean_leansearch did not return JSON content")
         assert {"module_name", "name", "type"} <= set(entry.keys())
+
+        # Test lean_finder with different query types
+        finder_informal = await client.call_tool(
+            "lean_leanfinder",
+            {
+                "query": "If two algebraic elements have the same minimal polynomial, are they related by a field isomorphism?",
+                "num_results": 3,
+            },
+        )
+        finder_results = _first_json_block(finder_informal)
+        if finder_results:
+            assert isinstance(finder_results, list) and len(finder_results) > 0
+            assert isinstance(finder_results[0], list) and len(finder_results[0]) == 2
+            formal, informal = finder_results[0]
+            assert isinstance(formal, str) and len(formal) > 0
+            assert isinstance(informal, str)
+        else:
+            finder_text = result_text(finder_informal)
+            assert finder_text and len(finder_text) > 0
+