smplkit MCP Server
OfficialThe smplkit MCP Server lets an AI agent operate the entire smplkit platform through natural-language requests, using stateless HTTP with per-request authentication (OAuth or API key).
Feature Flags: Create, list, get, set (per-environment values, kill switch, targeting rules), and delete flags. Supports boolean, string, number, and JSON types. Tools:
create_flag,list_flags,get_flag,set_flag,delete_flag.Configuration: Manage keyed collections of typed values with per-environment overrides and auto-declaration of keys. Tools:
create_config,list_configs,get_config,set_config_value,delete_config.Logging: Set, list, get, and reset log levels (TRACE, DEBUG, INFO, WARN, ERROR, FATAL, SILENT) for loggers across environments. Tools:
set_log_level,list_loggers,get_logger,reset_logger.Audit: Search immutable audit events by actor, resource, event type, time window, etc. View event details. Create, list, test, and delete SIEM forwarders to stream events to destinations like Datadog, Elastic, Honeycomb, HTTP, New Relic, Splunk HEC, and Sumo Logic. Tools:
query_events,get_event,list_forwarders,create_forwarder,test_forwarder,delete_forwarder.Scheduled Jobs: Create, list, get, update, delete, and run HTTP jobs (recurring via cron, one-off, or manual). Inspect run history and captured responses. Tools:
create_job,list_jobs,get_job,update_job,delete_job,run_job,list_runs,get_run.Platform: List environments for use as targets in environment-specific operations. Tool:
list_environments.Usability: Intent-named tools (list/get/create/set/delete), read-modify-write patterns, and "prove before you trust" helpers like
run_jobandtest_forwarder. Server holds no credentials; per-request auth via OAuth or API key.
Allows creating Datadog forwarders to stream audit events to Datadog.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@smplkit MCP Server Create a job that posts to my endpoint every morning at 8."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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
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.hosttodb-staging.internalfor staging."
"Raise the
sqlalchemy.enginelogger 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/warmevery 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 |
|
Config |
|
Logging |
|
Audit |
|
Jobs |
|
Platform |
|
A few load-bearing behaviors:
set_flag/set_config_value/set_log_levelare read-modify-write. You express a partial change in one environment and the tool preserves the rest.list_environmentstells you the valid environment targets (production,staging, …) for everyset_*tool and for jobs.Prove before you trust.
run_jobfires a job once and returns the captured response;test_forwarderdry-runs a SIEM destination before you save it.create_jobinfers the kind: a cronschedule→ recurring, arun_atdatetime → 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 testsRun 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/healthConfiguration (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_*backslist_environments).*_SCHEME—https(default) orhttp.*_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/mcpwith 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 toolscreate_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_atdatetime -> 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 configADestructiveInspect
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 flagADestructiveInspect
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 forwarderADestructiveInspect
Delete a forwarder. Past forwarded events are unaffected.
Inputs: forwarder_id (required). Returns: object
delete_jobDelete jobADestructiveInspect
Delete a job. Its run history is retained and the id may be reused later.
Inputs: job_id (required). Returns: object
get_configGet configARead-onlyInspect
Get one config's full state: items plus per-environment overrides.
Inputs: config_id (required). Returns: object
get_eventGet audit eventARead-onlyInspect
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 flagARead-onlyInspect
Get one flag's full config: values plus targeting per environment.
Inputs: key (required). Returns: object
get_jobGet jobARead-onlyInspect
Get one job's full configuration (schedule, target request, environments).
Inputs: job_id (required). Returns: object
get_loggerGet loggerARead-onlyInspect
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 runARead-onlyInspect
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 configsARead-onlyInspect
List configs with their keys and per-environment values.
Inputs: limit, parent, search, managed. Returns: object
list_environmentsList environmentsARead-onlyInspect
List the account's environments — the valid targets for every set_* tool.
Inputs: limit, search, managed, classification. Returns: object
list_flagsList feature flagsARead-onlyInspect
List feature flags with their per-environment state.
Inputs: type, limit, search, managed. Returns: object
list_forwardersList audit forwardersARead-onlyInspect
List SIEM forwarders and their per-environment enablement.
Inputs: limit, forwarder_type. Returns: object
list_jobsList jobsARead-onlyInspect
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 loggersARead-onlyInspect
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 runsARead-onlyInspect
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 eventsARead-onlyInspect
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 loggerADestructiveInspect
Stop managing a logger — delete its config so it reverts to the default.
Inputs: logger_id (required). Returns: object
run_jobRun job nowADestructiveInspect
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 valueADestructiveInspect
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 flagADestructiveInspect
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 levelADestructiveInspect
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 jobADestructiveInspect
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
Scored across 29 tools
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.
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.
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.
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
Related MCP Connectors
Manage scheduled requests, uptime monitors and heartbeats from your AI assistant.
Create and manage scheduled, guarded AI agent jobs with built-in quality control and 900+ connectors
Schedule tasks for later from your AI agent: reminders, delayed webhooks, recurring jobs.
Create, schedule, and run JavaScript jobs, manage files, and inspect runs from your AI agent.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables 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 npm3MIT
- AlicenseAqualityDmaintenanceLets AI agents schedule and manage HTTP jobs, cron schedules, rate-limited buffers, and alert channels via natural language, backed by Fliq's Postgres-native job scheduler.21MIT
- AlicenseNot gradedqualityCmaintenanceEnables AI agents to create, update, delete, list, and inspect OS-native scheduled tasks and their logs across Windows, Linux, and macOS through a unified interface.MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to convert schedule text to cron expressions, describe cron in natural language, and compute upcoming run times.605 npm8MIT