lcode-cli 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

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/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/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/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/servers/__init__.py

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

lcode/servers/encord.py

@@ -0,0 +1,285 @@
+"""An MCP server for Encord: projects, datasets, ontologies, workflow progress, tasks and labels.
+
+Encord has a Python SDK but no MCP server, so lcode ships this one, built on the SDK
+(`pip install encord`; `uvx --from "lcode-cli[encord]" lcode-mcp-encord` brings it along). It signs in
+with an SSH key registered in Encord (Settings > Public keys): ENCORD_SSH_KEY_FILE names the key
+file, or ENCORD_SSH_KEY holds the key itself. It's read-only unless started with --allow-writes,
+which adds assigning tasks and setting their priority.
+
+Run: lcode-mcp-encord [--allow-writes]   (lcode mcp add encord sets it up)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+from collections import Counter
+
+from lcode import __version__
+from lcode.mcp.server import Server, ToolFailure
+
+MAX_ROWS = 20_000  # label rows read for progress counts
+UUID = re.compile(r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I)
+
+
+def _title(value) -> str:
+    return getattr(value, "title", None) or str(value or "")
+
+
+def _status(row) -> str:
+    status = getattr(row, "annotation_task_status", None) or getattr(row, "label_status", None)
+    return str(getattr(status, "value", status) or "")
+
+
+def _stage(row) -> str:
+    return _title(getattr(row, "workflow_graph_node", None)) or "(no workflow stage)"
+
+
+def build(client, allow_writes: bool = False) -> Server:
+    """The server for an EncordUserClient (or anything with the same methods, in tests)."""
+    server = Server(
+        "encord",
+        __version__,
+        "Encord data and annotation platform: projects (annotation work on datasets, with an ontology and a "
+        "workflow of stages such as Annotate and Review), datasets, tasks (one per data unit) and labels.",
+        allow_writes,
+    )
+    project_arg = {"type": "string", "description": "Project title or project hash"}
+
+    def find_project(name: str):
+        name = name.strip()
+        if UUID.match(name):
+            return client.get_project(name)
+        found = list(client.list_projects(title_eq=name)) or list(client.list_projects(title_like=f"%{name}%"))
+        if not found:
+            raise ToolFailure(f"no project {name!r}; list_projects shows the ones you can see")
+        if len(found) > 1 and not any(p.title == name for p in found):
+            raise ToolFailure(f"{len(found)} projects match {name!r}: {', '.join(p.title for p in found[:10])}")
+        return next((p for p in found if p.title == name), found[0])
+
+    def rows(p, **filters) -> list:
+        return list(p.list_label_rows_v2(include_workflow_graph_node=True, **filters))[:MAX_ROWS]
+
+    @server.tool(
+        "list_projects",
+        "List the Encord projects you can see.",
+        {"title_contains": {"type": "string", "description": "Only projects whose title contains this"}},
+    )
+    def list_projects(title_contains: str = "") -> str:
+        found = list(client.list_projects(title_like=f"%{title_contains}%" if title_contains else None))
+        if not found:
+            return "No projects."
+        return "\n".join(
+            f"{p.title}  hash={p.project_hash}  created {str(getattr(p, 'created_at', ''))[:10]}"
+            + (f"\n    {p.description[:150]}" if getattr(p, "description", "") else "")
+            for p in found
+        )
+
+    @server.tool(
+        "list_datasets",
+        "List the Encord datasets you can see.",
+        {"title_contains": {"type": "string", "description": "Only datasets whose title contains this"}},
+    )
+    def list_datasets(title_contains: str = "") -> str:
+        found = client.get_datasets(title_like=f"%{title_contains}%" if title_contains else None)
+        if not found:
+            return "No datasets."
+        lines = []
+        for entry in found:
+            d = entry.get("dataset") if isinstance(entry, dict) else entry
+            lines.append(f"{d.title}  hash={d.dataset_hash}  edited {str(getattr(d, 'last_edited_at', ''))[:10]}")
+        return "\n".join(lines)
+
+    @server.tool(
+        "get_project",
+        "A project's description, datasets, ontology (object and classification classes) and workflow stages.",
+        {"project": project_arg},
+        ["project"],
+    )
+    def get_project(project: str) -> str:
+        p = find_project(project)
+        parts = [f"{p.title}  hash={p.project_hash}"]
+        if getattr(p, "description", ""):
+            parts.append(p.description)
+        datasets = [f"{d.title} ({d.dataset_hash})" for d in p.list_datasets()]
+        parts.append(f"datasets: {', '.join(datasets) or 'none'}")
+        parts.append(ontology_text(p))
+        try:
+            stages = [f"{s.title} ({type(s).__name__.removesuffix('Stage').lower()})" for s in p.workflow.stages]
+            parts.append(f"workflow stages: {', '.join(stages)}")
+        except Exception:  # projects without a workflow
+            pass
+        return "\n".join(parts)
+
+    def ontology_text(p) -> str:
+        structure = p.ontology_structure
+        objects = [
+            f"{o.name} ({getattr(getattr(o, 'shape', ''), 'value', getattr(o, 'shape', ''))})"
+            for o in structure.objects
+        ]
+        classifications = []
+        for c in structure.classifications:
+            attributes = getattr(c, "attributes", []) or []
+            classifications.append(attributes[0].name if attributes else str(getattr(c, "feature_node_hash", "?")))
+        return (
+            f"ontology objects: {', '.join(objects) or 'none'}\n"
+            f"ontology classifications: {', '.join(classifications) or 'none'}"
+        )
+
+    @server.tool(
+        "workflow_progress",
+        "How many tasks are in each workflow stage, and their statuses: a project's labeling progress.",
+        {"project": project_arg},
+        ["project"],
+    )
+    def workflow_progress(project: str) -> str:
+        p = find_project(project)
+        found = rows(p)
+        if not found:
+            return "No data units in this project."
+        stages = Counter(_stage(r) for r in found)
+        statuses = Counter((_stage(r), _status(r)) for r in found)
+        lines = [f"{len(found)} data units" + (" (stopped counting here)" if len(found) >= MAX_ROWS else "")]
+        for stage, count in stages.most_common():
+            detail = ", ".join(f"{s or 'no status'} {n}" for (st, s), n in statuses.items() if st == stage)
+            lines.append(f"{stage}: {count}  ({detail})")
+        return "\n".join(lines)
+
+    @server.tool(
+        "list_tasks",
+        "List data units (tasks) of a project with their workflow stage, status and last edit.",
+        {
+            "project": project_arg,
+            "stage": {"type": "string", "description": "Only tasks in this workflow stage, e.g. Review"},
+            "title_contains": {"type": "string", "description": "Only data units whose title contains this"},
+            "limit": {"type": "integer", "description": "How many (default 50, at most 500)"},
+        },
+        ["project"],
+    )
+    def list_tasks(project: str, stage: str = "", title_contains: str = "", limit: int = 50) -> str:
+        p = find_project(project)
+        filters = {}
+        if stage:
+            filters["workflow_graph_node_title_eq"] = stage
+        if title_contains:
+            filters["data_title_like"] = f"%{title_contains}%"
+        found = rows(p, **filters)[: max(1, min(int(limit), 500))]
+        if not found:
+            return "No tasks match."
+        return "\n".join(
+            f"{r.data_title}  stage={_stage(r)}  status={_status(r) or '-'}  "
+            f"edited {str(getattr(r, 'last_edited_at', '') or '')[:16]}  data_hash={r.data_hash}"
+            for r in found
+        )
+
+    @server.tool(
+        "get_labels",
+        "The labels on one data unit: how many objects and classifications of each class, and the label JSON.",
+        {
+            "project": project_arg,
+            "data_title": {"type": "string", "description": "The data unit's title (file name), from list_tasks"},
+        },
+        ["project", "data_title"],
+    )
+    def get_labels(project: str, data_title: str) -> str:
+        p = find_project(project)
+        found = rows(p, data_title_eq=data_title)
+        if not found:
+            raise ToolFailure(f"no data unit titled {data_title!r} in {p.title}")
+        row = found[0]
+        row.initialise_labels()
+        objects = Counter(o.ontology_item.name for o in row.get_object_instances())
+        classifications = Counter(_classification_name(c) for c in row.get_classification_instances())
+        summary = [
+            f"{row.data_title}  stage={_stage(row)}  status={_status(row) or '-'}",
+            f"objects: {', '.join(f'{k} ×{v}' for k, v in objects.items()) or 'none'}",
+            f"classifications: {', '.join(f'{k} ×{v}' for k, v in classifications.items()) or 'none'}",
+        ]
+        return "\n".join(summary) + "\n\n" + json.dumps(row.to_encord_dict(), default=str)[:40_000]
+
+    @server.tool(
+        "get_ontology",
+        "A project's ontology: object classes with their shapes, and classifications.",
+        {"project": project_arg},
+        ["project"],
+    )
+    def get_ontology(project: str) -> str:
+        return ontology_text(find_project(project))
+
+    @server.tool(
+        "assign_task",
+        "Assign the task of one data unit, in a workflow stage, to a person (by email).",
+        {
+            "project": project_arg,
+            "stage": {"type": "string", "description": "The workflow stage, e.g. Annotate"},
+            "data_title": {"type": "string"},
+            "assignee": {"type": "string", "description": "The person's email in Encord"},
+        },
+        ["project", "stage", "data_title", "assignee"],
+        writes=True,
+    )
+    def assign_task(project: str, stage: str, data_title: str, assignee: str) -> str:
+        p = find_project(project)
+        try:
+            workflow_stage = p.workflow.get_stage(name=stage)
+        except Exception as e:
+            raise ToolFailure(f"no workflow stage {stage!r} in {p.title}") from e
+        tasks = list(workflow_stage.get_tasks(data_title=data_title))
+        if not tasks:
+            raise ToolFailure(f"no task for {data_title!r} in the {stage} stage")
+        for task in tasks:
+            task.assign(assignee)
+        return f"Assigned {len(tasks)} task(s) for {data_title} in {stage} to {assignee}."
+
+    @server.tool(
+        "set_priority",
+        "Set the priority of a data unit's task (0 to 1; higher is worked on first).",
+        {"project": project_arg, "data_title": {"type": "string"}, "priority": {"type": "number"}},
+        ["project", "data_title", "priority"],
+        writes=True,
+    )
+    def set_priority(project: str, data_title: str, priority: float) -> str:
+        if not 0 <= float(priority) <= 1:
+            raise ToolFailure("priority must be between 0 and 1")
+        p = find_project(project)
+        found = rows(p, data_title_eq=data_title)
+        if not found:
+            raise ToolFailure(f"no data unit titled {data_title!r} in {p.title}")
+        for row in found:
+            row.set_priority(float(priority))
+        return f"Set the priority of {data_title} to {float(priority)}."
+
+    return server
+
+
+def _classification_name(instance) -> str:
+    classification = getattr(instance, "ontology_item", None)
+    attributes = getattr(classification, "attributes", None) or []
+    return attributes[0].name if attributes else str(getattr(classification, "feature_node_hash", "?"))
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="lcode-mcp-encord", description="MCP server for Encord (stdio).")
+    parser.add_argument("--allow-writes", action="store_true", help="also offer assigning tasks and setting priorities")
+    args = parser.parse_args(argv)
+    try:
+        from encord import EncordUserClient
+    except ImportError:
+        parser.error('needs the Encord SDK: run it with uvx --from "lcode-cli[encord]" lcode-mcp-encord')
+    if os.environ.get("ENCORD_SSH_KEY_FILE"):
+        key_file = os.path.expanduser(os.environ["ENCORD_SSH_KEY_FILE"])
+        if not os.path.isfile(key_file):
+            parser.error(f"ENCORD_SSH_KEY_FILE is {key_file}, which doesn't exist")
+        os.environ["ENCORD_SSH_KEY_FILE"] = key_file
+    elif not os.environ.get("ENCORD_SSH_KEY"):
+        parser.error("set ENCORD_SSH_KEY_FILE to the path of an SSH key registered in Encord (Settings > Public keys)")
+    client = EncordUserClient.create_with_ssh_private_key(
+        domain=os.environ.get("ENCORD_DOMAIN") or "https://api.encord.com"
+    )
+    build(client, args.allow_writes).serve()
+
+
+if __name__ == "__main__":
+    main()

lcode/servers/valohai.py

@@ -0,0 +1,329 @@
+"""An MCP server for Valohai: projects, executions, their logs, metrics and outputs, and pipelines.
+
+Valohai has a REST API but no MCP server, so lcode ships this one. It needs an API token
+(VALOHAI_TOKEN, or VH_API_TOKEN as in Valohai's docs; create one under My Profile > Authentication)
+and talks to https://app.valohai.com unless VALOHAI_HOST names a self-hosted installation.
+It's read-only unless started with --allow-writes, which adds starting and stopping executions.
+
+Run: lcode-mcp-valohai [--allow-writes]   (lcode mcp add valohai sets it up)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+
+import requests
+
+from lcode import __version__
+from lcode.mcp.server import Server, ToolFailure
+
+DEFAULT_HOST = "https://app.valohai.com"
+TIMEOUT = 60
+
+
+class Valohai:
+    def __init__(self, host: str, token: str):
+        host = host.strip().rstrip("/")
+        self.base = ("" if "://" in host else "https://") + host + "/api/v0/"
+        self.session = requests.Session()
+        self.session.headers.update({"Authorization": f"Token {token}", "Accept": "application/json"})
+
+    def request(self, method: str, path: str, **kwargs) -> dict:
+        url = path if path.startswith("http") else self.base + path.lstrip("/")
+        try:
+            r = self.session.request(method, url, timeout=TIMEOUT, **kwargs)
+        except requests.RequestException as e:
+            raise ToolFailure(f"can't reach Valohai: {e}") from e
+        if r.status_code in (401, 403):
+            raise ToolFailure("Valohai refused the token: check VALOHAI_TOKEN (My Profile > Authentication)")
+        if r.status_code == 404:
+            raise ToolFailure(f"not found in Valohai: {path}")
+        if r.status_code >= 400:
+            raise ToolFailure(f"Valohai error {r.status_code}: {r.text[:500]}")
+        return r.json() if r.content else {}
+
+    def all(self, path: str, params: dict, limit: int) -> list[dict]:
+        """Up to `limit` results of a paginated listing."""
+        found: list[dict] = []
+        data = self.request("GET", path, params={**params, "limit": min(limit, 100)})
+        while True:
+            found += data.get("results") or []
+            if len(found) >= limit or not data.get("next"):
+                return found[:limit]
+            data = self.request("GET", data["next"])
+
+    def project(self, name_or_id: str) -> dict:
+        """A project by id, name or owner/name."""
+        wanted = name_or_id.strip().lower()
+        projects = self.all("projects/", {}, 1000)
+        for p in projects:
+            owner = (p.get("owner") or {}).get("username", "")
+            if wanted in (
+                str(p.get("id", "")).lower(),
+                str(p.get("name", "")).lower(),
+                f"{owner}/{p.get('name')}".lower(),
+            ):
+                return p
+        names = ", ".join(sorted(str(p.get("name")) for p in projects)[:30])
+        raise ToolFailure(f"no project {name_or_id!r}; projects: {names or 'none'}")
+
+    def execution(self, project: str, counter: int) -> dict:
+        p = self.project(project)
+        return self.request("GET", f"executions/{p['id']}:{int(counter)}/", params={"exclude": "events"})
+
+
+def _when(value: str | None) -> str:
+    return (value or "")[:16].replace("T", " ")
+
+
+def _stream(event: dict) -> str:
+    return str(event.get("stream", "")).removeprefix("std")[:3]  # out, err or sta(tus)
+
+
+def _duration(seconds) -> str:
+    if not isinstance(seconds, (int, float)):
+        return ""
+    minutes, secs = divmod(int(seconds), 60)
+    hours, minutes = divmod(minutes, 60)
+    return f"{hours}h{minutes:02d}m" if hours else f"{minutes}m{secs:02d}s"
+
+
+def build(api: Valohai, allow_writes: bool = False) -> Server:
+    server = Server(
+        "valohai",
+        __version__,
+        "Valohai ML platform: projects, executions (runs of a step from valohai.yaml), their logs, metrics "
+        "(metadata) and outputs, and pipelines. Executions are identified by project and counter (#12).",
+        allow_writes,
+    )
+    project_arg = {"type": "string", "description": "Project name, owner/name or id"}
+    counter_arg = {"type": "integer", "description": "The execution's counter (the #number in Valohai)"}
+
+    @server.tool(
+        "list_projects",
+        "List the Valohai projects you can see, with their execution counts.",
+        {"name_contains": {"type": "string", "description": "Only projects whose name contains this"}},
+    )
+    def list_projects(name_contains: str = "") -> str:
+        projects = [
+            p for p in api.all("projects/", {}, 1000) if name_contains.lower() in str(p.get("name", "")).lower()
+        ]
+        if not projects:
+            return "No projects."
+        lines = []
+        for p in projects:
+            owner = (p.get("owner") or {}).get("username", "")
+            name = f"{owner}/{p.get('name')}" if owner else str(p.get("name"))
+            lines.append(
+                f"{name}  id={p.get('id')}  executions={p.get('execution_count', '?')}"
+                f"  last run {_when(p.get('last_execution_ctime')) or 'never'}"
+            )
+        return "\n".join(lines)
+
+    @server.tool(
+        "list_executions",
+        "List a project's executions, newest first: counter, status, step, duration, and the error for failed ones.",
+        {
+            "project": project_arg,
+            "status": {"type": "string", "enum": ["queued", "started", "completed", "error", "stopped", "crashed"]},
+            "limit": {"type": "integer", "description": "How many (default 20, at most 200)"},
+        },
+        ["project"],
+    )
+    def list_executions(project: str, status: str = "", limit: int = 20) -> str:
+        p = api.project(project)
+        params = {"project": p["id"], "ordering": "-counter"}
+        if status:
+            params["status"] = status
+        executions = api.all("executions/", params, max(1, min(int(limit), 200)))
+        if not executions:
+            return "No executions."
+        lines = []
+        for e in executions:
+            line = (
+                f"#{e.get('counter')} {e.get('status')}  step={e.get('step')}  "
+                f"{_duration(e.get('duration'))}  {_when(e.get('ctime'))}"
+            )
+            if e.get("error_text"):
+                line += f"\n    error: {e['error_text'][:300]}"
+            lines.append(line)
+        return "\n".join(lines)
+
+    @server.tool(
+        "get_execution",
+        "One execution: status, step, commit, parameters, inputs, latest metrics (metadata), outputs and link.",
+        {"project": project_arg, "counter": counter_arg},
+        ["project", "counter"],
+    )
+    def get_execution(project: str, counter: int) -> str:
+        e = api.execution(project, counter)
+        commit = e.get("commit")
+        commit = commit.get("identifier") if isinstance(commit, dict) else commit
+        outputs = [o.get("name") for o in e.get("outputs") or [] if isinstance(o, dict)]
+        parts = [
+            f"#{e.get('counter')} {e.get('status')}  step={e.get('step')}  commit={commit}",
+            f"started {_when(e.get('ctime'))}  duration {_duration(e.get('duration'))}",
+            f"link: {(e.get('urls') or {}).get('display', '')}",
+        ]
+        if e.get("error_text"):
+            parts.append(f"error: {e['error_text']}")
+        for key in ("parameters", "inputs", "cumulative_metadata"):
+            if e.get(key):
+                label = "metrics (latest values)" if key == "cumulative_metadata" else key
+                parts.append(f"{label}: {json.dumps(e[key], indent=1, default=str)}")
+        if outputs:
+            parts.append(f"outputs ({len(outputs)}): {', '.join(outputs[:50])}")
+        return "\n".join(parts)
+
+    @server.tool(
+        "get_execution_logs",
+        "The last lines of an execution's log (stdout and stderr, with timestamps).",
+        {
+            "project": project_arg,
+            "counter": counter_arg,
+            "limit": {"type": "integer", "description": "How many lines (default 200, at most 2000)"},
+            "stream": {"type": "string", "enum": ["stdout", "stderr", "status"], "description": "Only this stream"},
+        },
+        ["project", "counter"],
+    )
+    def get_execution_logs(project: str, counter: int, limit: int = 200, stream: str = "") -> str:
+        e = api.execution(project, counter)
+        data = api.request("GET", f"{e['url'].rstrip('/')}/events/", params={"limit": max(1, min(int(limit), 2000))})
+        fetched = data.get("events") or []
+        events = [ev for ev in fetched if not stream or ev.get("stream") == stream]
+        if not events:
+            return "No log lines."
+        lines = [
+            f"{str(ev.get('time', ''))[11:19]} {_stream(ev)} {str(ev.get('message', '')).rstrip()}" for ev in events
+        ]
+        if data.get("truncated"):
+            only = f", {stream} only" if stream else ""
+            lines.insert(0, f"(from the last {len(fetched)} of {data.get('total', '?')} lines{only})")
+        return "\n".join(lines)
+
+    @server.tool(
+        "list_outputs",
+        "The files an execution produced (datums), with sizes and their datum:// URIs for use as inputs.",
+        {"project": project_arg, "counter": counter_arg},
+        ["project", "counter"],
+    )
+    def list_outputs(project: str, counter: int) -> str:
+        e = api.execution(project, counter)
+        outputs = api.all("data/", {"output_execution": e["id"]}, 500)
+        if not outputs:
+            return "No outputs."
+        return "\n".join(f"{o.get('name')}  {o.get('size', '?')} bytes  datum://{o.get('id')}" for o in outputs)
+
+    @server.tool(
+        "compare_executions",
+        "Compare the latest metrics (metadata) and parameters of several executions side by side.",
+        {
+            "project": project_arg,
+            "counters": {"type": "array", "items": {"type": "integer"}, "description": "Execution counters, 2 to 20"},
+        },
+        ["project", "counters"],
+    )
+    def compare_executions(project: str, counters: list) -> str:
+        if not 1 < len(counters) <= 20:
+            raise ToolFailure("give 2 to 20 execution counters")
+        rows = []
+        for counter in counters:
+            e = api.execution(project, int(counter))
+            rows.append((counter, e.get("status"), e.get("parameters") or {}, e.get("cumulative_metadata") or {}))
+        keys = sorted({k for _, _, _, m in rows for k in m})
+        params = sorted({k for _, _, p, _ in rows for k in p if len({json.dumps(r[2].get(k)) for r in rows}) > 1})
+        header = ["execution", "status", *params, *keys]
+        lines = ["\t".join(header)]
+        for counter, status, p, m in rows:
+            lines.append(
+                "\t".join(
+                    [
+                        f"#{counter}",
+                        str(status),
+                        *(str(p.get(k, "")) for k in params),
+                        *(str(m.get(k, "")) for k in keys),
+                    ]
+                )
+            )
+        return "\n".join(lines) + ("\n(only parameters that differ are shown)" if params else "")
+
+    @server.tool(
+        "list_pipelines",
+        "List a project's pipelines, newest first, with their status.",
+        {"project": project_arg, "limit": {"type": "integer", "description": "How many (default 20)"}},
+        ["project"],
+    )
+    def list_pipelines(project: str, limit: int = 20) -> str:
+        p = api.project(project)
+        pipelines = api.all("pipelines/", {"project": p["id"], "ordering": "-counter"}, max(1, min(int(limit), 200)))
+        if not pipelines:
+            return "No pipelines."
+        return "\n".join(
+            f"={pl.get('counter')} {pl.get('status')}  {pl.get('title') or ''}  {_when(pl.get('ctime'))}"
+            for pl in pipelines
+        )
+
+    @server.tool(
+        "start_execution",
+        "Start an execution of a step defined in the project's valohai.yaml.",
+        {
+            "project": project_arg,
+            "step": {"type": "string", "description": "The step's name in valohai.yaml"},
+            "commit": {"type": "string", "description": "The commit to run (as Valohai knows it, e.g. a git SHA)"},
+            "parameters": {"type": "object", "description": "Parameter values, by name"},
+            "inputs": {"type": "object", "description": "Input URLs or datum:// URIs, by input name (lists allowed)"},
+            "title": {"type": "string"},
+        },
+        ["project", "step", "commit"],
+        writes=True,
+    )
+    def start_execution(
+        project: str,
+        step: str,
+        commit: str,
+        parameters: dict | None = None,
+        inputs: dict | None = None,
+        title: str = "",
+    ) -> str:
+        p = api.project(project)
+        payload = {"project": p["id"], "step": step, "commit": commit, "parameters": parameters or {}}
+        if inputs:
+            payload["inputs"] = {k: v if isinstance(v, list) else [v] for k, v in inputs.items()}
+        if title:
+            payload["title"] = title
+        e = api.request("POST", "executions/", json=payload)
+        return f"Started execution #{e.get('counter')} ({e.get('status')}): {(e.get('urls') or {}).get('display', '')}"
+
+    @server.tool(
+        "stop_execution",
+        "Stop a queued or running execution.",
+        {"project": project_arg, "counter": counter_arg},
+        ["project", "counter"],
+        writes=True,
+    )
+    def stop_execution(project: str, counter: int) -> str:
+        e = api.execution(project, counter)
+        stop = (e.get("urls") or {}).get("stop")
+        if not stop:
+            raise ToolFailure(f"execution #{counter} can't be stopped (status {e.get('status')})")
+        api.request("POST", stop)
+        return f"Asked Valohai to stop execution #{counter}."
+
+    return server
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(prog="lcode-mcp-valohai", description="MCP server for Valohai (stdio).")
+    parser.add_argument("--allow-writes", action="store_true", help="also offer starting and stopping executions")
+    args = parser.parse_args(argv)
+    token = os.environ.get("VALOHAI_TOKEN") or os.environ.get("VH_API_TOKEN")
+    if not token:
+        parser.error("set VALOHAI_TOKEN to a Valohai API token (My Profile > Authentication)")
+    api = Valohai(os.environ.get("VALOHAI_HOST") or DEFAULT_HOST, token)
+    build(api, args.allow_writes).serve()
+
+
+if __name__ == "__main__":
+    main()

{lcode_cli-0.10.0.dist-info → lcode_cli-0.11.0.dist-info}/METADATA

@@ -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.dist-info → lcode_cli-0.11.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lcode/__init__.py,sha256=Vt4u1brdsy5UMBysZVsHXtLIwN6S7GISlXj5GAGQI1w,118
+lcode/__init__.py,sha256=i-okekpLRmfoVYVspTCLPm0ObNE0H6AiUYLOm67-GZM,118
 lcode/__main__.py,sha256=s5N5pryX2FAu93GGZ3FxUrIXHWGzxz66lKUoaV_h8Ws,35
 lcode/agent.py,sha256=5vSYZYFg-5doSF1yx3YRWI8hKSMCxPnSNzJiIwicY_8,40626
 lcode/bench.py,sha256=FCn94Gs7L8bpq4hzf6ILoQG8dKrbbd5WC4BRwrTp4LM,37950
@@ -25,17 +25,21 @@ lcode/vision.py,sha256=w33QPmdGwP33wM4mvmAH4amFDZ1xzeXhEsSLJ-STSHY,4243
 lcode/web.py,sha256=vyxKbSRJTl1Lj3hj7Yd_NwTgbv0Xi6dup2YfUXjqp-Y,14579
 lcode/mcp/__init__.py,sha256=XujtAmRoXW9S0uq1XPf_CAeCkHh_UvA8FCmoAKP9j1Y,171
 lcode/mcp/auth.py,sha256=vyH3oolgIBNJLYabr2h5Soui99NTY1QxjQEgtczfF6A,16655
-lcode/mcp/catalog.py,sha256=GnIF1fyeHSut9h2y_VJNAHc2FCJT81EIhLFM40V780k,3504
-lcode/mcp/catalog.toml,sha256=_kFzKD2FD78KD2URuE5B-kcQehW9Y3Zi2xf5tu3v4Xc,9230
+lcode/mcp/catalog.py,sha256=I_O10N7cBl0ZW6O7x2kwKn89pvEXUXODUh8FsPXnB-E,3790
+lcode/mcp/catalog.toml,sha256=1KYskueMO35cdBGZbMPF7hnrzyE01QN_xeqlF6oNmTc,11540
 lcode/mcp/client.py,sha256=3Gen7zRvWehngXn_dAMOAdKqFkFkQZIQW96hQcW4N4k,7119
 lcode/mcp/commands.py,sha256=mnp0G-GW5ZsARi2tkHuT3hl883sBGFUVRAV3AapA5oU,16478
 lcode/mcp/config.py,sha256=Ej6WX2b_55a84H5WdAwSk9DzERKoq5ifUBQ9uDgSG_o,8780
 lcode/mcp/http.py,sha256=sG9MajwU4_6sqvZhwD4WfyzRKzaR_Lc8C02jwePz18E,7380
 lcode/mcp/manager.py,sha256=79nNWoT5pxgoQD_Pv4ZH0obHIm7rQ-LyB8OmJnQgc6k,15104
 lcode/mcp/protocol.py,sha256=-xwhA2Tz-vzR2zdSdbPx4IjTu29uRrXMaePg0vEz_Vc,5223
+lcode/mcp/server.py,sha256=Ru6CEpaFoweB_RPgIUMwB147GHDjMvylxQ54s-fJQhw,6242
 lcode/mcp/stdio.py,sha256=kC6KHwzMMDjBr-yCZLmyVKS7PZXU299WpZdYRoX5eRQ,6292
-lcode_cli-0.10.0.dist-info/METADATA,sha256=qlFYNWlZjDePi7kqZ2JnRUVasJODV0Emqu6SDFhKvhI,11487
-lcode_cli-0.10.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-lcode_cli-0.10.0.dist-info/entry_points.txt,sha256=pZ_uDQ98UzVAHUQeXn5HeyQWKGSH3r3T5aPHuSB89eI,41
-lcode_cli-0.10.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
-lcode_cli-0.10.0.dist-info/RECORD,,
+lcode/servers/__init__.py,sha256=qrIhxEodEB8cjKEQ4Cicc0GsQhE2OH-9qlVHzr3-tq8,77
+lcode/servers/encord.py,sha256=FzOINlIbQ9woL-x88nOiuptOtIxvPqse5IroXkT39iE,12648
+lcode/servers/valohai.py,sha256=e5xZGIoa4cja4f5i85q1GpL9c7cglUjV8jN2co1CFMY,14430
+lcode_cli-0.11.0.dist-info/METADATA,sha256=OH_2_AWP3TysK3gUIkyWitRrcyfRm5jSNxrkMc60xWA,11549
+lcode_cli-0.11.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lcode_cli-0.11.0.dist-info/entry_points.txt,sha256=pMz2Byj2QRyt-ZZQYZvmWUtmKPCeE7f8iCvu-sjZPIo,133
+lcode_cli-0.11.0.dist-info/licenses/LICENSE,sha256=JWjmoL7nNIC1XUa-dZm2hwLUgjUQMFo6k8APb0idNzs,1074
+lcode_cli-0.11.0.dist-info/RECORD,,

lcode_cli-0.11.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+lcode = lcode.cli:main
+lcode-mcp-encord = lcode.servers.encord:main
+lcode-mcp-valohai = lcode.servers.valohai:main

lcode_cli-0.10.0.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-lcode = lcode.cli:main