Getting Started

Your first 5 minutes

Install the binary, send a request, and watch the platform light up. Here's what actually happens at each step.

Install

One command. No runtime, no Docker, no dependencies.

# Downloads a single static binary to /usr/local/bin
curl -sSL stockyard.dev/install | sh
      

What just happened: A ~15MB Go binary is now on your PATH. It contains all 6 apps, 58 middleware modules, an embedded SQLite database, and a full web console. Nothing else was installed.

Start the platform

One command. All 6 apps boot on a single port.

stockyard

# Output:
# Stockyard v1.0 — Where LLM traffic gets sorted
# ┌─────────────────────────────────────────────┐
# │  Proxy      :4200/v1    ✓ 58 modules active │
# │  Console    :4200/ui    ✓ 6 apps loaded     │
# │  API        :4200/api   ✓ 69 endpoints      │
# │  Playground :4200/play  ✓ ready              │
# └─────────────────────────────────────────────┘
      

What just happened: The proxy is listening. The console is live. The SQLite database was created at ~/.stockyard/stockyard.db. All 16 providers are auto-configured. Fifty-eight modules are running in the middleware chain. Nothing to configure yet — sensible defaults are already active.

Send your first request

Point any OpenAI-compatible client at localhost:4200.

# Just change the base URL — your API key stays yours
curl http://localhost:4200/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"Hello"}]}'
      

Or in your app code — one line changes:

# Before — direct to OpenAI
client = OpenAI()

# After — through Stockyard
client = OpenAI(base_url="http://localhost:4200/v1")
      

What just happened: Your request hit the proxy, flowed through 58 middleware modules (rate limiter, cost tracker, safety filter, semantic cache, etc.), reached OpenAI, and the response came back — with a trace logged in Observe and an audit event written to Trust. You didn't configure any of that.

Open the console

See what just happened — traces, costs, live events.

Open http://localhost:4200/ui in your browser.

Observe dashboard showing request traces with model, provider, latency, tokens, cost, and time columns

Observe → Traces: every request logged with model, latency, tokens, and cost

What you're seeing: The Observe dashboard shows every request that's flowed through the proxy. Each row is a trace — which model was called, through which provider, how long it took, how many tokens were used, and what it cost. The cost rollup at the top gives you today's spend at a glance.

Toggle a module

Turn features on and off at runtime — no restart, no redeploy.

Navigate to Proxy in the sidebar. You'll see all 58 modules with toggle switches.

# Or via the API:
curl -X PUT http://localhost:4200/api/proxy/modules/cost-cap \
  -d '{"enabled": true}'
      

What just happened: The module was toggled in the live middleware chain — the next request will flow through the updated pipeline. No binary restart, no config file change, no deploy. The toggle is persisted to SQLite and survives restarts.

Who it's for

Three developers, three problems

The same platform, configured differently.

Solo developer

"I don't want a surprise $400 bill."

You're building a side project with GPT-4o. You want a hard cost cap at $20/month, automatic fallback to a cheaper model when you're close, and a daily email if anything looks off.

Enable three modules and you're done.

cost-cap · model-fallback · spend-alerts

Startup going to prod

"Our safety review is next week."

You need PII filtering before responses hit users, injection attempt blocking, and an audit trail that proves you're doing it. Install the safety pack — five modules, pre-configured.

block-pii-output · block-injection · content-filter · audit-log · safety-score

Enterprise team

"Compliance wants a tamper-proof ledger."

Every LLM call needs to be hash-chained in an append-only audit log. Trust does this automatically — every request through the proxy is a signed ledger entry with chain verification.

trust-ledger · evidence-export · chain-verify · policy-engine

The Console

What you're actually looking at

Six apps, one dashboard. Each tab is a different lens on the same traffic.

Every request traced. Cost attribution by model and provider. Latency sparklines. Anomaly detection. Alerts when something looks wrong.

Observe dashboard with traces, cost, latency, and error rate stats

Traces & Cost Dashboard — real-time request monitoring

Integration

One line in your code

If your code talks to the OpenAI API, it already works with Stockyard.

from openai import OpenAI

# Your API key goes straight to the provider — Stockyard never stores it
client = OpenAI(
    base_url="http://localhost:4200/v1",  # ← the only change
    api_key="sk-your-key",
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Explain LLM proxies in one sentence."}],
)
print(response.choices[0].message.content)
      

Works with any OpenAI-compatible client. The Anthropic, Google, and Groq SDKs all support custom base URLs.

Ready to try it?

Three commands. Thirty seconds. Everything between your app and the model.

Install Stockyard Try the Playground