Kael MCP Server

Install

Config snippet generator goes here (5 client tabs)

README

# ⚡ Kael MCP Server

**AI-native tools for agents** — use cheap compute for web, DNS, WHOIS, screenshots, extraction, and sandboxed code execution instead of spending model tokens on guesswork.

> Kael is for tasks where an agent needs fresh external data, structured output, or real execution — not another paragraph of reasoning.

## Why this exists

LLMs are expensive at:
- fetching and cleaning live web content
- checking DNS / WHOIS / IP facts
- extracting structured data from messy pages
- executing code safely and reproducibly
- producing screenshots or binary artifacts

Kael turns those jobs into **real tools with JSON output**.

## Best fit

Use Kael MCP when your agent needs:
- **fresh data** from the web or internet infrastructure
- **structured results** instead of prose
- **deterministic execution** instead of model simulation
- **lower token burn** on repetitive utility work
- **small tool outputs** that are easier to feed back into a model

Do **not** use Kael MCP when:
- the task is pure reasoning or writing
- the data is already in context
- a local tool already solves the problem cheaper/faster
- you need a full browser workflow with human-style interaction across many steps

## Included tools

### Web and content
- `web_fetch` — URL → clean readable markdown/text
- `web_search` — real-time search results
- `html_extract` — HTML/page content → structured data
- `screenshot` — webpage → PNG screenshot
- `pdf_extract` — PDF → extracted text
- `url_unshorten` — resolve shortened links safely

### Internet and infrastructure
- `dns_lookup` — A, AAAA, MX, TXT, NS, CNAME, SOA, SRV records
- `whois` — domain registration data
- `ip_geo` — IP geolocation and network info

### Data and utility
- `code_run` — execute JavaScript, Python, or Bash in a sandbox
- `text_diff` — compare text versions
- `json_query` — query/filter JSON data
- `hash_text` — compute common hashes

## Tool selection guide

| Tool | Use when | Avoid when |
|---|---|---|
| `web_fetch` | You need readable page content for summarization or downstream extraction | You need pixel-perfect rendering or JS-heavy interaction |
| `web_search` | You need fresh discovery across the web | You already know the exact URL |
| `html_extract` | You need tables, lists, metadata, or page structure as data | Plain cleaned text is enough |
| `screenshot` | You need visual verification, layout evidence, or image output | Text content alone is enough |
| `dns_lookup` | You need factual DNS records now | Static knowledge is acceptable |
| `whois` | You need domain ownership/registration details | DNS records alone answer the question |
| `ip_geo` | You need IP location/ASN/ISP context | You only need DNS or hostname resolution |
| `code_run` | You need actual execution, parsing, transformation, or calculation | The task is simple enough to do directly in-model |
| `pdf_extract` | The source is a PDF and you need text back | The source is already HTML/text |
| `url_unshorten` | You need to inspect where a short link resolves | You already trust and know the final URL |
| `text_diff` | You need a concrete change set between two texts | You just need a summary |
| `json_query` | You need to filter/reshape JSON before reasoning | The JSON is already tiny and easy to inspect |
| `hash_text` | You need a deterministic fingerprint/checksum | Semantic comparison matters more than exact bytes |

## Quick start

### Server endpoints

Kael supports two MCP transports:

| Transport | URL | Best for |
|---|---|---|
| SSE | `https://www.kael.ink/mcp/sse` | Broad client compatibility |
| Streamable HTTP | `https://www.kael.ink/mcp/stream` | Newer clients, simpler connection model |

Use SSE if your client doesn't specify a preference. Use streamable-http if your client supports the 2025-03-26+ MCP protocol version.

Health check:

```text
https://www.kael.ink/mcp/health
```

### Claude Desktop

Add this to `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "kael-tools": {
      "url": "https://www.kael.ink/mcp/sse"
    }
  }
}
```

Or use streamable-http if your Claude Desktop version supports it:

```json
{
  "mcpServers": {
    "kael-tools": {
      "type": "streamable-http",
      "url": "https://www.kael.ink/mcp/stream"
    }
  }
}
```

### Claude Code

Add Kael as a remote MCP server:

```bash
claude mcp add kael-tools --transport sse https://www.kael.ink/mcp/sse
```

Or add to `.claude/settings.json`:

```json
{
  "mcpServers": {
    "kael-tools": {
      "type": "sse",
      "url": "https://www.kael.ink/mcp/sse"
    }
  }
}
```

Good first checks in Claude Code:
1. connect Kael and confirm the server appears in MCP tool listings
2. ask Claude to run `dns_lookup` for `example.com` MX records
3. ask Claude to use `web_fetch` on a live page and summarize it

Example evaluator prompt:

> Use the `dns_lookup` tool from the Kael MCP server to get MX records for example.com, then use `web_fetch` on https://modelcontextprotocol.io and give me a short summar