from headroom.transforms import SmartCrusherConfig

config = SmartCrusherConfig(
    max_items_after_crush=15,        # 壓縮後最多保留 15 項
    min_tokens_to_crush=200,         # 低於 200 Token 不壓縮
    relevance_tier="bm25",           # 相關度評分方式：bm25（快）或 embedding（準）
    preserve_fields=["error", "warning", "failure"],  # 含有這些欄位值的項目永遠保留
)

原始碼 → tree-sitter 解析 → AST → 結構保留 + 主體壓縮 → 壓縮後程式碼

# 壓縮前（完整原始碼）
def process_data(items: List[str]) -> Dict[str, int]:
    """Process items and count occurrences."""
    result = {}
    for item in items:
        item = item.strip().lower()
        if item in result:
            result[item] += 1
        else:
            result[item] = 1
    return result

# 壓縮後（簽名與目的保留，主體精簡）
def process_data(items: List[str]) -> Dict[str, int]:
    """Process items and count occurrences."""
    result = {}
    for item in items:
    # ... (5 lines compressed)
    pass

pip install "headroom-ai[code]"

pip install "headroom-ai[ml]"  # 需要 PyTorch

壓縮前：
"You are helpful. Current Date: 2026-06-12"
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         每日變動 → Cache 每日失效

壓縮後：
"You are helpful."                          ← 穩定前綴，Cache 命中
"[Context: Current Date: 2026-06-12]"       ← 動態部分移至尾端

from headroom.transforms import CacheAlignerConfig

config = CacheAlignerConfig(
    enabled=True,
    dynamic_patterns=[
        r"Today is \w+ \d+, \d{4}",
        r"Current time: .*",
        r"Session ID: [a-f0-9-]+",
    ],
)

{
  "name": "headroom_retrieve",
  "parameters": {
    "hash": "abc123",
    "query": "authentication errors"
  }
}

100 則對話（50K Token）
→ IntelligentContext 對訊息進行重要性評分
→ 丟棄 60 則低分訊息
→ 已丟棄訊息以 hash=def456 快取
→ 插入標記："60 messages dropped, retrieve: def456"

# 乾跑模式（預設）——預覽將寫入的內容
headroom learn

# 實際寫入
headroom learn --apply

# 分析所有專案
headroom learn --apply --all

# 指定最低證據次數
headroom learn --apply --min-evidence 5

Read 輸出 → 事件追蹤 → 過期/取代偵測 → CCR 標記取代 → 原始資料存入 CCR

from headroom import ReadLifecycleConfig

config = ReadLifecycleConfig(
    enabled=True,  # 預設為 False，需明確啟用
)

pip install headroom-ai

# 安裝所有功能
pip install "headroom-ai[all]"

# 或依需求選擇
pip install "headroom-ai[proxy]"       # Proxy 伺服器 + MCP 工具 + HTTP API
pip install "headroom-ai[proxy-prod]"  # 正式環境（含 gunicorn，僅 Linux/macOS）
pip install "headroom-ai[mcp]"         # MCP Server 工具
pip install "headroom-ai[ml]"          # Kompress-base（需 PyTorch）
pip install "headroom-ai[code]"        # CodeCompressor（tree-sitter AST）
pip install "headroom-ai[memory]"      # Persistent Memory
pip install "headroom-ai[relevance]"   # Embedding 相關度評分
pip install "headroom-ai[image]"       # 圖片壓縮
pip install "headroom-ai[langchain]"   # LangChain 整合
pip install "headroom-ai[agno]"        # Agno 整合
pip install "headroom-ai[evals]"       # 評估框架
pip install "headroom-ai[pytorch-mps]" # Apple GPU (MPS) Embedding 加速
pip install "headroom-ai[anyllm]"      # any-llm 後端（38+ LLM Provider 路由）

# 組合安裝
pip install "headroom-ai[proxy,langchain,ml]"

uv pip install "headroom-ai[all]"

pipx install --python python3.13 "headroom-ai[all]"

# npm
npm install headroom-ai

# pnpm
pnpm add headroom-ai

# bun
bun add headroom-ai

# 先啟動 Proxy
pip install "headroom-ai[proxy]"
headroom proxy --port 8787

# TypeScript 程式碼中指向 Proxy
import { compress } from 'headroom-ai';
const result = await compress(messages, {
  baseUrl: 'http://localhost:8787',
});

# 拉取映像
docker pull ghcr.io/chopratejas/headroom:latest

# 啟動
docker run -p 8787:8787 ghcr.io/chopratejas/headroom:latest

# 搭配持久化儲存與環境變數
docker run -p 8787:8787 \
  -v ~/.headroom:/root/.headroom \
  -e ANTHROPIC_API_KEY \
  -e HEADROOM_CCR_BACKEND=sqlite \
  ghcr.io/chopratejas/headroom:latest

HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:8787/readyz || exit 1

# 列出所有建置目標
docker buildx bake --list targets

# 建置預設映像
docker buildx bake runtime-default

# 建置特定變體
docker buildx bake runtime-code-slim-nonroot \
  --set '*.tags=my-registry/headroom:code-slim-nonroot'

# 拉取映像
podman pull ghcr.io/chopratejas/headroom:latest

# 啟動
podman run -p 8787:8787 ghcr.io/chopratejas/headroom:latest

# 使用 podman-compose（參見附錄 D）
podman-compose up -d

# macOS / Linux
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh && rustup default stable

# Windows
winget install Rustlang.Rustup && rustup default stable

export REQUESTS_CA_BUNDLE=/path/to/corporate-ca-bundle.crt
export SSL_CERT_FILE=/path/to/corporate-ca-bundle.crt
export CURL_CA_BUNDLE=/path/to/corporate-ca-bundle.crt

pip install "headroom-ai[all]"

python -c "import headroom; print(headroom.__version__)"
# 預期輸出: 0.25.0

node -e "const h = require('headroom-ai'); console.log('headroom-ai loaded')"

# 啟動 Proxy
headroom proxy --port 8787

# 另一個終端機測試
curl http://localhost:8787/health
# 預期回應:
# {"status": "healthy", "optimize": true, "stats": {"total_requests": 0, ...}}

# 預設文字格式
headroom perf

# JSON 格式（適合 CI/CD 整合）
headroom perf --format json

# CSV 格式（適合匯入試算表）
headroom perf --format csv

from headroom import compress

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Analyze these search results"},
    {"role": "tool", "content": '{"results": [...1000 items...]}', "tool_call_id": "call_1"},
]

result = compress(messages, model="gpt-4o")

print(f"壓縮前: {result.tokens_before} tokens")
print(f"壓縮後: {result.tokens_after} tokens")
print(f"節省: {result.tokens_saved} tokens ({result.compression_ratio:.0%})")
print(f"套用的轉換: {result.transforms_applied}")

import { compress } from 'headroom-ai';

const messages = [
  { role: 'system' as const, content: 'You are a helpful assistant.' },
  { role: 'user' as const, content: 'Analyze these results' },
];

const result = await compress(messages, { model: 'gpt-4o' });

console.log(`Saved ${result.tokensSaved} tokens (${(result.compressionRatio * 100).toFixed(0)}%)`);

// 將 OpenAI 客戶端的 Base URL 指向 Headroom Proxy
OpenAIClient client = OpenAIClient.builder()
    .baseUrl("http://localhost:8787/v1")
    .apiKey(System.getenv("OPENAI_API_KEY"))
    .build();

// 正常呼叫，Headroom 自動壓縮
ChatCompletion response = client.chatCompletion()
    .model("gpt-4o")
    .messages(messages)
    .execute();

from openai import OpenAI
from headroom import with_memory

# 一行啟用跨 Session 記憶
client = with_memory(OpenAI(), user_id="alice")

# 正常使用，記憶自動提取與注入
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "I prefer Python for backend work"}]
)

# 下次新對話中，LLM 會自動記住 Python 偏好

# 基本啟動
headroom proxy

# 自訂主機與埠
headroom proxy --host 0.0.0.0 --port 8080

# 帶日誌與預算限制
headroom proxy \
  --log-file /var/log/headroom.jsonl \
  --budget 100.0

# AWS Bedrock
headroom proxy --backend bedrock --region us-east-1

# Google Vertex AI（v0.25.0 新增）
headroom proxy --backend vertex_ai --region us-central1

# Azure OpenAI
headroom proxy --backend azure

# OpenRouter (400+ 模型)
OPENROUTER_API_KEY=sk-or-... headroom proxy --backend openrouter

# any-llm（38+ Provider 路由）
pip install "headroom-ai[anyllm]"
headroom proxy --backend anyllm --anyllm-provider <provider>

# Foundry Gateway（Claude Code 企業環境）
CLAUDE_CODE_USE_FOUNDRY=1 headroom proxy

pip install "headroom-ai[proxy-prod]"

gunicorn headroom.proxy.server:app \
  --workers 4 \
  --bind 0.0.0.0:8787 \
  --worker-class uvicorn.workers.UvicornWorker

FROM python:3.13-slim
RUN apt-get update && apt-get install -y --no-install-recommends build-essential \
    && pip install "headroom-ai[proxy]" \
    && apt-get purge -y build-essential && apt-get autoremove -y \
    && rm -rf /var/lib/apt/lists/*
EXPOSE 8787
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:8787/readyz || exit 1
CMD ["headroom", "proxy", "--host", "0.0.0.0"]

# Claude Code
headroom wrap claude

# OpenAI Codex
headroom wrap codex

# Cursor
headroom wrap cursor

# Aider
headroom wrap aider

# GitHub Copilot CLI
headroom wrap copilot

# Gemini CLI
headroom wrap gemini

# Cline（v0.22.4+）
headroom wrap cline

# Continue（v0.22.4+）
headroom wrap continue

# Goose（v0.22.4+）
headroom wrap goose

# OpenHands（v0.22.4+）
headroom wrap openhands

# 啟用跨 Agent 記憶共享
headroom wrap claude --memory

# 啟用程式碼圖譜分析
headroom wrap claude --code-graph

# 同時啟用
headroom wrap claude --memory --code-graph

# 還原 Codex 配置
headroom unwrap codex

# 還原 Claude 配置
headroom unwrap claude

# Claude Code
ANTHROPIC_BASE_URL=http://localhost:8787 claude

# Cursor / 任何 OpenAI 相容客戶端
OPENAI_BASE_URL=http://localhost:8787/v1 cursor

headroom wrap copilot --subscription -- --model gpt-4o

# 安裝 MCP 工具
pip install "headroom-ai[mcp]"

# 註冊至 Claude Code（一次性）
headroom mcp install

# 啟動 Claude Code——現在有 Headroom 工具可用
claude

# 安裝（本機 stdio，預設）
headroom mcp install

# 安裝（遠端 HTTP，Docker/網路場景）
headroom mcp install --remote http://proxy-host:8787/mcp

# 覆寫現有設定
headroom mcp install --force

# 啟動 MCP Server（stdio，Claude Code 自動呼叫）
headroom mcp serve

# 啟動 MCP Server（HTTP，供遠端 Agent）
headroom mcp serve --transport http --port 8080

# 檢查狀態
headroom mcp status

# 解除安裝
headroom mcp uninstall

# Terminal 1：啟動 Proxy（自動壓縮所有流量）
headroom proxy

# Terminal 2：啟動 Claude Code（MCP 工具 + 流量壓縮）
ANTHROPIC_BASE_URL=http://127.0.0.1:8787 claude

# 使用 Headroom 包裝 Claude Code，啟用記憶與程式碼圖譜
headroom wrap claude --memory --code-graph

# RTK 自動精簡 Shell 指令輸出
# Headroom 壓縮大量原始碼分析結果
# Memory 跨 Session 保留架構理解

# 設定特定工具的壓縮策略
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    headroom_tool_profiles={
        "database_query": {"max_items_after_crush": 25},     # DB 查詢保留更多項
        "search_code": {"max_items_after_crush": 10},        # 程式碼搜尋保留較少
        "important_tool": {"skip_compression": True},        # 重要工具跳過壓縮
    },
)

# 方法一：Agent Wrap（推薦）
headroom wrap claude --memory --code-graph

# 方法二：手動設定
# Terminal 1
headroom proxy --port 8787

# Terminal 2
headroom mcp install
ANTHROPIC_BASE_URL=http://127.0.0.1:8787 claude

# CLAUDE.md

## Headroom 整合
- 大量搜尋結果請先使用 headroom_compress 壓縮後再分析
- 需要完整資料時使用 headroom_retrieve 取回
- 定期使用 headroom_stats 檢查 Token 節省狀況
- 優先使用 code-graph 查詢模組依賴，避免全專案掃描

# 使用 Proxy 模式
headroom proxy --port 8787

# Copilot CLI 訂閱模式
headroom wrap copilot --subscription -- --model gpt-4o

<!-- .github/copilot-instructions.md -->
## Token 最佳化
- 使用 Headroom Proxy 壓縮所有 LLM 流量
- 避免一次讀取超過 10 個檔案
- 優先使用 Symbol Search 而非全文搜尋
- 利用 Headroom MCP 工具壓縮大量搜尋結果

# 一鍵包裝 Codex
headroom wrap codex

# Codex 與 Claude 共享記憶
# 在 Claude Code 中分析的架構知識，Codex 也能存取

# 一鍵包裝 Gemini CLI
headroom wrap gemini

# 或手動設定 Proxy
headroom proxy --backend vertex_ai --region us-central1

headroom wrap cline

headroom wrap continue

headroom wrap goose

headroom wrap openhands

# OpenAI 相容
OPENAI_BASE_URL=http://localhost:8787/v1 <your-agent>

# Anthropic 相容
ANTHROPIC_BASE_URL=http://localhost:8787 <your-agent>

# 啟用 LLMLingua ML 壓縮
headroom proxy --llmlingua --llmlingua-device cuda --llmlingua-rate 0.2

from headroom import OpenAIProvider, AnthropicProvider

# Anthropic：明確標記 cache_control
provider = AnthropicProvider(enable_prefix_caching=True)

# OpenAI：確保前綴穩定性
provider = OpenAIProvider(enable_prefix_caching=True)

原始輸入：100K Token
├── SmartCrusher 壓縮 80% → 20K Token
├── 其中 18K 命中 Anthropic Cache（90% 折扣）
│   └── 等效成本：18K × 0.1 = 1.8K
├── 剩餘 2K 全價
└── 等效總成本：1.8K + 2K = 3.8K Token

總節省率：96.2%

# AGENTS.md

## Token 最佳化規範
1. 所有 AI Agent 流量必須經過 Headroom Proxy
2. 搜尋結果超過 20 筆時，必須使用 headroom_compress 壓縮
3. 禁止一次讀取超過 10 個完整檔案
4. 優先使用 Symbol Search 而非 Full Text Search
5. 長時間任務必須啟用 --memory 以跨 Session 保留進度

## 壓縮例外
以下工具輸出不壓縮：
- 安全掃描結果（skip_compression: true）
- 使用者認證 Token
- 加密相關操作

## Headroom 配置
- Proxy URL: http://localhost:8787
- MCP: headroom mcp install
- Budget: $10/day

# CLAUDE.md

## Headroom 使用指引
- 大量搜尋結果 → headroom_compress → 分析壓縮結果
- 需要細節 → headroom_retrieve(hash, query="關鍵字")
- 定期 → headroom_stats 檢查節省狀況
- 架構分析 → 使用 code-graph 而非全專案掃描
- 升級任務 → 啟用 memory 保存進度

## 壓縮後檢查
若 AI 回答似乎遺漏資訊：
1. 使用 headroom_retrieve 取回完整資料
2. 調整 max_items_after_crush 增加保留項目
3. 將特定工具加入 skip_compression 清單

<!-- .github/copilot-instructions.md -->

## Headroom Token 最佳化
所有 Copilot Agent 流量透過 Headroom Proxy (http://localhost:8787) 壓縮。

### 開發規範
1. 每次查詢聚焦單一模組，避免跨模組大範圍搜尋
2. 利用 .copilot-codebase-index 縮小搜尋範圍
3. 大型 JSON 結果使用 Headroom MCP 工具壓縮
4. 修改前先讀取目標檔案片段，非整個檔案

新手 → headroom wrap claude（Day 1）
     → 觀察 /stats 節省數據（Day 2-3）
     → 學習 MCP 工具使用（Week 1）
     → 了解 CCR 可逆壓縮（Week 2）
     → 掌握 Proxy 部署與監控（Week 3）
     → 進階調校與維運（Week 4+）

# 啟動帶日誌的 Proxy
headroom proxy --log-file /var/log/headroom.jsonl --log-level debug

# 分析日誌
# JSONL 格式，每行一個 JSON 物件
# 包含：時間戳、請求 ID、壓縮前後 Token、套用的轉換、延遲

# 預設路徑
~/.headroom/proxy_savings.json

# 自訂路徑
export HEADROOM_SAVINGS_PATH=/data/headroom/savings.json

# 取得歷史統計（時/日/週/月彙整）
curl http://localhost:8787/stats-history

# CSV 格式匯出
curl "http://localhost:8787/stats-history?format=csv&series=weekly"

# 查看 CCR 快取統計（含有效 TTL）
curl http://localhost:8787/v1/retrieve/stats

# Python 升級
pip install --upgrade headroom-ai

# Docker 升級
docker pull ghcr.io/chopratejas/headroom:latest
docker-compose up -d  # 或 podman-compose up -d

# 檢查版本
python -c "import headroom; print(headroom.__version__)"

# 鎖定特定版本
pip install headroom-ai==0.25.0

# Docker 鎖定版本
docker pull ghcr.io/chopratejas/headroom:0.25.0

# 備份腳本範例
#!/bin/bash
BACKUP_DIR="/backup/headroom/$(date +%Y%m%d)"
mkdir -p $BACKUP_DIR
cp ~/.headroom/proxy_savings.json $BACKUP_DIR/
cp memory.db $BACKUP_DIR/ 2>/dev/null || true
cp ~/.headroom/models.json $BACKUP_DIR/ 2>/dev/null || true

# 啟用完整日誌
import logging
logging.getLogger("headroom").setLevel(logging.DEBUG)

# 模擬模式（不呼叫 LLM）
plan = client.chat.completions.simulate(
    model="gpt-4o",
    messages=messages,
)
print(f"Tokens: {plan.tokens_before} -> {plan.tokens_after}")
print(f"Transforms: {plan.transforms_applied}")
print(f"Waste signals: {plan.waste_signals}")

# 驗證配置
result = client.validate_setup()
if not result["valid"]:
    for issue in result["issues"]:
        print(f"  - {issue}")

{
  "mcpServers": {
    "headroom": {
      "command": "headroom",
      "args": ["mcp", "serve"]
    }
  }
}

{
  "mcpServers": {
    "headroom": {
      "url": "http://proxy-host:8787/mcp"
    }
  }
}

{
  "mcpServers": {
    "headroom": {
      "command": "headroom",
      "args": ["mcp", "serve"],
      "env": {
        "HEADROOM_LOG_LEVEL": "INFO"
      }
    }
  }
}

version: '3.8'

services:
  headroom-proxy:
    image: ghcr.io/chopratejas/headroom:latest
    container_name: headroom-proxy
    ports:
      - "8787:8787"
    environment:
      - HEADROOM_HOST=0.0.0.0
      - HEADROOM_PORT=8787
      - HEADROOM_MODE=optimize
      - HEADROOM_LOG_LEVEL=INFO
      - HEADROOM_TELEMETRY=on
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    volumes:
      - headroom-data:/root/.headroom
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8787/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 可選：Prometheus 監控
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    depends_on:
      - headroom-proxy

volumes:
  headroom-data:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'headroom'
    static_configs:
      - targets: ['headroom-proxy:8787']
    metrics_path: '/metrics'

version: '3.8'

services:
  headroom-proxy:
    image: ghcr.io/chopratejas/headroom:nonroot
    container_name: headroom-proxy
    ports:
      - "8787:8787"
    environment:
      - HEADROOM_HOST=0.0.0.0
      - HEADROOM_PORT=8787
      - HEADROOM_MODE=optimize
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
    volumes:
      - headroom-data:/home/nonroot/.headroom
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true

volumes:
  headroom-data:

# 啟動
podman-compose up -d

# 檢查狀態
podman-compose ps

# 查看日誌
podman-compose logs -f headroom-proxy

# 停止
podman-compose down

# === 完整設定流程 ===

# Step 1: 安裝 Headroom
pip install "headroom-ai[all]"

# Step 2: 安裝 MCP 工具
headroom mcp install

# Step 3: 啟動（方法一：Agent Wrap，推薦）
headroom wrap claude --memory --code-graph

# Step 3: 啟動（方法二：手動）
# Terminal 1
headroom proxy --port 8787 --budget 10.0
# Terminal 2
ANTHROPIC_BASE_URL=http://127.0.0.1:8787 claude

# Step 4: 在 Claude Code 中驗證
# /mcp  ← 應看到 headroom_compress, headroom_retrieve, headroom_stats

# === Copilot CLI 整合 ===

# Step 1: 安裝
pip install "headroom-ai[proxy]"

# Step 2: 啟動 Proxy
headroom proxy --port 8787

# Step 3: 使用 Agent Wrap
headroom wrap copilot --subscription -- --model gpt-4o

# === Copilot Agent Mode（VS Code）===
# 在 VS Code settings.json 中設定：
# "github.copilot.advanced": {
#   "baseUrl": "http://localhost:8787/v1"
# }

# === Codex CLI 整合 ===

# Step 1: 安裝
pip install "headroom-ai[all]"

# Step 2: 一鍵包裝
headroom wrap codex

# Codex 自動共享 Claude 的 Memory
# 在 Claude Code 中建立的架構理解，Codex 也能存取

# Step 3: 手動設定（替代方案）
# Terminal 1
headroom proxy --port 8787
# Terminal 2
OPENAI_BASE_URL=http://localhost:8787/v1 codex

# === Gemini CLI 整合 ===

# Step 1: 安裝
pip install "headroom-ai[proxy]"

# Step 2: 一鍵包裝
headroom wrap gemini

# Step 3: 使用 Vertex AI 後端
headroom proxy --backend vertex_ai --region us-central1
# 另一個終端
headroom wrap gemini

# === RTK + Headroom 完整整合 ===

# Headroom 已內建 RTK，直接使用即可
headroom wrap claude --memory --code-graph

# RTK 自動處理 Shell 指令輸出精簡
# Headroom 處理後續的 Prompt/Response 壓縮

# === 驗證整合效果 ===
# 在 Claude Code 中執行：
# > 搜尋專案中所有 TODO 標記
# 觀察 headroom_stats 輸出：
# - RTK 精簡了 Shell 輸出
# - SmartCrusher 壓縮了 JSON 結果
# - CacheAligner 穩定了 System Prompt 前綴

# === 自訂 Context Tool ===
# 使用 lean-ctx 替代 RTK（可選）
export HEADROOM_CONTEXT_TOOL=lean-ctx
headroom wrap claude

# 一鍵設定
headroom wrap cline

# 還原
headroom unwrap cline

# 一鍵設定
headroom wrap continue

# 還原
headroom unwrap continue

# 一鍵設定
headroom wrap goose

# 還原
headroom unwrap goose

# 一鍵設定（自動處理 systemMessage gate）
headroom wrap openhands

# 還原
headroom unwrap openhands

# Step 1: 啟動 Headroom Proxy
headroom proxy

# Step 2: 將 Agent 的 API URL 指向 Proxy
# OpenAI 相容 Agent
export OPENAI_BASE_URL=http://localhost:8787/v1

# Anthropic 相容 Agent
export ANTHROPIC_BASE_URL=http://localhost:8787

# Step 3: 正常啟動 Agent
<your-agent-command>