You install ToolPiper for the local LLM inference, or the MCP tools, or the browser automation. What you get for free is a logging service that quietly solves a problem every developer building with local AI has: where did things go wrong, and when?

LogPiper is a real-time logging bus built into ToolPiper. Any process on your machine - a Python script, a shell command, an Angular app, a browser extension, another Swift app - can write structured log entries to it over HTTP. Any process can query those logs or stream them in real time, and with a token you can export them to disk. There's nothing to install, nothing to configure, and no account to create. If ToolPiper is running, LogPiper is running.

The Problem With Local AI Debugging

When you're building with cloud APIs, observability is someone else's problem. OpenAI gives you a dashboard. Anthropic gives you a console. The request leaves your machine, hits an endpoint, and the provider's infrastructure handles logging, metrics, and error reporting.

Local AI flips this. The model runs on your machine. The inference server runs on your machine. The API gateway, the proxy, the embedding engine, the TTS pipeline - all local. When something fails, there's no dashboard to check. You're left grepping through multiple terminal windows, correlating timestamps by hand, and guessing which component dropped the ball.

This gets worse when you have multiple local apps collaborating. ToolPiper runs inference. VisionPiper captures screens. AudioPiper records audio. The ModelPiper web app sends requests to ToolPiper. A browser extension detects image sources. Each has its own stdout, its own error handling, its own log format. The failure you're debugging might span three of them.

How LogPiper Works

LogPiper is a few HTTP routes and a query engine. That's it.

Write a Log Entry

curl -X POST http://127.0.0.1:9998/v1/logs \
  -H "Content-Type: application/json" \
  -d '{
    "source": "my-script",
    "level": "info",
    "event": "pipeline.start",
    "message": "Starting data processing",
    "data": {"inputFile": "dataset.csv", "rows": 50000},
    "correlationId": "job_abc123"
  }'

That's a fire-and-forget POST, and from the same Mac it needs no token. The response is {"ok": true, "count": 1}. If ToolPiper isn't running, the connection is refused; give your client a short timeout and ignore the error, and logging never blocks your app.

Need to send multiple entries at once? Batch them:

curl -X POST http://127.0.0.1:9998/v1/logs \
  -H "Content-Type: application/json" \
  -d '[{"source": "my-script", "level": "info", ...}, ...]'

A batch is all-or-nothing. One bad entry, such as a level other than debug, info, warn or error, fails the whole request with a 400. Every field is optional; ToolPiper fills in the id, timestamp, source, level and event when they're missing.

Query Logs

# Recent errors from any source
curl "http://127.0.0.1:9998/v1/logs?level=error&limit=20"

# The web app's HTTP traffic (when you run it locally)
curl "http://127.0.0.1:9998/v1/logs?event=http&limit=100"

# Logs from a specific app
curl "http://127.0.0.1:9998/v1/logs?source=my-script&limit=50"

# Everything related to one job
curl "http://127.0.0.1:9998/v1/logs?correlationId=job_abc123"

Queries filter by level (minimum severity), source, event prefix, correlation ID, and comma-separated excludeSource / excludeEvent lists. There's no time-range or text search over HTTP. limit defaults to 100 and caps at 2,000, and results come back as a JSON array of the newest matching entries, oldest first.

Stream in Real-Time

# Stream all errors as they happen (SSE)
curl -N "http://127.0.0.1:9998/v1/logs/stream?level=error"

# Stream events from a specific source
curl -N "http://127.0.0.1:9998/v1/logs/stream?source=my-script"

The stream endpoint uses Server-Sent Events. Open it in one terminal while your app runs in another. Every matching log entry appears the moment it's ingested. No polling, no delay. The stream takes the level, source, event and exclude filters, but not correlationId. Each entry carries its id, so a client that reconnects with Last-Event-ID gets what it missed, as long as those entries are still in the buffer.

What Gets Logged Today

An entry exists only because something POSTed it. ToolPiper doesn't intercept other apps' traffic, so the bus holds three kinds of entries: what ToolPiper logs about itself, what the ModelPiper web app logs when you run it locally, and what your own code posts.

ToolPiper's Own Events

EventWhat It Covers
server.httpA request line for each call ToolPiper serves, refusals included
auth.accepted, auth.rejectedAuthentication outcomes
tool.start, tool.stop, tool.error, tool.crashBackend process lifecycle
tool.outputBackend stdout and stderr, with the backend id as the source
engine.loadModel load results
cloud.proxy.*Cloud proxy request metadata (URL, method, streaming), plus the upstream error body, up to 8,192 characters, only when a streaming call returns 400 or above
anthropic.proxy.*Calls to the Anthropic-compatible /v1/messages route, metadata only
mcp.tools.callEach MCP tool call ToolPiper serves: tool name and arguments, credential keys masked
mcp.tool.complete, mcp.tool.errorDuration and success of that call. The output isn't logged

If your local model stops responding mid-conversation, query event=tool and you'll see whether the backend process crashed or stopped, next to the stdout and stderr lines it wrote before that. Companion apps post their own entries too: VisionPiper under source visionpiper, AudioPiper under audiopiper, the MediaPiper browser extension under mediapiper.

ModelPiper Web App HTTP Traffic

When you run the ModelPiper web app locally (on localhost or 127.0.0.1), it logs every HTTP request it makes as http.request, http.response, http.error and http.cancel. Request and response bodies are included, truncated at 8,000 characters, and credential-named JSON keys are replaced with [REDACTED]. The hosted app at modelpiper.com logs nothing.

// A streamed chat turn from the web app:
{
  "event": "http.request",
  "data": {
    "method": "POST",
    "url": "/v1/chat/completions",
    "requestBody": "{\"model\":\"llama-3.2-3b\",\"messages\":[...]}"
  }
}
{
  "event": "http.response",
  "durationMs": 1250,
  "data": {
    "status": 200,
    "isStreaming": true
  }
}

When a cloud API returns a 400 error, you don't have to guess what the web app sent. The request body is right there, and the error body sits on the http.error entry. Streaming responses, like the chat turn above, log their status with isStreaming: true and no body. Binary responses show their type and size instead of a body.

Your Own Entries

Everything else is what you post. There's no per-entry size cap (only a 25 MB limit per request), so your code can put full request and response bodies in data and ToolPiper stores them untruncated. The 8,000-character cut applies only to the web app's own logging.

Correlation IDs

A correlationId is an optional string your code sets. Pass the same one on every entry for a job, and correlationId=job_abc123 returns that job's timeline across every app that used it. The All Logs view's Execution picker filters on the same field. Nothing assigns correlation IDs for you: ToolPiper's own events and the web app's HTTP events carry none. This is how you trace a multi-step job through different services without manually correlating timestamps.

Event Prefixes

LogPiper uses a prefix-based event taxonomy. Query by prefix and you get all subtypes: event=tool returns every backend lifecycle and output entry, event=mcp every MCP entry, event=http the web app's traffic.

The event field is a free-form string. Your own apps can use any prefix scheme you want: myapp.auth.login, myapp.queue.stall, whatever makes sense for your domain.

Why This Is Better Than Console Logs

Console logs are write-only. You print them, they scroll past, and they're gone. If you didn't have the right terminal open at the right time, you missed it.

LogPiper is write-once, query-many. Every entry lands in an in-memory buffer (5,000 entries, circular) that supports filtered queries and real-time subscriptions. The data is structured - level, source, event, correlation ID - so you can slice it precisely instead of grepping through unstructured text.

The key difference: you can query logs after the fact without having been watching when they happened. Your script crashed at 3 AM? Query its errors in the morning, as long as ToolPiper stayed up and the buffer hasn't rolled past them. A user reports a bug? Ask them to copy their logs from the All Logs view. An MCP tool returned garbage? event=mcp shows the arguments it was called with, how long it ran and whether it succeeded.

Integration Is One HTTP Call

There's no SDK to install, no client library to import, no dependency to manage. If your language can make an HTTP POST, it can log to LogPiper.

From Python

import requests

def log(level, event, message, data=None, correlation_id=None):
    requests.post("http://127.0.0.1:9998/v1/logs", json={
        "source": "my-python-app",
        "level": level,
        "event": event,
        "message": message,
        "data": data or {},
        "correlationId": correlation_id
    }, timeout=2)

log("info", "training.epoch", "Epoch 5 complete", {"loss": 0.023, "lr": 1e-4})

From a Shell Script

log_event() {
  curl -s -X POST http://127.0.0.1:9998/v1/logs \
    -H "Content-Type: application/json" \
    -d "{\"source\":\"deploy\",\"level\":\"$1\",\"event\":\"$2\",\"message\":\"$3\"}" \
    --max-time 2 > /dev/null 2>&1 &
}

log_event info deploy.start "Deploying v2.1.0 to staging"
rsync -az ./dist/ staging:/var/www/
log_event info deploy.complete "Deploy finished"

From JavaScript (Node or Browser)

fetch('http://127.0.0.1:9998/v1/logs', {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({
    source: 'my-app',
    level: 'error',
    event: 'payment.failed',
    message: 'Stripe returned 402',
    data: {customerId: 'cus_123', amount: 4999}
  })
}).catch(() => {}) // fire-and-forget

In a browser, this works from pages served on localhost or 127.0.0.1. ToolPiper's CORS allowlist doesn't include arbitrary websites.

From ToolPiper's MCP Tools

If you're using ToolPiper's MCP tools from Claude Code, Cursor, or any MCP-compatible AI assistant, ToolPiper logs every tool call it serves without any logging code on your side. You get the tool name and its arguments (credential keys masked) on mcp.tools.call, then the duration and success on mcp.tool.complete or mcp.tool.error. The output isn't logged. Query event=mcp and the AI's tool usage reads as an audit trail.

The Debugging Workflow

Here's how to use LogPiper when something breaks. This works whether you're debugging your own app, a ToolPiper feature, or an MCP tool interaction.

# 1. Clear old noise (needs a bearer token with system:control,
#    or use Clear Logs in the All Logs view)
curl -X POST http://127.0.0.1:9998/v1/logs/clear \
  -H "Authorization: Bearer tp_..."

# 2. Reproduce the problem
# (run your app, trigger the bug, execute the MCP tool, etc.)

# 3. Check what happened
curl "http://127.0.0.1:9998/v1/logs?level=error&limit=20"

# 4. Narrow it: your app's entries, or the MCP tool calls
curl "http://127.0.0.1:9998/v1/logs?source=my-app&limit=50"
curl "http://127.0.0.1:9998/v1/logs?event=mcp&limit=50"

# 5. If you need everything, export to a file (same token)
curl -X POST http://127.0.0.1:9998/v1/logs/export \
  -H "Authorization: Bearer tp_..."
# Writes JSON to ~/Library/Application Support/ToolPiper/exports/ and returns the path

The clear-reproduce-query cycle takes seconds. No log file to find, no grep to construct, no timestamps to correlate. And when your code logs the bodies at its API boundaries, you often find the root cause on the first query: the error message is right there in the entry's data.

Designed to Disappear

The interface your apps use is HTTP, the same interface they already speak. Query it from curl, from a script, from your AI assistant, from a monitoring tool. Pipe the SSE stream into jq. Build a custom dashboard if you want one. The data is yours.

When you'd rather look than query, ToolPiper's main window has an All Logs view: search across event, message and source; Level, Source and Execution pickers; rows with level, time, source, event, message and duration; a detail panel for the data payload; and Copy Logs and Clear Logs. The ModelPiper web app has no log viewer.

From the same Mac, ingest (POST /v1/logs), query (GET /v1/logs) and stream (GET /v1/logs/stream) need no token. No session key, no handshake. ToolPiper waives the token only for connections from the Mac itself, so any local process can log, query and stream without credential management. Clear and export are different: /v1/logs/clear and /v1/logs/export need a bearer token (tp_...) with the system:control scope, even from the same Mac. Create one in ToolPiper's Security pane.

The buffer is in-memory (5,000 entries, oldest evicted first). LogPiper is a debugging tool, not an archival system. It's always fast, never fills your disk, and restarts clean. If you need persistence, export before clearing.

What Developers Are Doing With It

  • AI pipeline debugging: Logging each step of a multi-model pipeline (transcribe → summarize → speak) with a shared correlation ID, then querying the full chain when output quality drops
  • MCP tool audit trails: Reviewing exactly what arguments an AI assistant sent to a tool, how long it ran and whether it succeeded - useful for prompt tuning and tool schema refinement
  • CI/CD visibility: Shell scripts logging deploy events to LogPiper, then querying for errors if the deploy fails - all without setting up a dedicated logging service
  • Cross-app debugging: Reading a locally run web app's HTTP calls, bodies included, next to the ToolPiper request lines and cloud proxy entries from the same moment
  • Model performance tracking: Logging inference duration and token counts per request, then querying to compare performance across models or quantization levels

The Logging Endpoint You Already Have

If ToolPiper is installed on your Mac, LogPiper is already running. There's nothing to enable, nothing to configure, and nothing to pay for. Every ToolPiper installation - free or Pro - includes the full logging bus.

The next time you're debugging a local AI workflow, an MCP tool interaction, or a multi-app integration, skip the console.log archaeology. POST to http://127.0.0.1:9998/v1/logs and query http://127.0.0.1:9998/v1/logs. The data is structured, the queries are instant, and ToolPiper's own events are already there.

LogPiper won't replace your production observability stack. It's not trying to. It's the local debugging companion that makes building with ToolPiper - and building anything on your Mac - faster to diagnose when things go sideways.

ToolPiper is a free download from the modelpiper.com/download.