🔗 Easy Mode for Local Agents and Small LLMs

Give Hermes Agent, OpenClaw, Open WebUI, LM Studio, or another MCP/OpenAI-compatible stack a privacy-first small-model tool layer. Small models see six simple tools while deterministic discovery and workflows cover all 76+ local and hosted capabilities. Local ComfyUI, image editing, PDF extraction, OCR, diagnostics, and saved workflows stay on your machines.

Before you start

You'll need these pieces in place before the bridge can connect everything:

• Node.js 18+ — Download or verify with node -v
• A local LLM server — LM Studio, Ollama, vLLM, llama.cpp, or SGLang running with a model loaded
• Open WebUI — up and running (local install, Docker, or self-hosted)
• ~5 minutes — the basic bridge setup takes about five minutes

Free locally. Paid when your agent needs hosted operations.

Free: the bridge, Easy Mode, local ComfyUI and document processing, bounded diagnostics, and saved local workflows. Your own model and hardware are never placed behind a subscription.

Pro ($5/month): use the same local agent with 1,000 hosted tool calls per day, 100 flexible monthly credits, durable 30-day files, 25 schedules, 25 website watches, and Discord/Telegram alerts. Builder increases credits, retention, and automation limits and includes most Blueprint packs. Hosted access still requires your explicit opt-in. Compare plans →

🔒 Method 1: Full Easy Mode Bridge (Recommended)

Choose this for the complete catalog. The model sees six simplified controls, while discovery and the universal runner provide access to all 76+ local and hosted tools. The bridge runs on your computer, talks to an OpenAI-compatible model server such as LM Studio, Ollama, vLLM, llama.cpp, or SGLang, executes tool calls, and returns results to the model. Hermes Agent can alternatively use the MCP package directly. Hosted tools, consequential actions, and hosted image fallback are independently disabled by default.

Download for Windows / macOS / Linux

# Windows PowerShell
$env:AMT_LLM_UPSTREAM_URL = "http://127.0.0.1:1234/v1"
$env:AMT_COMFYUI_URL = "http://127.0.0.1:8188"
$env:AMT_EASY_MODE = "true"
npm start

# Linux / macOS
export AMT_LLM_UPSTREAM_URL=http://127.0.0.1:1234/v1
export AMT_COMFYUI_URL=http://127.0.0.1:8188
export AMT_EASY_MODE=true
npm start

# Or inline (single command, no export):
AMT_LLM_UPSTREAM_URL=http://127.0.0.1:1234/v1 \
AMT_COMFYUI_URL=http://127.0.0.1:8188 \
AMT_EASY_MODE=true \
npm start

Verify it's working

Check that the bridge is healthy and proxying models correctly:

# Bridge health check
curl http://127.0.0.1:3333/health
# → {"success":true,"service":"agent-media-tools-local-bridge","easy_tools":6}

# Model list (forwarded from your LLM server)
curl http://127.0.0.1:3333/v1/models

# Run history (visible after first tool call)
curl http://127.0.0.1:3333/amt/runs

Quick test prompts

Try these in Open WebUI to confirm tool calling works:

• "Generate a UUID" — tests local tool execution
• "Create a QR code for https://agentmediatools.com" — tests hosted tools
• "Find tools related to image generation" — tests tool discovery

Enable hosted features (optional)

Remote tools are disabled by default. Set any of these before starting the bridge to enable them:

# Allow hosted API calls (image editing, QR codes, pastes, etc.)
AMT_ALLOW_REMOTE_TOOLS=true

# Allow sensitive actions (purchases, deletions, schedules, approvals)
AMT_ALLOW_SENSITIVE_TOOLS=true

# Allow hosted image generation as fallback when local ComfyUI is unavailable
AMT_ALLOW_HOSTED_IMAGE_FALLBACK=true

# Change the bridge port (default: 3333)
AMT_BRIDGE_PORT=4444

Keep the bridge alive

The bridge runs in your terminal window by default. When you close it, the bridge stops. Here's how to keep it running:

Linux (systemd — persistent across reboots)

# Create a user service
mkdir -p ~/.config/systemd/user
cat > ~/.config/systemd/user/amt-bridge.service << 'SERVICE'
[Unit]
Description=Agent Media Tools Local Bridge
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/node /path/to/bridge/local-llm-bridge.js
WorkingDirectory=/path/to/bridge
Environment=AMT_LLM_UPSTREAM_URL=http://127.0.0.1:1234/v1
Environment=AMT_EASY_MODE=true
Environment=AMT_BRIDGE_PORT=3333
Restart=on-failure
RestartSec=5

[Install]
WantedBy=default.target
SERVICE

# Enable and start
systemctl --user daemon-reload
systemctl --user enable amt-bridge.service
systemctl --user start amt-bridge.service

macOS / Linux (quick background)

screen -S amt-bridge   # or: tmux new -s amt-bridge
npm start
# Detach with Ctrl+A D (screen) or Ctrl+B D (tmux)

Windows (PowerShell background)

Start-Process -NoNewWindow -RedirectStandardOutput "bridge.log" node "local-llm-bridge.js"

Inspect and reuse successful runs

The bridge keeps a bounded diagnostic history on your computer. It records tool names, arguments, timing, errors, token usage, and local/remote privacy classifications, but never stores your prompt or the model's prose. Open http://127.0.0.1:3333/amt/runs to inspect recent runs.

A successful run can be saved explicitly as a deterministic workflow with POST /amt/runs/{run_id}/workflow, then replayed through POST /amt/workflows/{workflow_id}/run. Replays enforce the same remote and sensitive-action permission gates. The included bridge README has complete examples and configuration.

Claude Desktop extension builds

Prefer native MCP in Claude Desktop? Use the build matching your computer:

Windows x64 · macOS Apple Silicon · macOS Intel · Linux x64

Hermes Agent MCP integration

If you use Hermes Agent, you can connect directly to the Bridge's MCP server instead of the OpenAI-compatible endpoint:

# Add to ~/.hermes/config.yaml under mcp_servers:

mcp_servers:
  media-tool:
    command: "node"
    args: ["/absolute/path/to/bridge/mcp-server.js"]
    env:
      MEDIA_TOOL_URL: "https://agentmediatools.com"

Then restart Hermes. All 76+ tools appear as mcp_media-tool_* commands alongside your built-in tools. Requires the MCP Python SDK: pip install mcp (or uv pip install mcp).

🛠️ Method 2: Six-Utility Starter Toolkit

Choose this for a quick, limited setup. This is not the complete Easy Mode catalog: it exposes only UUID, password, timestamp, QR code, text paste, and public-IP lookup. It runs directly inside Open WebUI without the local bridge. UUIDs, passwords, and timestamps stay local; the other three operations use Agent Media Tools. An API key prevents a self-hosted Open WebUI instance from relying on the shared anonymous rate-limit bucket.

"""
title: Agent Media Tools
description: Local utilities plus authenticated Agent Media Tools calls.
requirements: requests
version: 1.1.0
"""

import requests
import secrets
import string
import uuid
from datetime import datetime, timezone
from pydantic import BaseModel, Field

BASE = "https://agentmediatools.com"

class Tools:
    class Valves(BaseModel):
        api_key: str = Field(
            default="",
            description="Your Agent Media Tools API key (starts with mt_)",
        )

    def __init__(self):
        self.valves = self.Valves()

    def _headers(self) -> dict:
        if not self.valves.api_key:
            return {}
        return {"Authorization": f"Bearer {self.valves.api_key}"}

    def generate_uuid(self) -> str:
        """Generate a random UUID v4 locally without an API request."""
        return str(uuid.uuid4())

    def generate_password(self, length: int = 20, symbols: bool = True) -> str:
        """Generate a secure random password locally."""
        length = max(8, min(int(length), 128))
        alphabet = string.ascii_letters + string.digits
        if symbols:
            alphabet += string.punctuation
        return "".join(secrets.choice(alphabet) for _ in range(length))

    def convert_timestamp(self, value: str = "now") -> str:
        """Convert a Unix timestamp to UTC, or return the current time."""
        if value.lower() == "now":
            moment = datetime.now(timezone.utc)
        else:
            moment = datetime.fromtimestamp(int(value), timezone.utc)
        return f"Unix: {int(moment.timestamp())}; ISO UTC: {moment.isoformat()}"

    def generate_qrcode(self, text: str, size: int = 300) -> str:
        """Generate a hosted QR-code data URL from text or a URL."""
        response = requests.post(
            f"{BASE}/api/qrcode",
            json={"text": text, "size": size},
            headers=self._headers(),
            timeout=30,
        )
        response.raise_for_status()
        return response.json().get("dataUrl", "No QR code was returned")

    def create_paste(self, content: str, syntax: str = "text", title: str = "") -> str:
        """Create a hosted text paste and return its shareable URL."""
        response = requests.post(
            f"{BASE}/api/paste",
            json={"content": content, "syntax": syntax, "title": title},
            headers=self._headers(),
            timeout=30,
        )
        response.raise_for_status()
        return response.json().get("url", "No paste URL was returned")

    def lookup_public_ip(self) -> str:
        """Look up the public IP and approximate location of this Open WebUI host."""
        response = requests.get(
            f"{BASE}/api/ip",
            headers=self._headers(),
            timeout=30,
        )
        response.raise_for_status()
        return response.text

📖 Recommended System Prompt for Tool Use

Use this alongside Method 2, especially with smaller local models. Add it to the Open WebUI model's system prompt or model instructions; the Agent Media Tools toolkit must still be enabled for the model or chat.

You are running inside Open WebUI with the Agent Media Tools toolkit enabled.

Before answering, identify whether the user is asking for information or asking you to perform an action. Inspect the available tools, but call one only when the user clearly requests the operation it performs.

This Method 2 starter toolkit has exactly six utilities: generate UUIDs and secure passwords, convert timestamps, generate QR codes, create shareable text pastes, and look up this Open WebUI host's public IP information. It does not expose the complete Agent Media Tools catalog.

Rules:
1. If the user asks what Agent Media Tools is, what it has, or what you can do, answer in plain language with a short readable list. Do not call a tool for a capability question.
2. Mention that this enabled Method 2 toolkit has only six operations: UUID, password, timestamp, QR code, text paste, and public-IP lookup. Do not imply that other platform capabilities are enabled. Full Easy Mode uses the Method 1 bridge; the wider platform is described at https://agentmediatools.com/tools.
3. Never turn a URL into a QR code unless the user explicitly asks for a QR code. The presence of a URL alone is not permission to call generate_qrcode.
4. Never create a paste unless the user explicitly asks to create or share a paste.
5. Use generate_uuid only for a requested UUID; generate_password only for a requested password; convert_timestamp only for a requested conversion; and lookup_public_ip only for a requested public-IP lookup.
6. Do not send users to /api/tools when they want a human-readable explanation. Use https://agentmediatools.com/tools for a browsable catalog.
7. Do not ask the user to confirm that tools are enabled; they are already enabled.
8. Never invent a tool result. After a successful call, briefly present the result in human-readable language.
9. If a tool returns an error, report its exact error once and do not repeatedly retry.
10. UUID, password, and timestamp operations run locally. QR codes, paste creation, and public-IP lookup use Agent Media Tools.

🔧 Troubleshooting

First-time setup issues are common and usually quick to fix. Here are the most frequent ones:

💡 What You Can Do

• Local images: Generate through ComfyUI/SD WebUI; resize, compress, convert, or grayscale locally
• Hosted images: Resize, convert, compress, crop, analyze, remove backgrounds, or generate when explicitly enabled
• PDFs: Merge, split, compress, extract text, convert to/from images
• Data: QR codes, pastebin, short URLs, hash, Base64, JWT decode
• Dev: UUID, passwords, timestamps, IP lookup, unit conversion