lcode-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/CHANGELOG.md

@@ -6,6 +6,21 @@ All notable changes to lcode are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.11.0] - 2026-10-05
+
+### Added
+
+- Ready-made MCP servers for data and ML platforms:
+  - `lcode mcp add metabase` connects to the MCP server built into Metabase 60 and later, with browser
+    sign-in, so the model sees your data with your Metabase permissions.
+  - `lcode mcp add encord` and `lcode mcp add valohai`: those platforms have no MCP server of their own,
+    so lcode now ships `lcode-mcp-encord` (projects, datasets, ontologies, labeling progress, tasks and
+    labels, built on the Encord SDK) and `lcode-mcp-valohai` (executions with their logs, metrics and
+    outputs, pipelines). Both are read-only unless started with `--allow-writes`, which adds
+    assigning tasks and setting priorities (Encord) or starting and stopping executions (Valohai), and
+    both work with other MCP clients too. See [MCP servers](https://nasser1941.github.io/lcode/mcp/#encord).
+- Catalog questions that ask for an address now accept it without `https://`.
+
 ## [0.10.0] - 2026-10-05
 
 ### Added
@@ -287,7 +302,8 @@ First public release.
 - `AGENTS.md` project instructions and `/init` to generate them.
 - One-line installer for Linux and macOS.
 
-[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.10.0...HEAD
+[Unreleased]: https://github.com/nasser1941/lcode/compare/v0.11.0...HEAD
+[0.11.0]: https://github.com/nasser1941/lcode/compare/v0.10.0...v0.11.0
 [0.10.0]: https://github.com/nasser1941/lcode/compare/v0.9.0...v0.10.0
 [0.9.0]: https://github.com/nasser1941/lcode/compare/v0.8.0...v0.9.0
 [0.8.0]: https://github.com/nasser1941/lcode/compare/v0.7.0...v0.8.0

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lcode-cli
-Version: 0.10.0
+Version: 0.11.0
 Summary: A local-first terminal coding agent powered by open-weight models on your own GPU or Mac, via Ollama.
 Project-URL: Homepage, https://nasser1941.github.io/lcode/
 Project-URL: Documentation, https://nasser1941.github.io/lcode/
@@ -30,6 +30,8 @@ Requires-Dist: prompt-toolkit>=3.0.43
 Requires-Dist: requests>=2.31
 Requires-Dist: rich>=13.7
 Requires-Dist: tomli>=2.0; python_version < '3.11'
+Provides-Extra: encord
+Requires-Dist: encord>=0.1.200; extra == 'encord'
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -95,7 +97,7 @@ through [Ollama](https://ollama.com), and when it needs current information it c
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
-  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes and more with one command
+  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes, Metabase, Encord, Valohai and more with one command
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Sees images.** Attach a screenshot or mockup with `@path` and lcode looks at it, using the
   vision part of your model. With ComfyUI (`lcode mcp add comfyui`) it can also generate and edit
@@ -199,8 +201,10 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Ready-made MCP for Metabase, Encord and Valohai](https://github.com/nasser1941/lcode/issues/53)
-- Then: [smarter context for small windows](https://github.com/nasser1941/lcode/issues/46), [language servers](https://github.com/nasser1941/lcode/issues/44), [a repository map with local embeddings](https://github.com/nasser1941/lcode/issues/45), [hooks](https://github.com/nasser1941/lcode/issues/43)
+- [Smarter context for small windows](https://github.com/nasser1941/lcode/issues/46)
+- [Code intelligence with language servers](https://github.com/nasser1941/lcode/issues/44)
+- [A repository map and semantic search with local embeddings](https://github.com/nasser1941/lcode/issues/45)
+- [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/README.md

@@ -61,7 +61,7 @@ through [Ollama](https://ollama.com), and when it needs current information it c
 - **Bring your own model.** Eight curated open-weight models, all tested end to end, or any Ollama model
   with tool calling.
 - **MCP servers, ready to go.** Connect Jira and Confluence, GitHub, AWS, Google Drive, Grafana,
-  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes and more with one command
+  Google Cloud, Sentry, Linear, Notion, Postgres, Kubernetes, Metabase, Encord, Valohai and more with one command
   (`lcode mcp add atlassian`), image generation with ComfyUI, or any other MCP server. Browser sign-in (OAuth) is built in.
 - **Sees images.** Attach a screenshot or mockup with `@path` and lcode looks at it, using the
   vision part of your model. With ComfyUI (`lcode mcp add comfyui`) it can also generate and edit
@@ -165,8 +165,10 @@ fills up. Details: [How it works](https://nasser1941.github.io/lcode/how-it-work
 
 See the pinned [Roadmap issue](https://github.com/nasser1941/lcode/issues/10). Next up:
 
-- [Ready-made MCP for Metabase, Encord and Valohai](https://github.com/nasser1941/lcode/issues/53)
-- Then: [smarter context for small windows](https://github.com/nasser1941/lcode/issues/46), [language servers](https://github.com/nasser1941/lcode/issues/44), [a repository map with local embeddings](https://github.com/nasser1941/lcode/issues/45), [hooks](https://github.com/nasser1941/lcode/issues/43)
+- [Smarter context for small windows](https://github.com/nasser1941/lcode/issues/46)
+- [Code intelligence with language servers](https://github.com/nasser1941/lcode/issues/44)
+- [A repository map and semantic search with local embeddings](https://github.com/nasser1941/lcode/issues/45)
+- [Hooks and permission rules](https://github.com/nasser1941/lcode/issues/43)
 - More models in the catalog, and test reports from your hardware ([report one](https://github.com/nasser1941/lcode/issues/new?template=model_request.yml))
 
 ## Contributing

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/docs/how-it-works.md

@@ -85,6 +85,7 @@ the Ollama server you configure, it only contacts the web when the model searche
 | `agent.py` | System prompt, streaming, tool loop, compaction, sessions |
 | `tools.py` | Tool schemas and implementations |
 | `permissions.py` | Approval prompts and the read-only allowlist |
+| `servers/` | The MCP servers lcode ships for services without one: Encord, Valohai |
 | `mcp/` | MCP client: stdio and HTTP transports, OAuth sign-in, server settings, the catalog, `lcode mcp` |
 | `bench.py` | `lcode bench`: the benchmark tasks, their checks and the reports |
 | `vision.py` | Looking at images with a model that can see |

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/docs/mcp.md

@@ -35,13 +35,16 @@ and find the code for the top one."*
 | `kubernetes` | Pods, deployments, logs and events, read-only | `npx` and a kubeconfig |
 | `linear` | Issues, projects and cycles | a Linear account (browser sign-in) |
 | `notion` | Pages and databases | a Notion account (browser sign-in) |
+| `metabase` | Explore your data and ask questions through Metabase's semantic layer | Metabase 60 or later with MCP on ([below](#metabase)) |
+| `encord` | Projects, datasets, ontologies, labeling progress, tasks and labels, read-only | `uvx`, an SSH key registered in Encord ([below](#encord)) |
+| `valohai` | ML executions with their logs, metrics and outputs, and pipelines, read-only | `uvx`, a Valohai API token ([below](#valohai)) |
 
 `npx` comes with [Node.js](https://nodejs.org) (18 or newer) and `uvx` with
 [uv](https://docs.astral.sh/uv/getting-started/installation/). `lcode mcp catalog` shows what's missing
 on your machine.
 
 Servers that can change things start read-only where the server supports it (`aws`, `postgres`,
-`kubernetes`); the setup note tells you which setting to change to allow writes.
+`kubernetes`, `encord`, `valohai`); the setup note tells you which setting to change to allow writes.
 
 ### Signing in
 
@@ -134,6 +137,51 @@ size, prompt), which can take several minutes of trial and error. Once an image
 lcode to save that workflow in your project (for example `assets/icon.workflow.json`) and reuse it:
 later images are a single `run_workflow` call.
 
+### Metabase
+
+Metabase has its own MCP server inside every instance (Metabase 60 and later), at
+`/api/metabase-mcp`. An admin switches it on under **Admin > AI > MCP**. Then:
+
+```bash
+lcode mcp add metabase        # asks for your Metabase address, then signs in in the browser
+```
+
+You sign in with your Metabase account, and the model sees exactly the data your Metabase
+permissions allow. See [Metabase's MCP docs](https://www.metabase.com/docs/latest/ai/mcp).
+
+### Encord
+
+Encord has no MCP server of its own, so lcode ships one: `lcode-mcp-encord`, built on the Encord SDK
+and run with `uvx --from "lcode-cli[encord]"`. It signs in with an SSH key that you register in
+Encord under **Settings > Public keys**; `lcode mcp add encord` asks for the key file's path.
+
+| Tool | |
+|---|---|
+| `list_projects`, `list_datasets` | What you can see |
+| `get_project`, `get_ontology` | A project's datasets, ontology classes and workflow stages |
+| `workflow_progress` | How many tasks are in each workflow stage, by status |
+| `list_tasks` | Data units with their stage, status and last edit, filtered by stage or title |
+| `get_labels` | The labels on one data unit: counts per class and the label JSON |
+| `assign_task`, `set_priority` | Only with `--allow-writes` in the server's `args` in `mcp.json` |
+
+### Valohai
+
+Valohai has no MCP server of its own either, so lcode ships `lcode-mcp-valohai`, which talks to
+Valohai's REST API. It needs an API token (**My Profile > Authentication > Manage tokens**), and the
+address of a self-hosted installation if you use one; `lcode mcp add valohai` asks for both.
+
+| Tool | |
+|---|---|
+| `list_projects`, `list_pipelines` | Projects and their pipelines |
+| `list_executions`, `get_execution` | Executions with their status, parameters, metrics, outputs and errors |
+| `get_execution_logs` | The last lines of an execution's log, optionally only stderr |
+| `list_outputs` | The files an execution produced, with `datum://` URIs to use as inputs |
+| `compare_executions` | Metrics and differing parameters of several executions side by side |
+| `start_execution`, `stop_execution` | Only with `--allow-writes` in the server's `args` in `mcp.json` |
+
+Both servers are ordinary MCP servers: other MCP clients can use them too, for example
+`uvx --from lcode-cli lcode-mcp-valohai` with `VALOHAI_TOKEN` set.
+
 ## Adding your own servers
 
 Any MCP server works. For a remote server, give its URL; for a local one, the command that starts it:

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/docs/quickstart.md

@@ -12,7 +12,7 @@ lcode
 
 ```text
 ╭──────────────────────────────────────────────╮
-│ lcode v0.10.0 — local coding agent           │
+│ lcode v0.11.0 — local coding agent           │
 │                                              │
 │ model    lcode-qwen3.6-35b                   │
 │ context  256K tokens                         │

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/pyproject.toml

@@ -35,6 +35,9 @@ dependencies = [
     "tomli>=2.0; python_version < '3.11'",
 ]
 
+[project.optional-dependencies]
+encord = ["encord>=0.1.200"]  # for lcode-mcp-encord
+
 [project.urls]
 Homepage = "https://nasser1941.github.io/lcode/"
 Documentation = "https://nasser1941.github.io/lcode/"
@@ -44,6 +47,8 @@ Changelog = "https://github.com/nasser1941/lcode/blob/main/CHANGELOG.md"
 
 [project.scripts]
 lcode = "lcode.cli:main"
+lcode-mcp-valohai = "lcode.servers.valohai:main"
+lcode-mcp-encord = "lcode.servers.encord:main"
 
 [dependency-groups]
 dev = ["pytest>=8", "ruff>=0.6"]

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/src/lcode/__init__.py

@@ -1,3 +1,3 @@
 """lcode — a local-first terminal coding agent powered by open-weight models via Ollama."""
 
-__version__ = "0.10.0"
+__version__ = "0.11.0"

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/src/lcode/mcp/catalog.py

@@ -99,6 +99,10 @@ def build(preset: Preset, answers: dict[str, str | None]) -> dict:
     server = copy.deepcopy(preset.server)
     for spec in preset.inputs:
         value = answers.get(spec.var)
+        if value and spec.var.endswith(("_URL", "_HOST")):
+            value = value.rstrip("/")  # the URL may have a path appended, e.g. ${METABASE_URL}/api/metabase-mcp
+            if "://" not in value:
+                value = "https://" + value  # people type metabase.example.com
         if value:
             server = _replace(server, spec.var, value)
         elif spec.optional and not os.environ.get(spec.var):

{lcode_cli-0.10.0 → lcode_cli-0.11.0}/src/lcode/mcp/catalog.toml

@@ -7,7 +7,7 @@
 # requires commands that must be installed.
 # login    sign in through the browser (OAuth) after adding.
 #
-# Commands and URLs were checked against each project's documentation in September 2026.
+# Commands and URLs were checked against each project's documentation in September and October 2026.
 
 [atlassian]
 name = "Atlassian"
@@ -224,3 +224,59 @@ homepage = "https://developers.notion.com/docs/mcp"
 login = true
 setup = "Sign in with your Notion account in the browser."
 server = { type = "http", url = "https://mcp.notion.com/mcp" }
+
+[metabase]
+name = "Metabase"
+description = "Explore your data and ask questions through Metabase's semantic layer, with your Metabase permissions"
+homepage = "https://www.metabase.com/docs/latest/ai/mcp"
+login = true
+setup = """Needs Metabase 60 or later with its MCP server switched on: an admin turns it on under Admin > AI > MCP.
+Sign in with your Metabase account in the browser."""
+server = { type = "http", url = "${METABASE_URL}/api/metabase-mcp" }
+
+[[metabase.inputs]]
+var = "METABASE_URL"
+prompt = "Metabase address, e.g. https://metabase.example.com"
+
+[encord]
+name = "Encord"
+description = "Projects, datasets, ontologies, labeling progress, tasks and labels (read-only)"
+homepage = "https://nasser1941.github.io/lcode/mcp/#encord"
+requires = ["uvx"]
+setup = """Encord has no MCP server of its own, so this one comes with lcode (it uses the Encord SDK). It signs in with an SSH
+key registered in Encord: Settings > Public keys. Read-only: add --allow-writes to its args in mcp.json to let the
+model assign tasks and set priorities; lcode still asks before every call."""
+
+[encord.server]
+command = "uvx"
+args = ["--python", "3.12", "--from", "lcode-cli[encord]", "lcode-mcp-encord"]
+env = { ENCORD_SSH_KEY_FILE = "${ENCORD_SSH_KEY_FILE}" }
+
+[[encord.inputs]]
+var = "ENCORD_SSH_KEY_FILE"
+prompt = "Path to the SSH private key registered in Encord"
+default = "~/.ssh/id_ed25519"
+
+[valohai]
+name = "Valohai"
+description = "ML executions with their logs, metrics and outputs, and pipelines (read-only)"
+homepage = "https://nasser1941.github.io/lcode/mcp/#valohai"
+requires = ["uvx"]
+setup = """Valohai has no MCP server of its own, so this one comes with lcode. It needs an API token: My Profile >
+Authentication > Manage tokens. Read-only: add --allow-writes to its args in mcp.json to let the model start and stop
+executions; lcode still asks before every call."""
+
+[valohai.server]
+command = "uvx"
+args = ["--python", "3.12", "--from", "lcode-cli", "lcode-mcp-valohai"]
+env = { VALOHAI_TOKEN = "${VALOHAI_TOKEN}", VALOHAI_HOST = "${VALOHAI_HOST}" }
+
+[[valohai.inputs]]
+var = "VALOHAI_TOKEN"
+prompt = "Valohai API token"
+secret = true
+
+[[valohai.inputs]]
+var = "VALOHAI_HOST"
+prompt = "Valohai address (Enter for app.valohai.com; for a self-hosted installation, its URL)"
+optional = true

lcode_cli-0.11.0/src/lcode/mcp/server.py

@@ -0,0 +1,152 @@
+"""A small MCP server over stdio, for the servers lcode ships itself (lcode.servers).
+
+It speaks both eras of MCP, like lcode's client: the legacy `initialize` handshake and the modern
+stateless `server/discover`. Tools are plain functions that return text; raising ToolFailure turns
+into an error result the model can read. Tools that change something are only listed when the
+server is started with --allow-writes.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import traceback
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import IO
+
+from lcode.mcp.protocol import LEGACY_VERSIONS, METHOD_NOT_FOUND, MODERN_VERSIONS
+
+INVALID_PARAMS = -32602
+MAX_RESULT = 60_000  # characters per tool result; long listings are cut with a note
+
+
+class ToolFailure(Exception):
+    """A tool couldn't do its job; the message goes to the model."""
+
+
+@dataclass
+class Tool:
+    name: str
+    description: str
+    properties: dict
+    required: list[str]
+    fn: Callable[..., str]
+    writes: bool = False
+
+    def definition(self) -> dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "inputSchema": {"type": "object", "properties": self.properties, "required": self.required},
+            "annotations": {"readOnlyHint": not self.writes, "destructiveHint": self.writes},
+        }
+
+
+@dataclass
+class Server:
+    name: str
+    version: str
+    instructions: str = ""
+    allow_writes: bool = False
+    tools: dict[str, Tool] = field(default_factory=dict)
+
+    def tool(self, name: str, description: str, properties: dict | None = None, required=(), writes: bool = False):
+        """Register a function as a tool (a decorator)."""
+
+        def register(fn: Callable[..., str]) -> Callable[..., str]:
+            self.tools[name] = Tool(name, description, properties or {}, list(required), fn, writes)
+            return fn
+
+        return register
+
+    def listed(self) -> list[Tool]:
+        return [t for t in self.tools.values() if self.allow_writes or not t.writes]
+
+    # -- JSON-RPC
+    def handle(self, message: dict) -> dict | None:
+        """The response to one message (None for notifications)."""
+        method, params, ident = message.get("method"), message.get("params") or {}, message.get("id")
+        if ident is None:
+            return None  # a notification, such as notifications/initialized
+        try:
+            result = self.dispatch(str(method), params if isinstance(params, dict) else {})
+        except _RpcError as e:
+            return {"jsonrpc": "2.0", "id": ident, "error": {"code": e.code, "message": str(e)}}
+        return {"jsonrpc": "2.0", "id": ident, "result": result}
+
+    def dispatch(self, method: str, params: dict) -> dict:
+        info = {"name": self.name, "version": self.version}
+        if method == "initialize":
+            asked = str(params.get("protocolVersion") or "")
+            return {
+                "protocolVersion": asked if asked in LEGACY_VERSIONS else LEGACY_VERSIONS[0],
+                "capabilities": {"tools": {}},
+                "serverInfo": info,
+                "instructions": self.instructions,
+            }
+        if method == "server/discover":
+            return {
+                "supportedVersions": list(MODERN_VERSIONS),
+                "capabilities": {"tools": {}},
+                "instructions": self.instructions,
+                "_meta": {"io.modelcontextprotocol/serverInfo": info},
+            }
+        if method == "ping":
+            return {}
+        if method == "tools/list":
+            return {"tools": [t.definition() for t in self.listed()]}
+        if method == "tools/call":
+            return self.call(str(params.get("name", "")), params.get("arguments") or {})
+        raise _RpcError(METHOD_NOT_FOUND, f"unknown method {method}")
+
+    def call(self, name: str, arguments: dict) -> dict:
+        tool = self.tools.get(name)
+        if tool is None or tool not in self.listed():
+            hint = " (start the server with --allow-writes to enable it)" if tool else ""
+            return _text(f"Unknown tool {name}{hint}", error=True)
+        if not isinstance(arguments, dict):
+            raise _RpcError(INVALID_PARAMS, "arguments must be an object")
+        unknown = set(arguments) - set(tool.properties)
+        missing = [r for r in tool.required if arguments.get(r) in (None, "")]
+        if unknown or missing:
+            problems = [f"unknown argument(s): {', '.join(sorted(unknown))}"] if unknown else []
+            problems += [f"missing: {', '.join(missing)}"] if missing else []
+            return _text(f"Bad arguments for {name}: {'; '.join(problems)}", error=True)
+        try:
+            text = tool.fn(**arguments)
+        except ToolFailure as e:
+            return _text(str(e), error=True)
+        except Exception as e:  # report, don't crash the server
+            traceback.print_exc(file=sys.stderr)
+            return _text(f"{type(e).__name__}: {e}", error=True)
+        if len(text) > MAX_RESULT:
+            text = text[:MAX_RESULT] + "\n… (cut off: ask for less, e.g. with a smaller limit or a filter)"
+        return _text(text)
+
+    def serve(self, stdin: IO[str] | None = None, stdout: IO[str] | None = None) -> None:
+        """Answer newline-delimited JSON-RPC on stdin/stdout until stdin closes."""
+        stdin, stdout = stdin or sys.stdin, stdout or sys.stdout
+        for line in stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                message = json.loads(line)
+            except json.JSONDecodeError:
+                response = {"jsonrpc": "2.0", "id": None, "error": {"code": -32700, "message": "parse error"}}
+            else:
+                response = self.handle(message) if isinstance(message, dict) else None
+            if response is not None:
+                stdout.write(json.dumps(response) + "\n")
+                stdout.flush()
+
+
+class _RpcError(Exception):
+    def __init__(self, code: int, message: str):
+        super().__init__(message)
+        self.code = code
+
+
+def _text(text: str, error: bool = False) -> dict:
+    return {"content": [{"type": "text", "text": text}], "isError": error}

lcode_cli-0.11.0/src/lcode/servers/__init__.py

@@ -0,0 +1 @@
+"""MCP servers that lcode ships for services that have none of their own."""