⚡ 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

Quick start

Server endpoints

Kael supports two MCP transports:

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:

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

Claude Desktop

Add this to claude_desktop_config.json:

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

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

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

Claude Code

Add Kael as a remote MCP server:

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

Or add to .claude/settings.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 summary.

Why this is a good Claude Code test:

• verifies Kael is reachable as a real MCP server
• exercises both a factual infrastructure tool and a fresh-web retrieval tool
• makes it obvious whether Claude is actually using tools instead of guessing

For deeper integration — including CLAUDE.md instructions, hook examples for tool routing, and project-specific patterns — see Claude Code Integration Guide.

MCP Inspector

Useful for quick validation before wiring Kael into a larger agent stack:

npx @modelcontextprotocol/inspector

Then connect to:

https://www.kael.ink/mcp/sse

Other MCP-capable clients

If your runtime or editor lets you add a remote MCP server by URL, use one of:

Adoption-friendly rule of thumb:

• if the client asks for an MCP server URL, try the SSE endpoint first
• if the client supports streamable-http (newer protocol), use the stream endpoint
• if it wants a named server entry, use kael-tools
• if it supports a quick test prompt after connecting, start with dns_lookup or web_fetch

Example generic config shape (SSE):

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

Example generic config shape (streamable-http):

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

This same pattern is typically what you want in MCP-capable editors and agent runtimes such as Cursor, Cline, OpenCode, and similar tools that accept remote MCP servers.

Generic MCP client (Node.js)

SSE transport

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const transport = new SSEClientTransport(
  new URL("https://www.kael.ink/mcp/sse")
);

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map(t => t.name));

const dns = await client.callTool({
  name: "dns_lookup",
  arguments: { domain: "example.com", type: "MX" }
});

console.log(dns.content);

Streamable HTTP transport

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://www.kael.ink/mcp/stream")
);

const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const tools = await client.listTools();
console.log(tools.tools.map(t => t.name));

Quick connection test flow

If you are evaluating whether Kael is worth adding to your stack, use this order:

1. Hit https://www.kael.ink/mcp/health
2. Connect your MCP client to https://www.kael.ink/mcp/sse (or https://www.kael.ink/mcp/stream for streamable-http)
3. List tools
4. Run one factual tool like dns_lookup or web_fetch
5. Only then wire it into a larger agent workflow

That keeps evaluation cheap and makes failures obvious early.

Example agent tasks

1. Fetch a page for summarization

Ask your model to use web_fetch when:

• the page is live
• raw HTML would waste tokens
• you want readable markdown returned first

Example prompt:

Fetch the pricing page with web_fetch, then summarize the plans and highlight any usage limits.

2. Check a domain's email setup

Ask your model to use dns_lookup when:

• you need MX/TXT/SPF/DMARC facts
• hallucinated infrastructure answers would be risky

Example prompt:

Use dns_lookup to inspect MX and TXT records for example.com and tell me whether email appears configured.

3. Turn a messy page into structured data

Ask your model to use html_extract when:

• the page contains tables, lists, or repeated blocks
• you want JSON-like structure before reasoning

Example prompt:

Load the page, extract the product table with html_extract, then compare the plans.

4. Execute code instead of simulating it

Ask your model to use code_run when:

• exact calculation matters
• a parser or transformation would be more reliable in code
• the result should be reproducible

Example prompt:

Use code_run in Python to normalize this CSV and return the cleaned JSON.

Example outputs evaluators can expect

These are abbreviated examples so builders can sanity-check the shape of Kael results before integrating it into an agent loop.

dns_lookup

{
  "domain": "example.com",
  "type": "MX",
  "answers": [
    {
      "exchange": "mx.example.com",
      "priority": 10
    }
  ]
}