Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

{
  "mcpServers": {
    "humanmcp": {
      "type": "http",
      "url": "https://kapoost.humanmcp.net/mcp"
    }
  }
}

claude mcp add --transport http humanmcp https://kapoost.humanmcp.net/mcp

[mcp_servers.humanmcp]
url = "https://kapoost.humanmcp.net/mcp"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "humanmcp": {
      "type": "remote",
      "url": "https://kapoost.humanmcp.net/mcp",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "humanmcp": {
      "type": "http",
      "url": "https://kapoost.humanmcp.net/mcp"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=humanmcp&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8va2Fwb29zdC5odW1hbm1jcC5uZXQvbWNwIn0%3D"
}

{
  "servers": {
    "humanmcp": {
      "type": "http",
      "url": "https://kapoost.humanmcp.net/mcp"
    }
  }
}

{
  "mcpServers": {
    "humanmcp": {
      "httpUrl": "https://kapoost.humanmcp.net/mcp"
    }
  }
}

extensions:
  "humanmcp":
    enabled: true
    name: "humanmcp"
    type: streamable_http
    uri: "https://kapoost.humanmcp.net/mcp"
    timeout: 300

Quality 83 / 100good

protocol88 · weight 25

pass
protocol.modernsupports 2026-07-28 (server/discover)
pass
protocol.statelessanswers without a session
pass
protocol.transportstreamable HTTP
warn
protocol.list_ttltools/list declares ttlMs 0, so clients re-fetch it on every use

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene71 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
fail
tools.annotationsno tool declares readOnlyHint or destructiveHint, so clients cannot tell safe calls from risky ones
fail
tools.directory_hintsno tool declares all four of readOnlyHint, destructiveHint, idempotentHint and openWorldHint; missing: get_skill (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); fetch_narada_result (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); list_provenance (readOnlyHint, destructiveHint, idempotentHint, openWorldHint); …
pass
tools.token_costabout 3,771 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability100 · weight 15

pass
stability.changesno tool changes in 30 days
pass
stability.rug_pullno tool changed its meaning under the same name

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

43 tools, about 3,771 tokens to load them all · tool set 3e768c16bb83 · checked 2026-10-20 12:45 UTC

Tool changes

No tool definition changes recorded. A server's first observation is its baseline; later probes record what changes.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 87 / 100

provenance80

liveness100

freshness65

hygiene100

+repository +namespace-matches-repo +reachable +uptime-99% ~updated-168d-ago

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://kapoost.humanmcp.net/mcp` streamable-http	none	yes	99%	339 ms	2026-07-28, 2025-11-25, 2025-06-18, 2025-03-26, 2024-11-05	2026-10-20

Tools (43)

`about_humanmcp`	Self-description of this humanMCP server. Deterministic, no bootstrap required — call this first to decide whether the rest of the API is relevant.
`ask_human`	Submit an async question to kapoost. Returns an ID. Rate-limited 5/hr/IP. Poll fetch_answer later — kapoost answers on his own schedule (minutes, hours, or days). ALWAYS set `from` to a stable name for yourself: with it, sending the same question again returns the answer instead of creating a duplicate, which is the reliable path when your runtime cannot keep the ID between sessions.
`bootstrap_session`	Validate the Polish poetry session code, then emit the full team briefing (guardian + style + personas + skills + persist block). Rate-limited 5/min/IP.
`delete_skill`	Delete a skill by slug. Owner-only: requires Authorization: Bearer <token>.
`fetch_answer`	Poll for an answer to an ask_human question. Marks the question as fetched the first time an answer is returned. Rate-limited 30/hr/IP.
`fetch_narada_result`	Poll a narada job by ID. Statuses: pending, running, done, failed. When done, returns all persona voices.
`get_author_profile`	Author identity, bio, and a browsing cheatsheet. Records a profile-view event.
`get_certificate`	Return a formatted copyright/authenticity certificate for a piece.
`get_persona`	Return one persona's full prompt by slug. Session-gated except for Hodor (guardian rules must always apply). Pass session_token if your client cannot set an Authorization header.
`get_persona_journal`	Read a persona's raw reflection journal. Owner-only — the journal is a private feedback loop, not for external callers.
`get_skill`	Return one skill's full body by slug. Session-gated except for -public suffixed skills (guardian bypass). Pass session_token if your client cannot set an Authorization header.
`leave_comment`	Attach a short comment (≤280 chars) to a piece kapoost has published. Truncated silently past the limit.
`leave_message`	Send kapoost a longer message. context REQUIRED (why you're writing / which piece / which task). contact optional — without it no reply is possible.
`list_blobs`	List typed data artifacts (images, contact, vectors, documents, datasets, capsules). Filter by blob_type. Readable-column reflects caller_kind + caller_id vs audience.
`list_collection`	List works kapoost owns but did NOT create. Public items always; members-only surface only after session activation.
`list_content`	List published pieces (slug, title, type, access, tags). Optional type/tag filters.
`list_personas`	List every persona (slug, title, role). Full prompts unlock after bootstrap_session.
`list_provenance`	List provenance items (chain of custody, certificates, invoices) for an artwork slug. Tries piece then collection.
`list_skill_groups`	Index of every skill tag in use, with slugs per group. Public — no bootstrap required.
`list_skills`	List skills (slug, category, title, tags). Optional category / tag filters.
`load_skill_group`	Bulk-fetch every skill tagged with the given group name. Respects the bootstrap gate per-skill: -public suffix bypasses, everything else needs session.
`mysloodsiewnia_get`	Fetch one document from kapoost's vault by slug. Requires Authorization: Bearer <edit token or friend token>. Friend tokens: vault-side filter enforces scope + access:private invisibility — an out-of-scope or private slug returns not_found. Vault offline ⇒ {status:offline}.
`mysloodsiewnia_list`	Enumerate vault documents without FTS — for browsing by type or paginating. Requires Authorization: Bearer <edit token or friend token>. Friend tokens see only their scoped doc_types; access:private is invisible. Args: {doc_type?: string filter (note/pdf/literatura/calendar_event/...), limit?: int 1-200 default 50, offset?: int default 0}. Returns [{slug, title, doc_type, created_at, chunk_count}]. Vault offline ⇒ {status:offline}.
`mysloodsiewnia_search`	Full-text search (BM25 over SQLite FTS5) on kapoost's local vault corpus. Requires Authorization: Bearer <edit token or friend token>. Friend tokens see only their scoped doc_types; access:private is invisible. Returns {status, results:[{source, type, body, doc_slug, title, page, citation}], summary}. Vault offline ⇒ {status:offline}.
`mysloodsiewnia_status`	Read-only liveness probe on kapoost's local vault (mysłoodsiewnia). Returns {status: online\|degraded\|offline, last_seen, commit_sha, personas_updated_at, skills_updated_at}. Offline is a stable state — retry later, don't escalate. Requires Authorization: Bearer <edit token or friend token>.
`mysloodsiewnia_write`	Ingest a new document into kapoost's vault (wave 2). OWNER-ONLY — friend tokens receive {status:write_denied,reason:owner_only}. Args: {doc_type (required), title (required), body (required, ≤100 KiB), source_path?, meta?}. Requires Authorization: Bearer <owner token>. On Unauthorized: obtain the token by either (a) calling bootstrap_session(code=<owner poet fragment>) and reading SESSION_TOKEN from the response briefing (1h TTL, preferred for agents that already know the code), or (b) if you have shell access on kapoost's Mac, running `security find-generic-password -s humanmcp-edit-token -w` to fetch the persistent EDIT_TOKEN. Server-side vault auto-tags via:humanmcp-bridge; op_id is dedup key (idempotent retries safe). Delete is permanently unavailable. Envelopes: {status:online, op_id, result:{slug, created_at}}, {status:invalid_args}, {status:payload_too_large, limit, got}, {status:offline}, {status:vault_timeout}, {status:vault_error, error}.
`prepare_narada`	Offline narada: returns the panel plus each persona's ready-to-run SYSTEM/USER prompts so YOU run them as your own subagents, instead of the server generating voices. No LLM cost, no rate limit, nothing recorded — no narada ID and no journal feedback. Prefer this over run_narada when your subagents can read material the server cannot (a repository, local files) or when the server has no API key. Session-gated.
`read_blob`	Read one blob by slug. Returns text or base64-encoded data. Access-gated by audience unless blob is public.
`read_collection_item`	Full record for one collection item + dossier count. Access-gated: private is never visible, members needs session.
`read_content`	Read a public piece by slug. Locked pieces return a hint pointing at request_access.
`read_provenance`	Return one provenance item with resolvable file URLs. slug + id required.
`recall`	List memories saved under the given code, optionally substring-filtered by query. Session-gated for symmetry with remember.
`record_persona_reflection`	Ask a persona to write a lesson-for-self after a rolled-back narada recommendation. Appends to the persona's journal via Sonnet/Haiku. Owner-only.
`remember`	Persist a note under the given session code. Session-gated — bootstrap_session first. Callers sharing the code share the memory.
`request_access`	Get the gate details for a locked piece: challenge question, manual-review flow, time-lock countdown, payment terms, or trade rules.
`request_license`	Declare intended use of a piece, get licensing terms + audit-log entry. caller_id is REQUIRED (whitespace-only rejected — storyboard-pinned).
`run_narada`	Create an async narada job: server routes context to 3-5 personas via keyword manifest, then generates each voice via Sonnet 4.6 (Haiku 4.5 for journal recaps). Returns job ID for polling. Pass `personas` to pick the voices yourself and skip the router entirely — the router matches keywords only and cannot read a request to include or exclude someone written in the context.
`search_content`	Search kapoost's pieces by words in title, tags, description and body. Every word must match (AND). Polish diacritics are folded, so "czlowieczenstwa" finds "człowieczeństwa". Use this BEFORE ask_human — most questions about which piece is which are answered here instantly, while ask_human waits for a human. Locked pieces are matched by title and tags only; their body is never searched or quoted.
`submit_answer`	Submit an answer to a challenge-gated piece. Correct answer unlocks and returns the full body.
`suggest_skills`	Deterministic manifest→tag mapping. Given files + languages + git_origin, returns up to 8 skill slugs and up to 5 personas, each with the reason it fired. No LLM classification.
`synthesise_persona_patterns`	Force-run Sonnet synthesis over a persona's raw journal, replacing the previous pattern set. Owner-only — paid + writes internal state.
`upsert_skill`	Create or replace a skill by slug. Owner-only: requires Authorization: Bearer <token>. Writes JSON to content/skills/<slug>.json.
`verify_content`	Verify a piece's Ed25519 signature against the server's owner public key.

Schemas: list_tools.

Similar MCP servers

More from io.github.kapoost

Official server.json

{
  "name": "io.github.kapoost/humanmcp",
  "title": "humanMCP — kapoost",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://kapoost.humanmcp.net/mcp",
      "type": "streamable-http"
    }
  ],
  "version": "0.3.0",
  "repository": {
    "url": "https://github.com/kapoost/humanmcp-go",
    "source": "github"
  },
  "description": "Personal MCP server for humans who create. Proof of authorship, license control."
}