# Divergent Thinking Tools — MCP Server

An MCP (Model Context Protocol) server that makes all 15 Divergent Thinking Tools available to any MCP-compatible client — Claude, ChatGPT, Cursor, or any agent framework that supports MCP.

The server distributes the tool prompts. All LLM calls happen on your side, using your own API key or subscription. The server itself makes zero API calls.

## Install via npx

No clone, no build, no API key. The server distributes skill prompts — your client's LLM executes them.

#### Claude Code

```bash
claude mcp add divergent-thinking-tools -- npx -y divergent-thinking-tools-mcp
```

#### Codex

```bash
codex mcp add divergent-thinking-tools -- npx -y divergent-thinking-tools-mcp
```

#### Claude Desktop / Cursor

Add to your config (`~/Library/Application Support/Claude/claude_desktop_config.json` or `.cursor/mcp.json`):

```json
{
  "mcpServers": {
    "divergent-thinking-tools": {
      "command": "npx",
      "args": ["-y", "divergent-thinking-tools-mcp"]
    }
  }
}
```

---

## Hosted server (no install at all)

Connect to the hosted server instead of running anything locally.

#### Claude.ai (easiest)

1. Go to [claude.ai/customize/connectors](https://claude.ai/customize/connectors)
2. Click the **+** button
3. Name: `Divergent Thinking Tools`
4. URL: `https://mcp.paralogy.ai/mcp`
5. Click **Add**
6. Start a new chat and describe your problem. The Router handles the rest.

#### Claude Code / Codex (terminal)

```bash
claude mcp add divergent-thinking-tools --transport http https://mcp.paralogy.ai/mcp
codex mcp add divergent-thinking-tools --transport http https://mcp.paralogy.ai/mcp
```

#### Claude Desktop / Cursor

```json
{
  "mcpServers": {
    "divergent-thinking-tools": {
      "url": "https://mcp.paralogy.ai/mcp"
    }
  }
}
```

#### ChatGPT (Plus, Pro, Team, Enterprise, or Edu)

ChatGPT supports MCP servers through Developer Mode.

1. Go to **Settings → Apps → Advanced settings**
2. Toggle **Developer mode** on
3. Click **Create app**
4. Fill in:
   - **Name:** `Paralogy`
   - **Description:** `Divergent thinking and creative ideation tools`
   - **MCP Server URL:** `https://mcp.paralogy.ai/mcp`
   - **Authentication:** `No Auth`
5. Check **"I understand and want to continue"**
6. Click **Create**

ChatGPT will connect and discover all 15 tools. To use them:

1. Start a new chat — it will default to Developer Mode
2. Describe your problem, or explicitly reference a tool:
   ```
   Use the Paralogy app's think-wrong tool to brainstorm unconventional approaches to [your problem]
   ```

> **Note:** ChatGPT memory is disabled in Developer Mode. Your tools will work, but ChatGPT won't remember previous conversations while this mode is active. You can toggle Developer Mode off in the same settings menu when you don't need the tools.

#### OpenClaw

```bash
openclaw mcp set divergent-thinking-tools '{"url":"https://mcp.paralogy.ai/mcp"}'
```

For dedicated agent setups and full multi-agent pipelines, see [docs/for-openclaw.md](../docs/for-openclaw.md).

---

## Self-hosted setup (optional)

If you prefer to clone and build from source:

### 1. Clone and build

```bash
git clone https://github.com/d4vidc4rson/paralogy-divergent-thinking-tools.git
cd paralogy-divergent-thinking-tools/mcp-server
npm install
npm run build
```

### 2. Connect to your MCP client

#### Claude Desktop / Cursor

Add to your config file:

```json
{
  "mcpServers": {
    "divergent-thinking-tools": {
      "command": "node",
      "args": ["/absolute/path/to/paralogy-divergent-thinking-tools/mcp-server/dist/index.js"]
    }
  }
}
```

#### Claude Code (terminal)

```bash
claude mcp add divergent-thinking-tools -- node /absolute/path/to/mcp-server/dist/index.js
```

#### Codex (terminal)

```bash
codex mcp add divergent-thinking-tools -- node /absolute/path/to/mcp-server/dist/index.js
```

### 3. Use the tools

Once connected, your client will have access to all 15 tools. Start with the **router** — describe your problem and it will tell you which tools to use:

```
Use the divergent-thinking-tools-router tool with objective: "We need to reduce customer churn but every strategy we've tried plateaus at 15%"
```

## Available tools

| Tool | What it does |
|------|-------------|
| `divergent-thinking-tools-router` | **Start here.** Routes your problem to the right tools. |
| `wrong-problem-detector` | Checks if you're solving the right problem before you start |
| `strip-down` | Strips briefs to raw human desire so ideas aren't anchored |
| `dumb-questions-engine` | Generates questions nobody is asking about your problem |
| `blind-spot-scan` | Maps what you forgot to think about |
| `guilford-engine` | Structured divergent ideation (5 dimensions, research-backed) |
| `persona-divergence-engine` | Ideas through radically different constructed personas |
| `think-wrong` | Pushes toward counterintuitive, non-obvious approaches |
| `short-think` | Fast, gut-level ideas — kills overthinking |
| `bad-on-purpose` | Deliberately terrible ideas, then mines them for value |
| `wild-to-mild` | Full spectrum from moonshots to Monday-morning moves |
| `macgyver-mode` | Solutions using only what you already have |
| `random-injection` | Injects randomness and forces structural connections |
| `anti-homogeneity-check` | Audits whether your ideas are actually different |
| `de-slop` | Transforms AI-polished text into authentic human voice |

## How it works

Each tool accepts two parameters:
- **`objective`** (required) — the problem or challenge to work on
- **`context`** (optional) — additional constraints, background, or domain information

When you call a tool, the server returns the full skill instructions along with your input. Your LLM reads those instructions and executes the skill. No API calls are made by the server — everything runs in your client's context.

## Remote hosting

The hosted server is live at **`https://mcp.paralogy.ai/mcp`** — this is what the quick start config above connects to. Health check: `https://mcp.paralogy.ai/health`.

If you want to deploy your own instance, the server supports HTTP transport:

```bash
TRANSPORT=http PORT=3000 node dist/index.js
```

The server will listen on `http://0.0.0.0:3000/mcp`. Deploy to Railway, Render, or Fly.io — the hosting platform provides the `PORT` environment variable automatically.

## Two transport modes

| Mode | When to use | How to run |
|------|-------------|------------|
| **stdio** (default) | Local use with Claude Desktop, Claude Code, Cursor | `node dist/index.js` |
| **http** | Remote hosting for Claude.ai, ChatGPT, web clients, shared teams | `TRANSPORT=http node dist/index.js` |

## Requirements

- Node.js 18+ (for self-hosted only)
- An MCP-compatible client (Claude Desktop, Claude Code, ChatGPT, Cursor, etc.)