docs

Documentation

JustClaw-It is a remote MCP server: your coding agent searches 1,082,445 licence-cleared components mined from real production repositories, then pulls full source with a GitHub permalink and its licence.

Quickstart Client setup Tools Credits & plans Licences & attribution FAQ

Quickstart

1. Get a free API key (no card). 2. Run one of these on the machine your agent runs on:

npx @justclaw-it/cli init

curl -fsSL https://justclaw.it.com/install | sh

The CLI checks your key with a live tools/list call, finds the agents on your machine and adds the justclaw-it server to each, backing up every file it edits first (<file>.justclaw-it-bak-<timestamp>). Restart your agent and ask: "search JustClaw-It for a stripe checkout handler".

npx @justclaw-it/cli doctor        # connection, plan/usage, which agents are configured
npx @justclaw-it/cli uninstall     # removes exactly what init added

Non-interactive: JUSTCLAW_IT_API_KEY=… npx @justclaw-it/cli init --yes. Limit clients with --clients claude-code,cursor; skip the agent skills with --no-skills. Requires Node.js 18+. The connector is MIT-licensed; the installer at /install just runs the CLI.

Client setup (manual)

Server URL https://justclaw.it.com/mcp (Streamable HTTP), header Authorization: Bearer <YOUR_API_KEY>. Replace <YOUR_API_KEY> with your key.

Claude Code

One command:

claude mcp add --transport http --scope user justclaw-it https://justclaw.it.com/mcp \
  --header "Authorization: Bearer <YOUR_API_KEY>"

Cursor

Add to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "justclaw-it": {
      "url": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}

Codex CLI

Add to ~/.codex/config.toml:

[mcp_servers.justclaw-it]
url = "https://justclaw.it.com/mcp"
http_headers = { "Authorization" = "Bearer <YOUR_API_KEY>" }

OpenClaw

openclaw mcp set justclaw-it '{"url":"https://justclaw.it.com/mcp","transport":"streamable-http","headers":{"Authorization":"Bearer <YOUR_API_KEY>"}}'
openclaw mcp reload

Hermes Agent

Add to ~/.hermes/config.yaml, and put JUSTCLAW_IT_API_KEY=<YOUR_API_KEY> in ~/.hermes/.env:

mcp_servers:
  justclaw-it:
    url: "https://justclaw.it.com/mcp"
    headers:
      Authorization: "Bearer ${JUSTCLAW_IT_API_KEY}"

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "justclaw-it": {
      "serverUrl": "https://justclaw.it.com/mcp",
      "headers": { "Authorization": "Bearer <YOUR_API_KEY>" }
    }
  }
}

Claude Desktop

Add to claude_desktop_config.json (macOS ~/Library/Application Support/Claude/, Windows %APPDATA%\Claude\, Linux ~/.config/Claude/). Claude Desktop reaches remote servers through the mcp-remote bridge, so it needs Node.js:

{
  "mcpServers": {
    "justclaw-it": {
      "command": "npx",
      "args": ["-y", "mcp-remote@latest", "https://justclaw.it.com/mcp", "--header", "Authorization:${JUSTCLAW_IT_AUTH}"],
      "env": { "JUSTCLAW_IT_AUTH": "Bearer <YOUR_API_KEY>" }
    }
  }
}

Any other MCP client

Streamable HTTP with a standard bearer header:

{ "mcpServers": { "justclaw-it": { "url": "https://justclaw.it.com/mcp", "headers": { "Authorization": "Bearer <YOUR_API_KEY>" } } } }

Tool reference

Generated from the server's own tools/list, so it always matches what your agent sees.

tool	parameters	credits	plan	what it does
`search_components`	`query` string `limit` integer, optional, default 8 `category` string, optional `min_composite` number, optional, default 0.0 `language` string, optional `license` string, optional, default 'any' `offset` integer, optional, default 0 `max_per_repo` integer, optional, default 3	1	All plans	Hybrid semantic + keyword search over licence-cleared code components from real repos. Returns ranked matches with repo, path, language, license, quality scores, similarity and a GitHub permalink (no code body -- use get_component). category: a function tag, see list_categories. language: python, typescript, javascript, go, rust, java, ... . license: 'permissive' (MIT/BSD/Apache/ISC...), 'commercial-safe' (+ weak copyleft), 'open-source', or 'any'; prefer 'permissive' when the code will be copied into a product. min_composite: minimum 1-10 quality score. offset: pagination. max_per_repo: cap per source repo (0 = none).
`find_similar`	`id` string `limit` integer, optional, default 8	1	All plans	Components most similar to a given component id (alternatives / variants). Same result shape as search_components.
`list_categories`	`limit` integer, optional, default 40	1	All plans	Most-used function tags with counts; valid values for search_components.category.
`get_component`	`id` string	1	All plans	Fetch one component's full source code, GitHub permalink, license and an attribution line to keep with the copied code.
`library_stats`	none	1	All plans	Live counts for the library: total, with-source, repositories, languages, license filters and (once backfilled) repositories by license class.
`list_licenses`	none	1	All plans	Every source repository, SPDX licence and copyright holder in the library (a NOTICE file). Components you use must keep the attribution shown here and in each result.
`get_component_bundle`	`component_id` string	3	Pro	Pro only (3 credits). One component plus the components it imports from its own repository, each with source, licence/attribution header and a manifest (files, npm/pip packages, install commands). Use it to drop a working, attributed set of files into a project.
`compose_starter`	`prompt` string `stack` string, optional	10	Pro	Pro only (10 credits). Describe what you are building (and optionally the stack, e.g. "nextjs", "python fastapi"); returns a starter project assembled from 3-8 complementary library components and their dependencies: file tree, files with attribution headers, README listing every source and licence, NOTICE, and install commands.

Search results carry five sub-scores (completeness, code quality, deployability, reusability, strategic value) and a composite score from 0 to 10; filter with min_composite. category takes one of: ai, ui, auth, database, payments, pos, crm, voice, email, infra, integration, automation, analytics, files, realtime, scraping, dev-tools, testing, security, search, chat, cli. Search page size is capped by your plan.

Credits & plans

One credit is one tool call; the Pro tools cost more (see above). Free gets 30 credits on day one, then 10 a day. Paid plans refill weekly, keep what you don't spend, and earn up to 1.5x credits the longer you stay. Pro ($49/mo) adds component bundles, starter projects and overage. Live prices and checkout: /pricing.

plan	price	credits	fair-use cap	keys	extras
Free	$0	10 per day · +30 on day one resets daily, no carry-over	n/a	1	—
Solo	$10/mo	300 per week unused credits carry over	6,000 distinct components / 12 months	1	—
Indie	$19/mo	1,000 per week unused credits carry over	15,000 distinct components / 12 months	1	—
Pro	$49/mo	5,000 per week unused credits carry over	100,000 distinct components / 12 months	3	bundles + starter projects, overage

Licences & attribution

Every component is third-party open-source code, served under its original licence. JustClaw-It sells access to the search and retrieval service (credits), not the code itself.
The public library only includes permissive and weak-copyleft licences. Code without a clear licence, and strong copyleft (GPL/AGPL), is excluded.
Each result carries its SPDX licence, copyright holder and repository, and returned source starts with an attribution header. Keep that header with the code, and include the licence text where the licence requires it (a THIRD_PARTY_LICENSES or NOTICE file works).
For weak-copyleft files (for example MPL-2.0), modifications to that file stay under its licence.
The full list of source repositories, licences and copyright holders: list_licenses, or /licenses.
Think a component shouldn't be here? Email mike+mcpsupport@two7.design and we'll review and remove it.

FAQ

Is it a library I install?

No. JustClaw-It is a hosted MCP server. The CLI only writes a config entry (and optional agent skills) into your agents; searches run on our side and return code, scores and licences.

How is this different from Context7?

Context7 tells your agent how a library works; JustClaw-It hands it production code that uses it. They complement each other: docs for the API, JustClaw-It for a working, attributed implementation.

What does a search cost?

Every tool call is 1 credit except the Pro tools: get_component_bundle is 3 and compose_starter is 10. Connecting, listing tools and handshakes are free.

What happens when I run out?

Free waits for tomorrow's refill; Solo and Indie wait for next week's (no overage, so no surprise bill). Pro continues on pay-as-you-go overage past its weekly refill.

Can I use the code in a commercial product?

The public library only serves permissive and weak-copyleft code (for example MIT, Apache-2.0, BSD, MPL-2.0). Each component's own licence governs, so keep its attribution header, and for weak-copyleft files keep modifications to that file under the same licence.

Where do I see my usage or rotate a key?

Sign in at /account, or run npx @justclaw-it/cli doctor. With a key: curl -H "Authorization: Bearer $KEY" https://justclaw.it.com/usage.

Is the service up?

See /status.

More: support · terms · privacy · refunds.