Kamiwaza MCP server
A Model Context Protocol server that gives an AI agent the whole Kamiwaza platform through a tool surface whose size never changes.
The pinned platform client exposes 439 callable operations and grows every release. Publishing one tool per operation would spend thousands of tokens of every agent's context before it did any work, and tool-selection accuracy falls as the list grows. This server publishes 21 tools — four discovery tools plus 17 workflow tools — holds the operation index server-side, and reaches the other 405 published operations by search.
Any standards-conformant host can connect. There is no Kamiwaza SDK to install on the client, no custom transport, no private header, and no bespoke handshake.
What this server supports
Protocol revisions
One process serves two revisions, and each is a separate claim. A statement proved for one revision is not a statement about the other: the two arms negotiate differently, so a conformance result for either has to be read as that revision's result alone.
| Revision | How a host negotiates it | Session |
|---|---|---|
2026-07-28 |
Per request. The host declares the protocol version and its client capabilities in that request's own _meta; there is no handshake. |
None |
2025-11-25 |
Once, in initialize. |
None issued — the transport is stateless |
Both are in SERVED_REVISIONS (src/kamiwaza_mcp/protocol/revisions.py), and
SERVED_MODERN_REVISIONS is the modern subset server/discover advertises. Any
other revision is refused on every method by revision_gate
(src/kamiwaza_mcp/protocol/refusals.py), and the refusal names this server's
served set rather than every revision the library can speak. An import-time check
in revisions.py fails the process if the served set is not one revision from
each era, so the two arms cannot silently become one.
Conformance is asserted per revision, not once for both:
tests/conformance/test_dual_revision.py drives both arms of a single
application, tests/conformance/test_capabilities.py probes each advertised
capability per revision against the method that implements it, and
tests/conformance/test_revision_refusals.py asserts the refusal for everything
else.
Deployment topologies, and how each is run
The topologies differ in exactly one thing — who established the caller. Both
then build the same protocol server from the same factory (server/app.py
build_server), which is what makes the published surface identical.
Hosted, behind the platform edge (transport/http.py hosted_deployment):
the edge authenticates the member and forwards the context, so this server
terminates no public edge and holds no edge certificate.
from kamiwaza_mcp.transport.http import hosted_deployment, serve_http
app = serve_http(
hosted_deployment(platform_base_url="https://kamiwaza.example.com/api"),
host="0.0.0.0",
port=8080,
)
Which infrastructure installed it is not this server's business. The same
image runs under the platform operator, under the legacy deploy
infrastructure, and under plain Compose, because the hosted topology depends on
the forwarded-envelope contract and not on what produced it: the member, the
workroom and the caller's token, parsed by
kamiwaza_extensions_lib.identity.extract_identity — the platform's own
parser, shared with every other extension — rather than by header names
invented here (FR-034, tests/conformance/test_implementation_neutrality.py).
The one place the two planes genuinely disagree is the tenant. The platform's
signed ForwardAuth payload carries no tenant header at all, while the
platform's own services do send x-tenant-id. So the tenant is read from the
forwarded credential's claims, which the authorization server signed, and
x-tenant-id is only a fallback for a deployment whose tokens carry no tenant
claim — a request with neither is refused, because its isolation scope is
unknown.
Measured against one live cluster, all three ways: through the operator's edge
with the extension installed, through Compose with the header-less envelope,
and in-process with and without x-tenant-id
(tests/integration/test_hosted_live.py). The published listing is
byte-identical to the standalone one in every case.
Standalone, as its own protected resource (transport/http.py
standalone_deployment): no edge sits in front, so this server validates the
bearer credential itself. The credential verifier is required with no default,
because a standalone deployment that admitted callers without verifying them
would be an open endpoint.
from kamiwaza_mcp.authority.resource_server import (
PlatformCredentialVerifier,
ProtectedResource,
)
from kamiwaza_mcp.transport.http import serve_http, standalone_deployment
resource = ProtectedResource(
resource="https://mcp.kamiwaza.example.com/mcp",
authorization_servers=("https://auth.kamiwaza.example.com",),
scopes_supported=("kamiwaza.read",),
resource_name="Kamiwaza platform",
)
app = serve_http(
standalone_deployment(
PlatformCredentialVerifier(
resource=resource,
issuer="https://auth.kamiwaza.example.com",
resolve_signing_key=fetch_signing_key, # your key-set lookup
tenant_claim="tenant", # required, never guessed
),
platform_base_url="https://kamiwaza.example.com/api",
resource=resource,
),
host="0.0.0.0",
port=8080,
)
A host-launched local process (cli.py, over transport/stdio.py):
standalone, never hosted. A pipe carries no per-request credential, so the
member is established once — by asking the cluster whose credential the process
was started with — and every call runs as that member. LocalCredentialAdmission
refuses a second identity rather than serving it under the first, and refuses to
run with no credential at all.
Installing the package leaves a command behind, which is what a host's launch configuration names:
kz-ext login https://kamiwaza.example.com/api # once; stores a connection
kamiwaza-mcp # stdio, the default
kamiwaza-mcp --connection staging # a stored connection other than the active one
kamiwaza-mcp --transport http --port 8080 # a loopback listener instead
With neither KAMIWAZA_API_URL nor KAMIWAZA_MCP_CREDENTIAL in the
environment, the process serves the connection kz-ext login made active, read
through the descriptor package's own connection store. --connection NAME
serves that stored connection and overrides both variables. Otherwise, setting
both variables serves exactly what they name, which is what a host without a
kz-ext sign-in does:
export KAMIWAZA_API_URL=https://kamiwaza.example.com/api
export KAMIWAZA_MCP_CREDENTIAL='<credential issued by that cluster>'
kamiwaza-mcp
Setting only one of the two, or setting either to an empty value, is refused
rather than completed from a stored connection, because one cluster's address
with another's credential is the mistake that refusal exists to stop. Nothing
is defaulted: a default cluster address would be one cluster's address in every
other deployment, and this server has no identity of its own to fall back on.
Certificate verification stays on regardless of a stored connection's
verify_ssl setting; trust a private CA with REQUESTS_CA_BUNDLE and
SSL_CERT_FILE. The credential is never read from an argument, because a
credential in argv is readable by every process on the machine. Who the
process serves is not configuration either — the credential is presented to the
platform's own auth/users/me at startup, so a stale credential fails
immediately instead of misattributing calls to a member somebody typed.
Hosted plus stdio is refused when the deployment is constructed
(Deployment.__post_init__): there is no edge in front of a process reading
standard input, so a forwarded context arriving there would be one nothing
produced.
--transport http is the local listener of FR-032e: it binds 127.0.0.1 only,
switches on the origin check the library leaves off by default
(transport/local_guard.py), and still requires a credential per request.
Measured against a live cluster: a request from an unrecognised origin is
refused with 403 and one carrying no credential with 401.
Transports
Two, and only two — the Transport enum in authority/admission.py has no third
member:
- Streamable HTTP, served at
/mcp(server/app.pyPROTOCOL_PATH), builtstateless_http=Trueso any replica can serve any request. - stdio, for a host-launched local process.
The deprecated HTTP-with-SSE transport is not served. It is deprecated in both targeted revisions, so it is neither the default nor a way to reach anything: nothing mounts it, and the only HTTP application this repository builds is the Streamable HTTP one.
Authorization
| Topology | How a caller is established | What this server publishes |
|---|---|---|
| Hosted | The platform edge's forwarded context: x-user-id, x-user-roles, x-workroom-id, x-tenant-id, x-auth-token. Any field missing is a refusal, and the platform is never reached. |
No protected-resource route and no challenge. A challenge here would send a host to authorize directly against this server, past the edge that already refused it. |
| Standalone | A bearer credential this server verifies, audience-checked against its own resource identifier. | The RFC 9728 document at /.well-known/oauth-protected-resource/mcp, served unauthenticated because discovery is what a caller holding no credential is doing. |
Standalone challenges, per RFC 6750 §3.1 (server/metadata.py,
authority/resource_server.py):
| Request | Status | WWW-Authenticate |
|---|---|---|
No authorization header |
401 | error="invalid_request", plus resource_metadata |
| A credential for another audience, or an unverifiable one | 401 | error="invalid_token", plus resource_metadata |
| A valid credential missing a required scope | 403 | error="insufficient_scope", scope="…", plus resource_metadata |
The 401/403 split is load-bearing rather than cosmetic: a host retries a 401 by authorizing, and a 403 by authorizing for more. A 401 for insufficient scope would send it round the same flow to arrive at the same refusal.
The discovery path is built by metadata_path, which inserts the well-known
segment before the resource's own path, so a host asking about /mcp is
answered about /mcp.
No caller credential is forwarded onward, and this server holds no workload identity of its own: inbound it validates a platform credential, outbound it uses the caller's own authority. It refuses rather than escalating.
The negotiated extension
io.modelcontextprotocol/tasks — optional, and advertised only when it is
registered. The library derives capabilities.extensions from the extensions the
server was constructed with (server/app.py passes deployment.extensions
through), so the capability map cannot claim an extension whose methods are
unreachable. Its three methods are bound only at the modern revision.
A client that did not declare the extension and calls a task method is refused
with the specification's -32021 and a requiredCapabilities payload naming what
to declare (protocol/tasks.py, via the library's require_client_extension).
A host that never negotiates it is not locked out of slow work: a workflow call
gets a wait bounded at 45 seconds (workflows/wait.py) and an expired_wait
outcome carrying the identifier of whatever already exists, so the correct
response is to resume rather than to start a second one. call_operation has
no wait budget of its own at this version (surface/call_operation.py), so a
slow single operation is bounded by the host's own patience and not by this
server.
A task handle is a sealed reference to the platform's own record, not a row in this server's memory, so it survives a disconnect and a restart.
The tool surface
Discovery
| Tool | Accepts | Returns |
|---|---|---|
find_operations |
a plain-language query, optionally a category and limit | candidates with operation_id and a one-line summary — never shapes |
describe_operation |
one operation_id |
the input shape, the result shape, the approval requirement, and any workflow hint |
call_operation |
an operation_id and arguments |
the success envelope, a failure envelope, or a task handle |
docs |
an optional topic | usage guidance, plus this server's version and the pinned descriptor version |
docs answers six topics — overview (the default), entitlement,
slow-work, failures, shapes, withheld (surface/docs.py).
Workflow tools
Seventeen, always published, from the pinned descriptor package
(workflows/publish.py published_workflows; descriptions are asserted against
the package's own docstrings by
tests/conformance/test_description_provenance.py):
| Area | Tools |
|---|---|
| Models | find_and_deploy_model, deploy_and_connect_model, preflight_and_deploy_model, diagnose_deployment, retire_deployment |
| Data | ingest_dataset_and_index, run_source_ingestion, complete_dataset_ingestion, rag_query, enclave_ingest |
| Federation and access | pair_federation_and_allow_user, grant_subject_access |
| Gates | install_and_bind_gate_package, replace_gate_package |
| Workrooms and apps | create_workroom_and_enter, export_workroom_bundle, deploy_app_from_garden |
Each names at most one polling step, bundles at most one approval-bearing step,
and states whether it is idempotent. Sixteen of the seventeen declare an
approval step — every one but diagnose_deployment, counted from the pinned
descriptors — and each of those names the change a member is consenting to.
Single destructive acts are deliberately not wrapped: deleting something,
rotating a credential, or uninstalling a package stays one explicit call.
The listing is the same for every caller
Entitlement is never marked at discovery: the platform authorizes by relation on
an object, and discovery has no object. Two callers receive byte-identical
listing, search and shape answers
(tests/conformance/test_listing_invariance.py). There is no persona — not as a
parameter, not as a tool set, not as a deployment
(tests/conformance/test_persona_neutrality.py).
One posture changes the listing, and no request can reach it: the deployment's
own read-only posture. Deployment.read_only withholds every write and every
credential-returning read, taking the published set from 21 tools to 5.
The posture is set by the deployment's own KAMIWAZA_MCP_READ_ONLY — declared
in docker-compose.yml and defaulted off in kamiwaza.json, so an install that
says nothing serves the full surface. With it on, a withheld operation is absent
from find_operations, reported as unknown by describe_operation, refused by
call_operation even when a caller guesses its identifier, and the workflows
that change something are not published at all. A value that is neither on nor
off stops the container at startup rather than being read as off.
A gated act is answered by asking, and the question is the caller's own "do you want to run this?" rather than a second person's approval. It goes out by whichever mechanism the connection's revision defines, and it is the same question either way:
2026-07-28— the call returns an awaiting-input result carrying the described act and opaque state; the client answers and retries. Nothing is held open, so any replica can serve the retry.2025-11-25— the server sendselicitation/createinside the call and waits for the reply, which is the only mechanism that revision has. It needs a connection that keeps a channel back, which stdio has and stateless HTTP does not.
A client that declared no elicitation is refused rather than served unasked: "the host could not be asked" is not a reason to proceed. A client that did declare it but connected without a channel back gets a refusal naming the channel, because it has already done what a capability refusal would ask of it. FR-037c records the third carriage — URL mode elicitation, for a client that can render no prompt at all — as deferred.
A read-only deployment withholds every gated act along with the writes: an approval marks a privileged result (FR-020), so those acts are absent from discovery and refused on call.
Thirty-four of the 439 callable operations are withheld, each with a stated
reason. A withheld identifier is refused by name and reason rather than reported
as unknown, because "unknown" invites another guess
(tests/conformance/test_unpublished_set.py).
Token cost
Asserted, not estimated — tests/contract/test_listing_budget.py measures the
published surface with cl100k_base:
| What | Measured | Ceiling |
|---|---|---|
| The four discovery tools | 1,957 | 2,000 |
| The 17 workflow tools | 3,887 | 4,000 |
Everything one tools/list returns |
5,300 | 6,000 |
| The largest single tool | 636 | 700 |
The workflow half got 1,632 tokens cheaper by declaring one thing once: all 17
return the same result envelope, and each was publishing an identical 96-token
outputSchema to say so. The shape is published once as a resource now
(kamiwaza://shapes/workflow-result), where resources/read is a separate
call and a host that never validates never pays for it. The four discovery
tools still declare their own, because theirs differ — for comparison, Neon
publishes none across 113 tools and GitHub none across 45.
A host that wants the whole catalog anyway — one running its own code mode — asks
for it deliberately on GET /mcp?codemode=false, narrowable by category and
q, and the answer states its own measured token cost (server/catalog.py).
It is never the default, and it is behind the same admission as everything else.
detail decides how much of each entry comes back, which is a different
question from which entries come back:
detail |
Each entry carries | 405 operations |
|---|---|---|
names |
identifier | 3,196 |
brief |
identifier, category, description | 10,579 |
full (default) |
every field | 27,119 |
What a result tells you
Five failure kinds, each with a distinct next step, produced in one place
(envelope/outcomes.py). Two kinds sharing a next step fails at import, because
two kinds an agent cannot tell apart are one kind.
| Outcome | Next step | Retry the identical call? |
|---|---|---|
| success | continue | — |
rejected_input |
correct_and_retry, naming the argument that did not validate |
yes |
entitlement_refusal |
stop_and_report, naming what would grant it |
no |
unmet_prerequisite |
satisfy_prerequisite, naming what was absent |
yes |
expired_wait |
resume_existing, naming the work already under way |
no — a retry creates a second one |
platform_fault |
retry_only_if_idempotent, naming the layer that failed |
only if idempotent |
Every tool carries the protocol's advisory annotations — readOnlyHint,
destructiveHint, idempotentHint, openWorldHint — derived from the
operation's own effect rather than from an HTTP verb. Hints are advisory;
enforcement is server-side, and a host that ignores every hint is still refused.
Resources and prompts
The knowledge resource kamiwaza://docs/using-this-surface carries the same six
topics as one Markdown document, assembled by surface/docs.py as_document and
committed at docs/using-this-surface.md in the repository.
tests/contract/test_resources.py asserts the committed copy matches what the
server serves, and its failure message carries the regeneration command. Tool
descriptions state only what a tool does and returns, so behavioural rules live
in exactly one place.
The prompt primitive is served and empty. Served, because an unserved method reads to a host as a gap in the server; empty, because prompts would become a second home for behavioural policy. No completion capability is advertised, since completion completes the arguments of a prompt or a resource template and this server publishes neither.
Operating it
GET /healthz— liveness, shallow on purpose: a probe that consulted the platform would have an orchestrator restart a healthy process during someone else's outage.GET /readyz— readiness, reported separately from liveness, and flipped when the protocol transport is actually running rather than when the object graph exists.GET /version— this server's version, the pinned descriptor version and the served revisions, each read from the running install rather than from a constant, so a replica left behind by a partial rollout reports the old version. The same two versions are readable through thedocstool.
Shutdown drains in-flight work before terminating. One replica is fully functional alone, and a second needs no leader election, sticky routing or inter-instance messaging: the transport is stateless and task state is the platform's.
Blocking SDK calls, workflows, and task-status reads run in worker threads, so
an in-flight platform request does not prevent /healthz from responding. The
SDK exposes no per-call timeout; shutting down still waits for accepted work.
Installing it as a standalone server
pip install kamiwaza-mcp # or run it directly: uvx kamiwaza-mcp
kamiwaza-sdk is pinned exactly, because this server's whole surface is
derived from its kamiwaza_sdk.agent_tools layer; both it and
kamiwaza-extensions-lib resolve from PyPI. tests/contract/test_exact_pin.py
fails if the pin becomes a range or the lock resolves the descriptor package
from anywhere but the index.
Packages
Two standalone packages are built and checked on every change:
kamiwaza-mcpon PyPI, the distribution this repository builds (make package).kamiwaza-mcpon npm (npm/), a dependency-free launcher for clients that start servers withnpx. It runs thekamiwaza-mcprelease of its own version withuvx, or the container image when only Docker is available:npx -y kamiwaza-mcp.
.github/workflows/release-packages.yml publishes both, with trusted
publishing, for a vX.Y.Z tag on main once scripts/check_publishable.py
passes and the PUBLISH_PACKAGES repository variable is true. CI runs the
same check on every change, so a dependency that only resolves from a private
source fails the change that adds it rather than the release. The repository
is internal, and npm does not generate provenance for a package published
from a non-public repository.
Installing it as a Kamiwaza extension
The same server runs as a platform extension, built to the platform's own
kz-ext contract rather than a packaging scheme invented here: kamiwaza.json
(type tool), docker-compose.yml, and a Dockerfile that builds non-root
and runs with a read-only root filesystem. kz-ext validate passes.
kz-ext dev writes local deployment state under .kz-ext/. That directory is
excluded from Git and the Docker build context. The image build installs every
dependency from the lockfile with hashes, from the public index, so it needs no
credential.
kz-ext validate # the platform's own three validators
kz-ext dev # build, push, install into a cluster
kz-ext status # the installed instance and its phase
The extension is the same server: its entry point, python -m kamiwaza_mcp, goes through the one application factory and selects the hosted
topology, because an extension runs behind the platform's edge and receives
exactly the forwarded context that topology reads. The install asks for
nothing. It prefers KAMIWAZA_API_URL; otherwise it derives the API root from
platform-injected KAMIWAZA_INTERNAL_ORIGIN, KAMIWAZA_PUBLIC_API_URL,
KAMIWAZA_ORIGIN, or the origin of KAMIWAZA_APP_URL. It uses
KAMIWAZA_PLATFORM_GATEWAY_URL only as the last fallback because an internal
gateway hostname might not match the platform certificate. No hostname, port,
container engine, or registry address is compiled into this choice. An
extension given no platform fact fails its rollout rather than starting against
the wrong cluster.
Three deliberate deviations from the scaffolded template
Each was measured against a live cluster, and each is a place where the
kz-ext tool template disagrees with what the platform accepts or with what
this server can serve.
The transport. The template's src/server.py imports
mcp.server.fastmcp.FastMCP and runs transport="sse". FastMCP does not
exist in the protocol library this server pins, and HTTP-with-SSE is deprecated
in both revisions it serves. The extension serves Streamable HTTP at /mcp.
The probe. Following from that, the platform's payload builder gives a
primary tool an httpGet probe on /sse — an endpoint this server does not
have, so the pod would never report ready. The descriptor package documents the
escape hatch for exactly this case, and kamiwaza.json uses it: a
services.tool.healthCheck override probing /healthz.
The verification switch. The template declares KAMIWAZA_VERIFY_SSL. With
it present the platform refuses the install outright — "egress verification is
not weakenable by tenant intent, extension artifact content, a model requester,
a carried pod template, or workload environment". The platform is right, and
the variable is absent here: whether egress certificates are verified is the
platform's decision, not a value an extension carries.
Two things to know before installing
Use the container engine and registry selected by local kz-ext
configuration; this repository does not require a specific engine, registry
implementation, hostname, or port.
The target may require immutable image references. kz-ext dev must resolve
those references through its configured build and registry workflow. If the
installed SDK sends tag-only images or fields the target rejects, stop and use
a compatible SDK instead of hand-authoring a deployment payload.
The platform merges a re-installed extension's service environment rather than replacing it, so a payload corrected after a failed install can still carry the field that failed. Delete the extension and install again rather than reinstalling over it.
Pointing an LLM client at it
Three ways to reach the same tool surface, and the configuration each takes.
The key name differs between clients — mcpServers here is the spelling Claude
Desktop, Cursor and VS Code use; claude mcp add and Codex write the same
fields under their own key.
Standalone over stdio, where the client launches the process. Nothing
listens on a port, and with a kz-ext login sign-in the client configuration
holds no credential and no cluster address at all:
{
"mcpServers": {
"kamiwaza": {
"command": "uvx",
"args": ["kamiwaza-mcp==0.2.1"]
}
}
}
Add "--connection", "NAME" to args to pin a stored connection other than
the active one. Without a sign-in, put KAMIWAZA_API_URL and
KAMIWAZA_MCP_CREDENTIAL in the entry's env; the credential is read from the
environment and never from argv, where every process on the machine could
read it.
Standalone over HTTP, for a client that attaches to a running server. Start
it with kamiwaza-mcp --transport http --port 8080; it binds loopback only:
{
"mcpServers": {
"kamiwaza": {
"type": "http",
"url": "http://127.0.0.1:8080/mcp",
"headers": { "Authorization": "Bearer <a credential that cluster issued>" }
}
}
}
A client that implements RFC 9728 needs no headers block: it reads
/.well-known/oauth-protected-resource/mcp, which this server publishes
unauthenticated, and authorizes from there. A client that does not gets a 401
carrying the same pointer in WWW-Authenticate.
As a Kamiwaza extension, where the server runs in the cluster behind the
platform edge and the client is remote. The URL is the platform host, the
runtime prefix, and the instance name kz-ext status reports:
{
"mcpServers": {
"kamiwaza": {
"type": "http",
"url": "https://kamiwaza.example.com/runtime/tools/tool-kamiwaza-mcp/mcp",
"headers": { "Authorization": "Bearer <the member's access token>" }
}
}
}
The edge authenticates, not this server. Measured against a live install:
Authorization: Bearer <member token> initializes; x-auth-token alone and no
header at all are both 401 {"detail":"Not authenticated"} from the edge,
before anything here is reached. Everything after that — which member, which
roles, which tenant — arrives as the forwarded context the hosted topology
reads, so nothing else belongs in the client's configuration.
One thing a client can trip over in every mode. The two revisions served are
2026-07-28, declared per request in MCP-Protocol-Version, and 2025-11-25,
negotiated once in initialize — so a client that opens with initialize is
answered about the second alone. Measured against a running server, a client
pinned to 2025-06-18 gets:
{"code": -32022, "message": "Unsupported protocol version",
"data": {"supported": ["2025-11-25"], "requested": "2025-06-18"}}
2026-07-28 is absent from that list because it is not negotiated there, not
because it is unavailable: the same server answers tools/list with all 21
tools over that revision, given the header and the _meta envelope it
requires. Either way the refusal is explicit rather than a silent downgrade.
Development
uv sync # install, including dev dependencies
.venv/bin/python -m pytest # unit, contract, integration, conformance
.venv/bin/python -m pytest -m conformance # one marker at a time
.venv/bin/python -m ruff check .
.venv/bin/python -m mypy
.venv/bin/python -m uat.runner # the declared acceptance criteria
.venv/bin/python -m uat.selfcheck # verify the harness itself
The four pytest markers are unit, contract, integration and conformance
(pyproject.toml). uat.runner takes --area, --criterion and --json; a
declared criterion with no registered case reports NOT_EXERCISED rather than
being skipped, so missing coverage is visible in the report instead of absent
from it.
This repository is developed with spec-kit, and the specification is the source of truth:
| Artifact | Purpose |
|---|---|
specs/001-mcp-server/spec.md |
What the server must do — requirements and success criteria |
specs/001-mcp-server/plan.md |
Technical context and constitution gates |
specs/001-mcp-server/research.md |
Every design decision with its alternatives |
specs/001-mcp-server/data-model.md |
Entities and their relationships |
specs/001-mcp-server/contracts/ |
Tool surface, resource descriptors, result envelopes, protocol conformance |
specs/001-mcp-server/tasks.md |
Implementation tasks, each mirrored to a GitHub issue |
.specify/memory/constitution.md |
The principles every change is checked against |
Changes to behaviour start in the specification, not in the code. See
AGENTS.md in the repository for the working rules.
Compatibility
| MCP revisions | 2026-07-28 and 2025-11-25, both from one process |
| Extension | io.modelcontextprotocol/tasks, optional |
| Transports | Streamable HTTP, stdio |
| Primitives | tools, resources. Prompts served and empty |
| Python | >=3.11 |
| Protocol library | mcp>=2.2.0,<3.0.0 |
| Descriptor layer | kamiwaza-sdk, pinned exactly, readable from the surface |
Security
- No caller credential is forwarded onward. The protocol names token passthrough an anti-pattern, and this server follows it.
- No secret appears in a tool description, a log line, or an error. A refusal repeats nothing the caller presented, so a probe is not logged verbatim.
- Identity and scope are never accepted from a request. A claim about the
caller —
FORBIDDEN_CALLER_FIELDSinauthority/admission.py— is refused where a caller could be making it, at the top level of a call's arguments; the scope this server fills,CALLER_SCOPE_FIELDS(workroom_id,tenant_id), is refused at any depth, because it is stripped from every published shape. Both refuse before the platform is reached. - Operations whose result is itself a credential are not published, and each withheld operation is refused by name with its reason rather than silently omitted.
- Every call is authorized individually. A prior discovery result is not authorization.
Report a suspected vulnerability privately to the Kamiwaza security contact rather than in a public issue.
License
The source code and the Python and npm packages are licensed under the Apache
License 2.0. See the LICENSE and NOTICE files, which ship in every package.
The container image is distributed under the
Kamiwaza EULA and carries its
third-party notices under /licenses.
Metadata
Release files for kamiwaza-mcp 0.2.1
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| kamiwaza_mcp-0.2.1.tar.gz | 225.1 kB | With provenance | Details for kamiwaza_mcp-0.2.1.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| kamiwaza_mcp-0.2.1-py3-none-any.whl | Python 3 | none | any | Details for kamiwaza_mcp-0.2.1-py3-none-any.whl |
Total release size: 460.9 kB
Release files / kamiwaza_mcp-0.2.1.tar.gz
| Download URL | kamiwaza_mcp-0.2.1.tar.gz |
|---|---|
| Size | 225.1 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
af81fd839acedcb26f74fa83f372f06a4c0da941f7d6f1f27bae1695026ed988
|
|
BLAKE2b-256 checksum How to use checksums |
f5cb50e4fdc56cc158d87f4e1d6c6a378e32a4c09789fe2bbfef818b33cf5055
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 20, 2026.
Transparency logRelease files / kamiwaza_mcp-0.2.1-py3-none-any.whl
| Download URL | kamiwaza_mcp-0.2.1-py3-none-any.whl |
|---|---|
| Size | 235.8 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
7bd03866b29b1487b855401901b436d82282aef5de3f314997edde6ee78bd5d8
|
|
BLAKE2b-256 checksum How to use checksums |
83c2c688de3b2006a971cc47f4a7c7d2cbd6523e479794882251e1b8856c2c81
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 20, 2026.
Transparency logSecurity for kamiwaza-mcp 0.2.1
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for kamiwaza_mcp-0.2.1.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 20, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.