mock-gkn-hpc 0.3.0__tar.gz

mock_gkn_hpc-0.3.0/.github/workflows/publish.yml

@@ -0,0 +1,53 @@
+name: Test and Publish
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Smoke import
+        run: uv run python -c "import mock_gkn_hpc; print(mock_gkn_hpc.__version__)"
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python
+        run: uv python install 3.14
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

mock_gkn_hpc-0.3.0/.gitignore

@@ -0,0 +1,13 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Mock HPC job artifacts
+runs/

mock_gkn_hpc-0.3.0/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "mock-gkn-hpc": {
+      "type": "stdio",
+      "command": "uv",
+      "args": ["run", "mock-gkn-hpc"]
+    }
+  }
+}

mock_gkn_hpc-0.3.0/.python-version

@@ -0,0 +1 @@
+3.14

mock_gkn_hpc-0.3.0/CLAUDE.md

@@ -0,0 +1,42 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Purpose
+
+A FastMCP server that **mocks** GKN's HPC for Ansys / Finite Element analysis. It is an external demo that lets clients exercise the full submit → poll → fetch-artifacts loop against a fake HPC, with no real solver, queue, or cluster behind it.
+
+## Architecture
+
+Packaged distribution under `src/mock_gkn_hpc/`. Single module `server.py` (~190 lines of FastMCP). The model is intentionally tiny:
+
+- **Filesystem is the state store.** No in-memory registry. `RUNS_DIR/<job_id>/` exists ⇒ job submitted; `results.rst` present ⇒ ready; older than `JOB_TTL_SECONDS` ⇒ expired. `_job_status()` derives status from directory + `results.rst` mtime — `log.txt` is *not* a readiness sentinel because it's created at submit time and grown during the run.
+- **`RUNS_DIR` defaults to `gettempdir()/mock-gkn-hpc`.** Overridable via `--runs-dir` CLI flag or `MOCK_GKN_HPC_RUNS_DIR` env var. Set in `main()` before `mcp.run()` — the module-level `RUNS_DIR` is reassigned, so all tools/resources see the override.
+- **Async submit, streaming log, terminal results.** `submit_ansys_run` returns immediately with a `job_id` and two `ansys://...` URIs. A background `asyncio.create_task(_finish(job_id))` walks `LOG_SCHEDULE` (a list of `(sleep, line)` tuples summing to `MOCK_RUN_SECONDS = 30s`) appending each line to `log.txt`, then renders `results.rst` from `src/mock_gkn_hpc/templates/results.rst.tmpl` with current date/time/job_id substituted in.
+- **Resources are templated**: `ansys://{job_id}/log` and `ansys://{job_id}/results`. The log resource serves whatever has been written so far — clients can poll it to watch progress mid-run. The results resource 404s ("not found or still running") until `_finish` writes it at t≈30s. Both self-delete + 404 when past TTL.
+- **`age_seconds` in `list_jobs` is intentionally inconsistent**: time-since-submit while pending (dir mtime), time-since-completion once ready (`results.rst` mtime). Not a bug — derives from the dir-vs-file state model.
+- `submit_ansys_run`'s `input_file` and `version` are part of the tool schema for client realism but unused by the mock.
+
+The `templates/` directory ships *inside* the wheel (`hatchling` includes everything under `src/mock_gkn_hpc/`), so `Path(__file__).parent / "templates"` resolves identically in editable and installed mode.
+
+## Dev workflow
+
+The server is registered via project-scoped `.mcp.json` as a stdio server invoking `uv run mock-gkn-hpc` (the entry-point script that `uv sync` installs in editable mode). Claude Code spawns it on connect; **after every edit to `server.py`, manually reconnect via `/mcp` in Claude Code** to pick up the change.
+
+Avoid `fastmcp call ... submit_ansys_run`: each call is a one-shot subprocess that exits before the 30s `_finish()` background task fires, leaving zombie pending jobs in `RUNS_DIR`. Either go through Claude Code (long-lived stdio session) or write a client that holds the connection open past `MOCK_RUN_SECONDS`.
+
+Useful commands:
+
+```bash
+uv sync                                      # editable install
+uv run mock-gkn-hpc --help                   # show CLI flags
+uv run mock-gkn-hpc                          # run the server over stdio
+uv build                                     # produce wheel + sdist in dist/
+uvx --from ./dist/mock_gkn_hpc-*.whl mock-gkn-hpc --help   # smoke-test the built wheel
+```
+
+No tests, no linter configured.
+
+## Gotchas
+
+- Python ≥ 3.14. Per global guidance, use 3.14 syntax — no `from typing import Optional/List/Dict`.

mock_gkn_hpc-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Pradas Gómez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mock_gkn_hpc-0.3.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: mock-gkn-hpc
+Version: 0.3.0
+Summary: Public MCP mock of GKN's internal HPC server for Ansys/FEA analysis
+Project-URL: Homepage, https://github.com/alex-pradas/mock-gkn-hpc
+Project-URL: Repository, https://github.com/alex-pradas/mock-gkn-hpc
+Author-email: Alejandro Pradas Gómez <alex@pradas.eu>
+License: MIT
+License-File: LICENSE
+Keywords: ansys,fastmcp,fea,gkn,hpc,mcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.14
+Requires-Dist: fastmcp>=3.2.4
+Description-Content-Type: text/markdown
+
+# mock-gkn-hpc
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18836517.svg)](https://doi.org/10.5281/zenodo.18836517)
+
+A public MCP **mock** of GKN's internal HPC server for Ansys / Finite Element analysis. It lets external clients exercise the full submit → poll → fetch-artifacts loop against a fake HPC — no real solver, queue, or cluster behind it.
+
+This is a sample MCP server developed alongside the DUCTILE agentic orchestration paper. See the [DUCTILE repository](https://github.com/alex-pradas/DUCTILE) or the paper (DOI: TBD) for context.
+
+## Install and run
+
+```bash
+uvx mock-gkn-hpc
+```
+
+Or wire it into your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "mock-gkn-hpc": {
+      "command": "uvx",
+      "args": ["mock-gkn-hpc"]
+    }
+  }
+}
+```
+
+Job artifacts default to a system tempdir (`gettempdir()/mock-gkn-hpc`). Override with `--runs-dir /custom/path` or the `MOCK_GKN_HPC_RUNS_DIR` env var.

mock_gkn_hpc-0.3.0/README.md

@@ -0,0 +1,28 @@
+# mock-gkn-hpc
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18836517.svg)](https://doi.org/10.5281/zenodo.18836517)
+
+A public MCP **mock** of GKN's internal HPC server for Ansys / Finite Element analysis. It lets external clients exercise the full submit → poll → fetch-artifacts loop against a fake HPC — no real solver, queue, or cluster behind it.
+
+This is a sample MCP server developed alongside the DUCTILE agentic orchestration paper. See the [DUCTILE repository](https://github.com/alex-pradas/DUCTILE) or the paper (DOI: TBD) for context.
+
+## Install and run
+
+```bash
+uvx mock-gkn-hpc
+```
+
+Or wire it into your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "mock-gkn-hpc": {
+      "command": "uvx",
+      "args": ["mock-gkn-hpc"]
+    }
+  }
+}
+```
+
+Job artifacts default to a system tempdir (`gettempdir()/mock-gkn-hpc`). Override with `--runs-dir /custom/path` or the `MOCK_GKN_HPC_RUNS_DIR` env var.

mock_gkn_hpc-0.3.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "mock-gkn-hpc"
+version = "0.3.0"
+description = "Public MCP mock of GKN's internal HPC server for Ansys/FEA analysis"
+readme = "README.md"
+requires-python = ">=3.14"
+license = { text = "MIT" }
+authors = [{ name = "Alejandro Pradas Gómez", email = "alex@pradas.eu" }]
+keywords = ["mcp", "ansys", "fea", "hpc", "fastmcp", "gkn"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = [
+    "fastmcp>=3.2.4",
+]
+
+[project.urls]
+Homepage = "https://github.com/alex-pradas/mock-gkn-hpc"
+Repository = "https://github.com/alex-pradas/mock-gkn-hpc"
+
+[project.scripts]
+mock-gkn-hpc = "mock_gkn_hpc.server:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mock_gkn_hpc"]

mock_gkn_hpc-0.3.0/src/mock_gkn_hpc/__init__.py

@@ -0,0 +1,4 @@
+"""Public MCP mock of GKN's internal HPC for Ansys / FEA analysis."""
+from importlib.metadata import version
+
+__version__ = version("mock-gkn-hpc")

mock_gkn_hpc-0.3.0/src/mock_gkn_hpc/server.py

@@ -0,0 +1,186 @@
+import argparse
+import asyncio
+import os
+import shutil
+import tempfile
+import time
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+from fastmcp import FastMCP
+from pydantic import FilePath
+
+mcp = FastMCP(
+    "HPC at GKN, external demo",
+    instructions="Simulates the HPC for Finite Elements analyisis at GKN",
+)
+
+DEFAULT_RUNS_DIR = Path(tempfile.gettempdir()) / "mock-gkn-hpc"
+RUNS_DIR = DEFAULT_RUNS_DIR
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+JOB_TTL_SECONDS = 3600
+MOCK_RUN_SECONDS = 30
+
+# (sleep_before_writing_seconds, line). Sleeps sum to MOCK_RUN_SECONDS.
+LOG_SCHEDULE: list[tuple[float, str]] = [
+    (0.0, "ANSYS Mechanical 2025R1 starting..."),
+    (0.2, "License: ANSYS Mechanical Enterprise -- checked out"),
+    (0.3, "Reading input file: model.cdb"),
+    (0.5, "Mesh statistics: 12847 nodes, 8432 elements, 38541 dofs"),
+    (0.5, "Material: Structural Steel (E=200 GPa, nu=0.30)"),
+    (0.5, "Boundary conditions: 1 fixed support, 2 force loads"),
+    (0.5, ""),
+    (0.0, "--- SOLUTION ---"),
+    (0.5, "Solver: Sparse Direct"),
+    (0.5, "Reordering equations (METIS)..."),
+    (1.0, "Equation reordering complete; matrix non-zeros = 1.84M, factor non-zeros = 8.2M"),
+    (1.0, "Symbolic factorization..."),
+    (2.0, "Numeric factorization (LDL^T)..."),
+    (5.0, "Factor complete; peak memory = 412 MB"),
+    (2.0, "Forward/back substitution..."),
+    (4.0, "Solver complete; max residual = 4.21e-09"),
+    (2.0, "*** LOAD STEP 1 SUBSTEP 1 COMPLETED. CUM ITER = 1 ***"),
+    (2.0, ""),
+    (0.0, "--- POSTPROCESSING ---"),
+    (1.0, "Computing element results..."),
+    (2.0, "Max von Mises stress: 187.4 MPa @ node 4521"),
+    (1.0, "Max displacement: 0.842 mm @ node 9183"),
+    (1.0, "Reaction force at fixed support: (-2104.3, 8.2, -45.1) N"),
+    (1.0, "Writing results database..."),
+    (1.5, "Wrote results.rst"),
+    (0.5, "Solution complete. CPU time: 28.7s, elapsed: 30.1s"),
+]
+
+
+def _render_results(job_id: str, dst: Path) -> None:
+    tmpl = (TEMPLATES_DIR / "results.rst.tmpl").read_text()
+    now = datetime.now()
+    dst.write_text(tmpl.format(
+        run_date=now.strftime("%Y-%m-%d"),
+        run_time=now.strftime("%H:%M:%S"),
+        job_id=job_id,
+    ))
+
+
+async def _finish(job_id: str) -> None:
+    job_dir = RUNS_DIR / job_id
+    job_dir.mkdir(parents=True, exist_ok=True)
+    log = job_dir / "log.txt"
+    log.write_text("")
+    for delay, line in LOG_SCHEDULE:
+        if delay:
+            await asyncio.sleep(delay)
+        with log.open("a") as f:
+            f.write(line + "\n")
+    _render_results(job_id, job_dir / "results.rst")
+
+
+def _job_status(job_dir: Path) -> tuple[str, float]:
+    results = job_dir / "results.rst"
+    if not results.exists():
+        return "pending", time.time() - job_dir.stat().st_mtime
+    age = time.time() - results.stat().st_mtime
+    if age > JOB_TTL_SECONDS:
+        return "expired", age
+    return "ready", age
+
+
+@mcp.tool
+async def submit_ansys_run(
+    input_file: FilePath,
+    version: str = "2025r1",
+) -> dict:
+    """Submits run to HPC. Returns immediately; log and results become
+    available at the returned URIs after ~30s. Resources expire after 1h."""
+    job_id = uuid.uuid4().hex[:8]
+    (RUNS_DIR / job_id).mkdir(parents=True, exist_ok=True)
+    asyncio.create_task(_finish(job_id))
+    return {
+        "status": "submitted",
+        "job_id": job_id,
+        "log_uri": f"ansys://{job_id}/log",
+        "results_uri": f"ansys://{job_id}/results",
+    }
+
+
+@mcp.tool
+def status() -> str:
+    return "online"
+
+
+@mcp.tool
+def list_jobs() -> list[dict]:
+    """Lists every submitted job with its current status (pending/ready/expired) and age in seconds."""
+    if not RUNS_DIR.exists():
+        return []
+    jobs = []
+    for job_dir in sorted(RUNS_DIR.iterdir()):
+        if not job_dir.is_dir():
+            continue
+        st, age = _job_status(job_dir)
+        jobs.append({
+            "job_id": job_dir.name,
+            "status": st,
+            "age_seconds": round(age, 1),
+            "log_uri": f"ansys://{job_dir.name}/log",
+            "results_uri": f"ansys://{job_dir.name}/results",
+        })
+    return jobs
+
+
+@mcp.tool
+def delete_results() -> dict:
+    """Deletes every job's log and results files."""
+    if not RUNS_DIR.exists():
+        return {"deleted": 0}
+    count = sum(1 for p in RUNS_DIR.iterdir() if p.is_dir())
+    shutil.rmtree(RUNS_DIR)
+    return {"deleted": count}
+
+
+def _read_artifact(job_id: str, name: str) -> str:
+    path = RUNS_DIR / job_id / name
+    if not path.exists():
+        raise ValueError(f"Job {job_id} {name}: not found or still running.")
+    if time.time() - path.stat().st_mtime > JOB_TTL_SECONDS:
+        path.unlink(missing_ok=True)
+        raise ValueError(f"Job {job_id} {name}: expired.")
+    return path.read_text()
+
+
+@mcp.resource("ansys://{job_id}/log")
+def ansys_log(job_id: str) -> str:
+    return _read_artifact(job_id, "log.txt")
+
+
+@mcp.resource("ansys://{job_id}/results")
+def ansys_results(job_id: str) -> str:
+    return _read_artifact(job_id, "results.rst")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Public MCP mock of GKN's HPC for Ansys/FEA analysis"
+    )
+    parser.add_argument(
+        "--runs-dir",
+        type=Path,
+        default=None,
+        help=f"Where to store job artifacts (default: {DEFAULT_RUNS_DIR})",
+    )
+    args = parser.parse_args()
+
+    runs = args.runs_dir
+    if runs is None:
+        env = os.environ.get("MOCK_GKN_HPC_RUNS_DIR")
+        runs = Path(env) if env else DEFAULT_RUNS_DIR
+
+    global RUNS_DIR
+    RUNS_DIR = runs
+
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

mock_gkn_hpc-0.3.0/src/mock_gkn_hpc/templates/results.rst.tmpl

@@ -0,0 +1,28 @@
+ANSYS RESULTS FILE (.rst) - text mock
+=====================================
+Run date:  {run_date}
+Run time:  {run_time}
+Job ID:    {job_id}
+Solver:    Sparse Direct
+Analysis:  Linear Static
+
+Summary
+-------
+Nodes:                12847
+Elements:             8432
+DOF:                  38541
+Load steps:           1
+Substeps:             1
+
+Maximum results
+---------------
+von Mises stress:     187.4 MPa  (node 4521)
+Displacement:         0.842 mm   (node 9183)
+Reaction force:       (-2104.3, 8.2, -45.1) N
+
+Solver
+------
+Iterations:           1
+Final residual:       4.21e-09
+CPU time:             28.7 s
+Elapsed time:         30.1 s