Quick Start

1. Go to chat.pocketcode.in
2. Sign in with your Open WebUI admin account (first signup = admin)
3. Pick a model from the dropdown at the top center of the chat window
4. Type a message → press Enter

Pull a New Model

Models are pulled inside the Ollama container. You can do this from Open WebUI's admin panel OR via the web terminal:

docker exec ollama ollama pull llama3.2:3b
docker exec ollama ollama pull qwen2.5:7b
docker exec ollama ollama pull nomic-embed-text   # for RAG embeddings

Or in Open WebUI: Settings → Admin Panel → Models → Pull a model from Ollama.com. Type the model name (e.g. llama3.2:3b) and click pull.

Common Tasks

Upload a document for Q&A (RAG):

1. Click the 📎 paperclip icon in the chat input
2. Select a PDF, DOCX, MD, or TXT file
3. Ask questions about it — the model reads the document and answers

Build a permanent knowledge base:

1. Profile (top right) → Workspace → Knowledge → + Create Knowledge
2. Name it (e.g. "Company Docs") → upload multiple files
3. Open WebUI chunks the docs, embeds them with nomic-embed-text, stores in ChromaDB
4. In any chat, reference the collection with #Company Docs

Create a custom model with a pinned system prompt:

1. Workspace → Models → + Create a model
2. Choose base model (e.g. llama3.2), add a system prompt, save
3. Now appears in the chat model dropdown

Use as OpenAI-compatible API for other tools:

curl https://chat.pocketcode.in/api/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3.2:3b",
    "messages": [{"role":"user","content":"Hello"}]
  }'

API key is in Settings → Account → API Keys. Click "Create new secret key".

Useful Settings

This Setup's Quirks

Resources

• Official docs
• GitHub
• Ollama model library

Quick Start

1. Go to sim.pocketcode.in
2. Sign up (first time) or sign in
3. Click + New Workflow
4. Drag blocks from the left panel onto the canvas, connect them with lines
5. Click Run in the top right to test

Block Types

Connecting to Models

Inside any Agent block:

• Local Ollama: Provider = Ollama, base URL is auto-set to http://ollama:11434
• Cloud models via OpenRouter: Provider = OpenAI, base URL = http://openrouter-proxy:4000, API key = whatever you set in LiteLLM config (or leave blank if disabled)
• Direct Claude API: Provider = Anthropic, paste your Anthropic API key

Build Your First Workflow — Hello World

1. Drag Agent block onto canvas
2. Set model: llama3.2:3b
3. Set system prompt: "You are a helpful assistant."
4. Set user message: "What is 2+2?"
5. Click Run → see the output in the right panel

Add Tools to an Agent

Tools let agents take actions. Click an Agent block → Tools tab → add:

• HTTP request — agent can call any URL
• JavaScript — agent can execute code
• Knowledge base — agent can query a Qdrant collection
• Memory — agent can read/write to short-term memory

Common Tasks

Schedule a workflow to run daily:

1. Add a Schedule block → set cron (e.g. 0 9 * * * = daily 9am)
2. Connect it to your first Agent block
3. Click Deploy in top right
4. Workflow now runs automatically

Expose workflow as a webhook (for external apps):

1. Add a Webhook block as the trigger
2. Deploy → copy the webhook URL
3. Any service can POST JSON to it → triggers the workflow

This Setup's Quirks

Resources

• Sim.ai docs
• GitHub

Quick Start

1. Go to n8n.pocketcode.in
2. Sign in with your owner account (first signup = owner)
3. Click + Add workflow
4. Click + in the canvas → search for a trigger (e.g. "Manual")
5. Add more nodes → connect → click Execute Workflow

Node Categories

Build Your First Workflow — Slack to Ollama

1. Trigger: Slack Trigger (or Webhook for testing)
2. Add Ollama Chat Model node — base URL http://ollama:11434, model llama3.2:3b
3. Add AI Agent node — pass the Slack message as user input
4. Add Slack Send Message node — post the AI response back
5. Click Activate in top right

Common Tasks

Use Ollama directly in a workflow:

1. Add Ollama Chat Model node
2. Credentials → New → Base URL: http://ollama:11434
3. Pick model from dropdown

Use cloud models (Claude/GPT) via OpenRouter:

1. Add OpenAI Chat Model node (yes, even for Claude — OpenRouter is OpenAI-compatible)
2. Credentials → New → Base URL: http://openrouter-proxy:4000, API key: any value (or your LiteLLM master key)
3. Set model name to OpenRouter format (e.g. anthropic/claude-3.5-sonnet)

Query the shared Postgres:

1. Add Postgres node
2. Credentials: Host = sim-db-1, Port = 5432, DB = n8n, User/Pass from your .env
3. Pick operation (Select, Insert, Update)

Receive webhooks from external apps:

1. Use Webhook trigger node
2. n8n shows you the test + production URLs
3. For production (after Activate), URL is https://n8n.pocketcode.in/webhook/<your-path>

This Setup's Quirks

Resources

• n8n docs
• Workflow templates

Quick Start

1. Go to openclaw.pocketcode.in
2. If first-time access, you may see a "Pair device" prompt — see "Device Pairing" below
3. Type a message in the chat input → send

Device Pairing

OpenClaw uses a device pairing system. New browsers/devices need to be approved from the CLI:

docker exec -it openclaw node /app/openclaw.mjs devices list
docker exec -it openclaw node /app/openclaw.mjs devices approve <UUID>

Common Tasks

Switch the active model:

1. Settings (gear icon) → Models
2. Choose from local Ollama or configured cloud providers

Configure cloud model providers:

1. Settings → API Keys → add Anthropic / OpenAI / OpenRouter keys
2. Models become available in the chat selector

Start a new agent session:

1. Click + New Session (sidebar)
2. Pick a model + system prompt template (or custom)
3. Sessions persist in the OpenClaw database

This Setup's Quirks

Resources

• OpenClaw docs (if available)

Quick Start

Claude Code is a CLI tool, not a web service. Access via the web terminal or SSH:

docker exec -it claude-code bash
claude

First run prompts for an Anthropic API key. Paste yours from console.anthropic.com → API Keys.

Basic Usage

• claude — start interactive session in current directory
• claude "fix the bug in main.py" — give a task directly
• claude --continue — resume the last conversation
• /help inside the session — see all commands
• /clear — clear the conversation
• /cost — see token usage and cost

Working with the Stack

The claude-code container mounts ~/ai-stack at /workspace. So you can:

docker exec -it claude-code bash
cd /workspace/sim          # Sim.ai config
claude "review the docker-compose.prod.yml and suggest improvements"

Common Tasks

Code review a file:

claude "review /workspace/manage/start-all.sh and find any race conditions"

Generate a new service config:

claude "create a docker-compose.yml for a Redis instance on the ai-stack network with persistence"

Debug a failing container:

docker logs sim-simstudio-1 --tail 100 > /tmp/logs.txt
claude "read /tmp/logs.txt and tell me why this container is restarting"

This Setup's Quirks

Resources

• Claude Code docs
• npm package

What This Is

A LiteLLM proxy that exposes an OpenAI-compatible API on port 4000. You configure cloud providers (OpenAI, Anthropic, OpenRouter.ai, etc.) once, and any tool that speaks OpenAI's API can use them.

From Inside the Stack

Containers on the ai-stack network reach the proxy at:

http://openrouter-proxy:4000

From Outside (via HTTPS)

https://openrouter.pocketcode.in

Configured Models

Check ~/ai-stack/openrouter-proxy/litellm-config.yaml on the server. Typical entries:

model_list:
  - model_name: claude-sonnet-4
    litellm_params:
      model: anthropic/claude-sonnet-4-20250514
      api_key: os.environ/ANTHROPIC_API_KEY
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: os.environ/OPENAI_API_KEY
  - model_name: llama-3.3-70b
    litellm_params:
      model: openrouter/meta-llama/llama-3.3-70b-instruct
      api_key: os.environ/OPENROUTER_API_KEY

Common Tasks

Test from terminal:

curl https://openrouter.pocketcode.in/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4",
    "messages": [{"role":"user","content":"Hello"}]
  }'

Add a new model:

1. Edit ~/ai-stack/openrouter-proxy/litellm-config.yaml → add a new entry
2. Restart the container: docker restart openrouter-proxy
3. The new model_name is now usable everywhere

Use from Python:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.pocketcode.in/v1",
    api_key="any-string"  # disabled in default config
)

response = client.chat.completions.create(
    model="claude-sonnet-4",
    messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)

This Setup's Quirks

Resources

• LiteLLM docs
• OpenRouter.ai model list

What This Is

The raw Ollama API. Most users interact with Ollama via Open WebUI (recommended for chat) or via the SDK in code. This page covers direct API usage.

Endpoints

Common Calls

List installed models:

curl https://ollama.pocketcode.in/api/tags

Chat completion:

curl https://ollama.pocketcode.in/api/chat -d '{
  "model": "llama3.2:3b",
  "messages": [{"role":"user","content":"Hello"}],
  "stream": false
}'

Generate embeddings (for RAG):

curl https://ollama.pocketcode.in/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "The text to embed"
}'

Pull a new model (from terminal, not API recommended):

docker exec ollama ollama pull llama3.2:3b
docker exec ollama ollama pull qwen2.5:7b
docker exec ollama ollama pull nomic-embed-text

Model Recommendations (CPU mode)

This Setup's Quirks

Resources

• Ollama API reference
• Model library

What This Is

A vector database for semantic search and RAG. Store embeddings of text/images, query by similarity. Used by Sim.ai's knowledge tool and any custom workflow that needs vector search.

Web UI

qdrant.pocketcode.in/dashboard opens the Qdrant Web UI for browsing collections, inspecting points, running test queries.

Endpoints

Quick Workflow — Create + Query Collection

Step 1 — Create a collection (vectors of size 768, matching nomic-embed-text):

curl -X PUT https://qdrant.pocketcode.in/collections/my-docs \
  -H "Content-Type: application/json" \
  -d '{"vectors":{"size":768,"distance":"Cosine"}}'

Step 2 — Get an embedding from Ollama and insert:

# Get embedding
EMB=$(curl -s https://ollama.pocketcode.in/api/embeddings \
  -d '{"model":"nomic-embed-text","prompt":"The quick brown fox"}' \
  | jq -c .embedding)

# Insert into Qdrant
curl -X PUT https://qdrant.pocketcode.in/collections/my-docs/points \
  -H "Content-Type: application/json" \
  -d "{\"points\":[{\"id\":1,\"vector\":$EMB,\"payload\":{\"text\":\"The quick brown fox\"}}]}"

Step 3 — Search:

QUERY_EMB=$(curl -s https://ollama.pocketcode.in/api/embeddings \
  -d '{"model":"nomic-embed-text","prompt":"fast animal"}' \
  | jq -c .embedding)

curl -X POST https://qdrant.pocketcode.in/collections/my-docs/points/search \
  -H "Content-Type: application/json" \
  -d "{\"vector\":$QUERY_EMB,\"limit\":5,\"with_payload\":true}"

Common Tasks

List collections:

curl https://qdrant.pocketcode.in/collections

Delete a collection:

curl -X DELETE https://qdrant.pocketcode.in/collections/my-docs

This Setup's Quirks

Resources

• Qdrant docs
• API reference

Quick Start

1. Go to pgadmin.pocketcode.in
2. Sign in with email/password from PGADMIN_DEFAULT_EMAIL / PGADMIN_DEFAULT_PASSWORD env vars
3. Add a new server connection (first-time only)

Connect to the Shared Postgres

In pgAdmin: right-click Servers → Register → Server. Then:

What Databases Are There?

Common Tasks

Run a query:

1. Navigate to a database in the tree
2. Right-click → Query Tool
3. Type SQL → F5 to execute

Export a table to CSV:

1. Right-click a table → Import/Export Data
2. Choose Export, set CSV format, browse for output location

Backup the whole stack DB:

docker exec sim-db-1 pg_dumpall -U postgres > ~/ai-stack/backups/all-$(date +%Y%m%d).sql

pgvector queries (Sim.ai uses this):

-- Find vectors closest to a target
SELECT id, content, embedding <-> '[0.1, 0.2, ...]'::vector AS distance
FROM documents
ORDER BY distance
LIMIT 5;

This Setup's Quirks

Resources

• pgAdmin docs
• pgvector reference

What This Is

A full bash terminal running in your browser. The container has the host Docker socket mounted, so you can manage every container in your stack without SSH. Perfect for quick admin from your phone, tablet, or any browser.

Quick Start

1. Go to terminal.pocketcode.in
2. If not logged in → bounces you to pocketcode.in to log in
3. Terminal loads — you see root@<container-id>:~# prompt
4. Type any command and press Enter

Keyboard Shortcuts

What You Can Do

Manage every container:

docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}"
docker logs sim-simstudio-1 --tail 50
docker restart n8n
docker exec -it ollama bash

Edit any config file:

nano ~/ai-stack/caddy/Caddyfile
nano ~/ai-stack/sim/.env
docker exec caddy caddy reload --config /etc/caddy/Caddyfile

Use stack aliases (after sourcing .bashrc):

source ~/.bashrc

ai-start          # bring up all containers
ai-stop           # graceful shutdown
ai-doctor         # full diagnostic
ai-status         # quick container health snapshot
ai-logs n8n       # tail any service's logs
ai-reboot         # restart whole stack

Pull new Ollama models:

docker exec ollama ollama pull qwen2.5:7b
docker exec ollama ollama list

Run Claude Code from here:

docker exec -it claude-code bash
claude "review the start-all.sh script for race conditions"

Query the shared Postgres:

docker exec -it sim-db-1 psql -U postgres -d simstudio
\dt    -- list tables
\q     -- quit

This Setup's Quirks

Resources

• ttyd on GitHub — the web terminal we're using
• Docker CLI reference

Architecture

One PostgreSQL container — sim-db-1 running pgvector/pgvector:pg17 — hosts every database in the stack. Sim.ai brings it up (it's in the Sim.ai compose file), but pgAdmin, n8n, OpenClaw, and any custom workflow share the same instance. The container sits on two Docker networks simultaneously: sim_default (Sim.ai's own) and ai-stack (the rest of the stack), so anyone can reach it.

The Five Databases

Connection Strings

pgvector Extension

Already installed in every database. Use it for semantic search inside Postgres without needing Qdrant for small datasets:

-- nomic-embed-text returns 768-dim vectors
CREATE TABLE documents (
  id BIGSERIAL PRIMARY KEY,
  content TEXT,
  embedding vector(768),
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Index for fast similarity search
CREATE INDEX ON documents USING hnsw (embedding vector_cosine_ops);

-- Find nearest neighbors
SELECT id, content, embedding <=> '[0.1, 0.2, ...]'::vector AS distance
FROM documents
ORDER BY distance
LIMIT 5;

Common Tasks

Get a psql shell:

docker exec -it sim-db-1 psql -U postgres -d ailab

List all databases:

docker exec sim-db-1 psql -U postgres -l

Backup a single database:

docker exec sim-db-1 pg_dump -U postgres -Fc -d n8n > ~/backups/n8n-$(date +%Y%m%d).pgcustom

Backup everything (pg_dumpall):

docker exec sim-db-1 pg_dumpall -U postgres > ~/backups/all-$(date +%Y%m%d).sql

Restore from backup:

cat ~/backups/all-20260516.sql | docker exec -i sim-db-1 psql -U postgres

Create a new database for your project:

-- via pgAdmin Query Tool or psql shell
CREATE DATABASE my_project;
\c my_project
CREATE EXTENSION vector;

Connection Pool Limits

Default Postgres config allows ~100 concurrent connections. Sim.ai + n8n + OpenClaw typically use ~30. If you start running into "too many connections" errors, increase the limit:

docker exec sim-db-1 psql -U postgres -c "ALTER SYSTEM SET max_connections=200;"
docker restart sim-db-1

This Setup's Quirks

Resources

• PostgreSQL 17 docs
• pgvector reference
• pgAdmin docs

The Network Architecture

Every container in the stack is on the ai-stack Docker network. Docker provides automatic DNS resolution between containers using their container names. Sim.ai's compose stack has its own internal network sim_default, and sim-db-1 straddles both so services on either network can reach it.

Internal Hostnames

Inside any container on ai-stack, these hostnames resolve automatically:

Why Use Internal Hostnames?

• Faster — stays inside Docker, no DNS over the internet, no TLS handshake
• More reliable — no dependence on external DNS or Caddy being up
• No auth wall — gateway auth is at Caddy; internal calls skip it (intentional: they're already trusted within Docker)
• Container IPs change on restart, but the hostname always resolves to the current IP

Common Patterns

n8n calling Ollama: In n8n's Ollama Chat Model credentials, set Base URL to:

http://ollama:11434

n8n calling OpenRouter (cloud models) via the proxy:

Base URL: http://openrouter-proxy:4000
API Key:  any-non-empty-string

Sim.ai calling Ollama: already wired via Sim.ai's OLLAMA_URL=http://ollama:11434 env var.

Custom script calling everything from a terminal:

curl http://ollama:11434/api/tags
curl http://qdrant:6333/collections
curl http://openrouter-proxy:4000/v1/models

Connecting from a brand-new container you create: Add it to the ai-stack network:

docker run -d --name my-app \
  --network ai-stack \
  -e DB_URL=postgres://postgres:PASS@sim-db-1:5432/ailab \
  -e LLM_URL=http://ollama:11434 \
  my-image:latest

Adding a Service to ai-stack

1. Run with --network ai-stack flag (or networks: [ai-stack] in compose)
2. Once started, it can reach every other container by name
3. If it needs to be public via HTTPS, add a Caddyfile block per Tab 13

Auto-SSO Across Services

The gateway at pocketcode.in ships with optional auto-SSO: when you sign in at the apex, hidden iframes silently log you into Sim.ai, Open WebUI, and n8n using credentials stored in ~/ai-stack/auth-gateway/.env. Three things are happening:

Which services auto-SSO works for

The /_sso_init endpoint

Each SSO-enabled subdomain has this Caddyfile block:

sim.pocketcode.in {
    import auth_gate
    handle /_sso_init {
        reverse_proxy auth-gateway:7000 {
            rewrite /sso-init/sim
        }
    }
    reverse_proxy sim-simstudio-1:3000
}

Browser loads /_sso_init in a hidden iframe → Caddy proxies to gateway → gateway logs into Sim.ai server-side → response carries Set-Cookie for the user → iframe posts a status message back to home.html.

What logging out does

• Logout at pocketcode.in: only the gateway cookie is cleared. Service-internal cookies remain valid. But Caddy now sees no gateway cookie → every *.pocketcode.in request gets 302'd to the login page. After re-login, every service is instantly accessible (their sessions never died).
• Logout inside a service (e.g., clicking Sim.ai's own "Logout" button): that service's session cookie is cleared. The next watchdog tick at pocketcode.in (≤ 2 min) re-runs /_sso_init for that service and restores the session.
• Closing the pocketcode tab: Watchdog stops. Sessions naturally expire after their normal TTL. Re-opening pocketcode restarts the watchdog.

Troubleshooting

"Host not found" / "getaddrinfo ENOTFOUND":

• Verify the container is on ai-stack: docker inspect <name> --format='{{json .NetworkSettings.Networks}}'
• If missing, attach it: docker network connect ai-stack <name>
• For sim-db-1 specifically, ai-start auto-reconnects it after Sim.ai recompose

"Connection refused" but container is up:

• The service may not be listening on 0.0.0.0 internally. Inspect: docker exec <name> netstat -tlnp
• Or it's still booting. docker logs <name> --tail 20

n8n shows "Failed to load model catalog" briefly at start:

• Transient Docker DNS race after a recompose. ai-doctor filters it. Self-heals within ~10 seconds.

Resources

• Docker networking
• See Tab 9 (Inter-Service Comms) in the setup guide for initial wiring

What's Mounted Where

Two file paths are mounted inside every relevant service container, so data can flow between them without HTTP roundtrips:

When to Use Which

How to Use From Each Service

From the web terminal:

ls /shared          # Inside the terminal container
ls /uploads
ls ~/ai-stack/uploads   # Same as /uploads — terminal's /root is mounted

From n8n (Read/Write Files node): point at /shared/output.csv or /uploads/input.csv directly. n8n already has both mounts.

From Sim.ai workflows: use the Function block with Node.js fs:

const fs = require('fs');
const content = fs.readFileSync('/uploads/data.json', 'utf-8');
const data = JSON.parse(content);
return { items: data };

From Open WebUI: upload files through the UI (paperclip icon) — they're stored in the open-webui-data volume separately. To make a host file available, copy it to /uploads first, then upload via the UI.

From OpenClaw and custom scripts: Same — read/write to /shared or /uploads within their containers.

Common Workflows

Drop a file from your Mac, process it in n8n:

scp ~/Documents/data.csv root@YOUR_SERVER_IP:~/ai-stack/uploads/data.csv

In n8n: Read Binary File node → /uploads/data.csv → process. n8n sees the file immediately, no restart needed.

n8n writes a result, Sim.ai picks it up:

• n8n workflow ends with a Write Binary File node → /shared/n8n-output.json
• Sim.ai workflow has a Function block reading /shared/n8n-output.json
• Two services collaborating without HTTP or queues

Build a dataset for Qdrant:

1. scp folder of PDFs to ~/ai-stack/uploads/pdfs/
2. From terminal: docker exec -it <some-python-container> python ingest.py /uploads/pdfs
3. Script chunks files, embeds via Ollama at http://ollama:11434, posts to Qdrant at http://qdrant:6333

Inspecting Each From the Host

The bind-mount (/uploads) is trivially visible on the host:

ls -la ~/ai-stack/uploads/
du -sh ~/ai-stack/uploads/

The Docker volume (/shared) lives under Docker's internal storage:

docker volume inspect ai-shared-data
# shows: Mountpoint /var/lib/docker/volumes/ai-shared-data/_data
ls -la /var/lib/docker/volumes/ai-shared-data/_data/

Backup & Restore

Backup /uploads (host bind-mount — just tar it):

tar czf ~/backups/uploads-$(date +%Y%m%d).tar.gz -C ~/ai-stack uploads/

Backup /shared (Docker volume — needs a helper container):

docker run --rm \
  -v ai-shared-data:/data \
  -v ~/backups:/backup \
  alpine tar czf /backup/shared-$(date +%Y%m%d).tar.gz -C /data .

Restore the volume:

docker run --rm \
  -v ai-shared-data:/data \
  -v ~/backups:/backup \
  alpine sh -c "cd /data && tar xzf /backup/shared-20260516.tar.gz"

Permissions Note

This Setup's Quirks

Resources

• Docker volumes docs
• Bind mounts docs
• See Tab 10 (Shared Storage) in the setup guide for initial setup

Recipe 1: Slack-to-Ollama Chatbot (via n8n)

Listen for Slack messages, route through Ollama, respond.

1. In n8n: Slack Trigger → AI Agent (Ollama, model llama3.2:3b) → Slack Send Message
2. Use the message text as user input to the agent
3. Pass the agent output back to Slack channel

Recipe 2: Document Q&A System (Open WebUI + Ollama)

1. Pull embedding model: docker exec ollama ollama pull nomic-embed-text
2. In Open WebUI: Settings → Documents → Embedding Model = nomic-embed-text
3. Workspace → Knowledge → New Collection → upload PDFs
4. In chat, reference with #collection-name

Recipe 3: Scheduled Web Scraping (n8n + OpenRouter)

1. n8n: Schedule trigger (daily 9am) → HTTP Request (fetch URL) → AI Agent (summarize via OpenRouter Claude) → Send Email/Slack
2. Claude does the summarization since it's better at structured output
3. Costs ~$0.01-0.05 per run depending on page size

Recipe 4: Custom RAG Pipeline (Ollama + Qdrant + Sim.ai)

1. Create a Qdrant collection (size 768 for nomic-embed-text)
2. In Sim.ai: build a workflow that takes a query, embeds via Ollama, searches Qdrant, passes top-K results + query to an Agent block
3. Agent uses retrieved context + query to produce grounded answer

Recipe 5: Multi-Model Comparison (LiteLLM)

Compare outputs from local Ollama vs cloud Claude vs GPT side-by-side.

PROMPT="Explain quantum computing in 2 sentences"

# Local Ollama
curl -s http://localhost:11434/api/generate \
  -d "{\"model\":\"llama3.2:3b\",\"prompt\":\"$PROMPT\",\"stream\":false}" \
  | jq -r .response

# Cloud Claude via OpenRouter proxy
curl -s http://localhost:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"claude-sonnet-4\",\"messages\":[{\"role\":\"user\",\"content\":\"$PROMPT\"}]}" \
  | jq -r '.choices[0].message.content'

Recipe 6: Voice Pipeline (Open WebUI + Whisper)

Open WebUI supports voice input via Whisper. To enable:

1. Settings → Audio → STT Engine: select "Local Whisper"
2. Pick a Whisper model size (base / small / medium)
3. Click 🎤 icon in chat input → speak → transcribed and sent

Recipe 7: Backup & Restore the Stack

Backup (run daily as a cron job or n8n workflow):

#!/bin/bash
DATE=$(date +%Y%m%d-%H%M)
mkdir -p ~/backups/$DATE

# Postgres dump
docker exec sim-db-1 pg_dumpall -U postgres > ~/backups/$DATE/postgres.sql

# Critical volumes (n8n encryption key, Open WebUI chats, etc.)
docker run --rm -v n8n-data:/data -v ~/backups/$DATE:/backup \
  alpine tar czf /backup/n8n-data.tar.gz -C /data .

docker run --rm -v open-webui-data:/data -v ~/backups/$DATE:/backup \
  alpine tar czf /backup/open-webui-data.tar.gz -C /data .

# Caddy data (certs)
docker run --rm -v caddy_data:/data -v ~/backups/$DATE:/backup \
  alpine tar czf /backup/caddy_data.tar.gz -C /data .

# Compress everything
tar czf ~/backups/$DATE.tar.gz -C ~/backups $DATE
rm -rf ~/backups/$DATE

Recipe 8: Manage Stack from the Web Terminal

Everything in this guide can be done from terminal.pocketcode.in in your browser:

ai-start          # bring up all containers
ai-stop           # shut down cleanly
ai-doctor         # diagnostic scan
ai-logs SERVICE   # tail any service's logs
ai-status         # quick health check