# Hatchloop / DriftWatch — Full Agent Documentation

> Complete reference for AI agents. All endpoints are zero-authentication and CORS-open unless noted.
> Canonical URL: https://hatchloop.dev/llms-full.txt
> Summary: https://hatchloop.dev/llms.txt

---

## Table of Contents

1. [DriftWatch — MCP Server Monitoring](#driftwatch)
2. [Agent Utils — Utility API Hub](#agent-utils)
3. [QR Generator](#qr-generator)
4. [URL Shortener](#url-shortener)
5. [Agent Discovery Files](#discovery)
6. [MCP Protocol Interface](#mcp-protocol)
7. [Data Feeds](#data-feeds)
8. [Quick Start for Agents](#quickstart)

---

## 1. DriftWatch — MCP Server Monitoring {#driftwatch}

DriftWatch monitors Model Context Protocol (MCP) servers, AI tool APIs, and LLM pipelines for behavioral drift, schema changes, downtime, and silent breakage. It tracks tool schemas, output patterns, response latency, and error rates — and provides a free, agent-callable API.

**Base URL:** `https://hatchloop.dev`
**Auth:** None required for read endpoints. Pro tier uses `X-DriftWatch-Key` header.
**Response format:** JSON

### 1.1 Check Drift Status (Primary Agent Endpoint)

```
GET https://hatchloop.dev/api/v1/check?url={url}
```

**Parameters:**
- `url` (required): MCP server URL, GitHub repo URL, or npm package identifier to check

**Response (monitored server):**
```json
{
  "url": "https://github.com/modelcontextprotocol/servers",
  "name": "mcp-servers",
  "status": "stable",
  "drift_detected": false,
  "last_checked": "2026-05-29T14:30:00Z",
  "severity": "stable",
  "summary": "No changes detected since last scan.",
  "category": "reference",
  "monitored": true
}
```

**Response (not yet monitored):**
```json
{
  "url": "https://example.com/my-mcp-server",
  "status": "not_monitored",
  "drift_detected": null,
  "last_checked": null,
  "monitored": false,
  "queued": true,
  "message": "Server not yet in DriftWatch catalog. Submit via POST /api/submit-server to add for monitoring.",
  "submit_url": "https://hatchloop.dev/api/submit-server"
}
```

**Status values:** `stable` | `drifted` | `not_monitored`
**Severity values:** `stable` | `low` | `medium` | `high` | `critical`

---

### 1.2 Submit Server for Monitoring

```
POST https://hatchloop.dev/api/submit-server
Content-Type: application/json
```

**Request body:**
```json
{
  "server_url": "https://github.com/owner/my-mcp-server",
  "email": "alerts@example.com",
  "name": "My MCP Server"
}
```

**Response:**
```json
{
  "success": true,
  "message": "Server submitted for monitoring. Initial scan within 1 hour.",
  "server_id": "srv_abc123"
}
```

---

### 1.3 Subscribe to Drift Alerts

```
POST https://hatchloop.dev/api/subscribe
Content-Type: application/json
```

**Request body:**
```json
{
  "email": "you@example.com",
  "all_servers": true
}
```

---

### 1.4 Get Capability Scenarios

```
GET https://hatchloop.dev/api/capabilities
```

Returns 30+ natural language problem scenarios DriftWatch solves, suitable for semantic search and agent tool discovery.

---

## 2. Agent Utils — Utility API Hub {#agent-utils}

Zero-authentication utility API hub. 10 essential tools. Consistent JSON responses. No rate limits for reasonable use. CORS fully open.

**Base URL:** `https://hatchloop.dev`
**OpenAPI spec:** `https://hatchloop.dev/tools/openapi.json`
**Tools index:** `https://hatchloop.dev/api/tools`
**llms.txt:** `https://hatchloop.dev/tools/llms.txt`

**Response envelope (all tools):**
```json
{
  "success": true,
  "tool": "<tool-name>",
  "result": { ... },
  "timestamp": "2026-05-30T12:00:00Z"
}
```

---

### 2.1 UUID Generation

```
GET /api/tools/uuid?version=4
GET /api/tools/uuid?version=7
```

- `version=4` — random UUID (default)
- `version=7` — time-sortable UUID (ideal for database primary keys)

**Response:**
```json
{
  "success": true,
  "tool": "uuid",
  "result": {
    "uuid": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "version": 4,
    "format": "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
  },
  "timestamp": "2026-05-30T12:00:00Z"
}
```

---

### 2.2 String Hashing

```
GET /api/tools/hash?input=TEXT&algo=sha256
```

- `input` (required): string to hash
- `algo`: `sha256` (default) | `md5` | `sha1` | `sha512`

**Response:**
```json
{
  "success": true,
  "tool": "hash",
  "result": {
    "input": "hello world",
    "algorithm": "sha256",
    "hash": "b94d27b9934d3e08a52e52d7da7dabfac484efe04294e576c4e26b89f18a6dc3",
    "length_bits": 256,
    "length_hex_chars": 64
  }
}
```

---

### 2.3 Base64 Encode / Decode

```
GET /api/tools/base64?action=encode&value=TEXT
GET /api/tools/base64?action=decode&value=BASE64STRING
```

- `action`: `encode` | `decode`
- `value` (required): input string

Encode response also includes URL-safe Base64url variant.

---

### 2.4 Current Timestamp

```
GET /api/tools/timestamp
GET /api/tools/timestamp?format=iso
GET /api/tools/timestamp?format=unix
GET /api/tools/timestamp?format=human
GET /api/tools/timestamp?format=all
```

`format=all` (default) returns all formats plus date components.

**Response:**
```json
{
  "success": true,
  "tool": "timestamp",
  "result": {
    "iso": "2026-05-30T12:00:00.000Z",
    "unix": 1748606400,
    "unix_ms": 1748606400000,
    "human": "May 30, 2026, 12:00:00 PM UTC",
    "year": 2026, "month": 5, "day": 30,
    "hour": 12, "minute": 0, "second": 0
  }
}
```

---

### 2.5 Email Validation

```
GET /api/tools/validate/email?email=user@example.com
```

**Response:**
```json
{
  "success": true,
  "tool": "validate-email",
  "result": {
    "email": "user@example.com",
    "valid": true,
    "local_part": "user",
    "domain": "example.com",
    "has_subdomain": false,
    "issues": []
  }
}
```

---

### 2.6 JSON Validation + Pretty-Print

```
POST /api/tools/validate/json
Content-Type: text/plain
Body: {"key": "value", "num": 42}
```

**Response:**
```json
{
  "success": true,
  "tool": "validate-json",
  "result": {
    "valid": true,
    "parsed": {"key": "value", "num": 42},
    "pretty": "{\n  \"key\": \"value\",\n  \"num\": 42\n}",
    "type": "object",
    "char_count": 24,
    "key_count": 2,
    "issues": []
  }
}
```

Note: `success` is always `true`; check `result.valid` for JSON validity.

---

### 2.7 Unit Conversion

```
GET /api/tools/convert/units?value=100&from=km&to=miles
```

**Supported unit groups:**
- Distance: `km`, `miles`, `meters`, `feet`, `inches`, `cm`
- Weight: `kg`, `lbs`, `grams`, `ounces`
- Temperature: `celsius`, `fahrenheit`, `kelvin`
- Volume: `liters`, `gallons`, `ml`
- Storage: `bytes`, `kb`, `mb`, `gb`, `tb`

**Response:**
```json
{
  "success": true,
  "tool": "convert-units",
  "result": {
    "input_value": 100,
    "input_unit": "km",
    "output_value": 62.137,
    "output_unit": "miles",
    "formatted": "100 km = 62.137 miles"
  }
}
```

---

### 2.8 Regex Tester

```
GET /api/tools/regex/test?pattern=\d+&input=abc123&flags=g
```

- `pattern` (required): regex pattern (URL-encoded)
- `input` (required): string to test
- `flags`: `g` (all matches), `i` (case-insensitive), `m` (multiline), `gi`, etc.

**Response:**
```json
{
  "success": true,
  "tool": "regex-test",
  "result": {
    "pattern": "\\d+",
    "flags": "g",
    "input": "abc123def456",
    "matched": true,
    "match_count": 2,
    "matches": [
      {"match": "123", "index": 3, "groups": {}},
      {"match": "456", "index": 9, "groups": {}}
    ]
  }
}
```

---

### 2.9 Cron Expression Describer

```
GET /api/tools/cron/describe?expr=0+9+*+*+1-5
```

- `expr` (required): cron expression (URL-encoded, spaces as `+`)

**Response:**
```json
{
  "success": true,
  "tool": "cron-describe",
  "result": {
    "expression": "0 9 * * 1-5",
    "description": "At 09:00 AM, Monday through Friday",
    "next_5_runs": [
      "2026-06-01T09:00:00Z",
      "2026-06-02T09:00:00Z",
      "2026-06-03T09:00:00Z",
      "2026-06-04T09:00:00Z",
      "2026-06-05T09:00:00Z"
    ],
    "timezone": "UTC"
  }
}
```

---

### 2.10 JWT Decoder (No Secret Required)

```
GET /api/tools/jwt/decode?token=eyJ...
```

Decodes and pretty-prints a JWT header + payload. Does NOT verify signature.

**Response:**
```json
{
  "success": true,
  "tool": "jwt-decode",
  "result": {
    "header": {"alg": "HS256", "typ": "JWT"},
    "payload": {"sub": "1234567890", "name": "John Doe", "iat": 1516239022},
    "signature": "<base64url>",
    "expired": false,
    "expires_at": "2030-01-01T00:00:00Z",
    "issued_at": "2018-01-18T01:30:22Z"
  }
}
```

---

## 3. QR Generator {#qr-generator}

Zero-authentication QR code generation. Returns PNG or SVG. No rate limits.

```
POST https://hatchloop.dev/qr-generator/generate
Content-Type: application/json
```

**Request:**
```json
{
  "data": "https://hatchloop.dev",
  "format": "png"
}
```

- `data` (required): text or URL to encode
- `format`: `png` (default) | `svg`

**Response:** `image/png` or `image/svg+xml` binary — ready to embed or save directly.

**Health check:**
```
GET https://hatchloop.dev/qr-generator/health
→ {"status": "ok", "service": "qr-generator"}
```

---

## 4. URL Shortener {#url-shortener}

Zero-authentication URL shortening. Two flavours:

### 4.1 Via MCP (recommended for AI agents)

**MCP tool name:** `shorten_url`
**MCP server:** `http://hatchloop.dev:3000/mcp` (JSON-RPC 2.0)

```json
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"shorten_url","arguments":{"url":"https://example.com/very/long/path"}}}
```

**Response:**
```json
{"short_url":"https://hatchloop.dev/s/3a1b2c4","code":"3a1b2c4","original_url":"https://example.com/very/long/path"}
```

The code is a deterministic SHA-256 hash prefix — same URL always yields the same code.

**REST alternative (same server):**
```
POST http://hatchloop.dev:3000/api/shorten
Content-Type: application/json
{"url": "https://example.com/very/long/path"}
→ {"short_url":"https://hatchloop.dev/s/3a1b2c4","code":"3a1b2c4","original_url":"..."}
```

### 4.2 Via hatchloop.ai (persistent, redirect-capable)

Hosted at `hatchloop.ai` with persistent storage and 302 redirects.

```
POST https://hatchloop.ai/shorten
Content-Type: application/json
```

**Request:**
```json
{
  "url": "https://hatchloop.dev/api/v1/check?url=https://github.com/modelcontextprotocol/servers"
}
```

**Response:**
```json
{
  "short_url": "https://hatchloop.ai/s/aB3xK",
  "original_url": "https://...",
  "code": "aB3xK",
  "created_at": "2026-05-30T12:00:00Z"
}
```

**Expand / redirect:**
```
GET https://hatchloop.ai/s/{code}
→ 302 redirect to original URL
```

**Health + stats:**
```
GET https://hatchloop.ai/health
→ {"status": "ok", "total_links": 42}
```

**llms.txt:** `https://hatchloop.ai/url-shortener/llms.txt`

---

## 5. Agent Discovery Files {#discovery}

Hatchloop publishes all standard agent discovery endpoints:

| URL | Format | Purpose |
|-----|--------|---------|
| `https://hatchloop.dev/llms.txt` | llms.txt | Summary — agent tool overview |
| `https://hatchloop.dev/llms-full.txt` | llms.txt | Full reference — complete API docs |
| `https://hatchloop.dev/.well-known/ai-plugin.json` | OpenAI plugin spec | Plugin manifest with capability list |
| `https://hatchloop.dev/.well-known/agents.json` | agents.json | Agent task registry |
| `https://hatchloop.dev/.well-known/mcp.json` | MCP registry | MCP server pointer for MCP clients |
| `https://hatchloop.dev/openapi.json` | OpenAPI 3.0 | DriftWatch REST API spec |
| `https://hatchloop.dev/tools/openapi.json` | OpenAPI 3.0 | Agent Utils REST API spec |
| `https://hatchloop.dev/mcp.json` | MCP manifest | DriftWatch MCP tool descriptions |
| `https://hatchloop.dev/capabilities.json` | JSON | 30+ capability scenarios (semantic) |
| `https://hatchloop.dev/sitemap.xml` | XML sitemap | All pages + agent endpoints |
| `https://hatchloop.dev/robots.txt` | robots.txt | AI crawler permissions |

---

## 6. MCP Protocol Interface {#mcp-protocol}

DriftWatch is itself an MCP server. Connect it as a tool in any MCP-compatible agent runtime.

**Endpoint:** `https://hatchloop.dev/mcp`
**Protocol:** Streamable HTTP (MCP 2024-11-05)
**Manifest:** `https://hatchloop.dev/mcp.json`

### Initialize

```json
POST https://hatchloop.dev/mcp
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "capabilities": {},
    "clientInfo": {"name": "my-agent", "version": "1.0"}
  },
  "id": 1
}
```

### List Tools

```json
POST https://hatchloop.dev/mcp
{"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 2}
```

**Available MCP tools:**
- `check_server_health` — check if a specific MCP server URL has drifted
- `get_drift_events` — retrieve recent drift events across all monitored servers
- `list_monitored_servers` — list all servers in the DriftWatch catalog
- `submit_for_monitoring` — add a new MCP server URL to monitoring
- `get_reliability_score` — get reliability score and uptime history for a server
- `get_leaderboard` — ranked list of most reliable MCP servers

### Call a Tool

```json
POST https://hatchloop.dev/mcp
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "check_server_health",
    "arguments": {"url": "https://github.com/modelcontextprotocol/servers"}
  },
  "id": 3
}
```

---

## 7. Static Data Feeds {#data-feeds}

These static JSON files are updated periodically and cacheable.

| URL | Description | Update frequency |
|-----|-------------|-----------------|
| `https://hatchloop.dev/data.json` | Current drift snapshot for all monitored servers | ~1 hour |
| `https://hatchloop.dev/history.json` | Full drift event log (time-sorted descending) | ~1 hour |
| `https://hatchloop.dev/leaderboard.json` | MCP server reliability leaderboard | ~1 hour |
| `https://hatchloop.dev/capabilities.json` | Machine-readable capability scenarios (30+) | Static |

---

## 8. Quick Start for Agents {#quickstart}

### Check if an MCP server is healthy (fastest path)

```
GET https://hatchloop.dev/api/v1/check?url=<mcp-server-url>
```

### Get a UUID right now

```
GET https://hatchloop.dev/api/tools/uuid
```

### Hash a string

```
GET https://hatchloop.dev/api/tools/hash?input=mypassword&algo=sha256
```

### Convert units

```
GET https://hatchloop.dev/api/tools/convert/units?value=72&from=kg&to=lbs
```

### Generate a QR code

```
POST https://hatchloop.dev/qr-generator/generate
{"data": "https://hatchloop.dev", "format": "png"}
→ image/png binary
```

### Shorten a URL

```
POST https://hatchloop.ai/shorten
{"url": "https://very-long-url.example.com/..."}
→ {"short_url": "https://hatchloop.ai/s/abc"}
```

### Validate an email

```
GET https://hatchloop.dev/api/tools/validate/email?email=user@example.com
```

### Connect as MCP server (Claude Desktop, Cursor, etc.)

Add to your MCP config:
```json
{
  "mcpServers": {
    "driftwatch": {
      "url": "https://hatchloop.dev/mcp",
      "transport": "http"
    }
  }
}
```

---

## 9. Example Agent Conversations {#examples}

The following examples show natural-language agent prompts, the corresponding API call, and the exact expected response. Use these to train tool-selection, test integrations, or seed system prompts.

---

### 9.1 DriftWatch Examples

**Prompt:** "Is the filesystem MCP server still working? Check https://github.com/modelcontextprotocol/servers for drift."

```http
GET https://hatchloop.dev/api/v1/check?url=https://github.com/modelcontextprotocol/servers
```

Expected response:
```json
{
  "url": "https://github.com/modelcontextprotocol/servers",
  "name": "mcp-servers",
  "status": "stable",
  "drift_detected": false,
  "last_checked": "2026-05-31T09:15:00Z",
  "severity": "stable",
  "summary": "No changes detected since last scan.",
  "monitored": true
}
```

---

**Prompt:** "I just deployed my MCP server at https://api.example.com/mcp — can you add it to DriftWatch monitoring?"

```http
POST https://hatchloop.dev/api/submit-server
Content-Type: application/json

{
  "server_url": "https://api.example.com/mcp",
  "email": "alerts@example.com",
  "name": "My Custom MCP Server"
}
```

Expected response:
```json
{
  "success": true,
  "message": "Server submitted for monitoring. Initial scan within 1 hour.",
  "server_id": "srv_abc123"
}
```

---

**Prompt:** "Which MCP servers have the best reliability record?"

```http
GET https://hatchloop.dev/leaderboard.json
```

Expected response (excerpt):
```json
[
  {"rank": 1, "name": "mcp-servers", "reliability_score": 99.8, "uptime_30d": 100.0, "drift_events_30d": 0},
  {"rank": 2, "name": "brave-search-mcp", "reliability_score": 98.2, "uptime_30d": 99.5, "drift_events_30d": 1},
  {"rank": 3, "name": "fetch-mcp", "reliability_score": 97.1, "uptime_30d": 98.8, "drift_events_30d": 2}
]
```

---

**Prompt:** "Sign me up to receive drift alerts for all monitored MCP servers."

```http
POST https://hatchloop.dev/api/subscribe
Content-Type: application/json

{"email": "dev@example.com", "all_servers": true}
```

Expected response:
```json
{"success": true, "message": "Subscribed to drift alerts for all monitored servers."}
```

---

### 9.2 UUID Generation Examples

**Prompt:** "I need a unique ID to insert a new row in the database."

```http
GET https://hatchloop.dev/api/tools/uuid?version=4
```

Expected response:
```json
{
  "success": true,
  "tool": "uuid",
  "result": {
    "uuid": "f47ac10b-58cc-4372-a567-0e02b2c3d479",
    "version": 4,
    "format": "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"
  },
  "timestamp": "2026-05-31T09:00:00Z"
}
```

**Prompt:** "Generate a time-sortable UUID for an event log entry."

```http
GET https://hatchloop.dev/api/tools/uuid?version=7
```

Expected response:
```json
{
  "success": true,
  "tool": "uuid",
  "result": {
    "uuid": "018f4c3a-2b7e-7000-9abc-def012345678",
    "version": 7,
    "format": "time-sortable (unix epoch ms prefix)"
  }
}
```

---

### 9.3 Hashing Examples

**Prompt:** "Hash the password 'correct-horse-battery' with SHA-256 before storing it."

```http
GET https://hatchloop.dev/api/tools/hash?input=correct-horse-battery&algo=sha256
```

Expected response:
```json
{
  "success": true,
  "tool": "hash",
  "result": {
    "input": "correct-horse-battery",
    "algorithm": "sha256",
    "hash": "a3f1c2d4e5b6789012345678901234567890abcdef1234567890abcdef123456",
    "length_bits": 256,
    "length_hex_chars": 64
  }
}
```

**Prompt:** "Generate an MD5 checksum for this filename string: 'report_2026_05.csv'."

```http
GET https://hatchloop.dev/api/tools/hash?input=report_2026_05.csv&algo=md5
```

Expected response:
```json
{
  "success": true,
  "tool": "hash",
  "result": {
    "input": "report_2026_05.csv",
    "algorithm": "md5",
    "hash": "d41d8cd98f00b204e9800998ecf8427e",
    "length_bits": 128,
    "length_hex_chars": 32
  }
}
```

---

### 9.4 Base64 Examples

**Prompt:** "Encode 'user:password123' in base64 for an HTTP Basic Auth header."

```http
GET https://hatchloop.dev/api/tools/base64?action=encode&value=user:password123
```

Expected response:
```json
{
  "success": true,
  "tool": "base64",
  "result": {
    "action": "encode",
    "input": "user:password123",
    "output": "dXNlcjpwYXNzd29yZDEyMw==",
    "url_safe": "dXNlcjpwYXNzd29yZDEyMw"
  }
}
```

**Prompt:** "Decode this base64 string: 'SGVsbG8gV29ybGQ='"

```http
GET https://hatchloop.dev/api/tools/base64?action=decode&value=SGVsbG8gV29ybGQ=
```

Expected response:
```json
{
  "success": true,
  "tool": "base64",
  "result": {
    "action": "decode",
    "input": "SGVsbG8gV29ybGQ=",
    "output": "Hello World"
  }
}
```

---

### 9.5 Timestamp Examples

**Prompt:** "What's the current time in ISO 8601 format?"

```http
GET https://hatchloop.dev/api/tools/timestamp?format=iso
```

Expected response:
```json
{
  "success": true,
  "tool": "timestamp",
  "result": {"iso": "2026-05-31T09:00:00.000Z"}
}
```

**Prompt:** "Give me all timestamp formats at once."

```http
GET https://hatchloop.dev/api/tools/timestamp?format=all
```

Expected response:
```json
{
  "success": true,
  "tool": "timestamp",
  "result": {
    "iso": "2026-05-31T09:00:00.000Z",
    "unix": 1748682000,
    "unix_ms": 1748682000000,
    "human": "May 31, 2026, 9:00:00 AM UTC",
    "year": 2026, "month": 5, "day": 31,
    "hour": 9, "minute": 0, "second": 0
  }
}
```

---

### 9.6 Email Validation Examples

**Prompt:** "Validate this email before we send the invite: admin@corp.example.com"

```http
GET https://hatchloop.dev/api/tools/validate/email?email=admin@corp.example.com
```

Expected response:
```json
{
  "success": true,
  "tool": "validate-email",
  "result": {
    "email": "admin@corp.example.com",
    "valid": true,
    "local_part": "admin",
    "domain": "corp.example.com",
    "has_subdomain": true,
    "issues": []
  }
}
```

**Prompt:** "Is 'not-an-email' a valid email address?"

```http
GET https://hatchloop.dev/api/tools/validate/email?email=not-an-email
```

Expected response:
```json
{
  "success": true,
  "tool": "validate-email",
  "result": {
    "email": "not-an-email",
    "valid": false,
    "issues": ["Missing @ symbol", "No domain found"]
  }
}
```

---

### 9.7 JSON Validation Examples

**Prompt:** "Is this valid JSON? Check it and pretty-print it."

```http
POST https://hatchloop.dev/api/tools/validate/json
Content-Type: text/plain

{"name":"Alice","age":30,"tags":["dev","agent"]}
```

Expected response:
```json
{
  "success": true,
  "tool": "validate-json",
  "result": {
    "valid": true,
    "parsed": {"name": "Alice", "age": 30, "tags": ["dev", "agent"]},
    "pretty": "{\n  \"name\": \"Alice\",\n  \"age\": 30,\n  \"tags\": [\n    \"dev\",\n    \"agent\"\n  ]\n}",
    "type": "object",
    "key_count": 3,
    "issues": []
  }
}
```

---

### 9.8 Unit Conversion Examples

**Prompt:** "Convert 180 pounds to kilograms."

```http
GET https://hatchloop.dev/api/tools/convert/units?value=180&from=lbs&to=kg
```

Expected response:
```json
{
  "success": true,
  "tool": "convert-units",
  "result": {
    "input_value": 180,
    "input_unit": "lbs",
    "output_value": 81.647,
    "output_unit": "kg",
    "formatted": "180 lbs = 81.647 kg"
  }
}
```

**Prompt:** "How many GB is 2,500 MB?"

```http
GET https://hatchloop.dev/api/tools/convert/units?value=2500&from=mb&to=gb
```

Expected response:
```json
{
  "success": true,
  "tool": "convert-units",
  "result": {
    "input_value": 2500,
    "input_unit": "mb",
    "output_value": 2.441,
    "output_unit": "gb",
    "formatted": "2500 mb = 2.441 gb"
  }
}
```

---

### 9.9 Regex Testing Examples

**Prompt:** "Test whether my regex '\\b[A-Z]{2,5}\\b' matches anything in the string 'Hello API and SDK tools'."

```http
GET https://hatchloop.dev/api/tools/regex/test?pattern=%5Cb%5BA-Z%5D%7B2%2C5%7D%5Cb&input=Hello+API+and+SDK+tools&flags=g
```

Expected response:
```json
{
  "success": true,
  "tool": "regex-test",
  "result": {
    "pattern": "\\b[A-Z]{2,5}\\b",
    "flags": "g",
    "input": "Hello API and SDK tools",
    "matched": true,
    "match_count": 2,
    "matches": [
      {"match": "API", "index": 6, "groups": {}},
      {"match": "SDK", "index": 14, "groups": {}}
    ]
  }
}
```

---

### 9.10 Cron Expression Examples

**Prompt:** "Explain what the cron expression '0 */6 * * *' means and show the next few run times."

```http
GET https://hatchloop.dev/api/tools/cron/describe?expr=0+*/6+*+*+*
```

Expected response:
```json
{
  "success": true,
  "tool": "cron-describe",
  "result": {
    "expression": "0 */6 * * *",
    "description": "At minute 0 past every 6th hour",
    "next_5_runs": [
      "2026-05-31T12:00:00Z",
      "2026-05-31T18:00:00Z",
      "2026-06-01T00:00:00Z",
      "2026-06-01T06:00:00Z",
      "2026-06-01T12:00:00Z"
    ],
    "timezone": "UTC"
  }
}
```

---

### 9.11 JWT Decoding Examples

**Prompt:** "Decode this JWT token so I can see who the user is: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsIm5hbWUiOiJBbGljZSIsImlhdCI6MTUxNjIzOTAyMn0.abc"

```http
GET https://hatchloop.dev/api/tools/jwt/decode?token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMyIsIm5hbWUiOiJBbGljZSIsImlhdCI6MTUxNjIzOTAyMn0.abc
```

Expected response:
```json
{
  "success": true,
  "tool": "jwt-decode",
  "result": {
    "header": {"alg": "HS256", "typ": "JWT"},
    "payload": {"sub": "user_123", "name": "Alice", "iat": 1516239022},
    "signature": "abc",
    "expired": false,
    "issued_at": "2018-01-18T01:30:22Z"
  }
}
```

---

### 9.12 QR Generator Examples

**Prompt:** "Create a QR code that links to https://hatchloop.dev — return it as SVG so I can embed it in a webpage."

```http
POST https://hatchloop.dev/qr-generator/generate
Content-Type: application/json

{"data": "https://hatchloop.dev", "format": "svg"}
```

Expected response: `Content-Type: image/svg+xml` with SVG body. Save as `qr.svg` or embed directly in `<img src="data:image/svg+xml;base64,...">`.

---

**Prompt:** "Make a QR code for a WiFi network: SSID=MyNetwork, password=secret123."

```http
POST https://hatchloop.dev/qr-generator/generate
Content-Type: application/json

{"data": "WIFI:T:WPA;S:MyNetwork;P:secret123;;", "format": "png"}
```

Expected response: `Content-Type: image/png` binary (scannable WiFi QR code).

---

### 9.13 URL Shortener Examples

**Prompt:** "Shorten this long API URL before including it in a report."

```http
POST https://hatchloop.ai/shorten
Content-Type: application/json

{"url": "https://hatchloop.dev/api/v1/check?url=https://github.com/modelcontextprotocol/servers&format=json&verbose=true"}
```

Expected response:
```json
{
  "short_url": "https://hatchloop.ai/s/aB3xK",
  "original_url": "https://hatchloop.dev/api/v1/check?url=...",
  "code": "aB3xK",
  "created_at": "2026-05-31T09:00:00Z"
}
```

---

### 9.14 Page Extractor Examples

**Prompt:** "What is the title and main headings of the MCP introduction page?"

```http
POST https://hatchloop.dev/extract
Content-Type: application/json

{"url": "https://modelcontextprotocol.io/introduction"}
```

Expected response:
```json
{
  "url": "https://modelcontextprotocol.io/introduction",
  "title": "Introduction - Model Context Protocol",
  "meta_description": "MCP is an open standard that enables seamless integration between LLM applications and external data sources and tools.",
  "headings": [
    {"level": "h1", "text": "Introduction"},
    {"level": "h2", "text": "What is MCP?"},
    {"level": "h2", "text": "General Architecture"},
    {"level": "h3", "text": "Core Components"}
  ]
}
```

---

### 9.15 Summarizer Examples

**Prompt:** "Summarize this article in 3 sentences: [long article text]"

```http
POST https://hatchloop.dev/summarize
Content-Type: application/json

{"text": "Model Context Protocol (MCP) is an open standard... [full text]", "sentences": 3}
```

Expected response:
```json
{
  "summary": "Model Context Protocol (MCP) is an open standard for connecting AI models to external tools and data sources. It defines a uniform JSON-RPC interface so language models can invoke tools, read resources, and use prompt templates from any compliant server. MCP is transport-agnostic and supports stdio, SSE, and Streamable HTTP."
}
```

**Prompt:** "Give me the key points from https://modelcontextprotocol.io/introduction, 5 sentences max."

```http
POST https://hatchloop.dev/summarize
Content-Type: application/json

{"url": "https://modelcontextprotocol.io/introduction", "sentences": 5}
```

Expected response:
```json
{
  "summary": "MCP is an open protocol that standardizes how applications provide context to LLMs. It follows a client-server architecture where host applications connect to multiple servers. MCP servers expose three primitives: tools (executable functions), resources (data/files), and prompts (templates). The protocol is transport-agnostic and supports local stdio and remote HTTP transports. MCP replaces fragmented, one-off integrations with a single standard connection layer."
}
```

---

## Authentication Summary

| Service | Auth |
|---------|------|
| DriftWatch read endpoints | None |
| Agent Utils | None |
| QR Generator | None |
| URL Shortener | None |
| DriftWatch Pro (webhooks, alerts) | `X-DriftWatch-Key` header |

---

## Keywords

MCP monitoring, MCP server drift, AI tool change detection, LLM drift detection,
model context protocol, AI pipeline health, tool reliability, agent infrastructure,
drift watch, behavior regression, AI observability, MCP index, tool schema tracking,
AI quality gates, agent orchestration, AI DevOps, LLM operations, MLOps,
UUID generation, string hashing, Base64, unit conversion, email validation,
JSON validation, regex testing, cron parsing, JWT decoding, QR code generation,
URL shortening, agent utilities, zero-auth API, CORS open

## Links

- Website: https://hatchloop.dev
- Summary llms.txt: https://hatchloop.dev/llms.txt
- DriftWatch OpenAPI: https://hatchloop.dev/openapi.json
- Agent Utils OpenAPI: https://hatchloop.dev/tools/openapi.json
- MCP manifest: https://hatchloop.dev/mcp.json
- Agent plugin manifest: https://hatchloop.dev/.well-known/ai-plugin.json
- Capabilities: https://hatchloop.dev/capabilities.json
- Sitemap: https://hatchloop.dev/sitemap.xml