DEVELOPER
DOCUMENTATION

Endpoint: https://meku.farm/api/public/mcp. Official registry name: farm.meku/human-cloud.

Every JSON-RPC POST requires an operator-issued, unrevoked Agent API key in Authorization: Bearer meku_…. Website sign-in is not a substitute. Apply through AI ACCESS; issuance is manual. Keep your key private, outside browser code, repositories and public examples.

The example expects MEKU_API_KEY to be supplied privately in your local environment. It reads aggregate availability; it creates no review request, mission or payment. Authenticated calls still consume the key’s shared REST/MCP rate limit, including initialization, discovery, retries and failed calls.

export MEKU_MCP_URL="https://meku.farm/api/public/mcp"
# Supply MEKU_API_KEY privately; never paste it into shared code.
curl -X POST "$MEKU_MCP_URL" \
  -H "Authorization: Bearer $MEKU_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"meku_search_humans","arguments":{"skills":["photography"]}}}'

Send these JSON bodies to the same endpoint with the same headers for initialization and tool discovery:

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"your-client","version":"1.0.0"}}}
{"jsonrpc":"2.0","method":"notifications/initialized"}
{"jsonrpc":"2.0","id":2,"method":"tools/list"}

The handler returns protocol 2025-06-18, server meku-human-cloud version 1.0.0, and tools.listChanged: false. It does not negotiate the requested protocol or track initialization sessions. Initialized notifications return 202 with no body; ping returns an empty result. GET returns public static connection metadata, not a tool catalog or SSE stream. Responses are JSON; no session ID or server event stream is implemented. Compatibility with every MCP client is not guaranteed.

MEKU Human Cloud is a remote MCP server using Streamable HTTP at https://meku.farm/api/public/mcp. Every request needs your MEKU Agent API key in the Authorization header. It supports initialize-based clients (protocol 2025-06-18). Keep your key in an environment variable, never in a file you commit or share.

export MEKU_API_KEY="meku_your_key_here"

Cursor: add to ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project):

{
  "mcpServers": {
    "meku-human-cloud": {
      "url": "https://meku.farm/api/public/mcp",
      "headers": {
        "Authorization": "Bearer ${env:MEKU_API_KEY}"
      }
    }
  }
}

Cursor resolves ${env:MEKU_API_KEY} from the environment it was launched in. Cursor asks for approval before each tool call by default; keep that on.

Claude Code: run in your terminal:

claude mcp add --transport http meku-human-cloud https://meku.farm/api/public/mcp \
  --header "Authorization: Bearer $MEKU_API_KEY"

Key-storage warning: this terminal command expands the variable before Claude Code runs and stores the resulting key in its local configuration. Do not commit or share that configuration. Prefer the environment-backed .mcp.json example below to avoid storing the key itself.

Then check the connection with claude mcp get meku-human-cloud, or /mcp inside Claude Code. If you configure it in .mcp.json instead, include "type": "http":

{
  "mcpServers": {
    "meku-human-cloud": {
      "type": "http",
      "url": "https://meku.farm/api/public/mcp",
      "headers": { "Authorization": "Bearer ${MEKU_API_KEY}" }
    }
  }
}

Recommended first test (read-only): ask your agent to call meku_search_humans (for example with no arguments, or with skills set). It returns aggregate availability only, with no names or profiles. meku_request_human is a real write that goes to operator review, so don't use it as a connectivity test.

Troubleshooting: a 401 with "Missing API key" means the header didn't reach the server. Check that the variable is set in the shell that launched your client and that the value starts with meku_. "Invalid API key" or "revoked" means the key itself isn't valid. Apply at /ai-access.

Compatibility: the configuration syntax follows the official Cursor and Claude Code documentation. MEKU returns protocol 2025-06-18 without negotiation; these specific clients have not been verified end-to-end with an issued key. The server's transport limitations are described above.

meku_search_humans

Advertised inputs: optional country: string and skills: string[]. Country is trimmed and capped at 80 characters. Skills are trimmed, non-string/empty entries dropped, and the first 10 retained. Matching is case-insensitive, any-of skills, and exact country equality.

Returns listed_humans, online_humans, matching_humans, matched_skills, countries, and a consent/privacy note. Counts cover at most 500 listed records, not necessarily the whole network. Online means anything except offline, including busy. Listed/online counts and countries are not narrowed by your filters. Matched skills echoes normalized requested skills, not proof those skills were found. No names, profile IDs, contacts or regions are returned.

Error: Could not load availability. Please try again.

meku_request_human

Real write, not a dry run. Creates an execution request for operator review, not a mission or payment. Review does not replace human consent. Humans can accept, reject or stop missions.

Advertised required fields: title: string, action: string, description: string, skills: string[]. Optional strings: country, region, deliverable, timeframe, budget_text, idempotencyKey. Optional booleans: travel_required, equipment_required.

Actual validation trims/string-coerces text and truncates before checking minimums: title 4–120 characters; action 4–200; description 20–2000. Skills defaults to an empty array if omitted, retains at most 10 entries and caps each at 40 characters. Always supply skills to satisfy the advertised schema. Optional caps: country/region 80, deliverable 300, timeframe 120, budget 80. Blank optional text becomes null.

Known contract mismatch: discovery describes title 3–120, action 2–80 and description 20–4000. It advertises snake_case budget/flags, but execution reads budgetText, travelRequired, equipmentRequired. Advertised snake_case values are ignored. CamelCase fields may be rejected by schema-enforcing clients; omit these options for interoperability until a separately authorized contract fix. An undocumented contact string is accepted (cap 300, https:// or mailto: prefix only); it is not in the advertised schema.

A string idempotencyKey is trimmed/capped at 80 characters and scoped to the submitting key. A repeat returns the original request without comparing payloads. Blank/missing keys do not deduplicate. Concurrent retries can return a generic submission error; do not assume retry success. Validation happens before deduplication.

Success fields: id, status, created_at, note, plus deduplicated: true on a recognized retry. New requests start as submitted.

Validation errors: Title must be at least 4 characters; Describe the physical-world action; Description must be at least 20 characters; Contact must be an https:// URL or mailto: address. Storage error: Could not submit the request. Please try again.

meku_get_request_status

Required id: string, using the ID returned from submission. Reads only requests belonging to the exact submitting API key; another key on the same account does not grant access. The current format check accepts 36 hexadecimal/hyphen characters, not a full canonical UUID check.

Returns {request: {...}} with id, title, action, description, country, region, skills, deliverable, timeframe, budget_text, travel_required, equipment_required, requester_kind, status, created_at. No contact, owner/key identifiers or operator notes are included.

Status values: submitted, under_review, approved, rejected, cancelled. Errors: Request not found. for malformed, absent or cross-key requests; Could not load the request. for query failures.

All three advertised input schemas disallow additional properties, but execution currently does not enforce those schemas. Unknown properties are ignored rather than rejected. No output schema or structuredContent is supplied.

// Success: HTTP 200; parse content[0].text as JSON.
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"<JSON-serialized tool result>"}]}}
// Tool failure: also HTTP 200; inspect isError.
{"jsonrpc":"2.0","id":1,"result":{"content":[{"type":"text","text":"Request not found."}],"isError":true}}
// Authentication failure:
{"jsonrpc":"2.0","id":null,"error":{"code":-32001,"message":"Invalid API key."}}

• 401 / -32001: missing or malformed key, unverifiable key, invalid key, revoked key. Messages: “Missing API key. Send Authorization: Bearer meku_...”, “Could not verify API key.”, “Invalid API key.”, “API key has been revoked.”
• 429 / -32001: “Could not check rate limit. Try again.” or “Rate limit reached. Limit: {per_minute} per minute, {per_day} per day.” Limits are operator-configured, fixed minute/day windows and shared across REST/MCP. No Retry-After header is supplied.
• 400 / -32700: “Parse error: body must be valid JSON.”
• 400 / -32600: “Invalid JSON-RPC 2.0 request.”
• 200 / -32601: “Method not found: {method}”.
• 200 / -32602: “Unknown tool: {name}”.

Authentication precedes JSON parsing; authentication/rate failures use id:null and a Bearer challenge header. Send one JSON-RPC object per POST, not batches or null. A null body or unexpected internal failure is not reliably converted into a JSON-RPC error. Apart from initialized notifications, requests without an ID can still receive id:null responses.

Operational MCP: authenticated aggregate discovery, execution-request submission for review, and per-key request status. No tool automatically hires a human, creates a mission, funds work or retrieves proof.

Planned API, not callable through this MCP: mission creation, funding and proof-retrieval REST endpoints. Public checkout, payouts, refunds and automated escrow are OFF. The existing restricted operator test-checkout exception remains separate from MCP; no financial operation is exposed by these tools.

MEKU SI is the exclusive Human Cloud transactional currency on Solana Mainnet. SOL covers network fees and token-account rent only. MEKU SI is not an investment product. Official contract:

J5h8bqFW7tncH2LM3ZvFxd1kZV2AJ4rq44Puc1sGpump

Universal high income is MEKU’s long-term vision for expanding access to voluntary, useful work—not guaranteed earnings, available missions or automatic payments.