polaris-mcp
This MCP server exposes Polaris' REST API as 16 grouped tools, letting you manage the full architectural fitness-function control plane over stdio or streamable HTTP.
Manage tribes: list, get, create, archive, and view aggregated tribe overviews.
Manage squads: list by tribe, get, create, transfer between tribes.
Manage fitness targets: list, get, create, transition lifecycle status, view history.
Discover measurement providers and manage sources: list provider types; create DRAFT sources, check connections, validate PromQL queries, activate, retire.
Register measurement producers for push-based submissions.
Manage fitness functions: create, add/update draft versions, validate, activate, retire, with revision guarding via If-Match.
Submit measurements: single or batch push submissions authenticated by X-API-Key.
Manage evaluation requests: create, get, cancel.
Read evaluations: get one or list by fitness function.
Manage pull collection attempts: list, get, collect now, retry.
Manage waivers: propose exceptions and approve/reject/revoke them.
Manage fitness-function templates: list, publish, adopt into squads.
Read insights: squad overviews, tribe overviews, target history.
Consume events: poll and acknowledge delivery events.
Check health: live and ready probes.
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., "@polaris-mcp show the fitness overview for the Payments tribe and list its squads"
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.
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 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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).
In Google Cloud Console, open the OAuth client used by Polaris (type Web application).
Add
http://localhost:8887as 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 allowhttp://localhost— Google ignores the port for loopback URIs).
2. Configure environment
Variable | Meaning | Default |
| Polaris API origin |
|
| Google OAuth client ID (same as the server's) | — (required for login) |
| Client secret, for clients that require it at token exchange | — |
| Ingest secret ( | — |
| Optional client-side sanity check at login | — |
| Where the refresh token is stored |
|
| HTTP timeout |
|
|
|
|
| Bind address for streamable-http |
|
| Listen port for streamable-http |
|
| Bind address for the login redirect listener (use |
|
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 healthlogin 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/mcpThe 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
networksblocks in compose.yaml (the network is namedpolaris_defaultunless the stack was started with-p), and setPOLARIS_BASE_URL=http://polaris:8080.A process on the Docker host listening on all interfaces: the default
http://host.docker.internal:8080works 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-browserOpen 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 statusConnecting 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 -dSecurity 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 checkandruff format --check;Unit tests — pytest on Python 3.10 and 3.13 with a 95% coverage gate (
coverage.xmluploaded 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
0600permissions and used only againsthttps://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 toolspolaris_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
revisionexplicitly, 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: truewhen 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
Scored across 16 tools
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.
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.
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.
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
Related MCP Connectors
Toolstile is a managed MCP gateway that connects remote MCP servers behind one endpoint, with per-agent permissions, shared accounts and activity logs. Connect at https://mcp.toolstile.com/mcp over Streamable HTTP with OAuth; sign in at https://toolstile.com, select a workspace and connect your upstream servers. Available tools, resources and prompts depend on that workspace and the agent's granted access.
Governed MCP gateway: one endpoint for your tools, with credential custody and audit log.
MCP server for mandates, delegation, policy-gated execution, credential grants, and audit.
Authenticated MCP server for ClearPolicy policy and compliance workflows.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceFull-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)8Apache 2.0
- AlicenseNot gradedqualityBmaintenanceProvides OAuth-based MCP integration and client-side tooling for connecting agents to a remote service, with CLI and plugin support.MIT

Daykeeper MCPofficial
AlicenseAqualityBmaintenanceA 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.824 npmApache 2.0- AlicenseNot gradedqualityAmaintenanceEnables clients such as Claude, Cursor, VS Code, and Windsurf to manage workspaces, projects, tasks, and AI agents through a hosted OAuth endpoint or a local stdio package, and to generate MCP tools from OpenAPI specs.2,530 npmMIT