lean-lsp-mcp 0.14.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

lean_lsp_mcp/__init__.py

@@ -1,4 +1,5 @@
 import argparse
+import os
 
 from lean_lsp_mcp.server import mcp
 
@@ -24,7 +25,25 @@ def main():
         default=8000,
         help="Host port for transport",
     )
+    parser.add_argument(
+        "--loogle-local",
+        action="store_true",
+        help="Enable local loogle (auto-installs on first run, ~5-10 min). "
+        "Avoids rate limits and network dependencies.",
+    )
+    parser.add_argument(
+        "--loogle-cache-dir",
+        type=str,
+        help="Override loogle cache location (default: ~/.cache/lean-lsp-mcp/loogle)",
+    )
     args = parser.parse_args()
+
+    # Set env vars from CLI args (CLI takes precedence over env vars)
+    if args.loogle_local:
+        os.environ["LEAN_LOOGLE_LOCAL"] = "true"
+    if args.loogle_cache_dir:
+        os.environ["LEAN_LOOGLE_CACHE_DIR"] = args.loogle_cache_dir
+
     mcp.settings.host = args.host
     mcp.settings.port = args.port
     mcp.run(transport=args.transport)

lean_lsp_mcp/loogle.py

@@ -0,0 +1,276 @@
+"""Loogle search - local subprocess and remote API."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+import subprocess
+import urllib.parse
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+import orjson
+
+logger = logging.getLogger(__name__)
+
+
+def get_cache_dir() -> Path:
+    if d := os.environ.get("LEAN_LOOGLE_CACHE_DIR"):
+        return Path(d)
+    xdg = os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")
+    return Path(xdg) / "lean-lsp-mcp" / "loogle"
+
+
+def loogle_remote(query: str, num_results: int) -> list[dict] | str:
+    """Query the remote loogle API."""
+    try:
+        req = urllib.request.Request(
+            f"https://loogle.lean-lang.org/json?q={urllib.parse.quote(query)}",
+            headers={"User-Agent": "lean-lsp-mcp/0.1"},
+        )
+        with urllib.request.urlopen(req, timeout=20) as response:
+            results = orjson.loads(response.read())
+        if "hits" not in results:
+            return "No results found."
+        results = results["hits"][:num_results]
+        for r in results:
+            r.pop("doc", None)
+        return results
+    except Exception as e:
+        return f"loogle error:\n{e}"
+
+
+class LoogleManager:
+    """Manages local loogle installation and async subprocess."""
+
+    REPO_URL = "https://github.com/nomeata/loogle.git"
+    READY_SIGNAL = "Loogle is ready."
+
+    def __init__(self, cache_dir: Path | None = None):
+        self.cache_dir = cache_dir or get_cache_dir()
+        self.repo_dir = self.cache_dir / "repo"
+        self.index_dir = self.cache_dir / "index"
+        self.process: asyncio.subprocess.Process | None = None
+        self._ready = False
+        self._lock = asyncio.Lock()
+
+    @property
+    def binary_path(self) -> Path:
+        return self.repo_dir / ".lake" / "build" / "bin" / "loogle"
+
+    @property
+    def is_installed(self) -> bool:
+        return self.binary_path.exists()
+
+    @property
+    def is_running(self) -> bool:
+        return (
+            self._ready and self.process is not None and self.process.returncode is None
+        )
+
+    def _check_prerequisites(self) -> tuple[bool, str]:
+        if not shutil.which("git"):
+            return False, "git not found in PATH"
+        if not shutil.which("lake"):
+            return (
+                False,
+                "lake not found (install elan: https://github.com/leanprover/elan)",
+            )
+        return True, ""
+
+    def _run(
+        self, cmd: list[str], timeout: int = 300, cwd: Path | None = None
+    ) -> subprocess.CompletedProcess:
+        env = os.environ.copy()
+        env["LAKE_ARTIFACT_CACHE"] = "false"
+        return subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            cwd=cwd or self.repo_dir,
+            env=env,
+        )
+
+    def _clone_repo(self) -> bool:
+        if self.repo_dir.exists():
+            return True
+        logger.info(f"Cloning loogle to {self.repo_dir}...")
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        try:
+            r = self._run(
+                ["git", "clone", "--depth", "1", self.REPO_URL, str(self.repo_dir)],
+                cwd=self.cache_dir,
+            )
+            if r.returncode != 0:
+                logger.error(f"Clone failed: {r.stderr}")
+                return False
+            return True
+        except Exception as e:
+            logger.error(f"Clone error: {e}")
+            return False
+
+    def _build_loogle(self) -> bool:
+        if self.is_installed:
+            return True
+        if not self.repo_dir.exists():
+            return False
+        logger.info("Downloading mathlib cache...")
+        try:
+            self._run(["lake", "exe", "cache", "get"], timeout=600)
+        except Exception as e:
+            logger.warning(f"Cache download: {e}")
+        logger.info("Building loogle...")
+        try:
+            return self._run(["lake", "build"], timeout=900).returncode == 0
+        except Exception as e:
+            logger.error(f"Build error: {e}")
+            return False
+
+    def _get_mathlib_version(self) -> str:
+        try:
+            manifest = json.loads((self.repo_dir / "lake-manifest.json").read_text())
+            for pkg in manifest.get("packages", []):
+                if pkg.get("name") == "mathlib":
+                    return pkg.get("rev", "unknown")[:12]
+        except Exception:
+            pass
+        return "unknown"
+
+    def _get_index_path(self) -> Path:
+        return self.index_dir / f"mathlib-{self._get_mathlib_version()}.idx"
+
+    def _cleanup_old_indices(self) -> None:
+        """Remove old index files from previous mathlib versions."""
+        if not self.index_dir.exists():
+            return
+        current = self._get_index_path()
+        for idx in self.index_dir.glob("*.idx"):
+            if idx != current:
+                try:
+                    idx.unlink()
+                    logger.info(f"Removed old index: {idx.name}")
+                except Exception:
+                    pass
+
+    def _build_index(self) -> Path | None:
+        index_path = self._get_index_path()
+        if index_path.exists():
+            return index_path
+        if not self.is_installed:
+            return None
+        self.index_dir.mkdir(parents=True, exist_ok=True)
+        self._cleanup_old_indices()
+        logger.info("Building search index...")
+        try:
+            self._run(
+                [str(self.binary_path), "--write-index", str(index_path), "--json", ""],
+                timeout=600,
+            )
+            return index_path if index_path.exists() else None
+        except Exception as e:
+            logger.error(f"Index build error: {e}")
+            return None
+
+    def ensure_installed(self) -> bool:
+        ok, err = self._check_prerequisites()
+        if not ok:
+            logger.warning(f"Prerequisites: {err}")
+            return False
+        if not self._clone_repo() or not self._build_loogle():
+            return False
+        if not self._build_index():
+            logger.warning("Index build failed, loogle will build on startup")
+        return self.is_installed
+
+    async def start(self) -> bool:
+        if self.process is not None and self.process.returncode is None:
+            return self._ready
+        if not self.is_installed:
+            return False
+        cmd = [str(self.binary_path), "--json", "--interactive"]
+        if (idx := self._get_index_path()).exists():
+            cmd.extend(["--read-index", str(idx)])
+        logger.info("Starting loogle subprocess...")
+        try:
+            self.process = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL,
+                cwd=self.repo_dir,
+            )
+            line = await asyncio.wait_for(self.process.stdout.readline(), timeout=120)
+            if self.READY_SIGNAL in line.decode():
+                self._ready = True
+                logger.info("Loogle ready")
+                return True
+            return False
+        except asyncio.TimeoutError:
+            logger.error("Loogle startup timeout")
+            return False
+        except Exception as e:
+            logger.error(f"Start failed: {e}")
+            return False
+
+    async def query(self, q: str, num_results: int = 8) -> list[dict[str, Any]]:
+        async with self._lock:
+            # Try up to 2 attempts (initial + one restart)
+            for attempt in range(2):
+                if (
+                    not self._ready
+                    or self.process is None
+                    or self.process.returncode is not None
+                ):
+                    if attempt > 0:
+                        raise RuntimeError("Loogle subprocess not ready")
+                    self._ready = False
+                    if not await self.start():
+                        raise RuntimeError("Failed to start loogle")
+                    continue
+
+                try:
+                    self.process.stdin.write(f"{q}\n".encode())
+                    await self.process.stdin.drain()
+                    line = await asyncio.wait_for(
+                        self.process.stdout.readline(), timeout=30
+                    )
+                    response = json.loads(line.decode())
+                    if err := response.get("error"):
+                        logger.warning(f"Query error: {err}")
+                        return []
+                    return [
+                        {
+                            "name": h.get("name", ""),
+                            "type": h.get("type", ""),
+                            "module": h.get("module", ""),
+                            "doc": h.get("doc"),
+                        }
+                        for h in response.get("hits", [])[:num_results]
+                    ]
+                except asyncio.TimeoutError:
+                    raise RuntimeError("Query timeout") from None
+                except json.JSONDecodeError as e:
+                    raise RuntimeError(f"Invalid response: {e}") from e
+
+            raise RuntimeError("Loogle subprocess not ready")
+
+    async def stop(self) -> None:
+        if self.process:
+            try:
+                self.process.terminate()
+                await asyncio.wait_for(self.process.wait(), timeout=5)
+            except asyncio.TimeoutError:
+                self.process.kill()
+                try:
+                    await asyncio.wait_for(self.process.wait(), timeout=2)
+                except asyncio.TimeoutError:
+                    pass
+            except Exception:
+                pass
+            self.process = None
+            self._ready = False

lean_lsp_mcp/outline_utils.py

@@ -8,38 +8,45 @@ METHOD_KIND = {6, "method"}
 KIND_TAGS = {"namespace": "Ns"}
 
 
-def _get_info_trees(client: LeanLSPClient, path: str, symbols: List[Dict]) -> Dict[str, str]:
+def _get_info_trees(
+    client: LeanLSPClient, path: str, symbols: List[Dict]
+) -> Dict[str, str]:
     """Insert #info_trees commands, collect diagnostics, then revert changes."""
     if not symbols:
         return {}
 
     symbol_by_line = {}
     changes = []
-    for i, sym in enumerate(sorted(symbols, key=lambda s: s['range']['start']['line'])):
-        line = sym['range']['start']['line'] + i
-        symbol_by_line[line] = sym['name']
+    for i, sym in enumerate(sorted(symbols, key=lambda s: s["range"]["start"]["line"])):
+        line = sym["range"]["start"]["line"] + i
+        symbol_by_line[line] = sym["name"]
         changes.append(DocumentContentChange("#info_trees in\n", [line, 0], [line, 0]))
 
     client.update_file(path, changes)
     diagnostics = client.get_diagnostics(path)
 
     info_trees = {
-        symbol_by_line[diag['range']['start']['line']]: diag['message']
+        symbol_by_line[diag["range"]["start"]["line"]]: diag["message"]
         for diag in diagnostics
-        if diag['severity'] == 3 and diag['range']['start']['line'] in symbol_by_line
+        if diag["severity"] == 3 and diag["range"]["start"]["line"] in symbol_by_line
     }
 
     # Revert in reverse order
-    client.update_file(path, [
-        DocumentContentChange("", [line, 0], [line + 1, 0])
-        for line in sorted(symbol_by_line.keys(), reverse=True)
-    ])
+    client.update_file(
+        path,
+        [
+            DocumentContentChange("", [line, 0], [line + 1, 0])
+            for line in sorted(symbol_by_line.keys(), reverse=True)
+        ],
+    )
     return info_trees
 
 
 def _extract_type(info: str, name: str) -> Optional[str]:
     """Extract type signature from info tree message."""
-    if m := re.search(rf'  • \[Term\] {re.escape(name)} \(isBinder := true\) : ([^@]+) @', info):
+    if m := re.search(
+        rf"  • \[Term\] {re.escape(name)} \(isBinder := true\) : ([^@]+) @", info
+    ):
         return m.group(1).strip()
     return None
 
@@ -47,14 +54,16 @@ def _extract_type(info: str, name: str) -> Optional[str]:
 def _extract_fields(info: str, name: str) -> List[Tuple[str, str]]:
     """Extract structure/class fields from info tree message."""
     fields = []
-    for pattern in [rf'{re.escape(name)}\.(\w+)', rf'@{re.escape(name)}\.(\w+)']:
-        for m in re.finditer(rf'  • \[Term\] {pattern} \(isBinder := true\) : (.+?) @', info):
+    for pattern in [rf"{re.escape(name)}\.(\w+)", rf"@{re.escape(name)}\.(\w+)"]:
+        for m in re.finditer(
+            rf"  • \[Term\] {pattern} \(isBinder := true\) : (.+?) @", info
+        ):
             field_name, full_type = m.groups()
             # Clean up the type signature
-            if ']' in full_type:
-                field_type = full_type[full_type.rfind(']')+1:].lstrip('→ ').strip()
-            elif ' → ' in full_type:
-                field_type = full_type.split(' → ')[-1].strip()
+            if "]" in full_type:
+                field_type = full_type[full_type.rfind("]") + 1 :].lstrip("→ ").strip()
+            elif " → " in full_type:
+                field_type = full_type.split(" → ")[-1].strip()
             else:
                 field_type = full_type.strip()
             fields.append((field_name, field_type))
@@ -68,51 +77,61 @@ def _extract_declarations(content: str, start: int, end: int) -> List[Dict]:
 
     while i < min(end, len(lines)):
         line = lines[i].strip()
-        for keyword in ['theorem', 'lemma', 'def']:
+        for keyword in ["theorem", "lemma", "def"]:
             if line.startswith(f"{keyword} "):
-                name = line[len(keyword):].strip().split()[0]
-                if name and not name.startswith('_'):
+                name = line[len(keyword) :].strip().split()[0]
+                if name and not name.startswith("_"):
                     # Collect until :=
                     decl_lines = [line]
                     j = i + 1
-                    while j < min(end, len(lines)) and ':=' not in ' '.join(decl_lines):
-                        if (next_line := lines[j].strip()) and not next_line.startswith('--'):
+                    while j < min(end, len(lines)) and ":=" not in " ".join(decl_lines):
+                        if (next_line := lines[j].strip()) and not next_line.startswith(
+                            "--"
+                        ):
                             decl_lines.append(next_line)
                         j += 1
 
                     # Extract signature (everything before :=, minus keyword and name)
-                    full_decl = ' '.join(decl_lines)
+                    full_decl = " ".join(decl_lines)
                     type_sig = None
-                    if ':=' in full_decl:
-                        sig_part = full_decl.split(':=', 1)[0].strip()[len(keyword):].strip()
+                    if ":=" in full_decl:
+                        sig_part = (
+                            full_decl.split(":=", 1)[0].strip()[len(keyword) :].strip()
+                        )
                         if sig_part.startswith(name):
-                            type_sig = sig_part[len(name):].strip()
-
-                    decls.append({
-                        'name': name,
-                        'kind': 'method',
-                        'range': {'start': {'line': i, 'character': 0}, 
-                                 'end': {'line': i, 'character': len(lines[i])}},
-                        '_keyword': keyword,
-                        '_type': type_sig
-                    })
+                            type_sig = sig_part[len(name) :].strip()
+
+                    decls.append(
+                        {
+                            "name": name,
+                            "kind": "method",
+                            "range": {
+                                "start": {"line": i, "character": 0},
+                                "end": {"line": i, "character": len(lines[i])},
+                            },
+                            "_keyword": keyword,
+                            "_type": type_sig,
+                        }
+                    )
                 break
         i += 1
     return decls
 
 
-def _flatten_symbols(symbols: List[Dict], indent: int = 0, content: str = "") -> List[Tuple[Dict, int]]:
+def _flatten_symbols(
+    symbols: List[Dict], indent: int = 0, content: str = ""
+) -> List[Tuple[Dict, int]]:
     """Recursively flatten symbol hierarchy, extracting declarations from namespaces."""
     result = []
     for sym in symbols:
         result.append((sym, indent))
-        children = sym.get('children', [])
+        children = sym.get("children", [])
 
         # Extract theorem/lemma/def from namespace bodies
-        if content and sym.get('kind') == 'namespace':
-            ns_range = sym['range']
-            ns_start = ns_range['start']['line']
-            ns_end = ns_range['end']['line']
+        if content and sym.get("kind") == "namespace":
+            ns_range = sym["range"]
+            ns_start = ns_range["start"]["line"]
+            ns_end = ns_range["end"]["line"]
             children = children + _extract_declarations(content, ns_start, ns_end)
 
         if children:
@@ -120,32 +139,36 @@ def _flatten_symbols(symbols: List[Dict], indent: int = 0, content: str = "") ->
     return result
 
 
-def _detect_tag(name: str, kind: str, type_sig: str, has_fields: bool, keyword: Optional[str]) -> str:
+def _detect_tag(
+    name: str, kind: str, type_sig: str, has_fields: bool, keyword: Optional[str]
+) -> str:
     """Determine the appropriate tag for a symbol."""
     if has_fields:
-        return "Class" if '→' in type_sig else "Struct"
+        return "Class" if "→" in type_sig else "Struct"
     if name == "example":
         return "Ex"
-    if keyword in {'theorem', 'lemma'}:
+    if keyword in {"theorem", "lemma"}:
         return "Thm"
-    if type_sig and any(marker in type_sig for marker in ['∀', '=']):
+    if type_sig and any(marker in type_sig for marker in ["∀", "="]):
         return "Thm"
-    if type_sig and '→' in type_sig.replace(' → ', '', 1):  # More than one arrow
+    if type_sig and "→" in type_sig.replace(" → ", "", 1):  # More than one arrow
         return "Thm"
     return KIND_TAGS.get(kind, "Def")
 
 
 def _format_symbol(sym: Dict, type_sigs: Dict, fields_map: Dict, indent: int) -> str:
     """Format a single symbol with its type signature and fields."""
-    name = sym['name']
-    type_sig = sym.get('_type') or type_sigs.get(name, "")
+    name = sym["name"]
+    type_sig = sym.get("_type") or type_sigs.get(name, "")
     fields = fields_map.get(name, [])
 
-    tag = _detect_tag(name, sym.get('kind', ''), type_sig, bool(fields), sym.get('_keyword'))
+    tag = _detect_tag(
+        name, sym.get("kind", ""), type_sig, bool(fields), sym.get("_keyword")
+    )
     prefix = "\t" * indent
 
-    start = sym['range']['start']['line'] + 1
-    end = sym['range']['end']['line'] + 1
+    start = sym["range"]["start"]["line"] + 1
+    end = sym["range"]["end"]["line"] + 1
     line_info = f"L{start}" if start == end else f"L{start}-{end}"
 
     result = f"{prefix}[{tag}: {line_info}] {name}"
@@ -164,8 +187,11 @@ def generate_outline(client: LeanLSPClient, path: str) -> str:
     content = client.get_file_content(path)
 
     # Extract imports
-    imports = [line.strip()[7:] for line in content.splitlines() 
-               if line.strip().startswith("import ")]
+    imports = [
+        line.strip()[7:]
+        for line in content.splitlines()
+        if line.strip().startswith("import ")
+    ]
 
     symbols = client.get_document_symbols(path)
     if not symbols and not imports:
@@ -175,14 +201,24 @@ def generate_outline(client: LeanLSPClient, path: str) -> str:
     all_symbols = _flatten_symbols(symbols, content=content)
 
     # Get info trees only for LSP symbols (not extracted declarations)
-    lsp_methods = [s for s, _ in all_symbols if s.get('kind') in METHOD_KIND and '_keyword' not in s]
+    lsp_methods = [
+        s
+        for s, _ in all_symbols
+        if s.get("kind") in METHOD_KIND and "_keyword" not in s
+    ]
     info_trees = _get_info_trees(client, path, lsp_methods)
 
     # Extract type signatures and fields from info trees
-    type_sigs = {name: sig for name, info in info_trees.items() 
-                 if (sig := _extract_type(info, name))}
-    fields_map = {name: fields for name, info in info_trees.items() 
-                  if (fields := _extract_fields(info, name))}
+    type_sigs = {
+        name: sig
+        for name, info in info_trees.items()
+        if (sig := _extract_type(info, name))
+    }
+    fields_map = {
+        name: fields
+        for name, info in info_trees.items()
+        if (fields := _extract_fields(info, name))
+    }
 
     # Build output
     parts = []
@@ -193,7 +229,9 @@ def generate_outline(client: LeanLSPClient, path: str) -> str:
         declarations = [
             _format_symbol(sym, type_sigs, fields_map, indent)
             for sym, indent in all_symbols
-            if sym.get('kind') in METHOD_KIND or sym.get('_keyword') or sym.get('kind') == 'namespace'
+            if sym.get("kind") in METHOD_KIND
+            or sym.get("_keyword")
+            or sym.get("kind") == "namespace"
         ]
         parts.append("## Declarations\n" + "".join(declarations).rstrip())
 

lean_lsp_mcp/server.py

@@ -26,6 +26,7 @@ from lean_lsp_mcp.client_utils import (
 from lean_lsp_mcp.file_utils import get_file_contents
 from lean_lsp_mcp.instructions import INSTRUCTIONS
 from lean_lsp_mcp.search_utils import check_ripgrep_status, lean_local_search
+from lean_lsp_mcp.loogle import LoogleManager, loogle_remote
 from lean_lsp_mcp.outline_utils import generate_outline
 from lean_lsp_mcp.utils import (
     OutputCapture,
@@ -56,10 +57,15 @@ class AppContext:
     client: LeanLSPClient | None
     rate_limit: Dict[str, List[int]]
     lean_search_available: bool
+    loogle_manager: LoogleManager | None = None
+    loogle_local_available: bool = False
 
 
 @asynccontextmanager
 async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
+    loogle_manager: LoogleManager | None = None
+    loogle_local_available = False
+
     try:
         lean_project_path_str = os.environ.get("LEAN_PROJECT_PATH", "").strip()
         if not lean_project_path_str:
@@ -67,6 +73,19 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         else:
             lean_project_path = Path(lean_project_path_str).resolve()
 
+        # Initialize local loogle if enabled via env var or CLI
+        if os.environ.get("LEAN_LOOGLE_LOCAL", "").lower() in ("1", "true", "yes"):
+            logger.info("Local loogle enabled, initializing...")
+            loogle_manager = LoogleManager()
+            if loogle_manager.ensure_installed():
+                if await loogle_manager.start():
+                    loogle_local_available = True
+                    logger.info("Local loogle started successfully")
+                else:
+                    logger.warning("Local loogle failed to start, will use remote API")
+            else:
+                logger.warning("Local loogle installation failed, will use remote API")
+
         context = AppContext(
             lean_project_path=lean_project_path,
             client=None,
@@ -78,6 +97,8 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
                 "hammer_premise": [],
             },
             lean_search_available=_RG_AVAILABLE,
+            loogle_manager=loogle_manager,
+            loogle_local_available=loogle_local_available,
         )
         yield context
     finally:
@@ -86,6 +107,9 @@ async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         if context.client:
             context.client.close()
 
+        if loogle_manager:
+            await loogle_manager.stop()
+
 
 mcp_kwargs = dict(
     name="Lean LSP",
@@ -322,6 +346,7 @@ def diagnostic_messages(
         return "Invalid Lean file path: Unable to start LSP server or load file"
 
     client: LeanLSPClient = ctx.request_context.lifespan_context.client
+    client.open_file(rel_path)
 
     # If declaration_name is provided, get its range and use that for filtering
     if declaration_name:
@@ -821,8 +846,7 @@ def leansearch(ctx: Context, query: str, num_results: int = 5) -> List[Dict] | s
 
 
 @mcp.tool("lean_loogle")
-@rate_limited("loogle", max_requests=3, per_seconds=30)
-def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
+async def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
     """Search for definitions and theorems using loogle.
 
     Query patterns:
@@ -841,25 +865,27 @@ def loogle(ctx: Context, query: str, num_results: int = 8) -> List[dict] | str:
     Returns:
         List[dict] | str: Search results or error msg
     """
-    try:
-        req = urllib.request.Request(
-            f"https://loogle.lean-lang.org/json?q={urllib.parse.quote(query)}",
-            headers={"User-Agent": "lean-lsp-mcp/0.1"},
-            method="GET",
-        )
+    app_ctx: AppContext = ctx.request_context.lifespan_context
 
-        with urllib.request.urlopen(req, timeout=20) as response:
-            results = orjson.loads(response.read())
+    # Try local loogle first if available (no rate limiting)
+    if app_ctx.loogle_local_available and app_ctx.loogle_manager:
+        try:
+            results = await app_ctx.loogle_manager.query(query, num_results)
+            for result in results:
+                result.pop("doc", None)
+            return results if results else "No results found."
+        except Exception as e:
+            logger.warning(f"Local loogle failed: {e}, falling back to remote")
 
-        if "hits" not in results:
-            return "No results found."
+    # Fall back to remote (with rate limiting)
+    rate_limit = app_ctx.rate_limit["loogle"]
+    now = int(time.time())
+    rate_limit[:] = [t for t in rate_limit if now - t < 30]
+    if len(rate_limit) >= 3:
+        return "Rate limit exceeded: 3 requests per 30s. Use --loogle-local to avoid limits."
+    rate_limit.append(now)
 
-        results = results["hits"][:num_results]
-        for result in results:
-            result.pop("doc", None)
-        return results
-    except Exception as e:
-        return f"loogle error:\n{str(e)}"
+    return loogle_remote(query, num_results)
 
 
 @mcp.tool("lean_leanfinder")

{lean_lsp_mcp-0.14.0.dist-info → lean_lsp_mcp-0.15.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lean-lsp-mcp
-Version: 0.14.0
+Version: 0.15.0
 Summary: Lean Theorem Prover MCP
 Author-email: Oliver Dressler <hey@oli.show>
 License-Expression: MIT
@@ -8,8 +8,8 @@ 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.5.5
-Requires-Dist: mcp[cli]==1.21.2
+Requires-Dist: leanclient==0.6.1
+Requires-Dist: mcp[cli]==1.23.1
 Requires-Dist: orjson>=3.11.1
 Provides-Extra: lint
 Requires-Dist: ruff>=0.2.0; extra == "lint"
@@ -348,6 +348,7 @@ Search for Lean definitions and theorems using [loogle.lean-lang.org](https://lo
 
 - Supports queries by constant, lemma name, subexpression, type, or conclusion.
 - Example: `Real.sin`, `"differ"`, `_ * (_ ^ _)`, `(?a -> ?b) -> List ?a -> List ?b`, `|- tsum _ = _ * tsum _`
+- **Local mode available**: Use `--loogle-local` to run loogle locally (avoids rate limits, see [Local Loogle](#local-loogle) section)
 
 <details>
 <summary>Example output (`Real.sin`)</summary>
@@ -464,6 +465,8 @@ This MCP server works out-of-the-box without any configuration. However, a few o
 - `LEAN_LSP_MCP_TOKEN`: Secret token for bearer authentication when using `streamable-http` or `sse` transport.
 - `LEAN_STATE_SEARCH_URL`: URL for a self-hosted [premise-search.com](https://premise-search.com) instance.
 - `LEAN_HAMMER_URL`: URL for a self-hosted [Lean Hammer Premise Search](https://github.com/hanwenzhu/lean-premise-server) instance.
+- `LEAN_LOOGLE_LOCAL`: Set to `true`, `1`, or `yes` to enable local loogle (see [Local Loogle](#local-loogle) section).
+- `LEAN_LOOGLE_CACHE_DIR`: Override the cache directory for local loogle (default: `~/.cache/lean-lsp-mcp/loogle`).
 
 You can also often set these environment variables in your MCP client configuration:
 <details>
@@ -519,6 +522,24 @@ uvx lean-lsp-mcp --transport streamable-http
 
 Clients should then include the token in the `Authorization` header.
 
+### Local Loogle
+
+Run loogle locally to avoid the remote API's rate limit (3 req/30s). First run takes ~5-10 minutes to build; subsequent runs start in seconds.
+
+```bash
+# Enable via CLI
+uvx lean-lsp-mcp --loogle-local
+
+# Or via environment variable
+export LEAN_LOOGLE_LOCAL=true
+```
+
+**Requirements:** `git`, `lake` ([elan](https://github.com/leanprover/elan)), ~2GB disk space.
+
+**Note:** Local loogle is currently only supported on Unix systems (Linux/macOS). Windows users should use WSL or the remote API.
+
+Falls back to remote API if local loogle fails.
+
 ## Notes on MCP Security
 
 There are many valid security concerns with the Model Context Protocol (MCP) in general!

lean_lsp_mcp-0.15.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+lean_lsp_mcp/__init__.py,sha256=MN_bNFyb5-p33JWWGbrlUYBd1UUMQKtZYGC9KCh2mtM,1403
+lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
+lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
+lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
+lean_lsp_mcp/instructions.py,sha256=GUOCDILr5N4H_kNE5hiXtzy4Sz9tu-BnE7Y0ktXIF9M,955
+lean_lsp_mcp/loogle.py,sha256=NEs8b_P3RQ4EnWJG3LF9RLevsLS0F80T_uebEickx5c,9789
+lean_lsp_mcp/outline_utils.py,sha256=sZ5q19yxheWuDfb3w8FNfuL1ACGJ9ipqRsIQc-gb1SE,8249
+lean_lsp_mcp/search_utils.py,sha256=X2LPynDNLi767UDxbxHpMccOkbnfKJKv_HxvRNxIXM4,3984
+lean_lsp_mcp/server.py,sha256=m78vXmnVO3qUu6BIEsyOPhefeu6apU8EEZ7VIcVsTDU,39009
+lean_lsp_mcp/utils.py,sha256=qY2Ef82SmD46y0IgyX1jimigkgr6Q8-Hrme-yUYSBGo,11094
+lean_lsp_mcp-0.15.0.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
+lean_lsp_mcp-0.15.0.dist-info/METADATA,sha256=KtGWheExi2HzDKDwExeed8CRsa2k-0LHAYv8uRdhYBA,20787
+lean_lsp_mcp-0.15.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lean_lsp_mcp-0.15.0.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
+lean_lsp_mcp-0.15.0.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
+lean_lsp_mcp-0.15.0.dist-info/RECORD,,

lean_lsp_mcp-0.14.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-lean_lsp_mcp/__init__.py,sha256=lxqDq0G_sI2iu2Nniy-pTW7BE9Ux7ZXeDoGf0OAWIDc,763
-lean_lsp_mcp/__main__.py,sha256=XnpTzfJc0T-j9tHtdkA8ovTr1c139ffTewcJGhxYDaM,49
-lean_lsp_mcp/client_utils.py,sha256=HgPuB35rMitn2Xm8SCAErsFLq15trB6VMz3FDFgmPd8,4897
-lean_lsp_mcp/file_utils.py,sha256=kCTYQSfmV-R2cm_NCi_L8W5Dcsm0_rTOPpTtpyAin78,1365
-lean_lsp_mcp/instructions.py,sha256=GUOCDILr5N4H_kNE5hiXtzy4Sz9tu-BnE7Y0ktXIF9M,955
-lean_lsp_mcp/outline_utils.py,sha256=bXBpLp_QnxmvwoP2y1juCYog2eln6329MAKuOXOz0-E,7807
-lean_lsp_mcp/search_utils.py,sha256=X2LPynDNLi767UDxbxHpMccOkbnfKJKv_HxvRNxIXM4,3984
-lean_lsp_mcp/server.py,sha256=qf0iRVeWrrvX91EmJsgbx7DW8kwn28zMs1WyfkxCh5A,37644
-lean_lsp_mcp/utils.py,sha256=qY2Ef82SmD46y0IgyX1jimigkgr6Q8-Hrme-yUYSBGo,11094
-lean_lsp_mcp-0.14.0.dist-info/licenses/LICENSE,sha256=CQlxnf0tQyoVrBE93JYvAUYxv6Z5Yg6sX0pwogOkFvo,1071
-lean_lsp_mcp-0.14.0.dist-info/METADATA,sha256=8GGWXkG-1GH4Vyzo32QFITO1OhJrumsijULxDILlvcI,19855
-lean_lsp_mcp-0.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lean_lsp_mcp-0.14.0.dist-info/entry_points.txt,sha256=nQbvwctWkWD7I-2f4VrdVQBZYGUw8CnUnFC6QjXxOSE,51
-lean_lsp_mcp-0.14.0.dist-info/top_level.txt,sha256=LGEK0lgMSNPIQ6mG8EO-adaZEGPi_0daDs004epOTF0,13
-lean_lsp_mcp-0.14.0.dist-info/RECORD,,