synqtune-mcp 0.1.1__tar.gz

synqtune_mcp-0.1.1/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: synqtune-mcp
+Version: 0.1.1
+Summary: MCP server for SynqTune: check runs and comparison reports, estimate costs and launch fine-tuning pipelines in your own AWS account from your coding agent.
+Author: SynqTune
+Project-URL: Homepage, https://synqtune.com
+Project-URL: Documentation, https://synqtune.com/docs
+Project-URL: Repository, https://github.com/saurabh201153/SLM
+Project-URL: Changelog, https://synqtune.com/changelog
+Keywords: mcp,model-context-protocol,fine-tuning,small-language-models,llm,aws,claude-code
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<2,>=1.28
+Requires-Dist: httpx>=0.27
+
+# SynqTune MCP server
+
+Lets a coding agent (Claude Code, Cursor, Claude Desktop, or any MCP client) work with SynqTune: check runs, read comparison reports, estimate costs, and launch template pipelines in your own AWS account.
+
+## Setup
+
+1. In SynqTune, open **Settings → API tokens** and create a token. Tokens are read-only unless you tick **Can launch runs**.
+2. Add the server to your agent. You need [uv](https://docs.astral.sh/uv/) installed.
+
+**Claude Code**
+
+```sh
+claude mcp add synqtune \
+  --env SYNQTUNE_API_TOKEN=sqt_... \
+  --env SYNQTUNE_URL=https://synqtune.com \
+  -- uvx synqtune-mcp
+```
+
+**Other clients** (JSON config):
+
+```json
+{
+  "mcpServers": {
+    "synqtune": {
+      "command": "uvx",
+      "args": ["synqtune-mcp"],
+      "env": { "SYNQTUNE_API_TOKEN": "sqt_...", "SYNQTUNE_URL": "https://synqtune.com" }
+    }
+  }
+}
+```
+
+Without uv: `pip install synqtune-mcp` and use `synqtune-mcp` as the command. From a local checkout: `uvx --from ./mcp_server synqtune-mcp`.
+
+## Tools
+
+| Tool | What it does | Token needed |
+|---|---|---|
+| `list_templates` | Task templates, their inputs and the data format each expects | read |
+| `list_runs` | Recent runs with status and links | read |
+| `get_run` | One run's status, current step, error and evaluation summary | read |
+| `get_comparison_report` | Verdict against your current LLM, reasons, weakest labels or fields, worst examples | read |
+| `list_models` | Saved models and their versions | read |
+| `estimate_cost` | GPU cost per hour, per day and for a run; monthly API spend vs GPU serving | read |
+| `launch_pipeline` | Train a model from a template on data in S3 | launch |
+
+## Safety
+
+- `launch_pipeline` returns the plan and cost estimate first. It only starts a run when called again with `confirm=true`, so the agent has to show you the plan before anything is billed.
+- Runs use GPU instances in your AWS account, billed by AWS to you.
+- Provider API keys are never passed through the MCP server. A comparison with your current LLM uses the key saved in SynqTune under Settings → Provider keys.
+- Tokens can't create other tokens, read provider keys or change cloud accounts. Revoke a token in Settings and it stops working immediately.
+
+## Example
+
+> Train a ticket router on s3://my-bucket/tickets.jsonl with labels billing, refund, shipping, technical, and compare it with gpt-4.1-mini using our production prompt.
+
+The agent calls `launch_pipeline` without confirming, shows you the steps, the task instruction and the estimated cost, and launches once you agree. Later, ask "is the router ready to replace GPT?" and it reads the comparison report.
+
+## Development
+
+To release, bump `version` in `pyproject.toml` and push a tag `mcp-v<version>` (for example `mcp-v0.1.1`). The *Publish MCP server* workflow builds the package and publishes it to PyPI.
+
+Templates in `synqtune_mcp/templates.py` mirror `frontend/src/lib/task-templates.ts`; change both together. Tests: `python -m pytest tests/test_mcp_server.py` from the repository root.

synqtune_mcp-0.1.1/README.md

@@ -0,0 +1,64 @@
+# SynqTune MCP server
+
+Lets a coding agent (Claude Code, Cursor, Claude Desktop, or any MCP client) work with SynqTune: check runs, read comparison reports, estimate costs, and launch template pipelines in your own AWS account.
+
+## Setup
+
+1. In SynqTune, open **Settings → API tokens** and create a token. Tokens are read-only unless you tick **Can launch runs**.
+2. Add the server to your agent. You need [uv](https://docs.astral.sh/uv/) installed.
+
+**Claude Code**
+
+```sh
+claude mcp add synqtune \
+  --env SYNQTUNE_API_TOKEN=sqt_... \
+  --env SYNQTUNE_URL=https://synqtune.com \
+  -- uvx synqtune-mcp
+```
+
+**Other clients** (JSON config):
+
+```json
+{
+  "mcpServers": {
+    "synqtune": {
+      "command": "uvx",
+      "args": ["synqtune-mcp"],
+      "env": { "SYNQTUNE_API_TOKEN": "sqt_...", "SYNQTUNE_URL": "https://synqtune.com" }
+    }
+  }
+}
+```
+
+Without uv: `pip install synqtune-mcp` and use `synqtune-mcp` as the command. From a local checkout: `uvx --from ./mcp_server synqtune-mcp`.
+
+## Tools
+
+| Tool | What it does | Token needed |
+|---|---|---|
+| `list_templates` | Task templates, their inputs and the data format each expects | read |
+| `list_runs` | Recent runs with status and links | read |
+| `get_run` | One run's status, current step, error and evaluation summary | read |
+| `get_comparison_report` | Verdict against your current LLM, reasons, weakest labels or fields, worst examples | read |
+| `list_models` | Saved models and their versions | read |
+| `estimate_cost` | GPU cost per hour, per day and for a run; monthly API spend vs GPU serving | read |
+| `launch_pipeline` | Train a model from a template on data in S3 | launch |
+
+## Safety
+
+- `launch_pipeline` returns the plan and cost estimate first. It only starts a run when called again with `confirm=true`, so the agent has to show you the plan before anything is billed.
+- Runs use GPU instances in your AWS account, billed by AWS to you.
+- Provider API keys are never passed through the MCP server. A comparison with your current LLM uses the key saved in SynqTune under Settings → Provider keys.
+- Tokens can't create other tokens, read provider keys or change cloud accounts. Revoke a token in Settings and it stops working immediately.
+
+## Example
+
+> Train a ticket router on s3://my-bucket/tickets.jsonl with labels billing, refund, shipping, technical, and compare it with gpt-4.1-mini using our production prompt.
+
+The agent calls `launch_pipeline` without confirming, shows you the steps, the task instruction and the estimated cost, and launches once you agree. Later, ask "is the router ready to replace GPT?" and it reads the comparison report.
+
+## Development
+
+To release, bump `version` in `pyproject.toml` and push a tag `mcp-v<version>` (for example `mcp-v0.1.1`). The *Publish MCP server* workflow builds the package and publishes it to PyPI.
+
+Templates in `synqtune_mcp/templates.py` mirror `frontend/src/lib/task-templates.ts`; change both together. Tests: `python -m pytest tests/test_mcp_server.py` from the repository root.

synqtune_mcp-0.1.1/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "synqtune-mcp"
+version = "0.1.1"
+description = "MCP server for SynqTune: check runs and comparison reports, estimate costs and launch fine-tuning pipelines in your own AWS account from your coding agent."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "SynqTune" }]
+keywords = ["mcp", "model-context-protocol", "fine-tuning", "small-language-models", "llm", "aws", "claude-code"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+  "mcp>=1.28,<2",
+  "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://synqtune.com"
+Documentation = "https://synqtune.com/docs"
+Repository = "https://github.com/saurabh201153/SLM"
+Changelog = "https://synqtune.com/changelog"
+
+[project.scripts]
+synqtune-mcp = "synqtune_mcp.server:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["synqtune_mcp"]

synqtune_mcp-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

synqtune_mcp-0.1.1/synqtune_mcp/__init__.py

@@ -0,0 +1 @@
+"""SynqTune MCP server."""

synqtune_mcp-0.1.1/synqtune_mcp/__main__.py

@@ -0,0 +1,3 @@
+from synqtune_mcp.server import main
+
+main()

synqtune_mcp-0.1.1/synqtune_mcp/server.py

@@ -0,0 +1,317 @@
+"""
+SynqTune MCP server: lets a coding agent (Claude Code, Cursor, ...) check runs and comparison reports, estimate
+costs, and launch template pipelines in the user's own AWS account.
+
+Configuration (environment):
+  SYNQTUNE_API_TOKEN  personal API token from Settings > API tokens (read-only by default)
+  SYNQTUNE_URL        SynqTune web address, default https://synqtune.com
+
+Launching spends money in the user's AWS account, so launch_pipeline only starts a run when called with
+confirm=true after showing the plan and cost estimate, and needs a token created with "Can launch runs".
+"""
+import os
+import re
+from typing import Any, Dict, List, Optional
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+from synqtune_mcp.templates import PLUGINS, TEMPLATES
+
+SOURCE_EXTENSIONS = (".jsonl", ".json", ".csv", ".tsv", ".parquet", ".txt")
+DEFAULT_INSTANCE = "g4dn.xlarge"
+PROVIDERS = ("anthropic", "openai", "gemini")
+
+mcp = FastMCP("synqtune")
+
+
+# ---------------------------------------------------------------- API client
+
+class ApiError(Exception):
+    pass
+
+
+class SynqTuneClient:
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None, transport: Optional[httpx.BaseTransport] = None):
+        self.base_url = (base_url or os.environ.get("SYNQTUNE_URL") or "https://synqtune.com").rstrip("/")
+        self.token = token if token is not None else os.environ.get("SYNQTUNE_API_TOKEN", "")
+        self._http = httpx.Client(base_url=f"{self.base_url}/api/v1", timeout=30, transport=transport)
+
+    def run_url(self, run_id: str) -> str:
+        return f"{self.base_url}/monitor/{run_id}"
+
+    def request(self, method: str, path: str, json: Any = None, params: Optional[Dict] = None) -> Any:
+        if not self.token:
+            raise ApiError("SYNQTUNE_API_TOKEN is not set. Create a token under Settings > API tokens in SynqTune.")
+        res = self._http.request(method, path, json=json, params=params, headers={"Authorization": f"Bearer {self.token}"})
+        if res.status_code >= 400:
+            try:
+                detail = res.json().get("detail")
+            except ValueError:
+                detail = res.text[:300]
+            raise ApiError(f"SynqTune returned {res.status_code}: {detail}")
+        return res.json() if res.content else None
+
+
+_client: Optional[SynqTuneClient] = None
+
+
+def client() -> SynqTuneClient:
+    global _client
+    if _client is None:
+        _client = SynqTuneClient()
+    return _client
+
+
+# ---------------------------------------------------------------- planning (pure, tested)
+
+def schema_defaults(plugin: Optional[Dict]) -> Dict[str, Any]:
+    """Default settings of a plugin from its form schema, as the builder applies them."""
+    import json as _json
+
+    try:
+        fields = _json.loads((plugin or {}).get("ui_schema") or "[]")
+    except ValueError:
+        return {}
+    return {f["name"]: f["default"] for f in fields if isinstance(f, dict) and f.get("default") is not None and f.get("type") != "file"}
+
+
+def estimate_minutes(template_id: str, train: Dict, compare: bool) -> float:
+    """Same rough estimate as the builder: start-up and installs, training steps, evaluation, optional comparison."""
+    steps = float(train.get("max_steps") or 60)
+    batch = float(train.get("batch_size") or 2)
+    minutes = 12 + steps * 0.4 * batch / 60 + 2 + 100 * 0.3 / 60
+    if compare:
+        minutes += 300 * (3 if template_id == "summarization" else 0.8) / 60
+    minutes += 2  # one preparation step (deduplication)
+    return minutes
+
+
+def build_plan(template_id: str, source_uri: str, inputs: Optional[Dict[str, str]], run_name: str, instance: str,
+               compare_provider: str, compare_model: str, compare_prompt: str, plugins: List[Dict], instances: List[Dict]) -> Dict:
+    """Validates the request and builds the pipeline config the builder would build for this template."""
+    template = TEMPLATES.get(template_id)
+    if not template:
+        raise ApiError(f"Unknown template '{template_id}'. Use one of: {', '.join(TEMPLATES)}.")
+    problems: List[str] = []
+    if not re.match(r"^s3://[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]/.+", source_uri or ""):
+        problems.append("source_uri must be a full S3 path, e.g. s3://bucket/folder/data.jsonl")
+    elif not source_uri.split("?")[0].lower().endswith(SOURCE_EXTENSIONS):
+        problems.append(f"source_uri must end with one of: {', '.join(SOURCE_EXTENSIONS)}")
+    values = template.resolve_inputs(inputs)
+    problems += template.problems(values)
+    if compare_provider and compare_provider not in PROVIDERS:
+        problems.append(f"compare_provider must be one of: {', '.join(PROVIDERS)}")
+    if compare_provider and not compare_model:
+        problems.append("compare_model is required when compare_provider is set")
+    if template_id == "summarization" and compare_provider:
+        problems.append("Comparing summaries needs an LLM judge, which is set up in the builder. Launch without a comparison, or use the builder.")
+    price = next((i for i in instances if i.get("id") == instance), None)
+    if not price or price.get("type") != "gpu":
+        gpus = ", ".join(i["id"] for i in instances if i.get("type") == "gpu")
+        problems.append(f"instance must be a GPU instance: {gpus}")
+    by_id = {p["id"]: p for p in plugins}
+    missing = [p for p in PLUGINS if p not in by_id]
+    if missing:
+        problems.append(f"SynqTune is missing plugins: {', '.join(missing)}")
+    if problems:
+        raise ApiError("Can't launch yet:\n- " + "\n- ".join(problems))
+
+    instruction = template.instruction(values)
+    train = {**schema_defaults(by_id["unsloth"]), **template.train}
+    evaluation = {
+        **schema_defaults(by_id["eval_holdout"]),
+        **template.evaluation,
+        **template.evaluation_from_inputs(values),
+        "compare_provider": compare_provider or "",
+        "compare_model": compare_model or "",
+        "compare_system_prompt": compare_prompt or "",
+        "compare_gpu_hourly_usd": price["on_demand_usd_per_hour"],
+    }
+    nodes = [
+        {"id": "node_source", "type": "source", "plugin": "s3", "config": {"source_uri": source_uri}},
+        {"id": "node_step_1", "type": "modification", "plugin": "deduplication", "config": schema_defaults(by_id["deduplication"])},
+        {"id": "node_train", "type": "training", "plugin": "unsloth", "config": {
+            **train, "task_instruction": instruction, "task_template": template_id, "task_inputs": values,
+            "test_split_pct": evaluation.get("test_split_pct", 10), "randomize_seed": evaluation.get("randomize_seed", True), "custom_eval_uri": "",
+        }},
+        {"id": "node_evaluate", "type": "evaluation", "plugin": "eval_holdout", "config": evaluation},
+        {"id": "node_publish", "type": "destination", "plugin": "checkpoint_tracker", "config": {
+            **schema_defaults(by_id["checkpoint_tracker"]), "save_as": "new", "model_name": run_name, "version": "1",
+        }},
+    ]
+    minutes = estimate_minutes(template_id, train, bool(compare_provider))
+    hourly = float(price["on_demand_usd_per_hour"])
+    return {
+        "template": template.title,
+        "task_instruction": instruction,
+        "steps": ["Load data (S3)", "Deduplicate", f"Fine-tune {train['base_model']} ({train['max_steps']} steps)",
+                  "Evaluate on held-out data" + (f", compared with {compare_provider}/{compare_model}" if compare_provider else ""),
+                  f"Save model '{run_name}' v1"],
+        "instance": instance,
+        "cost": {
+            "usd_per_hour": hourly,
+            "usd_per_day": round(hourly * 24, 2),
+            "estimated_minutes": round(minutes),
+            "estimated_usd": round(hourly * minutes / 60, 2),
+            "basis": "AWS on-demand list price in us-east-1, billed by AWS to your account; rough time estimate",
+        },
+        "pipeline_config": {"nodes": nodes, "task_template": template_id, "name": run_name},
+    }
+
+
+# ---------------------------------------------------------------- tools
+
+@mcp.tool()
+def list_templates() -> List[Dict]:
+    """Task templates a pipeline can start from, with the inputs each needs and the data format it expects."""
+    return [t.describe() for t in TEMPLATES.values()]
+
+
+@mcp.tool()
+def list_runs(status: str = "all", limit: int = 10) -> List[Dict]:
+    """Recent pipeline runs, newest first. status: all, running, completed, failed or cancelled."""
+    data = client().request("GET", "/pipeline/jobs", params={"status": status, "page_size": max(1, min(limit, 50))})
+    return [
+        {"id": j["id"], "name": j.get("name"), "type": j.get("job_type"), "status": j.get("status"),
+         "current_step": j.get("current_stage"), "created_at": j.get("created_at"), "url": client().run_url(j["id"])}
+        for j in data.get("jobs", [])
+    ]
+
+
+@mcp.tool()
+def get_run(run_id: str) -> Dict:
+    """Status of one run: current step, progress, error, and a summary of its evaluation and comparison."""
+    j = client().request("GET", f"/training/{run_id}/status")
+    ev = j.get("eval_metrics") or {}
+    parity = ev.get("parity") or {}
+    return {
+        "id": j.get("job_id"), "name": j.get("name"), "status": j.get("status"), "progress_pct": j.get("progress"),
+        "current_step": j.get("current_stage"), "details": j.get("stage_details"), "error": j.get("error_message"),
+        "started_at": j.get("started_at"), "completed_at": j.get("completed_at"), "output_uri": j.get("output_uri"),
+        "evaluation": {k: ev.get(k) for k in ("perplexity", "base_perplexity", "improvement_pct", "samples_evaluated", "held_out") if k in ev} or None,
+        "comparison_verdict": parity.get("verdict") if parity.get("status") == "ok" else parity.get("status"),
+        "url": client().run_url(run_id),
+    }
+
+
+@mcp.tool()
+def get_comparison_report(run_id: str) -> Dict:
+    """
+    The comparison between the fine-tuned model and the LLM it should replace: verdict (ready / close / not_ready),
+    reasons, scores, the weakest labels or fields, and the examples where the fine-tuned model was worse.
+    """
+    j = client().request("GET", f"/training/{run_id}/status")
+    parity = (j.get("eval_metrics") or {}).get("parity")
+    if not parity:
+        return {"status": "none", "message": "This run has no comparison. Add one in the Evaluate step (compare against your current LLM)."}
+    if parity.get("status") != "ok":
+        return {"status": parity.get("status"), "message": parity.get("message")}
+    breakdown = parity.get("breakdown") or {}
+    weakest = sorted(breakdown.get("rows") or [], key=lambda r: (r.get("slm") or 0) - (r.get("incumbent") or 0))[:5]
+    return {
+        "verdict": parity.get("verdict"), "reasons": parity.get("reasons"), "task": parity.get("task"), "metric": parity.get("metric"),
+        "examples_compared": parity.get("examples_compared"), "tolerance_pts": parity.get("tolerance_pts"),
+        "fine_tuned": parity.get("slm"), "incumbent": parity.get("incumbent"),
+        "metrics": parity.get("rows"), "weakest": {"by": breakdown.get("group"), "rows": weakest} if weakest else None,
+        "cost": parity.get("cost"), "failure_counts": parity.get("failure_counts"),
+        "failures": [{k: f.get(k) for k in ("kind", "prompt", "reference", "slm_answer", "incumbent_answer")} for f in (parity.get("failures") or [])[:5]],
+        "url": client().run_url(run_id),
+    }
+
+
+@mcp.tool()
+def list_models() -> List[Dict]:
+    """Saved models with their latest and production versions."""
+    rows = client().request("GET", "/model-registry")
+    out = []
+    for m in rows or []:
+        latest, prod = m.get("latest") or {}, m.get("production") or {}
+        out.append({
+            "id": m.get("id"), "name": m.get("name"), "versions": m.get("version_count"), "base_models": m.get("base_models"),
+            "latest_version": latest.get("version_number"), "latest_status": latest.get("status"),
+            "latest_comparison_verdict": (latest.get("eval") or {}).get("parity_verdict"),
+            "production_version": prod.get("version_number"),
+        })
+    return out
+
+
+@mcp.tool()
+def estimate_cost(template: str = "classification", instance: str = DEFAULT_INSTANCE, with_comparison: bool = False,
+                  monthly_requests: Optional[float] = None, input_tokens: Optional[float] = None, output_tokens: Optional[float] = None,
+                  price_in_per_mtok: Optional[float] = None, price_out_per_mtok: Optional[float] = None,
+                  serving_hours_per_day: float = 24) -> Dict:
+    """
+    GPU cost of a training run (per hour, per day, rough total for the run) and, if you give current LLM usage and
+    prices, the monthly API spend vs serving the model on the same GPU.
+    """
+    instances = client().request("GET", "/cluster/instances")
+    price = next((i for i in instances if i.get("id") == instance), None)
+    if not price:
+        raise ApiError(f"Unknown instance '{instance}'. GPU instances: {', '.join(i['id'] for i in instances if i.get('type') == 'gpu')}")
+    t = TEMPLATES.get(template)
+    if not t:
+        raise ApiError(f"Unknown template '{template}'. Use one of: {', '.join(TEMPLATES)}.")
+    hourly = float(price["on_demand_usd_per_hour"])
+    minutes = estimate_minutes(template, t.train, with_comparison)
+    out: Dict[str, Any] = {
+        "instance": instance, "usd_per_hour": hourly, "usd_per_day": round(hourly * 24, 2),
+        "training_run": {"estimated_minutes": round(minutes), "estimated_usd": round(hourly * minutes / 60, 2)},
+        "basis": "AWS on-demand list price in us-east-1; spot and your discounts are lower. The time is a rough estimate.",
+    }
+    if None not in (monthly_requests, input_tokens, output_tokens, price_in_per_mtok, price_out_per_mtok):
+        api = monthly_requests * (input_tokens * price_in_per_mtok + output_tokens * price_out_per_mtok) / 1e6
+        serving = hourly * min(24, serving_hours_per_day) * 30
+        out["monthly"] = {
+            "current_api_usd": round(api, 2), "gpu_serving_usd": round(serving, 2), "difference_usd": round(api - serving, 2),
+            "tokens_no_longer_sent": int(monthly_requests * (input_tokens + output_tokens)),
+            "note": "Quality is checked separately by the comparison report on your own data.",
+        }
+    return out
+
+
+@mcp.tool()
+def launch_pipeline(template: str, source_uri: str, run_name: str, inputs: Optional[Dict[str, str]] = None,
+                    instance: str = DEFAULT_INSTANCE, compare_provider: str = "", compare_model: str = "",
+                    compare_system_prompt: str = "", cloud_account_id: str = "", confirm: bool = False) -> Dict:
+    """
+    Train a model from a task template on data in S3, in the user's AWS account.
+
+    Without confirm=true this only returns the plan and cost estimate: show it to the user and call again with
+    confirm=true once they agree. Launching starts GPU instances billed to the user's AWS account.
+
+    inputs: the template's inputs (see list_templates), e.g. {"labels": "billing, refund, shipping"}.
+    compare_*: optionally compare with the LLM the model should replace (provider anthropic, openai or gemini).
+    The provider key must already be saved in SynqTune under Settings > Provider keys; keys are never passed here.
+    """
+    api = client()
+    plan = build_plan(template, source_uri, inputs, run_name.strip() or f"{template}-model", instance, compare_provider,
+                      compare_model, compare_system_prompt, api.request("GET", "/plugins"), api.request("GET", "/cluster/instances"))
+    summary = {k: plan[k] for k in ("template", "task_instruction", "steps", "instance", "cost")}
+    if not confirm:
+        return {"status": "plan", **summary,
+                "next": "Nothing has been launched. Show this plan and cost to the user; call again with confirm=true to start the run."}
+
+    accounts = api.request("GET", "/accounts") or []
+    account = next((a for a in accounts if a.get("id") == cloud_account_id), None) if cloud_account_id else (accounts[0] if accounts else None)
+    if not account:
+        raise ApiError("No connected AWS account found. Connect one in SynqTune first." if not cloud_account_id else f"Cloud account '{cloud_account_id}' not found.")
+    config = plan["pipeline_config"]
+    for node in config["nodes"]:
+        if node["type"] in ("source", "training", "destination"):
+            node["config"]["cloud_account_id"] = account["id"]
+    project = api.request("POST", "/projects", json={"name": run_name, "description": f"{plan['template']} pipeline (launched via MCP)"})
+    launched = api.request("POST", "/pipeline/launch", json={
+        "project_id": project["id"], "name": run_name, "job_type": "training", "cloud_account_id": account["id"],
+        "pipeline_config": {**config, "cloud_account_id": account["id"]},
+        "cluster_config": {"machine_type": instance, "storage_gb": 100, "provider": "aws", "accelerator_type": "gpu"},
+    })
+    return {"status": "launched", "run_id": launched["job_id"], "url": api.run_url(launched["job_id"]), "aws_account": account.get("name"), **summary}
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

synqtune_mcp-0.1.1/synqtune_mcp/templates.py

@@ -0,0 +1,120 @@
+"""
+Task templates, mirroring frontend/src/lib/task-templates.ts so runs launched by an agent match runs from the
+builder: same steps, training defaults, task instruction and comparison settings. Change both together.
+"""
+import json
+import re
+from typing import Callable, Dict, List, Optional
+
+BASE_MODEL = "unsloth/gemma-2-2b-it"
+PLUGINS = ["s3", "deduplication", "unsloth", "eval_holdout", "checkpoint_tracker"]
+
+
+def split_list(value: str) -> List[str]:
+    return [v.strip() for v in re.split(r"[,\n]", value or "") if v.strip()]
+
+
+def _json_object_error(value: str) -> Optional[str]:
+    try:
+        parsed = json.loads(value)
+    except ValueError:
+        return "is not valid JSON"
+    return None if isinstance(parsed, dict) else "must be a JSON object"
+
+
+class Input:
+    def __init__(self, name: str, description: str, required: bool = False, default: str = "",
+                 check: Optional[Callable[[str], Optional[str]]] = None):
+        self.name, self.description, self.required, self.default, self.check = name, description, required, default, check
+
+
+class Template:
+    def __init__(self, id: str, title: str, summary: str, data: str, train: Dict, evaluation: Dict, inputs: List[Input],
+                 instruction: Callable[[Dict[str, str]], str], evaluation_from_inputs: Callable[[Dict[str, str]], Dict] = lambda v: {}):
+        self.id, self.title, self.summary, self.data = id, title, summary, data
+        self.train, self.evaluation, self.inputs = train, evaluation, inputs
+        self.instruction, self.evaluation_from_inputs = instruction, evaluation_from_inputs
+
+    def resolve_inputs(self, given: Optional[Dict[str, str]]) -> Dict[str, str]:
+        values = {i.name: i.default for i in self.inputs}
+        values.update({k: str(v) for k, v in (given or {}).items() if k in values})
+        return values
+
+    def problems(self, values: Dict[str, str]) -> List[str]:
+        out = []
+        for i in self.inputs:
+            value = (values.get(i.name) or "").strip()
+            if i.required and not value:
+                out.append(f"'{i.name}' is required: {i.description}")
+            elif value and i.check:
+                err = i.check(value)
+                if err:
+                    out.append(f"'{i.name}' {err}")
+        return out
+
+    def describe(self) -> Dict:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "summary": self.summary,
+            "data_format": self.data,
+            "inputs": [{"name": i.name, "required": i.required, "default": i.default or None, "description": i.description} for i in self.inputs],
+        }
+
+
+def _labels_check(v: str) -> Optional[str]:
+    return None if len(split_list(v)) >= 2 else "needs at least two comma-separated labels"
+
+
+TEMPLATES: Dict[str, Template] = {t.id: t for t in [
+    Template(
+        "classification", "Classification & routing", "Pick exactly one label for each input.",
+        "Each row: the input text (instruction or prompt column) and its label (output or response column).",
+        {"base_model": BASE_MODEL, "max_steps": 300, "learning_rate": "2e-4", "lora_r": 16, "lora_alpha": 16, "batch_size": 4},
+        {"compare_task": "classification", "compare_tolerance_pts": 2},
+        [Input("labels", "Comma-separated labels; every answer in the data must be one of them.", required=True, check=_labels_check)],
+        lambda v: f"Classify the input into exactly one of these labels: {', '.join(split_list(v['labels']))}. Reply with the label only.",
+        lambda v: {"compare_labels": ", ".join(split_list(v["labels"]))},
+    ),
+    Template(
+        "extraction", "Structured extraction", "Turn a document into JSON that matches your schema.",
+        "Each row: the document text, and the JSON object to extract as the answer.",
+        {"base_model": BASE_MODEL, "max_steps": 400, "learning_rate": "2e-4", "lora_r": 16, "lora_alpha": 16, "batch_size": 2},
+        {"compare_task": "extraction", "compare_tolerance_pts": 2},
+        [Input("schema", "JSON schema of the object to extract (required keys and property types are checked).", required=True, check=_json_object_error)],
+        lambda v: ("Extract the fields defined by this JSON schema from the input. Reply with a single JSON object only, "
+                   f"using null for fields that are not present.\n\nSchema:\n{v['schema']}"),
+        lambda v: {"compare_json_schema": v["schema"]},
+    ),
+    Template(
+        "tagging", "Tagging", "Attach every tag that applies, zero or more per input.",
+        "Each row: the input text, and its tags as a comma-separated list or JSON array.",
+        {"base_model": BASE_MODEL, "max_steps": 300, "learning_rate": "2e-4", "lora_r": 16, "lora_alpha": 16, "batch_size": 4},
+        {"compare_task": "tagging", "compare_tolerance_pts": 3},
+        [Input("tags", "Optional comma-separated allowed tags; empty allows any tag in the data.")],
+        lambda v: ("List every tag that applies to the input"
+                   + (f", choosing only from: {', '.join(split_list(v['tags']))}" if split_list(v.get("tags", "")) else "")
+                   + '. Reply with a comma-separated list, or "none".'),
+    ),
+    Template(
+        "redaction", "Redaction", "Remove sensitive details and keep everything else.",
+        "Each row: the original text, and the same text with sensitive details replaced.",
+        {"base_model": BASE_MODEL, "max_steps": 400, "learning_rate": "2e-4", "lora_r": 16, "lora_alpha": 16, "batch_size": 2},
+        {"compare_task": "redaction", "compare_tolerance_pts": 1},
+        [Input("entities", "What to remove.", required=True, default="names, email addresses, phone numbers, postal addresses, account and card numbers"),
+         Input("placeholder", "Replacement text.", required=True, default="[REDACTED]")],
+        lambda v: f"Rewrite the input with all {v['entities']} replaced by {v['placeholder']}. Keep all other text exactly as it is.",
+    ),
+    Template(
+        "summarization", "Summarization", "Short, faithful summaries in your format.",
+        "Each row: the text to summarize, and a good summary written by a person.",
+        {"base_model": BASE_MODEL, "max_steps": 500, "learning_rate": "2e-4", "lora_r": 16, "lora_alpha": 16, "batch_size": 2},
+        # Preference gap runs from -100 to +100 points: 10 means preferred at least ~45% of the time
+        {"compare_task": "summarization", "compare_tolerance_pts": 10},
+        [Input("length", "Maximum length, e.g. '3 sentences'.", required=True, default="3 sentences"),
+         Input("focus", "Optional: what the summary should focus on.")],
+        lambda v: (f"Summarize the input in at most {v['length']}"
+                   + (f", focusing on {v['focus'].strip()}" if (v.get("focus") or "").strip() else "")
+                   + ". Use only facts from the input."),
+    ),
+]}

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/PKG-INFO

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: synqtune-mcp
+Version: 0.1.1
+Summary: MCP server for SynqTune: check runs and comparison reports, estimate costs and launch fine-tuning pipelines in your own AWS account from your coding agent.
+Author: SynqTune
+Project-URL: Homepage, https://synqtune.com
+Project-URL: Documentation, https://synqtune.com/docs
+Project-URL: Repository, https://github.com/saurabh201153/SLM
+Project-URL: Changelog, https://synqtune.com/changelog
+Keywords: mcp,model-context-protocol,fine-tuning,small-language-models,llm,aws,claude-code
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: mcp<2,>=1.28
+Requires-Dist: httpx>=0.27
+
+# SynqTune MCP server
+
+Lets a coding agent (Claude Code, Cursor, Claude Desktop, or any MCP client) work with SynqTune: check runs, read comparison reports, estimate costs, and launch template pipelines in your own AWS account.
+
+## Setup
+
+1. In SynqTune, open **Settings → API tokens** and create a token. Tokens are read-only unless you tick **Can launch runs**.
+2. Add the server to your agent. You need [uv](https://docs.astral.sh/uv/) installed.
+
+**Claude Code**
+
+```sh
+claude mcp add synqtune \
+  --env SYNQTUNE_API_TOKEN=sqt_... \
+  --env SYNQTUNE_URL=https://synqtune.com \
+  -- uvx synqtune-mcp
+```
+
+**Other clients** (JSON config):
+
+```json
+{
+  "mcpServers": {
+    "synqtune": {
+      "command": "uvx",
+      "args": ["synqtune-mcp"],
+      "env": { "SYNQTUNE_API_TOKEN": "sqt_...", "SYNQTUNE_URL": "https://synqtune.com" }
+    }
+  }
+}
+```
+
+Without uv: `pip install synqtune-mcp` and use `synqtune-mcp` as the command. From a local checkout: `uvx --from ./mcp_server synqtune-mcp`.
+
+## Tools
+
+| Tool | What it does | Token needed |
+|---|---|---|
+| `list_templates` | Task templates, their inputs and the data format each expects | read |
+| `list_runs` | Recent runs with status and links | read |
+| `get_run` | One run's status, current step, error and evaluation summary | read |
+| `get_comparison_report` | Verdict against your current LLM, reasons, weakest labels or fields, worst examples | read |
+| `list_models` | Saved models and their versions | read |
+| `estimate_cost` | GPU cost per hour, per day and for a run; monthly API spend vs GPU serving | read |
+| `launch_pipeline` | Train a model from a template on data in S3 | launch |
+
+## Safety
+
+- `launch_pipeline` returns the plan and cost estimate first. It only starts a run when called again with `confirm=true`, so the agent has to show you the plan before anything is billed.
+- Runs use GPU instances in your AWS account, billed by AWS to you.
+- Provider API keys are never passed through the MCP server. A comparison with your current LLM uses the key saved in SynqTune under Settings → Provider keys.
+- Tokens can't create other tokens, read provider keys or change cloud accounts. Revoke a token in Settings and it stops working immediately.
+
+## Example
+
+> Train a ticket router on s3://my-bucket/tickets.jsonl with labels billing, refund, shipping, technical, and compare it with gpt-4.1-mini using our production prompt.
+
+The agent calls `launch_pipeline` without confirming, shows you the steps, the task instruction and the estimated cost, and launches once you agree. Later, ask "is the router ready to replace GPT?" and it reads the comparison report.
+
+## Development
+
+To release, bump `version` in `pyproject.toml` and push a tag `mcp-v<version>` (for example `mcp-v0.1.1`). The *Publish MCP server* workflow builds the package and publishes it to PyPI.
+
+Templates in `synqtune_mcp/templates.py` mirror `frontend/src/lib/task-templates.ts`; change both together. Tests: `python -m pytest tests/test_mcp_server.py` from the repository root.

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+synqtune_mcp/__init__.py
+synqtune_mcp/__main__.py
+synqtune_mcp/server.py
+synqtune_mcp/templates.py
+synqtune_mcp.egg-info/PKG-INFO
+synqtune_mcp.egg-info/SOURCES.txt
+synqtune_mcp.egg-info/dependency_links.txt
+synqtune_mcp.egg-info/entry_points.txt
+synqtune_mcp.egg-info/requires.txt
+synqtune_mcp.egg-info/top_level.txt

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+synqtune-mcp = synqtune_mcp.server:main

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/requires.txt

@@ -0,0 +1,2 @@
+mcp<2,>=1.28
+httpx>=0.27

synqtune_mcp-0.1.1/synqtune_mcp.egg-info/top_level.txt

@@ -0,0 +1 @@
+synqtune_mcp