com.smplkit/mcp

Official8 tools

by smplkit · Python

smplkit MCP Server

Operate smplkit from your agent: feature flags, config, logging, audit, and scheduled jobs.

Manage feature flags, configuration, logging, audits, and scheduled jobs.

Topics

ai-agentsclaudecroncursorfastmcpjobsmcpmodel-context-protocolscheduler

Captured live from the server via tools/list.

list_jobs

List the account's configured jobs, each enriched with its latest run. Use this to see what's scheduled and whether each job's most recent run succeeded or failed. Each job includes its schedule, target request, and a `last_run` summary (status and captured HTTP status).

Parameters (3)

nameany
Filter to jobs whose name contains this text (case-insensitive).
kindany
Filter by kind: 'recurring', 'manual', or 'one_off'.
limitany
Maximum number of jobs to return.

get_job

Get one job's full configuration (schedule, target request, environments).

Parameters (1)

job_idstringrequired
The job's id.

create_job

Create a scheduled HTTP job. The kind is inferred — never set it yourself. - A cron `schedule` -> a RECURRING job that fires on that cadence. - A `run_at` datetime -> a ONE-OFF job that runs a single time. - Neither -> a MANUAL job that runs only when you call run_job. The target URL must be publicly reachable. After creating a recurring job, call run_job to prove it works with a real captured response.

Parameters (12)

namestringrequired
Human-readable name for the job.
urlstringrequired
Destination URL to call. Must be reachable from the public internet (no localhost or private IPs).
methodstring
HTTP method — GET, POST, PUT, PATCH, or DELETE.
headersany
HTTP headers to send, as a name->value object. Set a secret auth header so only smplkit can call your endpoint.
bodyany
Request body sent verbatim on each run. Pair with a matching Content-Type header.
timeoutany
Per-run timeout in seconds (default 30).
scheduleany
A 5-field cron expression for a RECURRING job (e.g. '0 7 * * *' for 7am daily). Omit for a manual or one-time job.
run_atany
An ISO-8601 datetime to run the job ONCE (or 'now' to run once immediately). Mutually exclusive with `schedule`.
timezoneany
IANA timezone the cron `schedule` runs in (e.g. 'America/New_York'). Recurring jobs only; defaults to UTC.
retry_policyany
The id of a named retry policy to apply to failed runs.
environmentstring
Which environment to enable/run the job in (default 'production').
descriptionany
Optional free-text description.

update_job

Change a job. Only pass the fields you want to change. The tool reads the current job, applies your change, and saves the full updated job, so a partial change like "move it to 8am" works correctly.

Parameters (14)

job_idstringrequired
The id of the job to change.
nameany
New name.
urlany
New destination URL (must be publicly reachable).
methodany
New HTTP method.
headersany
Replace the request headers.
bodyany
Replace the request body.
timeoutany
New per-run timeout in seconds.
scheduleany
New cron schedule (makes the job recurring).
run_atany
New one-time run datetime (makes the job one-off).
timezoneany
New IANA timezone for the cron schedule.
retry_policyany
New named retry-policy id.
descriptionany
New description.
enabledany
Enable (true) or disable (false) the job in an environment.
environmentany
Environment that `enabled` applies to (default 'production').

delete_job

Delete a job. Its run history is retained and the id may be reused later.

Parameters (1)

job_idstringrequired
The id of the job to delete.

run_job

Fire one immediate run of a job and return the captured result. This is the way to prove a job works: it returns the run's status plus the captured HTTP response (status, headers, body) once it finishes. The job's schedule and enabled state are unchanged.

Parameters (3)

job_idstringrequired
The id of the job to run.
environmentany
Environment to run in. Optional when the job is enabled in exactly one environment; required if it's enabled in several.
waitboolean
Wait for the run to finish and return the captured response (default true).

list_runs

List runs by job, status, trigger, environment, and/or time window. The pull-based monitoring path: `failed_only=true` (or `status=FAILED`) answers "has anything failed?"; `job=<id>` shows one job's history.

Parameters (9)

jobany
Restrict to one job's run history (the job id).
statusany
Restrict to a status, or comma-separated statuses: PENDING, RUNNING, SUCCEEDED, FAILED, CANCELED.
failed_onlyboolean
Shortcut for status=FAILED — answers "has anything failed?".
triggerany
Restrict to a trigger, or comma-separated: SCHEDULE, MANUAL, RERUN, RETRY.
environmentany
Restrict to one or more environments (comma-separated).
sinceany
Only runs created at/after this ISO-8601 time.
untilany
Only runs created before this ISO-8601 time.
last_run_onlyboolean
Collapse to the last completed run per job-and-environment.
limitinteger
Maximum number of runs to return (default 50).

get_run

Get one run: status, timings, failure reason, and the captured HTTP response. This is where "what did it return?" lives — the run carries the captured `result` (status, headers, body, and whether the body was truncated).

Parameters (1)

run_idstringrequired
The run's id (a UUID).

README.md8 KBView on GitHub

smplkit MCP Server

A hosted, agent-native Model Context Protocol server — the gateway that lets an AI agent (Claude Code, Claude Desktop, Cursor, …) operate the whole smplkit platform on your behalf, without you ever leaving the chat.

One server, the whole platform:

Flags — feature flags with per-environment values and targeting.
Config — keyed, typed config with per-environment overrides.
Logging — change runtime log levels per environment.
Audit — search the audit log and wire SIEM forwarders.
Jobs — scheduled HTTP jobs (cron, one-off, or on-demand) with response capture.

Once connected, tell your agent "turn on the new checkout for enterprise users in prod," "set the staging database host," "raise the SQL logger to DEBUG in prod," "stream audit events to Datadog," or "POST my endpoint every morning at 7." It makes the change, proves it works, and answers follow-up questions straight from the live state.

It is a thin, stateless HTTP client to the smplkit product APIs — it holds no credential of its own.

Connect once

The server lives at https://mcp.smplkit.com/api/mcp. Point your MCP client at that URL — the first time it connects, the client opens your browser for a one-time sign-in (Continue with Google or Microsoft, standard OAuth). After that it reconnects and refreshes access on its own; there's no key to mint, copy, or rotate.

Claude Code (CLI):

bash

claude mcp add --transport http smplkit https://mcp.smplkit.com/api/mcp

…or in .mcp.json:

json

{
  "mcpServers": {
    "smplkit": {
      "type": "http",
      "url": "https://mcp.smplkit.com/api/mcp"
    }
  }
}

Cursor (~/.cursor/mcp.json or project .cursor/mcp.json):

json

{
  "mcpServers": {
    "smplkit": {
      "url": "https://mcp.smplkit.com/api/mcp"
    }
  }
}

Claude Desktop (claude_desktop_config.json) — Desktop bridges remote servers through mcp-remote, which opens a browser for the one-time sign-in and caches the connection:

json

{
  "mcpServers": {
    "smplkit": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.smplkit.com/api/mcp"]
    }
  }
}

Prefer a static key?

For non-interactive use — CI, scripts, headless clients, or writing code with the smplkit SDKs — skip the browser and authenticate with an API key as a bearer token. Sign up at https://smplkit.com (Google or Microsoft SSO, email-verified instantly), create an API key in the console, and send it as Authorization: Bearer YOUR_SMPLKIT_API_KEY (a custom X-Smplkit-Api-Key header is also accepted). The SDKs read the same key from SMPLKIT_API_KEY. For example, add a headers block to the config above:

json

{
  "mcpServers": {
    "smplkit": {
      "type": "http",
      "url": "https://mcp.smplkit.com/api/mcp",
      "headers": { "Authorization": "Bearer ${SMPLKIT_API_KEY}" }
    }
  }
}

2. Ask your agent

"Create a boolean flag new-checkout, off by default, then turn it on in prod only for enterprise users."

"List my environments, then set database.host to db-staging.internal for staging."

"Raise the sqlalchemy.engine logger to DEBUG in production while I debug, then reset it."

"Test whether https://http-intake.logs.datadoghq.com/... accepts a sample, then create a Datadog forwarder for our audit events."

"POST https://api.example.com/cache/warm every morning at 7am NY time, then run it now to prove it works."

Tools

All tools share intent-named verbs — list_*, get_*, create_*, set_*, delete_* — and hide the JSON:API envelopes, per-environment nesting, and full-replace PUTs behind partial-intent calls.

Capability	Tools
Flags	`create_flag`, `list_flags`, `get_flag`, `set_flag`, `delete_flag`
Config	`create_config`, `list_configs`, `get_config`, `set_config_value`, `delete_config`
Logging	`set_log_level`, `list_loggers`, `get_logger`, `reset_logger`
Audit	`query_events`, `get_event`, `list_forwarders`, `create_forwarder`, `test_forwarder`, `delete_forwarder`
Jobs	`create_job`, `list_jobs`, `get_job`, `update_job`, `delete_job`, `run_job`, `list_runs`, `get_run`
Platform	`list_environments`

A few load-bearing behaviors:

set_flag / set_config_value / set_log_level are read-modify-write. You express a partial change in one environment and the tool preserves the rest.
list_environments tells you the valid environment targets (production, staging, …) for every set_* tool and for jobs.
Prove before you trust. run_job fires a job once and returns the captured response; test_forwarder dry-runs a SIEM destination before you save it.
create_job infers the kind: a cron schedule → recurring, a run_at datetime → one-off, neither → manual. You never set a kind.

The bundled SKILL.md teaches an agent the whole surface.

The public-internet constraint

smplkit calls job targets and forwarder destinations from the cloud, so those URLs must be reachable from the public internet — localhost/private addresses won't fire. To target a local server, point at its deployed URL or expose it with a tunnel (cloudflared tunnel --url http://localhost:PORT or ngrok http PORT) and set a secret auth header.

Development

bash

python3.13 -m venv .venv && . .venv/bin/activate
pip install -r requirements-test.txt
pytest                                          # unit tests (acceptance deselected)
ruff check src tests

Run the server locally:

bash

PYTHONPATH=src uvicorn smplkit_mcp.app:app --host 0.0.0.0 --port 8000
# MCP endpoint:  http://localhost:8000/api/mcp
# Health check:  http://localhost:8000/health

Configuration (env vars) — each product's base host is independently configurable, mirroring the SDK's base_domain pattern:

JOBS_BASE_DOMAIN / FLAGS_BASE_DOMAIN / CONFIG_BASE_DOMAIN / LOGGING_BASE_DOMAIN / AUDIT_BASE_DOMAIN / APP_BASE_DOMAIN — the host for each product API (defaults <product>.smplkit.com; APP_* backs list_environments).
*_SCHEME — https (default) or http.
*_BASE_URL — full base-URL override (e.g. http://localhost:8002); wins over the two above. Used for the local platform and tests.

Acceptance tests

tests/test_acceptance.py provisions an ephemeral verified account and drives the full tool surface against the real product APIs end-to-end — create/set/get/ delete a flag, set and read a config value, set and list a log level, query events, create/test/delete a forwarder, list environments, and the eight Jobs tools — then cleans up. These tests require smplkit-internal admin credentials, so they self-skip unless an admin key is available (ADMIN_API_KEY env or the [admin] profile in ~/.smplkit) — external contributors can ignore them; the unit suite needs no credentials. Run them explicitly:

bash

pytest -m acceptance
# point at a non-prod platform with <PRODUCT>_BASE_URL=...

Architecture

Stateless Python service built on FastMCP: it holds no database and no platform credential of its own.
Auth is per request — whether the caller signs in with OAuth or sends an API key, the credential is validated and used per request to reach each product API, and is never cached or logged.
One thin JSON:API HTTP client per product (flags, config, logging, audit, environments), each pointed at its own configurable base host.
The MCP endpoint is served under /api/mcp with a stateless, JSON-response transport (no long-lived SSE), so it behaves correctly through proxies and load balancers with short idle timeouts.

License

MIT.

Install

claude_desktop_config.json

{
  "mcpServers": {
    "mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.smplkit.com/api/mcp"
      ]
    }
  }
}

Desktop config is stdio-only; this bridges via mcp-remote. Native remote: Settings > Connectors.

Topics

list_jobs

get_job

create_job

update_job

delete_job

run_job

list_runs

get_run

smplkit MCP Server

Connect once

1. Add the server and sign in

Prefer a static key?

2. Ask your agent

Tools

The public-internet constraint

Development

Acceptance tests

Architecture

License

Install