Server data from the Official MCP Registry
MCP server exposing Kettle Logic insight articles & industry guidance as tools + resources.
MCP server exposing Kettle Logic insight articles & industry guidance as tools + resources.
Remote endpoints: streamable-http: https://kettlelogic.com/mcp
This is a well-engineered MCP server with clean architecture, proper input validation, and appropriate security controls. The server is read-only, requires no authentication (by design—it only fetches public website content), and has no sensitive credential handling. Permissions align with its stated purpose. Minor code quality observations exist but do not pose security risks. Supply chain analysis found 3 known vulnerabilities in dependencies (0 critical, 3 high severity).
7 files analyzed · 7 issues found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
This plugin requests these system permissions. Most are normal for its category.
Available as Local & Remote
This plugin can run on your machine or connect to a hosted endpoint. during install.
From the project's GitHub README.
A Model Context Protocol (MCP) server that exposes a Kettle Logic site's published content — whitepapers/playbooks ("insights") and industry pages — to any MCP-capable agent (Claude Desktop, IDEs, custom orchestrators).
It is a pure, read-only client of the public website: it fetches content live over HTTP and parses it with the Python standard library. No database, no API keys, no dependency on any backend cluster or LLM. The target site is configurable, so you can point it at your own deployment — or any site with the same shape — and see what it discovers.
Built on the official mcp Python SDK (FastMCP),
speaking the standard stdio transport (and an optional streamable-http
transport for container/Kubernetes deployment).
Engineering note: this repository doubles as a reference for how we build — hexagonal layering, fully-typed OO, dependency injection, and a suite of ratchets (see ARCHITECTURE.md) that enforce the rules in CI.
pytestruns unit tests, real-stdio e2e tests, and the ratchets together.
| Tool | Description |
|---|---|
search_articles(query, limit=5) | Search insight articles by title / slug / description. |
get_industry_overview(industry) | Plain-text overview extracted from an industry page. |
list_articles() | JSON catalog of every insight article (title, slug, description). |
list_industries() | JSON list of industries with guidance (name + slug). |
get_article(slug) | A single insight article rendered as readable text. |
| URI | Description |
|---|---|
kettlelogic://articles/manifest | JSON catalog of every insight article. |
kettlelogic://industries/list | JSON list of industry pages discovered on the site. |
kettlelogic://articles/{slug} | A single article rendered as readable text. |
Discovery is live: articles from the site's /insights/ index, industries from its
/llms.txt (falling back to crawling /industries/).
pip install . # Python >= 3.11; pulls in mcp + httpx
mcp-kettlelogic # console script (stdio transport by default)
Normally an MCP client launches it. To explore interactively:
npx @modelcontextprotocol/inspector mcp-kettlelogic
{
"mcpServers": {
"kettlelogic": {
"command": "mcp-kettlelogic",
"env": { "KETTLELOGIC_BASE_URL": "https://kettlelogic.com" }
}
}
}
A hardened instance runs live over streamable-HTTP — point any MCP client at it:
{
"mcpServers": {
"kettlelogic": { "url": "https://kettlelogic.com/mcp" }
}
}
This server is listed in the public MCP registry
as com.kettlelogic/mcp-kettlelogic (brand: kettlelogic, not a personal GitHub
handle). server.json is the manifest — it advertises the hosted
streamable-HTTP remote and validates against the 2025-12-11 schema.
The listing is claimed by HTTP domain ownership, not a GitHub login: the registry
fetches https://kettlelogic.com/.well-known/mcp-registry-auth (a public-key challenge
served by the marketing site — web/public/.well-known/mcp-registry-auth in the
kettlelogic repo) and verifies a signature made with our Ed25519 private key.
.github/workflows/publish-registry.yml
publishes automatically on every GitHub Release (and via manual Run workflow).
It runs on a self-hosted runner in our cluster (runs-on: [self-hosted, linux, cluster]) — chosen because GitHub-hosted minutes run out fast, and this way the
publish costs zero quota and won't fail when the month is drained. That runner also
mounts the signing key from an in-cluster Secret (/opt/mcp/key-hex), so the key
never lives in GitHub Actions secrets.
So the normal flow is: bump version.py + server.json version → cut a GitHub
Release → the registry updates itself.
Runner setup is one-time and lives in the private home repo:
deployments/github-runner/ (README there). If the runner is down, re-run from
the Actions tab, or use the local fallback below — it always works with no infra.
If you ever need to publish by hand:
# 1. Get the CLI (prebuilt binary from the registry releases)
curl -L https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz | tar xz mcp-publisher
# 2. From the repo root (where server.json lives):
./mcp-publisher validate
./mcp-publisher login http --domain kettlelogic.com \
--private-key "$(openssl pkey -in .secrets/mcp-registry-key.pem -outform DER | tail -c 32 | xxd -p -c 64)"
./mcp-publisher publish
.secrets/mcp-registry-key.pem (gitignored) and
is the publish credential for the com.kettlelogic namespace — keep it in a password
manager. The matching public key is committed only as the served challenge file.openssl genpkey -algorithm Ed25519 -out .secrets/mcp-registry-key.pem), regenerate the challenge file
(echo "v=MCPv1; k=ed25519; p=$(openssl pkey -in .secrets/mcp-registry-key.pem -pubout -outform DER | tail -c 32 | base64)" > ../kettlelogic/web/public/.well-known/mcp-registry-auth),
redeploy the site, update the MCP_REGISTRY_KEY secret, then re-publish.| Env var | Default | Purpose |
|---|---|---|
KETTLELOGIC_BASE_URL | https://kettlelogic.com | Target site to read. Point it at your own. |
KETTLELOGIC_TRANSPORT | stdio | stdio (local clients) or streamable-http (network/k8s). |
KETTLELOGIC_HTTP_HOST / KETTLELOGIC_HTTP_PORT | 0.0.0.0 / 8080 | Bind for the http transport. |
KETTLELOGIC_METRICS_PORT | (unset) | If set, serve Prometheus metrics at /metrics. |
KETTLELOGIC_LOG_LEVEL | INFO | Log level. Logs go to stderr (stdout is the MCP channel). |
KETTLELOGIC_CACHE_TTL_SECONDS / KETTLELOGIC_MAX_ARTICLES / KETTLELOGIC_FETCH_CONCURRENCY / KETTLELOGIC_OVERVIEW_MAX_CHARS | see constants.py | Tuning. |
For network deployment the server runs the streamable-http transport.
docker compose -f deploy/docker/docker-compose.yaml up --build
Kubernetes manifests live in deploy/k8s/ (Deployment with 2
replicas, readiness/liveness probes, resource bounds, non-root + read-only root FS,
ClusterIP Service, ConfigMap). Apply with:
kubectl apply -k deploy/k8s
KETTLELOGIC_LOG_LEVEL./metrics (set KETTLELOGIC_METRICS_PORT):
mcp_operations_total, mcp_errors_total, mcp_http_fetches_total,
mcp_http_errors_total, mcp_cache_total{result}, mcp_op_duration_seconds.pip install -e ".[dev]"
ruff check src tests # lint + import order
mypy # type check (disallow-untyped-defs)
pytest # unit + e2e + ratchets, coverage gate (fail-under 90%)
Coverage runs ~99%. See ARCHITECTURE.md for layering, the request flow, and the full list of ratchets.
MIT — see LICENSE.
Be the first to review this server!
by Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
by Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
by mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.