菜单
Developer skill for running Hummingbot and Gateway from source, building wheel and Docker images, and testing against Hummingbot API running from source. Use this skill when a developer wants to build, run, or test Hummingbot components locally.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hummingbot/skills --skill hummingbot-developer命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
Step-by-step guide for building autonomous trading agents through 5 phases: design, routine, strategy, dry-run, live.
Create or edit Python routines for market analysis, monitoring, and data visualization. Use when the user asks to create, modify, or fix a routine in the routines/ folder.
Find Cross-Exchange Market Making (XEMM) opportunities by comparing order book depth and liquidity across exchanges. Identifies pairs where one exchange has thin liquidity (ideal for quoting) and another has deep liquidity (ideal for hedging).
基于 SOC 职业分类
正在显示 SKILL.md
| name | hummingbot-developer |
| description | Developer skill for running Hummingbot and Gateway from source, building wheel and Docker images, and testing against Hummingbot API running from source. Use this skill when a developer wants to build, run, or test Hummingbot components locally. |
| metadata | {"author":"hummingbot"} |
| commands | {"start":{"description":"Check dev environment — repo branches, prereqs, running services"},"install-deps":{"description":"Auto-install missing dev dependencies (conda, node, pnpm, docker, git)"},"select-branches":{"description":"Interactively pick branches for hummingbot, gateway, and hummingbot-api"},"install-all":{"description":"Install all three repos in order (hummingbot → gateway → hummingbot-api)"},"build-all":{"description":"Build hummingbot wheel + all Docker images in order"},"verify-build":{"description":"Verify all builds are correct and in sync across repos"},"run-dev-stack":{"description":"Start the full dev stack from source (infra + gateway + API)"},"setup-hummingbot":{"description":"Install Hummingbot from source (branch, conda env, solders fix)"},"run-hummingbot":{"description":"Run Hummingbot CLI from source"},"build-hummingbot":{"description":"Build Hummingbot wheel and Docker image from source"},"setup-gateway":{"description":"Install and configure Gateway from source (pnpm install/build/setup)"},"run-gateway":{"description":"Run Gateway from source in dev mode"},"build-gateway":{"description":"Build Gateway Docker image from source"},"setup-api-dev":{"description":"Configure Hummingbot API to use local Hummingbot source (pip install -e)"},"run-api-dev":{"description":"Run Hummingbot API from source with hot-reload against local Hummingbot"},"test-integration":{"description":"Smoke test the full stack — API, Gateway, and Hummingbot connectivity"}} |
Developer workflow skill for building and running the full Hummingbot stack from source.
Commands (run as /hummingbot-developer <command>):
| Command | Description |
|---|---|
start | Check dev environment status |
select-branches | Pick branches for all 3 repos |
install-all | Install all 3 repos in order |
build-all | Build wheel + all Docker images |
verify-build | Verify builds are correct + in sync |
run-dev-stack | Start full stack from source |
setup-hummingbot | Install Hummingbot from source |
run-hummingbot | Run Hummingbot CLI from source |
build-hummingbot | Build wheel + Docker image |
setup-gateway | Install Gateway from source |
run-gateway | Run Gateway in dev mode |
build-gateway | Build Gateway Docker image |
setup-api-dev | Wire API to local Hummingbot source |
run-api-dev | Run API from source with hot-reload |
test-integration | Smoke test the full stack |
Typical dev workflow:
install-deps → select-branches → install-all → build-all → verify-build → run-dev-stack → test-integration
Repo locations (all in workspace):
| Repo | Path |
|---|---|
| hummingbot | ~/.openclaw/workspace/hummingbot |
| gateway | ~/.openclaw/workspace/hummingbot-gateway |
| hummingbot-api |
~/.openclaw/workspace/hummingbot-api |
Override with env vars: HUMMINGBOT_DIR, GATEWAY_DIR, HUMMINGBOT_API_DIR, or WORKSPACE.
Auto-install all missing dev dependencies. Safe to re-run — skips anything already installed.
bash scripts/install_deps.sh
Installs (only if missing):
build_ext)Options:
--check # check only, don't install anything
--conda # only install conda
--node # only install node + nvm
--pnpm # only install pnpm
After installing, restart your terminal (or source ~/.zshrc) to apply PATH changes, then run check_env.sh to confirm.
Interactively pick a branch for each repo, checkout, and save to .dev-branches.
bash scripts/select_branches.sh
Non-interactive options:
# Use development for all
bash scripts/select_branches.sh --defaults
# Specify each branch
bash scripts/select_branches.sh \
--hummingbot development \
--gateway core-2.7 \
--api development
Branch selections are saved to $WORKSPACE/.dev-branches and automatically loaded by install_all.sh, build_all.sh, and verify_build.sh.
Install all three repos in the correct order. Requires select-branches first (or pass --defaults).
bash scripts/install_all.sh
What it does (in order):
solders from environment.yml (pip-only)make install in hummingbot → conda env hummingbotpip install solders>=0.19.0 into hummingbot envpnpm install && pnpm build && pnpm run setup:with-defaults for gatewayconda env create for hummingbot-apipip install -e <hummingbot_dir> --no-deps → wires local source into API envOptions:
--skip-hbot # skip hummingbot conda install
--skip-gateway # skip gateway pnpm install
--skip-api # skip hummingbot-api install
--no-local-hbot # use PyPI hummingbot in API env instead of local source
Build hummingbot wheel and all Docker images in the correct order.
bash scripts/build_all.sh
Build order:
hummingbot wheel (dist/*.whl) via python setup.py bdist_wheelhummingbot/hummingbot:dev Docker imagehummingbot/gateway:dev Docker image (also rebuilds dist/)hummingbot/hummingbot-api:dev Docker imageEach image is also tagged with the branch name (e.g., hummingbot/gateway:core-2.7).
Options:
--wheel-only # only build hummingbot wheel, no Docker
--no-docker # skip all Docker builds
--no-hbot # skip hummingbot builds
--no-gateway # skip gateway builds
--no-api # skip hummingbot-api builds
--tag <name> # Docker tag (default: dev)
Verify that all builds are correct and in sync.
bash scripts/verify_build.sh
Checks:
.dev-branches)dist/dist/ is built and not stale vs sourcebash scripts/verify_build.sh --no-docker # skip Docker checks
bash scripts/verify_build.sh --no-running # skip service checks
bash scripts/verify_build.sh --json # JSON output
Start the full dev stack from source.
bash scripts/run_dev_stack.sh
Start order:
docker compose up emqx postgres -dnode dist/index.js --passphrase=hummingbot --dev)uvicorn main:app --reload)Options:
--no-gateway # skip gateway start
--passphrase <pass> # gateway passphrase (default: hummingbot)
--stop # stop everything
--status # show running status
Logs:
tail -f ~/.openclaw/workspace/.gateway.logCheck the full dev environment and show a status summary.
bash scripts/check_env.sh --json
bash scripts/check_repos.sh --json
bash scripts/check_api.sh --json
bash scripts/check_gateway.sh --json
Present a checklist like:
Dev Environment Status
======================
[x] Prerequisites — conda, node, pnpm, docker, git OK
[x] Hummingbot repo — branch: development, env: hummingbot (installed)
[x] Gateway repo — branch: development, built: yes
[x] Hummingbot API — running at http://localhost:8000
[x] Gateway — running at http://localhost:15888
[ ] Local hummingbot — hummingbot-api NOT using local source
Next: run /hummingbot-developer setup-api-dev to wire API to local source
Adapt to actual state. If all good, show the test command.
Install Hummingbot from source on the development branch.
bash scripts/check_env.sh
cd <HUMMINGBOT_DIR>
git fetch origin
git checkout development
git pull origin development
sed -i '' '/solders/d' setup/environment.yml 2>/dev/null || sed -i '/solders/d' setup/environment.yml
make install
This creates the hummingbot conda env. Takes 3-10 minutes on first run.
conda run -n hummingbot pip install "solders>=0.19.0"
| Output | Meaning | Next step |
|---|---|---|
conda develop . succeeds | Dev install registered | Proceed |
PackagesNotFoundError: solders | Forgot step 3 | Run sed + reinstall |
Error: Conda is not found | conda not in PATH | source ~/.zshrc or install Anaconda |
build_ext errors | Missing build tools | Install Xcode CLT: xcode-select --install |
[x] conda env "hummingbot" created
[x] solders installed via pip
Run hummingbot: /hummingbot-developer run-hummingbot
Build image: /hummingbot-developer build-hummingbot
Run the Hummingbot CLI from source.
cd <HUMMINGBOT_DIR>
conda activate hummingbot
./bin/hummingbot_quickstart.py
Or via make:
cd <HUMMINGBOT_DIR>
make run
Note: This opens the interactive Hummingbot CLI. Use exit to quit.
To run with a specific config:
make run ARGS="--config-file-name conf_pure_mm_1.yml"
Build a Hummingbot wheel and/or Docker image from source.
cd <HUMMINGBOT_DIR>
conda activate hummingbot
pip install build wheel # if not already installed
python -m build --wheel --no-isolation
Wheel is output to dist/hummingbot-*.whl.
Important: The wheel must be built with Python 3.12 to match hummingbot-api's environment.
Use this wheel to install into other envs:
pip install dist/hummingbot-*.whl --force-reinstall --no-deps
When building hummingbot-api Docker images, you need a Linux wheel (not macOS/Windows). Build inside Docker to ensure compatibility:
cd <HUMMINGBOT_DIR>
# Build Linux wheel using Docker (Python 3.12 to match hummingbot-api)
docker run --rm -v $(pwd):/hummingbot -w /hummingbot continuumio/miniconda3 bash -c "
apt-get update -qq && apt-get install -y -qq gcc g++ build-essential > /dev/null 2>&1 &&
conda create -n build python=3.12 cython numpy -y -q &&
conda run -n build pip install -q build wheel &&
conda run -n build python -m build --wheel
"
# Verify the Linux wheel was created
ls dist/*linux*.whl
# Example: hummingbot-20260126-cp312-cp312-linux_aarch64.whl
Platform wheel suffixes:
linux_x86_64 — Linux AMD/Intel 64-bitlinux_aarch64 — Linux ARM64 (Apple Silicon Docker, AWS Graviton)macosx_11_0_arm64 — macOS Apple Silicon (native only, NOT for Docker)macosx_10_9_x86_64 — macOS Intel (native only, NOT for Docker)cd <HUMMINGBOT_DIR>
docker build -t hummingbot/hummingbot:dev -f Dockerfile .
Or with make (also cleans first):
make build TAG=:dev
Tag for use with hummingbot-api:
docker build -t hummingbot/hummingbot:development -f Dockerfile .
| Output | Meaning |
|---|---|
Successfully built + wheel path | Wheel ready in dist/ |
Successfully tagged hummingbot/hummingbot:dev | Docker image ready |
build_ext error | Cython compile issue — check conda env is active |
| OOM during Docker build | Add --memory 4g flag |
Install and configure Gateway from source.
Requires Node.js 20+, pnpm, and git.
bash scripts/check_env.sh
cd <GATEWAY_DIR>
git fetch origin
git checkout development
git pull origin development
cd <GATEWAY_DIR>
pnpm install
If you see USB HID errors on macOS:
pnpm install --force
pnpm build
# Non-interactive with defaults (recommended for dev)
pnpm run setup:with-defaults
# Interactive (choose which configs to update)
pnpm run setup
Setup creates:
conf/ — chain, connector, token, and RPC configscerts/ — TLS certificates (self-signed for dev)| Output | Meaning | Next step |
|---|---|---|
Gateway setup complete | Ready to start | run-gateway |
tsc errors | TypeScript compile error | Check Node version (node --version ≥ 20) |
pnpm: command not found | pnpm not installed | npm install -g pnpm |
ENOSPC | Disk space | Free up space |
Run Gateway from source in dev mode (HTTP, no TLS).
cd <GATEWAY_DIR>
pnpm start --passphrase=<PASSPHRASE> --dev
Default passphrase matches hummingbot-api setup: hummingbot
pnpm start --passphrase=hummingbot --dev
What --dev does:
http://localhost:15888Verify it's running:
curl http://localhost:15888/
Watch logs for startup sequence:
Gateway listening on port 15888
Solana mainnet-beta initialized
...
Configure custom RPC (recommended to avoid rate limits):
# After gateway is running, update RPC via API
curl -X POST http://localhost:15888/network/config \
-H "Content-Type: application/json" \
-d '{"chain": "solana", "network": "mainnet-beta", "nodeURL": "https://your-rpc.com"}'
Build a Gateway Docker image from source.
cd <GATEWAY_DIR>
docker build \
--build-arg BRANCH=$(git rev-parse --abbrev-ref HEAD) \
--build-arg COMMIT=$(git rev-parse HEAD) \
--build-arg BUILD_DATE=$(date -u +%Y-%m-%dT%H:%M:%SZ) \
-t hummingbot/gateway:dev \
-f Dockerfile .
Tag as development for use with hummingbot-api:
docker tag hummingbot/gateway:dev hummingbot/gateway:development
Verify image:
docker run --rm hummingbot/gateway:dev node -e "console.log('OK')"
Configure Hummingbot API to use a local Hummingbot source build instead of the PyPI package.
This lets you make changes to Hummingbot and immediately test them via the API without rebuilding Docker images.
cd <HUMMINGBOT_API_DIR>
make install
This creates the hummingbot-api conda env with the PyPI version of hummingbot.
Option A — Editable install (recommended for active development):
conda run -n hummingbot-api pip install -e <HUMMINGBOT_DIR> --no-deps
Changes to hummingbot source are reflected immediately (no reinstall needed).
Option B — Wheel install (for testing a specific build):
# First build the wheel
cd <HUMMINGBOT_DIR> && conda run -n hummingbot python setup.py bdist_wheel
# Install into hummingbot-api env
conda run -n hummingbot-api pip install <HUMMINGBOT_DIR>/dist/hummingbot-*.whl --force-reinstall --no-deps
conda run -n hummingbot-api python -c "import hummingbot; print(hummingbot.__file__)"
Should print a path inside <HUMMINGBOT_DIR>, not site-packages.
conda run -n hummingbot-api pip install "solders>=0.19.0"
| Output | Meaning |
|---|---|
| Path inside your hummingbot dir | ✅ Local source active |
Path inside anaconda3/.../site-packages | ❌ Still using PyPI version |
ImportError: No module named hummingbot | pip install failed — retry |
Run Hummingbot API from source with hot-reload, using local Hummingbot.
cd <HUMMINGBOT_API_DIR>
docker compose up emqx postgres -d
Verify they're healthy:
docker compose ps
cd <HUMMINGBOT_API_DIR>
conda run --no-capture-output -n hummingbot-api uvicorn main:app --reload
Or via make:
make run
API is available at http://localhost:8000
Swagger UI at http://localhost:8000/docs
What hot-reload means: Changes to *.py files in hummingbot-api are applied immediately. Changes to hummingbot source (editable install) are also picked up on reload.
curl -s http://localhost:8000/health | python3 -m json.tool
Check API logs for hummingbot version on startup.
# Watch logs
conda run -n hummingbot-api uvicorn main:app --reload --log-level debug
# Run on different port
conda run -n hummingbot-api uvicorn main:app --reload --port 8001
# Check what's running
docker compose ps
curl http://localhost:8000/health
Smoke test the full dev stack — API, Gateway, and Hummingbot connectivity.
bash scripts/check_api.sh
bash scripts/check_gateway.sh
python scripts/test_integration.py
| Test | Checks |
|---|---|
| API health | GET /health returns 200 |
| API version | Confirms hummingbot source path (not PyPI) |
| Gateway health | GET / on port 15888 returns 200 |
| API→Gateway | API can reach Gateway (/gateway/status) |
| Connectors | At least one connector visible via API |
| Wallets | Gateway wallet list accessible |
| Output | Meaning | Fix |
|---|---|---|
✓ API running | API up | — |
✓ Gateway running | Gateway up | — |
✓ API→Gateway connected | Full stack wired | — |
✗ API not running | Start with run-api-dev | — |
✗ Gateway not running | Start with run-gateway | — |
✗ API→Gateway: connection refused | Gateway URL mismatch | Check .env GATEWAY_URL=http://localhost:15888 |
✗ Local hummingbot not active | Using PyPI version | Run setup-api-dev |
For testing with Docker containers (instead of source), build a custom hummingbot-api image with your hummingbot wheel.
cd <HUMMINGBOT_DIR>
# Build Linux wheel using Docker (Python 3.12)
docker run --rm -v $(pwd):/hummingbot -w /hummingbot continuumio/miniconda3 bash -c "
apt-get update -qq && apt-get install -y -qq gcc g++ build-essential > /dev/null 2>&1 &&
conda create -n build python=3.12 cython numpy -y -q &&
conda run -n build pip install -q build wheel &&
conda run -n build python -m build --wheel
"
ls dist/*linux*.whl
cd <HUMMINGBOT_API_DIR>
# Copy wheel to API directory
cp <HUMMINGBOT_DIR>/dist/hummingbot-*-cp312-*-linux_*.whl .
# Update environment.docker.yml with wheel filename
# Then build using Dockerfile.dev
docker build -f Dockerfile.dev -t hummingbot/hummingbot-api:dev .
cd <HUMMINGBOT_API_DIR>
docker compose -f docker-compose.dev.yml up -d
# Check lp_executor is available (only in development hummingbot)
curl -s -u admin:admin http://localhost:8000/executors/types/available | grep lp_executor
When deploying bots via the API, specify which hummingbot Docker image to use.
curl -X POST http://localhost:8000/bot-orchestration/deploy-v2-controllers \
-u admin:admin \
-H "Content-Type: application/json" \
-d '{
"instance_name": "my-bot",
"credentials_profile": "master_account",
"controllers_config": ["my_controller.yml"],
"image": "hummingbot/hummingbot:development"
}'
| Image | Description |
|---|---|
hummingbot/hummingbot:latest | Stable PyPI release (default) |
hummingbot/hummingbot:development | Development branch from Docker Hub |
hummingbot/hummingbot:dev | Locally built image |
For connectors like meteora/clmm, Gateway must be running:
docker run -d --name gateway -p 15888:15888 \
-e GATEWAY_PASSPHRASE=admin \
hummingbot/gateway:development
# 1. Setup repos
cd ~/Documents/hummingbot && git checkout development && git pull
cd ~/.openclaw/workspace/hummingbot-gateway && git checkout development && git pull
# 2. Install hummingbot
cd ~/Documents/hummingbot
sed -i '' '/solders/d' setup/environment.yml
make install
conda run -n hummingbot pip install "solders>=0.19.0"
# 3. Install gateway
cd ~/.openclaw/workspace/hummingbot-gateway
pnpm install && pnpm build && pnpm run setup:with-defaults
# 4. Wire hummingbot-api to local source
cd ~/.openclaw/workspace/hummingbot-api
make install
conda run -n hummingbot-api pip install -e ~/Documents/hummingbot --no-deps
conda run -n hummingbot-api pip install "solders>=0.19.0"
# 5. Start everything
cd ~/.openclaw/workspace/hummingbot-gateway
pnpm start --passphrase=hummingbot --dev &
cd ~/.openclaw/workspace/hummingbot-api
docker compose up emqx postgres -d
make run
# 1. Make changes in hummingbot source
# 2. If editable install: just save the file (hot-reload picks it up)
# 3. If wheel install: rebuild and reinstall
cd ~/Documents/hummingbot
conda run -n hummingbot python setup.py bdist_wheel
conda run -n hummingbot-api pip install dist/hummingbot-*.whl --force-reinstall --no-deps
# 4. Restart API
# 5. Run tests
python scripts/test_integration.py
| Component | Default path |
|---|---|
| Hummingbot | ~/Documents/hummingbot |
| Gateway | ~/.openclaw/workspace/hummingbot-gateway |
| Hummingbot API | ~/.openclaw/workspace/hummingbot-api |
Override by setting env vars:
export HUMMINGBOT_DIR=~/code/hummingbot
export GATEWAY_DIR=~/code/gateway
export HUMMINGBOT_API_DIR=~/code/hummingbot-api
| Script | Purpose |
|---|---|
check_env.sh | Verify prereqs (conda, node, pnpm, docker, git) |
check_repos.sh | Show branch + build status for each repo |
check_api.sh | Check if Hummingbot API is running |
check_gateway.sh | Check if Gateway is running |
test_integration.py | End-to-end smoke tests |