# parallelix-mcp

An MCP (Model Context Protocol) server for the [ParalleliX](https://parallelix.io) Compute API. It gives an MCP client (Claude Code, Claude Desktop) tools to offload parallel inference sub-tasks to the ParalleliX network, paid in $PRLX credits.

The pattern: your frontier agent orchestrates and reasons; the distributed open-source fleet runs the cheap, embarrassingly-parallel parts. Bulk classify, extract, summarize, or translate hundreds of items in one `parallel_map` call instead of burning frontier tokens on a loop.

## What you need

1. An API key. Create one in the ParalleliX app under Developers (connect a wallet, add $PRLX credits, create a key). The key looks like `pk_live_…` and is shown once.
2. Node 18 or newer.

## Tools

- `parallel_map(items, instruction, model?)` Run the same instruction over many items in parallel across the network. Returns one result per item with a Proof-of-Execution hash.
- `infer(prompt, model?)` Run a single prompt on the network. Returns the completion, the serving node id, and its PoE hash.
- `network_status()` List the models the network currently serves.
- `usage()` Show this key's request count, $PRLX credits spent, and remaining balance.

## Use with Claude Desktop

Add this to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "parallelix": {
      "command": "npx",
      "args": ["-y", "parallelix-mcp"],
      "env": {
        "PARALLELIX_API_KEY": "pk_live_your_key_here"
      }
    }
  }
}
```

## Use with Claude Code

```bash
claude mcp add parallelix --env PARALLELIX_API_KEY=pk_live_your_key_here -- npx -y parallelix-mcp
```

## Configuration

| Env var | Required | Default | Notes |
| --- | --- | --- | --- |
| `PARALLELIX_API_KEY` | yes | none | Your `pk_live_…` key. |
| `PARALLELIX_BASE_URL` | no | `https://api.parallelix.io` | Point at a local coordinator for testing. |

## Honest notes

- The network runs open-source models (currently 7B-class, e.g. `qwen2.5:7b`). It is not a frontier model and is not meant to replace one. It is a cheap parallel executor for bulk independent sub-tasks.
- Capacity is real and finite. Large batches queue; `usage` and `network_status` show you what's available.
- Credits are metered off-chain by the coordinator (deposit $PRLX once on-chain, no per-call gas). v1 is custodial.

## License

MIT