Skip to main content
Glama
smplkit MCP Server

smplkit MCP Server

Official

smplkit MCP Server

smplkit/mcp 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

1. Add the server and sign in

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):

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

…or in .mcp.json:

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

Cursor (~/.cursor/mcp.json or project .cursor/mcp.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:

{
  "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:

{
  "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."

Related MCP server: @fliq/mcp

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

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:

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:

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.

Available Tools

29 tools
create_configCreate configAInspect

Create a named config: a keyed collection of typed values your code reads at runtime.

Each key holds one typed value that can be overridden per environment with set_config_value. Seed the starting keys here via items, or create the config empty and let set_config_value auto-declare keys later. Use parent to inherit another config's keys.

Inputs: name (required), items, parent, config_id, +1 more. Returns: object

create_flagCreate feature flagAInspect

Create a feature flag with an explicit type, key, and default value.

After creating, use set_flag to set per-environment values and targeting.

Inputs: key (required), type (required), default (required), name, +2 more. Returns: object

create_forwarderCreate audit forwarderAInspect

Wire a forwarder that delivers audit events to a SIEM/HTTP destination.

Prove the destination first with test_forwarder. The URL must be reachable from the public internet.

Inputs: url (required), name (required), filter, method, +8 more. Returns: object

create_jobCreate jobAInspect

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.

Inputs: url (required), name (required), body, method, +8 more. Returns: object

delete_configDelete configA
Destructive
Inspect

Permanently delete a config and all of its keys and per-environment values.

There is no undo — recreate it with create_config if needed. Afterward, SDKs reading these keys fall back to their code-level defaults. To change or clear a single value, use set_config_value instead of deleting the whole config.

Inputs: config_id (required). Returns: object

delete_flagDelete feature flagA
Destructive
Inspect

Permanently delete a flag and all of its per-environment values and rules.

There is no undo — recreate it with create_flag if needed. Afterward, SDKs that still evaluate this key serve the code-level default passed to their flag handle. To stop serving a flag without deleting it, prefer set_flag with enabled=false (the kill switch), which keeps the flag and its targeting intact.

Inputs: key (required). Returns: object

delete_forwarderDelete audit forwarderA
Destructive
Inspect

Delete a forwarder. Past forwarded events are unaffected.

Inputs: forwarder_id (required). Returns: object

delete_jobDelete jobA
Destructive
Inspect

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

Inputs: job_id (required). Returns: object

get_configGet configA
Read-only
Inspect

Get one config's full state: items plus per-environment overrides.

Inputs: config_id (required). Returns: object

get_eventGet audit eventA
Read-only
Inspect

Fetch one audit event by id, with its full detail.

Returns the event's actor, resource (type and id), event type, category, severity, timestamp, and its data payload. Find an event id with query_events first; use this to drill into a single event.

Inputs: event_id (required). Returns: object

get_flagGet feature flagA
Read-only
Inspect

Get one flag's full config: values plus targeting per environment.

Inputs: key (required). Returns: object

get_jobGet jobA
Read-only
Inspect

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

Inputs: job_id (required). Returns: object

get_loggerGet loggerA
Read-only
Inspect

Get one logger's configuration: its account-wide default level and per-environment overrides.

Use it to check the current level before or after set_log_level / reset_logger. Logger keys are dot-separated (e.g. 'sqlalchemy.engine'); list_loggers shows which keys exist.

Inputs: logger_id (required). Returns: object

get_runGet job runA
Read-only
Inspect

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).

Inputs: run_id (required). Returns: object

list_configsList configsA
Read-only
Inspect

List configs with their keys and per-environment values.

Inputs: limit, parent, search, managed. Returns: object

list_environmentsList environmentsA
Read-only
Inspect

List the account's environments — the valid targets for every set_* tool.

Inputs: limit, search, managed, classification. Returns: object

list_flagsList feature flagsA
Read-only
Inspect

List feature flags with their per-environment state.

Inputs: type, limit, search, managed. Returns: object

list_forwardersList audit forwardersA
Read-only
Inspect

List SIEM forwarders and their per-environment enablement.

Inputs: limit, forwarder_type. Returns: object

list_jobsList jobsA
Read-only
Inspect

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).

Inputs: kind, name, limit. Returns: object

list_loggersList loggersA
Read-only
Inspect

List the loggers smplkit knows about, with their account-wide and per-environment levels.

Includes loggers you've set a level on (managed) and those an SDK has reported observing (discovered) — filter with managed. Use it to discover the dot-separated logger keys you can then target with set_log_level.

Inputs: limit, search, managed, service. Returns: object

list_runsList job runsA
Read-only
Inspect

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.

Inputs: job, limit, since, until, +5 more. Returns: object

query_eventsSearch audit eventsA
Read-only
Inspect

Search the immutable audit log — "who changed what, and when?".

Returns matching events newest-first. Every filter is optional and they combine (AND) — call with none to see the most recent activity. Example: resource_type='flag' with since='2026-06-01T00:00:00Z' lists this month's flag changes. Read-only; pass an event's id to get_event to drill into one result.

Inputs: limit, since, until, search, +8 more. Returns: object

reset_loggerReset loggerA
Destructive
Inspect

Stop managing a logger — delete its config so it reverts to the default.

Inputs: logger_id (required). Returns: object

run_jobRun job nowA
Destructive
Inspect

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.

Inputs: job_id (required), wait, environment. Returns: object

set_config_valueSet config valueA
Destructive
Inspect

Set one config key's value in one environment.

Reads the config, sets the override, and saves the full config, so other keys and environments are preserved. The key is auto-declared (type inferred) if it isn't already defined.

Inputs: key (required), value (required), config_id (required), environment. Returns: object

set_flagSet feature flagA
Destructive
Inspect

Set a flag's value, kill switch, and targeting in one environment.

Reads the flag, applies your change, and saves the full flag, so other environments are preserved. Pass only what you want to change.

Inputs: key (required), rules, value, enabled, +1 more. Returns: object

set_log_levelSet log levelA
Destructive
Inspect

Set a logger's level in one environment (creates the logger if needed).

Use this to dial up verbosity (e.g. DEBUG) to investigate an issue, then reset_logger to revert. Other environments are preserved.

Inputs: level (required), logger_id (required), environment. Returns: object

test_forwarderTest audit forwarderAInspect

Dry-run a forwarder destination before saving it.

Sends one sample request to the destination and returns whether it succeeded, the response status/headers/body, and the latency — so you can prove a SIEM endpoint works before wiring create_forwarder.

Inputs: url (required), body, method, ca_cert, +4 more. Returns: object

update_jobUpdate jobA
Destructive
Inspect

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.

Inputs: job_id (required), url, body, name, +10 more. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 29 tools

    Disambiguation5/5

    Each tool targets a distinct resource (forwarder, config, logger, job, run, flag, event, environment) and a specific action (list, create, get, update, set, delete, test, run, query, reset). Resource names are in tool names, so there is no ambiguity between, e.g., get_config, get_logger, get_flag.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern in snake_case (e.g., list_forwarders, create_job, set_log_level). Standard verbs are used throughout, with no camelCase or mixed conventions. Naming is predictable and systematic.

    Tool Count4/5

    With 29 tools, the server covers a broad platform including forwarders, configs, loggers, jobs, runs, flags, events, and environments. While this exceeds the typical 3-15 range, each tool serves a distinct purpose and is justified by the multiple resource types. It is slightly heavy but not bloated.

    Completeness4/5

    The tool surface provides near-complete lifecycle coverage: full CRUD for configs, flags, and jobs; manage/read for loggers; read-only for runs and events; and list/test/create/delete for forwarders. The only notable gap is the lack of an update_forwarder, but delete+recreate works as a workaround.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables creation and management of scheduled tasks with interval, cron, or one-time triggers. Persists tasks in SQLite and supports MCP sampling to automatically invoke AI agents when schedules trigger.
      21 npm
      3
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to convert schedule text to cron expressions, describe cron in natural language, and compute upcoming run times.
      605 npm
      8
      MIT