Skip to main content
Glama

polaris-mcp

An MCP server for Polaris, the squad-owned architectural fitness-function control plane. It exposes Polaris' REST API (/api/v1) as 16 grouped tools over stdio or MCP streamable HTTP (for containerized deployment), handles Google OIDC automatically (one-time browser login, silent ID-token refresh), and uses the ingest X-API-Key for measurement submissions.

Tools

Tool

Actions

polaris_health

live, ready

polaris_tribes

list, get, create, archive, overview

polaris_squads

list, get, create, transfer

polaris_fitness_targets

list, get, create, transition, history

polaris_measurement_providers

list_types

polaris_measurement_sources

list, get, create, check_connection, validate_query, activate, retire

polaris_measurement_producers

create

polaris_fitness_functions

list, get, create, add_version, update_draft_version, validate_version, activate_version, retire

polaris_measurement_submissions

submit, submit_batch (X-API-Key)

polaris_evaluation_requests

create, get, cancel

polaris_evaluations

get, list_by_function

polaris_collection_attempts

list, get, collect_now, retry

polaris_waivers

propose, decide (approve / reject / revoke)

polaris_fitness_function_templates

list, publish, adopt

polaris_insights

squad_overview, tribe_overview, target_history

polaris_events

poll, acknowledge

Payloads use the REST API's camelCase keys exactly as documented in each tool description. Lists return {items, nextCursor}; pass nextCursor back as cursor, or set all_pages: true to follow cursors automatically (capped at 10 pages / 1000 items). Fitness-function version mutations are guarded by If-Match: pass the aggregate revision explicitly, or omit it to use the current one automatically. Errors surface Polaris' RFC 9457 problem code and correlationId.

Related MCP server: Attenza

Setup

1. Google OAuth client

Business endpoints require a Google OpenID Connect ID token, and Polaris verifies the audience — use the same OAuth client ID the Polaris server is configured with (POLARIS_OIDC_CLIENT_ID).

  1. In Google Cloud Console, open the OAuth client used by Polaris (type Web application).

  2. Add http://localhost:8887 as an authorized redirect URI (polaris-mcp listens there during login; it falls back to a random port if 8887 is taken, in which case also allow http://localhost — Google ignores the port for loopback URIs).

2. Configure environment

Variable

Meaning

Default

POLARIS_BASE_URL

Polaris API origin

http://localhost:8080

POLARIS_OIDC_CLIENT_ID

Google OAuth client ID (same as the server's)

— (required for login)

POLARIS_OIDC_CLIENT_SECRET

Client secret, for clients that require it at token exchange

—

POLARIS_INGEST_API_KEY

Ingest secret (X-API-Key) enabling the submission tools

—

POLARIS_AUTHORIZED_EMAIL

Optional client-side sanity check at login

—

POLARIS_CREDENTIALS_FILE

Where the refresh token is stored

~/.config/polaris-mcp/credentials.json (0600)

POLARIS_TIMEOUT_SECONDS

HTTP timeout

30

POLARIS_MCP_TRANSPORT

stdio or streamable-http

stdio

POLARIS_MCP_HOST

Bind address for streamable-http

127.0.0.1

POLARIS_MCP_PORT

Listen port for streamable-http

8000

POLARIS_CALLBACK_BIND_HOST

Bind address for the login redirect listener (use 0.0.0.0 inside containers)

127.0.0.1

3. Install and log in

python3 -m venv .venv && .venv/bin/pip install -e .
.venv/bin/polaris-mcp login    # one-time browser sign-in (OAuth code + PKCE)
.venv/bin/polaris-mcp status   # verify credentials, token refresh, and health

login opens a browser at Google, receives the redirect on a loopback port, and stores the refresh token locally. ID tokens (~1h lifetime) are refreshed silently from then on; no credentials or tokens are ever sent anywhere except Google's and Polaris's endpoints.

4. Register with an MCP host

Claude Desktop (claude_desktop_config.json):

{
  "mcpServers": {
    "polaris": {
      "command": "/Users/you/polaris-mcp/.venv/bin/polaris-mcp",
      "env": {
        "POLARIS_BASE_URL": "http://localhost:8080",
        "POLARIS_OIDC_CLIENT_ID": "<client-id>",
        "POLARIS_INGEST_API_KEY": "<ingest-secret>"
      }
    }
  }
}

opencode (opencode.json):

{
  "mcp": {
    "polaris": {
      "type": "local",
      "command": ["polaris-mcp", "serve"],
      "enabled": true,
      "environment": {
        "POLARIS_BASE_URL": "http://localhost:8080",
        "POLARIS_OIDC_CLIENT_ID": "<client-id>",
        "POLARIS_INGEST_API_KEY": "<ingest-secret>"
      }
    }
  }
}

(serve is the default subcommand, so command: ["polaris-mcp"] works too. If the script is on PATH — e.g. installed with pipx — no absolute path is needed.)

Deploy with Docker Compose

To serve polaris-mcp as a container speaking MCP streamable HTTP instead of stdio, copy .env.example to .env, set at least POLARIS_OIDC_CLIENT_ID, then:

docker compose up -d --build     # MCP endpoint at http://localhost:8000/mcp

The image defaults to streamable-http on 0.0.0.0:8000 inside the container, and compose publishes it loopback-only on the host. The Google refresh token lives in the polaris-mcp-data volume, so a login survives container upgrades.

Reaching the Polaris API

Pick the POLARIS_BASE_URL that matches where Polaris runs:

  • Same host, polaris compose stack (its ports publish loopback-only): join its network. Uncomment the networks blocks in compose.yaml (the network is named polaris_default unless the stack was started with -p), and set POLARIS_BASE_URL=http://polaris:8080.

  • A process on the Docker host listening on all interfaces: the default http://host.docker.internal:8080 works as-is.

  • A public origin (e.g. the polaris Caddy edge): set POLARIS_BASE_URL=https://<domain>.

One-time login in the container

docker compose run --rm --publish 8887:8887 \
  -e POLARIS_CALLBACK_BIND_HOST=0.0.0.0 \
  polaris-mcp login --no-browser

Open the printed authorize URL in a browser on your machine; Google redirects back to http://localhost:8887, which is forwarded into the container. Verify afterwards:

docker compose run --rm polaris-mcp status

Connecting MCP clients over HTTP

Any host that speaks streamable HTTP can point at http://localhost:8000/mcp. opencode:

{
  "mcp": {
    "polaris": {
      "type": "remote",
      "url": "http://localhost:8000/mcp",
      "enabled": true
    }
  }
}

Deploying released images

Every release is pushed to GHCR as ghcr.io/polaris-harness/polaris-mcp:vX.Y.Z (plus latest). To run a released version instead of building from source, set POLARIS_MCP_TAG in .env and:

docker compose pull && docker compose up -d

Security note: the streamable-http endpoint has no authentication of its own — keep it loopback-only (the compose default) or front it with a TLS edge before exposing it off-host.

Development

python3 -m venv .venv && .venv/bin/pip install -e '.[dev]'
.venv/bin/pytest        # client, auth, and in-memory MCP session tests (no network)

Or through the Makefile:

make install   # pip install -e '.[dev]'
make lint      # ruff check + format check
make format    # ruff autofix + format
make test      # pytest
make coverage  # pytest with a 95% coverage gate (currently at 100%)
make build     # sdist + wheel (twine-checked in CI)
make smoke     # install the wheel into a clean venv and drive it over stdio
make audit     # pip-audit over installed dependencies
make image     # build the Docker image locally (polaris-mcp:local)

Continuous integration

The GitHub Actions workflow in .github/workflows/ci.yml gates pushes, pull requests (to main/develop), and a weekly schedule with:

  • Python lint — ruff check and ruff format --check;

  • Unit tests — pytest on Python 3.10 and 3.13 with a 95% coverage gate (coverage.xml uploaded as an artifact);

  • Build distributions — python -m build + twine check;

  • Install smoke test — the wheel is installed into a clean venv and exercised over real stdio (scripts/smoke_stdio.py);

  • Dependency vulnerability scan — pip-audit --strict, re-run weekly to catch new CVEs;

  • Docker image — on pull requests the image is built and exercised over real streamable HTTP inside a container (scripts/smoke_http.py).

After all gates pass on main, the workflow computes the next patch version from git tags, tags the commit, and creates a GitHub release with the sdist and wheel attached, and publishes the container image to GHCR (ghcr.io/polaris-harness/polaris-mcp:vX.Y.Z and :latest). Publishing to PyPI via trusted publishing is opt-in: set the repository variable PYPI_PUBLISH=true and configure a pypi environment (with this repository as a trusted publisher) to enable it.

Security notes

  • The Google refresh token is stored with 0600 permissions and used only against https://oauth2.googleapis.com/token.

  • ID-token claims are decoded locally (no signature verification) only to decide when to refresh; Polaris performs full verification (issuer, audience, expiry, signature) on every request.

  • The ingest API key is only attached to the two measurement-submission endpoints, matching the server's expectations.

License

Proprietary, following Polaris.

Available Tools

16 tools
polaris_collection_attemptsA

Manage pull collection attempts.

Actions and required parameters:

  • list: fitness_function_id — retained attempts with measurements and provider evidence

  • get: attempt_id — one retained attempt (status SUCCEEDED|FAILED, measurements, evidence)

  • collect_now: fitness_function_id — executes the active PULL definition immediately (outside its schedule) and returns the recorded evaluation. Requires an ACTIVE function with a PULL acquisition and an ACTIVE source; provider failures surface as 500.

  • retry: attempt_id — re-runs collection after e.g. a provider outage; returns the new evaluation while the original attempt is retained unchanged

Attempt JSON: {id, parentId: fitnessFunctionId, kind: "collection-attempt", status: SUCCEEDED|FAILED, revision, data: {sourceId, measurements: [{criterionKey, value, unit}], evidence: [...]}, createdAt, updatedAt}.

Inputs: action (required), limit, cursor, all_pages, +2 more.

polaris_evaluation_requestsA

Manage evaluation requests.

Actions and required parameters:

  • create: fitness_function_id — accepted with 202 as PENDING; fulfilled when a producer pushes a submission carrying the request's id (or by pull collection)

  • get: request_id — poll the state (PENDING until fulfilled, CANCELLED after cancellation)

  • cancel: request_id — cancels a PENDING request (e.g. the triggering pipeline was aborted); cancelling twice yields 409

Evaluation-request JSON: {id, parentId: fitnessFunctionId, kind: "evaluation-request", status: PENDING|CANCELLED, revision, data, createdAt, updatedAt}. The created id is the evaluationRequestId a producer references in its submission.

Inputs: action (required), request_id, fitness_function_id.

polaris_evaluationsA

Read evaluations.

Actions and required parameters:

  • get: evaluation_id — the immutable evaluation in full

  • list_by_function: fitness_function_id — recorded evaluations in creation order (optional limit/cursor/all_pages)

Evaluation JSON: {evaluationId, fitnessFunctionId, fitnessFunctionVersion, acquisitionMode: PUSH|PULL, originId, outcome: PASS|WARN|FAIL|ERROR|NOT_APPLICABLE, disposition: ACCEPTED|ATTENTION_REQUIRED|BLOCKED|WAIVED (enforcement decision honoring approved unexpired waivers), observedAt, validUntil (stale after this), criterionResults: [{criterionKey, value, unit, outcome: PASS|WARN|FAIL}], data: retained measurements and evidence}. Evaluations are never modified after recording; no data never counts as success.

Inputs: action (required), limit, cursor, all_pages, +2 more.

polaris_eventsA

Consume delivery events published through the transactional outbox.

Actions and required parameters:

  • poll: consumer_id (stable identity, 1-100 chars) — returns events newer than cursor (optional limit). Persist the returned nextCursor between polls; without a cursor you start from the oldest event. After successfully processing events, acknowledge them.

  • acknowledge: consumer_id + event_ids (1-500 ids) — acknowledged events are never redelivered to that consumer; acknowledgement is idempotent per (consumer, event) pair.

Event JSON: {id, type (e.g. EvaluationRecorded, FitnessFunctionVersionActivated), version, aggregateType, aggregateId, occurredAt, actor, correlationId, payload}.

Inputs: action (required), limit, cursor, all_pages, +2 more.

polaris_fitness_functionsA

Manage fitness functions: versioned definitions of intent, scope, criteria, acquisition, freshness, and enforcement. Definitions evolve as immutable draft-then-activate versions.

Actions and required parameters:

  • list: squad_id — the squad's functions with full version history (limit/cursor/all_pages)

  • get: fitness_function_id — aggregate with lifecycle (DRAFT|ACTIVE|RETIRED), revision, and complete version history

  • create: squad_id + definition — creates the function with draft version 1

  • add_version: fitness_function_id + definition — appends a new draft version (guarded by If-Match: pass the aggregate revision explicitly, or omit it to use the current one)

  • update_draft_version: fitness_function_id + version + definition — replaces a still-DRAFT version (If-Match as above; activated versions are immutable)

  • validate_version: fitness_function_id + version — re-runs validation without side effects

  • activate_version: fitness_function_id + version (optional reason) — makes it the active definition; evaluations then use it

  • retire: fitness_function_id (optional reason) — terminal; history stays queryable

definition is a JSON object with camelCase keys (Polaris FitnessDefinition): required: name; purpose; objective; targetIds (array of the squad's fitness-target ids); criteria (array of {key (pattern ^[a-z][a-z0-9_]{0,62}$, unit, warningComparison?, warningValue?, failureComparison (GREATER_THAN|GREATER_THAN_OR_EQUAL|LESS_THAN|LESS_THAN_OR_EQUAL| EQUAL|NOT_EQUAL), failureValue, required?}); acquisition ({mode: "PUSH", producerId, maximumObservationAgeSeconds} or {mode: "PULL", sourceId, trigger: SCHEDULED|ON_DEMAND, intervalSeconds? (>=60, SCHEDULED only), timeoutSeconds (1-30), queries: array of {criterionKey, expression (PromQL), mode: INSTANT|RANGE, lookbackSeconds?, stepSeconds?, reduction (LAST|MIN|MAX|AVERAGE|SUM|COUNT), seriesPolicy (REQUIRE_SINGLE_SERIES|REDUCE_ACROSS_SERIES|ERROR_ON_MULTIPLE_SERIES), unit} covering every criterion key}); freshnessSeconds (how long an evaluation stays fresh); enforcement (OBSERVE|WARN|BLOCK); optional: characteristic (e.g. RELIABILITY), changeRationale. Warning thresholds must be milder than failure thresholds when both are declared.

Inputs: action (required), limit, cursor, reason, +6 more.

polaris_fitness_function_templatesA

Manage tribe-published fitness-function templates.

Actions and required parameters:

  • list: tribe_id — the tribe's templates (optional limit/cursor/all_pages)

  • publish: tribe_id + name (optional description, optional definition — a FitnessDefinition object with the same camelCase keys used by polaris_fitness_functions). Names are unique within a tribe (duplicate yields 409).

  • adopt: template_id + squad_id (optional target_ids scope override, optional reason) — creates a squad-owned DRAFT fitness function; the tribe retains no ownership, and the squad may adapt the draft before activating it.

Template JSON: {id, parentId: tribeId, kind: "fitness-function-template", status: ACTIVE, revision, data: {name, description?, definition?}, createdAt, updatedAt}.

Inputs: action (required), name, limit, cursor, +8 more.

polaris_fitness_targetsA

Manage fitness targets: systems (services, databases, queues, ...) a squad is accountable for.

Actions and required parameters:

  • list: squad_id (optional limit/cursor/all_pages)

  • get: target_id

  • create: squad_id + name (optional description, target_kind e.g. SERVICE/DATABASE/QUEUE, criticality e.g. CRITICAL/HIGH, external_reference object) — created ACTIVE

  • transition: target_id + status (ACTIVE|DEPRECATED|RETIRED, optional reason) — explicit, auditable lifecycle change; history stays queryable

  • history: target_id — chronological fitness-history entries (Insights read model)

Target JSON: {id, parentId: squadId, kind: "fitness-target", status: ACTIVE|DEPRECATED|RETIRED, revision, data: {name, description?, kind?, criticality?, externalReference?}, ...}.

Inputs: action (required), name, limit, cursor, +9 more.

polaris_healthA

Probe Polaris health.

  • live: process liveness (no dependencies; use for restart probes)

  • ready: readiness to serve traffic (verifies PostgreSQL; 503 problem document while down)

Returns {"status": "ok"} on success.

Inputs: action (required).

polaris_insightsA

Read insight aggregates computed from retained evaluations.

Actions and required parameters:

  • squad_overview: squad_id — aggregated architectural fitness for one squad

  • tribe_overview: tribe_id — patterns across the tribe's squads (no league table)

  • target_history: target_id — chronological fitness-history entries for one target (optional limit/cursor/all_pages)

Overviews expose outcomes and dispositions without collapsing them into a single universal score: {scope: squad|tribe, scopeId, generatedAt, status: AVAILABLE}.

Inputs: action (required), limit, cursor, squad_id, +3 more.

polaris_measurement_producersA

Register measurement producers: identities authorized to PUSH measurements for a squad.

Action: create — requires squad_id + name (optional description). A push fitness-function definition declares exactly one producerId, and only that producer may submit against it.

Producer JSON: {id, parentId: squadId, kind: "measurement-producer", status: ACTIVE, revision, data: {name, description?}, ...}. The returned id is the producerId to reference in PUSH acquisition definitions and submissions.

Inputs: action (required), name, squad_id, description.

polaris_measurement_providersA

Discover supported pull measurement providers.

Action: list_types — returns the provider capability catalog. Each entry states the query capabilities (INSTANT_QUERY, RANGE_QUERY) and supported outbound authentication modes (only NONE in v1; only PROMETHEUS is supported). Use this instead of hard-coding provider assumptions; new providers appear here without changing other resource shapes.

Inputs: action (required).

polaris_measurement_sourcesA

Manage measurement sources: squad-owned connections to pull providers.

Lifecycle: create → DRAFT, then check_connection must succeed, then activate. Retirement is rejected (409) while an active fitness-function version still depends on the source.

Actions and required parameters:

  • list: squad_id (optional limit/cursor/all_pages)

  • get: source_id

  • create: squad_id + name + provider_type (PROMETHEUS) + base_url (optional description). Never include credentials; none are stored or returned. Created in DRAFT.

  • check_connection: source_id — probes the provider; retained as evidence. A failed probe yields 422 with the provider error in the detail.

  • validate_query: source_id + query (a MetricQuery object; optional execute_sample=true also executes it once and returns the sample value with provider evidence). Query keys (camelCase): criterionKey, expression (PromQL), mode (INSTANT|RANGE), reduction (LAST|MIN|MAX|AVERAGE|SUM|COUNT), seriesPolicy (REQUIRE_SINGLE_SERIES|REDUCE_ACROSS_SERIES| ERROR_ON_MULTIPLE_SERIES), unit, plus lookbackSeconds/stepSeconds for RANGE.

  • activate: source_id (optional reason, e.g. which check id was reviewed)

  • retire: source_id (optional reason)

Source JSON: {id, parentId: squadId, kind: "measurement-source", status: DRAFT|ACTIVE|RETIRED, revision, data: {name, providerType, baseUrl, description?}, ...}.

Inputs: action (required), name, limit, query, +9 more.

polaris_measurement_submissionsA

Push measurements for evaluation against the ACTIVE fitness-function version.

These are the ingest endpoints: they authenticate with the X-API-Key configured as POLARIS_INGEST_API_KEY (no Google login involved).

Actions and required parameters:

  • submit: fitness_function_id + submission — evaluates synchronously and returns the recorded evaluation (with replayed: true when a duplicate producerId+externalRunId delivery returned the original evaluation). Submissions against a non-active version yield 409.

  • submit_batch: items — up to 100 independent submissions, each {fitnessFunctionId, submission}; the 207 response carries per-item status (201 success, or 404/409/422/500 with an error message); per-item failures do not abort the batch.

submission is a JSON object with camelCase keys: required: fitnessFunctionVersion (the active version number); producerId (the producer declared by the active definition); externalRunId (producer-scoped run id, the idempotency natural key); observedAt (RFC 3339 UTC, not in the future, within the definition's maximum observation age); measurements (array of {criterionKey, value, unit, observedAt?}, one per criterion, duplicates rejected); optional: evaluationRequestId (request this submission fulfills), evidence (array of arbitrary evidence documents).

Inputs: action (required), items, submission, fitness_function_id.

polaris_squadsA

Manage squads, the owning unit of fitness targets, sources, producers, and fitness functions.

Actions and required parameters:

  • list: tribe_id — squads currently in the tribe (optional limit/cursor/all_pages)

  • get: squad_id

  • create: tribe_id + name (optional mission) — squad is registered ACTIVE in the tribe

  • transfer: squad_id + destination_tribe_id (optional reason) — squad keeps ownership of everything it owns

Squad JSON: {id, parentId: tribeId, kind: "squad", status: ACTIVE, revision, data: {name, mission?}, createdAt, updatedAt}.

Inputs: action (required), name, limit, cursor, +6 more.

polaris_tribesA

Manage Polaris tribes, the topology level that groups squads.

Actions and required parameters:

  • list: optional limit (1-200) / cursor / all_pages

  • get: tribe_id

  • create: name (optional description)

  • archive: tribe_id (optional reason) — tribe stays queryable, status becomes ARCHIVED

  • overview: tribe_id — aggregated tribe fitness overview (Insights read model)

Tribe JSON: {id, kind: "tribe", status: ACTIVE|ARCHIVED, revision, data: {name, description?}, createdAt, updatedAt}. Lists return {items, nextCursor}; pass nextCursor back as cursor.

Inputs: action (required), name, limit, cursor, +4 more.

polaris_waiversA

Manage waivers: explicit, justified, time-limited exceptions for failing criteria.

Actions and required parameters:

  • propose: fitness_function_id + reason (why the exception is temporarily acceptable); optional criterion_keys (failing criteria covered; omit for all), risk, compensating_action, starts_at / expires_at (RFC 3339; expiresAt must be in the future and after startsAt). Enters state PROPOSED; only takes effect on approval.

  • decide: waiver_id + decision (approve|reject|revoke, optional reason). Approving accepts the risk (the waiver then influences dispositions until it expires); rejecting declines the proposal; revoking ends an approved waiver early. Deciding twice yields 409.

Waiver JSON: {id, parentId: fitnessFunctionId, kind: "waiver", status: PROPOSED|APPROVED| REJECTED|REVOKED, revision, data: {reason, criterionKeys?, risk?, compensatingAction?, startsAt?, expiresAt?}, createdAt, updatedAt}. Only APPROVED, unexpired waivers influence dispositions.

Inputs: action (required), risk, reason, decision, +6 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 16 tools

    Disambiguation4/5

    Most tools map to clearly distinct resources (tribes, squads, targets, functions, evaluations, waivers, etc.), and the descriptions clarify boundaries. However, there is some read-model overlap: polaris_insights duplicates tribe/squad overview and target history actions already exposed in polaris_tribes and polaris_fitness_targets, and the provider/source/producer trio requires careful reading to distinguish. These overlaps are manageable but prevent a perfect score.

    Naming Consistency5/5

    Every tool uses a consistent polaris_ prefix followed by a snake_case plural resource noun (polaris_tribes, polaris_fitness_functions, polaris_waivers, etc.). The only minor deviation is the singular polaris_health, but it still fits the predictable pattern. Actions are consistently described inside the tool rather than encoded in names.

    Tool Count4/5

    At 16 tools, the count is slightly above the typical 3–15 sweet spot but reasonable for a domain with many distinct resources and lifecycles (topology, fitness functions, measurements, evaluations, waivers, events). Each tool earns its place by grouping all actions for one resource, avoiding an explosion of per-action tools. It is borderline heavy but well-scoped.

    Completeness4/5

    The surface covers the core lifecycle for most entities: create, version, activate, retire, evaluate, collect, waive, and consume events. Minor gaps exist—several resources (tribes, squads, targets, sources, producers, templates) lack update or delete operations, and some read-model queries are split across tools. These gaps are unlikely to block common agent workflows but keep the surface from being fully complete.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Full-coverage GitLab MCP server with 44 tools across 18 resource types. Agent-optimized CQRS design — one tool call handles complete multi-step operations. Supports OAuth 2.1, read-only mode, stdio/SSE/StreamableHTTP transports, and GraphQL-native work items with full hierarchy (epics,issues,etc)
      8
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Provides OAuth-based MCP integration and client-side tooling for connecting agents to a remote service, with CLI and plugin support.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      A local stdio MCP adapter for the Daykeeper management API. It uses separately issued scoped credentials and exposes read-only tools by default; planning and mutations require explicit opt-in.
      8
      24 npm
      Apache 2.0