tuning-engines-cli

# Tuning Engines CLI & MCP Server

[![tuning-engines-cli MCP server](https://glama.ai/mcp/servers/cerebrixos-org/tuning-engines-cli/badges/card.svg)](https://glama.ai/mcp/servers/cerebrixos-org/tuning-engines-cli)

[![npm version](https://img.shields.io/npm/v/tuningengines-cli.svg)](https://www.npmjs.com/package/tuningengines-cli)
[![MCP Registry](https://img.shields.io/badge/MCP_Registry-tuning--engines-blue)](https://registry.modelcontextprotocol.io)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

Govern every AI workflow through one API.

**[Tuning Engines](https://tuningengines.com)** is a governed AI runtime for model, agent, skill, and MCP workflows. Route inference through one OpenAI-compatible API, apply RBAC and traffic policies, request approvals for high-risk actions, inspect traces and usage, and connect durable orchestration frameworks such as LangGraph and Temporal. The same CLI and MCP server also manage domain-specific fine-tuning of open-source models.

## Training Agents

Tuning Engines uses specialized **agents** that control how your data is analyzed and converted into training data. Each agent produces a different kind of domain-specific fine-tuned model optimized for its use case. Current agents focus on code, with more coming for customer support, data extraction, security review, ops, and other domains.

### Cody (`code_repo`) — Code Autocomplete Agent

Cody fine-tunes on your GitHub repo using QLoRA (4-bit quantized LoRA) via the Axolotl framework (HuggingFace Transformers + PEFT). It learns your codebase's patterns, naming conventions, and project structure to produce a fast, lightweight adapter optimized for real-time completions.

**Best for:** code autocomplete, inline suggestions, tab-complete, code style matching, pattern completion.

```bash
te jobs create --agent code_repo \
  --base-model Qwen/Qwen2.5-Coder-7B-Instruct \
  --repo-url https://github.com/your-org/your-repo \
  --output-name my-cody-model
```

### SIERA (`sera_code_repo`) — Bug-Fix Specialist

SIERA (Synthetic Intelligent Error Resolution Agent) uses the Open Coding Agents approach from AllenAI to generate targeted bug-fix training data from your repository. It synthesizes realistic error scenarios and their resolutions, then fine-tunes a model that learns your team's debugging style, error handling conventions, and fix patterns.

**Best for:** debugging, error resolution, patch generation, root cause analysis, fix suggestions.

```bash
te jobs create --agent sera_code_repo \
  --quality-tier high \
  --base-model Qwen/Qwen2.5-Coder-7B-Instruct \
  --repo-url https://github.com/your-org/your-repo \
  --output-name my-siera-model
```

**Quality tiers (SIERA only):**
- `low` — Faster, fewer synthetic pairs (default)
- `high` — Deeper analysis, more training data, better results

### Coming Soon

| Agent | Persona | What it does |
|-------|---------|-------------|
| **Resolve** | Mira | Fine-tunes on support tickets, macros, and KB articles for automated ticket resolution |
| **Extractor** | Flux | Trains for strict schema extraction from docs, PDFs, and business text |
| **Guard** | Aegis | Security-focused code reviewer that catches risky patterns and proposes safer fixes |
| **OpsPilot** | Atlas | Incident response agent trained on runbooks, postmortems, and on-call notes |

## Supported Base Models

| Size | Models |
|------|--------|
| **3B** | `Qwen/Qwen2.5-Coder-3B-Instruct` |
| **7B** | `codellama/CodeLlama-7b-hf`, `deepseek-ai/deepseek-coder-7b-instruct-v1.5`, `Qwen/Qwen2.5-Coder-7B-Instruct` |
| **13-15B** | `codellama/CodeLlama-13b-Instruct-hf`, `bigcode/starcoder2-15b`, `Qwen/Qwen2.5-Coder-14B-Instruct` |
| **32-34B** | `deepseek-ai/deepseek-coder-33b-instruct`, `codellama/CodeLlama-34b-Instruct-hf`, `Qwen/Qwen2.5-Coder-32B-Instruct` |
| **70-72B** | `codellama/CodeLlama-70b-Instruct-hf`, `meta-llama/Llama-3.1-70B-Instruct`, `Qwen/Qwen2.5-72B-Instruct` |

## Quick Start

```bash
npm install -g tuningengines-cli

# Or run without installing
npx -y --package tuningengines-cli@latest te auth status

# Sign up or log in (opens browser — works for new accounts too)
te auth login

# Add credits (opens browser to billing page)
te billing add-credits

# Estimate cost before training
te jobs estimate --base-model Qwen/Qwen2.5-Coder-7B-Instruct

# Train Cody on your repo
te jobs create --agent code_repo \
  --base-model Qwen/Qwen2.5-Coder-7B-Instruct \
  --repo-url https://github.com/your-org/your-repo \
  --output-name my-model

# Monitor training
te jobs status <job-id> --watch

# View your trained models
te models list

# Create a governed orchestration starter
te orchestration init langgraph
te orchestration init temporal
te orchestration init inngest
te orchestration init triggerdev
te orchestration init hatchet
te orchestration init restate
te orchestration init dbos
te orchestration init dapr
te orchestration init prefect
te orchestration init dagster
te orchestration init airflow
```

## MCP Server Setup

The CLI includes a built-in MCP server with 60+ tools. Any AI assistant that supports MCP can fine-tune models, manage training jobs, run evaluations, check inference usage, inspect traces, review approvals, and manage non-secret tenant registry metadata through natural language.

For security, the MCP server intentionally does not expose internal proxy routes. It also refuses MCP-side inference-key creation and raw secret-bearing mutation fields. Use the CLI or web UI for workflows that intentionally create one-time keys, submit raw provider secrets, validate S3 credentials, or import/export S3 assets with raw credentials.

### Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "tuning-engines": {
      "command": "npx",
      "args": ["-y", "--package", "tuningengines-cli@latest", "te", "mcp", "serve"],
      "env": {
        "TE_API_KEY": "te_your_key_here"
      }
    }
  }
}
```

### Claude Code

```bash
claude mcp add tuning-engines -- npx -y --package tuningengines-cli@latest te mcp serve
```

### Work Sessions and outcomes

Label the desired outcome for a project without interrupting your coding workflow:

```bash
te goal start "Fix flaky checkout retries"
te goal show
te goal complete --result succeeded
```

Install optional native telemetry hooks for Claude Code or Codex:

```bash
te guard claude-code install --mode observe --project .
te guard claude-code doctor
te guard claude-code doctor --probe
te guard codex install
```

Claude Code writes project-local hooks into `.claude/settings.local.json`. On
Windows, verify with `dir .\.claude`, `type .\.claude\settings.local.json`,
then restart Claude Code from the same project root and review `claude /hooks`.
`doctor --probe` is available in `tuningengines-cli` 0.4.20 and later; it runs
synthetic hook events through the installed commands and checks that the trace is
visible to Tuning Engines. Hook invocations also write a local redacted status
log at `.claude/tuning-engines-hook-status.jsonl`.
Codex project hooks require review and trust from `/hooks`. Tuning Engines sends
pseudonymous session and transcript references by default, not transcript
contents or local absolute paths.

### Claude Code Plugin

The repository also ships a Claude Code plugin wrapper around the same MCP
server. It keeps installation discoverable while preserving the same
`TE_API_KEY` environment-variable boundary:

```bash
claude plugin marketplace add cerebrixos-org/tuning-engines-cli
claude plugin install tuning-engines@tuning-engines
```

### VS Code / Cursor / Windsurf

Add to your MCP settings (`.vscode/mcp.json` or equivalent):

```json
{
  "servers": {
    "tuning-engines": {
      "command": "npx",
      "args": ["-y", "--package", "tuningengines-cli@latest", "te", "mcp", "serve"],
      "env": {
        "TE_API_KEY": "te_your_key_here"
      }
    }
  }
}
```

### What the AI assistant can do

When connected, your AI assistant can:

- "Fine-tune Qwen 7B on my-org/my-repo using the SIERA agent with high quality"
- "How much would it cost to train a 32B model for 3 epochs on this repo?"
- "Check the status of my latest training job"
- "List my trained models"
- "Export my model to s3://my-bucket/models/"
- "Show my account balance"
- "Train a bug-fix specialist on this repo" (auto-selects SIERA)
- "Create an autocomplete model for this codebase" (auto-selects Cody)

The `create_job` tool description includes full agent details and model lists, so AI assistants automatically select the right agent and model based on what you ask for.

## Unified API Endpoint

Tuning Engines can be used anywhere a tool accepts an OpenAI-compatible API
base URL. Point the client at:

```text
https://api.tuningengines.com/v1
```

Use an inference key that starts with `sk-te-...` for live model calls, and use
the model IDs shown by:

```bash
te inference models
```

This lets OpenCode, Temporal activities, LangGraph apps, OpenAI SDK clients,
and other custom-provider clients route through the same Tuning Engines control
plane for model RBAC, routing, fallbacks, guardrails, AGT policy, traces,
usage metering, and cost attribution.

See [docs/unified-api-endpoint.md](docs/unified-api-endpoint.md) for copy-paste
examples for OpenCode, Temporal, Python, JavaScript, and other
OpenAI-compatible clients.

## Agent Runtime SDK and Orchestration Starters

Use the CLI/MCP package when you want `npx` tools for assistants. Use the
Python SDK when you want your own app to run durable agent workflows while
Tuning Engines remains the governed control plane for models, agents, skills,
MCP tools, RBAC, AGT policy, audit, usage, and token economics.

Install the published Python SDK:

```bash
pip install "tuning-engines[langgraph]"
pip install "tuning-engines[temporal]"
```

The package installs the `tuning_agents` Python module.

LangGraph example:

```python
from langgraph.