GitHub Go Daily Trending Repositories

aldinokemal/go-whatsapp-web-multidevice

GOWA - WhatsApp REST API with support for UI, Multi Account, Webhooks, and MCP, and Chatwoot. Built with Golang for efficient memory use.

Golang WhatsApp - Built with Go for efficient memory use

If you're using this tools to generate income, consider supporting its development by becoming a Patreon member! Your support helps ensure the library stays maintained and receives regular updates!

Support for `ARM` & `AMD` Architecture along with `MCP` Support

Download:

Support n8n package (n8n.io)

n8n package
Go to Settings -> Community Nodes -> Input @aldinokemal2104/n8n-nodes-gowa -> Install

Breaking Changes

v6
- For REST mode, you need to run <binary> rest instead of <binary>
  - for example: ./whatsapp rest instead of ~~./whatsapp~~
- For MCP mode, you need to run <binary> mcp
  - for example: ./whatsapp mcp
v7
- Starting version 7.x we are using goreleaser to build the binary, so you can download the binary from release
v8
- Multi-device support: You can now connect and manage multiple WhatsApp accounts simultaneously in a single server instance
- New Device Management API: New endpoints under /devices for managing multiple devices
- Device scoping required: All device-scoped REST API calls now require either:
  - X-Device-Id header, or
  - device_id query parameter
  - If only one device is registered, it will be used as the default
- WebSocket device scoping: Connect to /ws?device_id=<id> to scope WebSocket to a specific device
- Remote UI support: CORS allows the Authorization and X-Device-Id headers, so a standalone web UI (e.g. gowa-ui) hosted on another origin can call the API directly. GET /app/info exposes version and media size limits. Since browsers cannot set headers on WebSocket connections, pass /ws?device_id=<id>&authorization=<base64(user:pass)> when basic auth is enabled (use TLS — the credential is visible in the URL)
- Webhook payload changes: All webhook payloads now include a top-level device_id field identifying which device received the event:
```
```json
  {
    "event": "message",
    "device_id": "628123456789@s.whatsapp.net",
    "payload": { ... }
  }
```
```
v9
- MCP and API are unified under rest: MCP is no longer a separate mode or process. Run ./whatsapp rest to serve both the REST API and MCP; MCP is available at /mcp (no standalone mcp subcommand). See MCP Server (Model Context Protocol) for migration details.
- UI moved to a separate repository: The web dashboard is no longer bundled in this repo. It now lives at aldinokemal/gowa-ui and ships as a single self-contained gowa-ui.html. This server is now a pure API backend that downloads the latest dashboard release at startup, verifies its sha256 digest, caches it under storages/ui/, and serves it at /. See Web dashboard (gowa-ui) for the APP_UI_* settings, supply-chain pinning, and air-gapped deployment.

Feature

Send WhatsApp message via http API, docs/openapi.yaml for more details
MCP (Model Context Protocol) Server Support - Integrate with AI agents and tools using standardized protocol
Mention someone
- @phoneNumber
- example: Hello @628974812XXXX, @628974812XXXX
Ghost Mentions (Mention All) - Mention group participants without showing @phone in message text
- Pass phone numbers in mentions field to mention users without visible @ in message
- Use special keyword @everyone to automatically mention ALL group participants
- UI checkbox available in Send Message modal for groups
Post Whatsapp Status
Send Stickers - Automatically converts images to WebP sticker format
- Supports JPG, JPEG, PNG, WebP, and GIF formats
- Automatic resizing to 512x512 pixels
- Preserves transparency for PNG images
- Animated WebP stickers are supported but must meet WhatsApp requirements:
  - Must be exactly 512x512 pixels
  - Must be under 500KB file size
  - Maximum 10 seconds duration
  - If your animated sticker doesn't meet these requirements, please resize it before uploading using tools like ezgif.com
Compress image before send
Compress video before send
Change OS name become your app (it's the device name when connect via mobile)
- --os=Chrome or --os=MyApplication
Basic Auth (able to add multi credentials)
- --basic-auth=kemal:secret,toni:password,userName:secretPassword, or you can simplify
- -b=kemal:secret,toni:password,userName:secretPassword
Subpath deployment support
- --base-path="/gowa" (allows deployment under a specific path like /gowa/sub/path)
Customizable port and debug mode
- --port 8000
- --debug true
Auto reply message
- --autoreply="Don't reply this message"
Auto mark read incoming messages
- --auto-mark-read=true (automatically marks incoming messages as read)
Auto download media from incoming messages
- --auto-download-media=false (disable automatic media downloads, default: true)
Auto reject incoming calls
- --auto-reject-call=true or WHATSAPP_AUTO_REJECT_CALL=true (see Webhook Payload for call events)
Configurable presence on connect
- --presence-on-connect=unavailable or WHATSAPP_PRESENCE_ON_CONNECT=unavailable
- available — mark as online (suppresses phone notifications)
- unavailable — register pushname without going online (default, preserves phone notifications)
- none — skip presence entirely (pushname won't be registered, contacts may see "-" as name)
Daily presence pulse
- --presence-pulse-enabled=true or WHATSAPP_PRESENCE_PULSE_ENABLED=true (default: true)
- --presence-pulse-interval=24h controls how often each connected device is pulsed
- --presence-pulse-duration=5m controls how long the account stays available before returning to unavailable
Webhook for received message
- --webhook="http://yourwebhook.site/handler", or you can simplify
- -w="http://yourwebhook.site/handler"
- for more detail, see Webhook Payload Documentation
Per-Device Webhook - Each device can have its own webhook URL
- Set via API: PATCH /devices/:device_id/webhook with {"webhook_url": "https://device-webhook.site/handler"}
- Get via API: GET /devices/:device_id/webhook
- When a device has a custom webhook, events for that device are sent to the device-specific URL
- When no device webhook is set, events fall back to the global webhook (--webhook)
- Set to empty string "" via PATCH to clear and use global webhook
Webhook Secret Our webhook will be sent to you with an HMAC header and a sha256 default key secret.

You may modify this by using the option below:
- --webhook-secret="secret"
Webhook Payload Documentation For detailed webhook payload schemas, security implementation, and integration examples, see Webhook Payload Documentation

Webhook Event Filtering You can filter which events are forwarded to your webhook using:

--webhook-events="message,message.ack" (comma-separated list)
Or environment variable: WHATSAPP_WEBHOOK_EVENTS=message,message.ack

Available Webhook Events:

Event	Description
`message`	Text, media, contact, location messages
`message.reaction`	Emoji reactions to messages
`message.revoked`	Deleted/revoked messages
`message.edited`	Edited messages
`message.ack`	Delivery and read receipts
`message.deleted`	Messages deleted for the user
`chat_presence`	Typing and recording indicators from contacts
`group.participants`	Group member join/leave/promote/demote events
`group.joined`	You were added to a group
`label.edit`	WhatsApp label metadata changed
`label.association`	Label applied to or removed from a chat
`newsletter.joined`	You subscribed to a newsletter/channel
`newsletter.left`	You unsubscribed from a newsletter
`newsletter.message`	New message(s) posted in a newsletter
`newsletter.mute`	Newsletter mute setting changed
`call.offer`	Incoming call received

If not configured (empty), all events will be forwarded.

Webhook JID Filtering

You can skip events for specific chats or senders (e.g. mute all groups) before they are forwarded:
- --webhook-ignore-jids="@g.us,628123456789@s.whatsapp.net" (comma-separated list)
- Or environment variable: WHATSAPP_WEBHOOK_IGNORE_JIDS=@g.us
- Supports the @g.us / @s.whatsapp.net / @lid wildcards (match a whole address space) and exact JIDs.
- This filters by conversation/sender and is independent of --webhook-events (which filters by event type). The Chatwoot integration keeps its own CHATWOOT_IGNORE_JIDS.
Webhook TLS Configuration

If you encounter TLS certificate verification errors when using webhooks (e.g., with Cloudflare tunnels or self-signed certificates):
```
tls: failed to verify certificate: x509: certificate signed by unknown authority
```
You can disable TLS certificate verification using:
- --webhook-insecure-skip-verify=true
- Or environment variable: WHATSAPP_WEBHOOK_INSECURE_SKIP_VERIFY=true
Security Warning: This option disables TLS certificate verification and should only be used in:
- Development/testing environments
- Cloudflare tunnels (which provide their own security layer)
- Internal networks with self-signed certificates
For production environments, it's strongly recommended to use proper SSL certificates (e.g., Let's Encrypt) instead of disabling verification.

Configuration

You can configure the application using either command-line flags (shown above) or environment variables. Configuration can be set in three ways (in order of priority):

Command-line flags (highest priority)
Environment variables
.env file (lowest priority)

Environment Variables

You can configure the application using environment variables. Configuration can be set in three ways (in order of priority):

Command-line flags (highest priority)
Environment variables
.env file (lowest priority)

To use environment variables:

Copy .env.example to .env in your project root (cp src/.env.example src/.env)
Modify the values in .env according to your needs
Or set the same variables as system environment variables

Available Environment Variables

Variable	Description	Default	Example
`APP_PORT`	Application port	`3000`	`APP_PORT=8080`
`APP_HOST`	Host address to bind the server	`0.0.0.0`	`APP_HOST=127.0.0.1`
`APP_DEBUG`	Enable debug logging	`false`	`APP_DEBUG=true`
`APP_OS`	OS name (device name in WhatsApp)	`GOWA`	`APP_OS=MyApp`
`APP_BASIC_AUTH`	Basic authentication credentials	-	`APP_BASIC_AUTH=user1:pass1,user2:pass2`
`APP_BASE_PATH`	Base path for subpath deployment	-	`APP_BASE_PATH=/gowa`
`APP_TRUSTED_PROXIES`	Trusted proxy IP ranges for reverse proxy	-	`APP_TRUSTED_PROXIES=0.0.0.0/0`
`APP_CORS_ALLOWED_ORIGINS`	Allowed CORS origins (any origin when empty)	-	`APP_CORS_ALLOWED_ORIGINS=https://ui.example.com`
`DB_URI`	Database connection URI	`file:storages/whatsapp.db`	`DB_URI=postgres://user:pass@host/db`
`DB_KEYS_URI`	Optional database URI for encryption/session key cache. Leave blank to use `DB_URI`; avoid in-memory storage in production because restarts can lose WhatsApp session state.	-	`DB_KEYS_URI=file:storages/whatsapp-keys.db?_foreign_keys=on`
`CHAT_STORAGE_MAX_OPEN_CONNS`	Max concurrent SQLite connections for chat storage	`5`	`CHAT_STORAGE_MAX_OPEN_CONNS=10`
`WHATSAPP_AUTO_REPLY`	Auto-reply message	-	`WHATSAPP_AUTO_REPLY="Auto reply message"`
`WHATSAPP_AUTO_MARK_READ`	Auto-mark incoming messages as read	`false`	`WHATSAPP_AUTO_MARK_READ=true`
`WHATSAPP_AUTO_DOWNLOAD_MEDIA`	Auto-download media from incoming messages	`true`	`WHATSAPP_AUTO_DOWNLOAD_MEDIA=false`
`WHATSAPP_AUTO_REJECT_CALL`	Auto-reject incoming WhatsApp calls	`false`	`WHATSAPP_AUTO_REJECT_CALL=true`
`WHATSAPP_WEBHOOK`	Webhook URL(s) for events (comma-separated)	-	`WHATSAPP_WEBHOOK=https://webhook.site/xxx`
`WHATSAPP_WEBHOOK_SECRET`	Webhook secret for validation	`secret`	`WHATSAPP_WEBHOOK_SECRET=super-secret-key`
`WHATSAPP_WEBHOOK_INSECURE_SKIP_VERIFY`	Skip TLS verification for webhooks (insecure)	`false`	`WHATSAPP_WEBHOOK_INSECURE_SKIP_VERIFY=true`
`WHATSAPP_WEBHOOK_EVENTS`	Whitelist of events to forward (comma-separated, empty = all)	-	`WHATSAPP_WEBHOOK_EVENTS=message,message.ack`
`WHATSAPP_WEBHOOK_IGNORE_JIDS`	JIDs/wildcards to skip when forwarding (comma-separated)	-	`WHATSAPP_WEBHOOK_IGNORE_JIDS=@g.us`
`WHATSAPP_ACCOUNT_VALIDATION`	Enable account validation	`true`	`WHATSAPP_ACCOUNT_VALIDATION=false`
`WHATSAPP_PRESENCE_ON_CONNECT`	Presence on connect: `available`, `unavailable`, or `none`	`unavailable`	`WHATSAPP_PRESENCE_ON_CONNECT=unavailable`
`WHATSAPP_PROXY`	Outbound proxy for the WhatsApp WebSocket (socks5/http/https)	-	`WHATSAPP_PROXY=socks5://user:pass@host:1080`
`WHATSAPP_PRESENCE_PULSE_ENABLED`	Enable daily available/unavailable presence pulse	`true`	`WHATSAPP_PRESENCE_PULSE_ENABLED=false`
`WHATSAPP_PRESENCE_PULSE_INTERVAL`	Interval between presence pulses	`24h`	`WHATSAPP_PRESENCE_PULSE_INTERVAL=24h`
`WHATSAPP_PRESENCE_PULSE_DURATION`	Duration to stay available during each pulse	`5m`	`WHATSAPP_PRESENCE_PULSE_DURATION=5m`
`CHATWOOT_ENABLED`	Enable Chatwoot integration	`false`	`CHATWOOT_ENABLED=true`
`CHATWOOT_URL`	Chatwoot instance URL	-	`CHATWOOT_URL=https://app.chatwoot.com`
`CHATWOOT_API_TOKEN`	Chatwoot API access token	-	`CHATWOOT_API_TOKEN=your-api-token`
`CHATWOOT_ACCOUNT_ID`	Chatwoot account ID	-	`CHATWOOT_ACCOUNT_ID=12345`
`CHATWOOT_INBOX_ID`	Chatwoot inbox ID	-	`CHATWOOT_INBOX_ID=67890`
`CHATWOOT_DEVICE_ID`	WhatsApp device ID for Chatwoot (single-device / env fallback)	-	`CHATWOOT_DEVICE_ID=628xxx@s.whatsapp.net`
`CHATWOOT_ALLOWED_HOSTS`	Allowlist of Chatwoot hosts for per-device configs (SSRF guard)	-	`CHATWOOT_ALLOWED_HOSTS=app.chatwoot.com,chat.example.com`
`CHATWOOT_IMPORT_MESSAGES`	Enable message history sync to Chatwoot	`false`	`CHATWOOT_IMPORT_MESSAGES=true`
`CHATWOOT_DAYS_LIMIT_IMPORT_MESSAGES`	Days of history to import	`3`	`CHATWOOT_DAYS_LIMIT_IMPORT_MESSAGES=7`
`CHATWOOT_IMPORT_DB_URI`	Direct Chatwoot PostgreSQL URI for history sync	-	`CHATWOOT_IMPORT_DB_URI=postgresql://user:pass@host:5432/chatwoot_production?sslmode=disable`
`CHATWOOT_IMPORT_PLACEHOLDER_MEDIA_MESSAGE`	Insert text placeholders for media rows during direct DB import	`true`	`CHATWOOT_IMPORT_PLACEHOLDER_MEDIA_MESSAGE=true`
`CHATWOOT_IMPORT_MEDIA_WITH_REST`	Upload direct-DB import media rows through Chatwoot REST	`false`	`CHATWOOT_IMPORT_MEDIA_WITH_REST=true`
`CHATWOOT_AUTO_CREATE`	Auto-create or reuse the Chatwoot API inbox at startup	`false`	`CHATWOOT_AUTO_CREATE=true`
`CHATWOOT_INBOX_NAME`	Inbox name used when auto-create is enabled	`WhatsApp`	`CHATWOOT_INBOX_NAME=WhatsApp Support`
`CHATWOOT_WEBHOOK_URL`	Public GOWA Chatwoot reply webhook URL	-	`CHATWOOT_WEBHOOK_URL=https://api.example.com/chatwoot/webhook?secret=shared`
`CHATWOOT_WEBHOOK_SECRET`	Shared secret required for incoming Chatwoot webhooks	-	`CHATWOOT_WEBHOOK_SECRET=shared`
`CHATWOOT_REOPEN_CONVERSATION`	Reopen resolved Chatwoot conversations for returning contacts	`true`	`CHATWOOT_REOPEN_CONVERSATION=false`
`CHATWOOT_CONVERSATION_PENDING`	Create new Chatwoot conversations as pending	`false`	`CHATWOOT_CONVERSATION_PENDING=true`
`CHATWOOT_IGNORE_JIDS`	JIDs or wildcards to exclude from Chatwoot forwarding	-	`CHATWOOT_IGNORE_JIDS=@g.us,628123@s.whatsapp.net`
`CHATWOOT_SIGN_MSG`	Prefix Chatwoot agent replies with the agent name	`false`	`CHATWOOT_SIGN_MSG=true`
`CHATWOOT_SIGN_DELIMITER`	Delimiter between Chatwoot agent signature and message body	`\n\n`	`CHATWOOT_SIGN_DELIMITER=" - "`
`CHATWOOT_FORWARD_EDITS`	Mirror WhatsApp edits into Chatwoot threaded notes	`true`	`CHATWOOT_FORWARD_EDITS=false`
`CHATWOOT_FORWARD_DELETES`	Mirror WhatsApp delete-for-everyone events into Chatwoot notes	`true`	`CHATWOOT_FORWARD_DELETES=false`
`CHATWOOT_MESSAGE_READ`	Sync read state for linked WhatsApp/Chatwoot messages	`false`	`CHATWOOT_MESSAGE_READ=true`
`CHATWOOT_MESSAGE_DELETE`	Delete linked opposite-side messages when deletion is reported	`false`	`CHATWOOT_MESSAGE_DELETE=true`

Documentation:

For detailed webhook payload schemas, security implementation, and integration examples, see Webhook Payload Documentation
For comprehensive Chatwoot integration guide, see Chatwoot Integration Documentation

Note: Command-line flags will override any values set in environment variables or .env file.

For more command ./whatsapp --help

Requirements

System Requirements

Go 1.25.5 or higher (for building from source)
FFmpeg (for media processing)

Platform Support

Linux (x86_64, ARM64)
macOS (Intel, Apple Silicon)
Windows (x86_64) - WSL recommended

Dependencies (without docker)

Mac OS:
- brew install ffmpeg webp
- export CGO_CFLAGS_ALLOW="-Xpreprocessor"
Linux:
- sudo apt update
- sudo apt install ffmpeg webp
Windows (not recommended, prefer using WSL):
- Install ffmpeg: download here
- Install libwebp: download here (extract and add bin folder to PATH)
- Add both to environment variable

Note: The webp package provides cwebp (encoder), dwebp (decoder), and webpmux (frame extractor) tools. FFmpeg is required for media processing. The libwebp tools (webpmux + dwebp) are used for animated WebP sticker support.

How to use

Basic

Clone this repo: git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice
Open the folder that was cloned via cmd/terminal.
run cd src
run go run . rest (for REST API mode)
Open http://localhost:3000

Docker (you don't need to install in required)

Clone this repo: git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice
Open the folder that was cloned via cmd/terminal.
run docker-compose up -d --build
open http://localhost:3000

Build your own binary

Clone this repo git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice
Open the folder that was cloned via cmd/terminal.
run cd src
run
1. Linux & MacOS: go build -o whatsapp
2. Windows (CMD / PowerShell): go build -o whatsapp.exe
run
1. Linux & MacOS: ./whatsapp rest (for REST API mode)
  1. run ./whatsapp --help for more detail flags
2. Windows: .\whatsapp.exe rest (for REST API mode)
  1. run .\whatsapp.exe --help for more detail flags
open http://localhost:3000 in browser

Cross-Compile for Raspberry Pi (ARM)

If you want to build for Raspberry Pi or other ARM devices without needing a C toolchain (CGO), you can use the purego build tag. This will use a pure-Go SQLite implementation.

Clone this repo git clone https://github.com/aldinokemal/go-whatsapp-web-multidevice
Open the folder that was cloned via cmd/terminal.
run cd src

Build for Raspberry Pi Zero / 1 (ARMv6):

CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -tags purego -o whatsapp-armv6

Build for Raspberry Pi 2 / 3 / 4 (ARMv7 32-bit):

CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -tags purego -o whatsapp-armv7

Transfer the binary to your Pi, give it execution permission (chmod +x), and run it:
- If you built ARMv6: ./whatsapp-armv6 rest
- If you built ARMv7: ./whatsapp-armv7 rest

MCP Server (Model Context Protocol)

MCP is not a separate mode or process — it's served by the REST server itself. Whenever ./whatsapp rest is running, the MCP endpoint is available at http://<host>:<port><base-path>/mcp (default http://localhost:3000/mcp) using the streamable HTTP transport. Disable it with MCP_ENABLED=false or --mcp-enabled=false (default: enabled).

Available MCP Tools

There are 5 consolidated tools; agents pick behavior via a type/action argument instead of one tool per operation:

Tool	`type` / `action` values
`whatsapp_send`	`text`, `image`, `video`, `audio`, `document`, `sticker`, `location`, `contact`, `poll`, `link`, `forward`
`whatsapp_message`	`react`, `edit`, `revoke`, `delete`, `mark_read`, `star`, `unstar`, `download_media`
`whatsapp_chat`	`list_chats`, `list_contacts`, `get_messages`, `archive`
`whatsapp_group`	`create`, `join_with_link`, `leave`, `info`, `participants`, `add_participants`, `remove_participants`, `promote`, `demote`, `invite_link`, `set_name`, `set_topic`, `set_settings`, `join_requests`, `manage_join_requests`
`whatsapp_app`	`status`, `login_qr`, `login_code`, `logout`, `reconnect`

Device selection

For multi-device deployments, the X-Device-Id header on the MCP client connection selects the device used by every tool call on that connection (falls back to the default device if omitted, same as REST). Any individual call can override it with an optional device_id argument.

MCP Configuration

Point your MCP client at the /mcp endpoint. It inherits the REST server's basic auth, so include the same Authorization header your REST calls use:

{
  "mcpServers": {
    "whatsapp": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "Authorization": "Basic dXNlcjpzZWNyZXQ=",
        "X-Device-Id": "628123456789"
      }
    }
  }
}

headers is optional: include Authorization only when basic auth is configured, and X-Device-Id only for multi-device setups.

Migrating from the standalone MCP mode

./whatsapp mcp → ./whatsapp rest (MCP is now included automatically)
http://localhost:8080/sse → http://localhost:3000/mcp
40 granular tools → 5 consolidated tools (agents pick actions via the type/action field)

Production Mode REST (docker)

Using Docker Hub:

docker run --detach --publish=3000:3000 --name=whatsapp --restart=always --volume=$(docker volume create --name=whatsapp):/app/storages aldinokemal2104/go-whatsapp-web-multidevice rest --autoreply="Dont't reply this message please"

Using GitHub Container Registry:

docker run --detach --publish=3000:3000 --name=whatsapp --restart=always --volume=$(docker volume create --name=whatsapp):/app/storages ghcr.io/aldinokemal/go-whatsapp-web-multidevice rest --autoreply="Dont't reply this message please"

Production Mode REST (docker compose)

create docker-compose.yml file with the following configuration:

Using Docker Hub:

services:
  whatsapp:
    image: aldinokemal2104/go-whatsapp-web-multidevice
    container_name: whatsapp
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - whatsapp:/app/storages
    command:
      - rest
      - --basic-auth=admin:admin
      - --port=3000
      - --debug=true
      - --os=Chrome
      - --account-validation=false

volumes:
  whatsapp:

Using GitHub Container Registry:

services:
  whatsapp:
    image: ghcr.io/aldinokemal/go-whatsapp-web-multidevice
    container_name: whatsapp
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - whatsapp:/app/storages
    command:
      - rest
      - --basic-auth=admin:admin
      - --port=3000
      - --debug=true
      - --os=Chrome
      - --account-validation=false

volumes:
  whatsapp:

or with env file (Docker Hub):

services:
  whatsapp:
    image: aldinokemal2104/go-whatsapp-web-multidevice
    container_name: whatsapp
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - whatsapp:/app/storages
    environment:
      - APP_BASIC_AUTH=admin:admin
      - APP_PORT=3000
      - APP_DEBUG=true
      - APP_OS=Chrome
      - WHATSAPP_ACCOUNT_VALIDATION=false

volumes:
  whatsapp:

or with env file (GitHub Container Registry):

services:
  whatsapp:
    image: ghcr.io/aldinokemal/go-whatsapp-web-multidevice
    container_name: whatsapp
    restart: always
    ports:
      - "3000:3000"
    volumes:
      - whatsapp:/app/storages
    environment:
      - APP_BASIC_AUTH=admin:admin
      - APP_PORT=3000
      - APP_DEBUG=true
      - APP_OS=Chrome
      - WHATSAPP_ACCOUNT_VALIDATION=false

volumes:
  whatsapp:

Production Mode (binary)

download binary from release

You can fork or edit this source code !

Current API

MCP (Model Context Protocol) API

Served at /mcp by the REST server (streamable HTTP transport) whenever MCP_ENABLED is true; with APP_BASE_PATH set, the route is <base-path>/mcp.
Available tools are listed in the "Available MCP Tools" section above.
Compatible with MCP-enabled AI tools and agents

HTTP REST API

Check docs/openapi.yaml for detailed API specifications.
Use SwaggerEditor to visualize the API.
Generate HTTP clients using openapi-generator.

Feature	Menu	Method	URL
✅	Health Check	GET	/health
✅	List Devices	GET	/devices
✅	Add Device	POST	/devices
✅	Get Device Info	GET	/devices/:device_id
✅	Remove Device	DELETE	/devices/:device_id
✅	Login Device (QR)	GET	/devices/:device_id/login
✅	Login Device (Code)	POST	/devices/:device_id/login/code
✅	Logout Device	POST	/devices/:device_id/logout
✅	Reconnect Device	POST	/devices/:device_id/reconnect
✅	Get Device Status	GET	/devices/:device_id/status
✅	Get Device Webhook	GET	/devices/:device_id/webhook
✅	Set Device Webhook	PATCH	/devices/:device_id/webhook
✅	Login with Scan QR	GET	/app/login
✅	Login With Pair Code	GET	/app/login-with-code
✅	Passkey Pairing Status	GET	/app/passkey
✅	Passkey Pairing Response	POST	/app/passkey/response
✅	Passkey Pairing Confirm	POST	/app/passkey/confirm
✅	Logout	GET	/app/logout
✅	Reconnect	GET	/app/reconnect
✅	Devices	GET	/app/devices
✅	Connection Status	GET	/app/status
✅	App Info (version, limits)	GET	/app/info
✅	User Info	GET	/user/info
✅	User Avatar	GET	/user/avatar
✅	User Change Avatar	POST	/user/avatar
✅	User Change PushName	POST	/user/pushname
✅	User My Groups*	GET	/user/my/groups
✅	User My Newsletter	GET	/user/my/newsletters
✅	User My Privacy Setting	GET	/user/my/privacy
✅	User My Contacts	GET	/user/my/contacts
✅	User Check	GET	/user/check
✅	User Business Profile	GET	/user/business-profile
✅	Send Message	POST	/send/message
✅	Send Image	POST	/send/image
✅	Send Audio	POST	/send/audio
✅	Send File	POST	/send/file
✅	Send Video	POST	/send/video
✅	Send Sticker	POST	/send/sticker
✅	Send Contact	POST	/send/contact
✅	Send Link	POST	/send/link
✅	Send Location	POST	/send/location
✅	Send Poll / Vote	POST	/send/poll
✅	Send Presence	POST	/send/presence
✅	Send Chat Presence (Typing Indicator)	POST	/send/chat-presence
✅	Revoke Message	POST	/message/:message_id/revoke
✅	React Message	POST	/message/:message_id/reaction
✅	Delete Message	POST	/message/:message_id/delete
✅	Edit Message	POST	/message/:message_id/update
✅	Read Message (DM)	POST	/message/:message_id/read
✅	Star Message	POST	/message/:message_id/star
✅	Unstar Message	POST	/message/:message_id/unstar
✅	Download Message Media	GET	/message/:message_id/download
✅	Reject Call	POST	/call/reject
✅	Join Group With Link	POST	/group/join-with-link
✅	Group Info From Link	GET	/group/info-from-link
✅	Group Info	GET	/group/info
✅	Leave Group	POST	/group/leave
✅	Create Group	POST	/group
✅	List Participants in Group	GET	/group/participants
✅	Add Participants in Group	POST	/group/participants
✅	Remove Participant in Group	POST	/group/participants/remove
✅	Promote Participant in Group	POST	/group/participants/promote
✅	Demote Participant in Group	POST	/group/participants/demote
✅	Export Group Participants (CSV)	GET	/group/participants/export
✅	List Requested Participants in Group	GET	/group/participant-requests
✅	Approve Requested Participant in Group	POST	/group/participant-requests/approve
✅	Reject Requested Participant in Group	POST	/group/participant-requests/reject
✅	Set Group Photo	POST	/group/photo
✅	Set Group Name	POST	/group/name
✅	Set Group Locked	POST	/group/locked
✅	Set Group Announce	POST	/group/announce
✅	Set Group Topic	POST	/group/topic
✅	Get Group Invite Link	GET	/group/invite-link
✅	Unfollow Newsletter	POST	/newsletter/unfollow
✅	Get Newsletter Messages	GET	/newsletter/messages
✅	Get Chat List	GET	/chats
✅	Get Chat Messages	GET	/chat/:chat_jid/messages
✅	Pin Chat	POST	/chat/:chat_jid/pin
✅	Archive Chat	POST	/chat/:chat_jid/archive
✅	Set Disappearing Messages	POST	/chat/:chat_jid/disappearing
✅	Chatwoot Sync History	POST	/chatwoot/sync
✅	Chatwoot Sync Status	GET	/chatwoot/sync/status
✅	Chatwoot Reply Webhook	POST	/chatwoot/webhook

✅ = Available
❌ = Not Available Yet
* = Has known limitations (see notes below)

Notes:

*User My Groups: Returns a maximum of 500 groups due to WhatsApp protocol limitation. This is enforced by WhatsApp servers, not this API. See whatsmeow source for details.
/health is public and always registered at the root path, even when APP_BASE_PATH is set.
Chatwoot routes are registered only when CHATWOOT_ENABLED=true.

User Interface

MCP UI

Setup MCP (tested in cursor)
Test MCP
Successfully setup MCP

Web dashboard (gowa-ui)

The dashboard lives in its own repository: aldinokemal/gowa-ui. Each gowa-ui release publishes a single self-contained gowa-ui.html; the server downloads the latest release at startup (and every APP_UI_UPDATE_INTERVAL, default 3h), verifies its sha256 digest, caches it under storages/ui/, and serves it at / behind basic auth.

Setting	Default	Purpose
`APP_UI_ENABLED`	`true`	Serve the dashboard at `/`; `false` returns a JSON banner (API-only)
`APP_UI_AUTO_UPDATE`	`true`	Download/refresh from GitHub; disable for air-gapped deployments
`APP_UI_REPO`	`aldinokemal/gowa-ui`	Repository the updater follows — always its latest release, not a version pin
`APP_UI_ASSET_NAME`	`gowa-ui.html`	Release asset filename to download
`APP_UI_UPDATE_INTERVAL`	`3h`	How often to check `releases/latest`
`APP_UI_GITHUB_TOKEN`	(empty)	Optional token to raise the GitHub API rate limit
`APP_UI_ASSET_SHA256`	(empty)	Supply-chain pin: refuse any dashboard whose sha256 differs

Trust model: the release digest proves the download matches what GitHub advertises, not who published it. Operators who audit a specific build can pin it with APP_UI_ASSET_SHA256 (each release ships a .sha256 asset — this is the only setting that pins an exact build), point APP_UI_REPO at a fork they control (the updater still tracks that repo's latest release), or pre-seed the cache and disable auto-update entirely.

Air-gapped servers: place a downloaded gowa-ui.html at storages/ui/index.html and set APP_UI_AUTO_UPDATE=false. The dashboard can also be self-hosted anywhere static and pointed at this server's URL (see the gowa-ui readme).

Mac OS NOTE

Please do this if you have an error (invalid flag in pkg-config --cflags: -Xpreprocessor) export CGO_CFLAGS_ALLOW="-Xpreprocessor"

Important

This project is unofficial and not affiliated with WhatsApp.
Please use official WhatsApp API to avoid any issues.

ollama/ollama

Get up and running with Kimi-K2.6, GLM-5.2, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.

Ollama

Start building with open models.

Download

macOS

curl -fsSL https://ollama.com/install.sh | sh

or download manually

Windows

irm https://ollama.com/install.ps1 | iex

or download manually

Linux

curl -fsSL https://ollama.com/install.sh | sh

Manual install instructions

Docker

The official Ollama Docker image ollama/ollama is available on Docker Hub.

Libraries

Community

Get started

ollama

You'll be prompted to run a model or connect Ollama to your existing agents or applications such as Claude Code, OpenClaw, OpenCode , Codex, Copilot, and more.

Coding

To launch a specific integration:

ollama launch claude

Supported integrations include Claude Code, Codex, Copilot CLI, DeepSeek Harness, Droid, and OpenCode.

AI assistant

Use OpenClaw to turn Ollama into a personal AI assistant across WhatsApp, Telegram, Slack, Discord, and more:

ollama launch openclaw

Chat with a model

Run and chat with Gemma 4:

ollama run gemma4

See ollama.com/library for the full list.

See the quickstart guide for more details.

REST API

Ollama has a REST API for running and managing models.

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4",
  "messages": [{
    "role": "user",
    "content": "Why is the sky blue?"
  }],
  "stream": false
}'

See the API documentation for all endpoints.

Python

pip install ollama

from ollama import chat

response = chat(model='gemma4', messages=[
  {
    'role': 'user',
    'content': 'Why is the sky blue?',
  },
])
print(response.message.content)

JavaScript

npm i ollama

import ollama from "ollama";

const response = await ollama.chat({
  model: "gemma4",
  messages: [{ role: "user", content: "Why is the sky blue?" }],
});
console.log(response.message.content);

Supported backends

llama.cpp project founded by Georgi Gerganov.

Documentation

Community Integrations

Want to add your project? Open a pull request.

Chat Interfaces

Web

Open WebUI - Extensible, self-hosted AI interface
Onyx - Connected AI workspace
LibreChat - Enhanced ChatGPT clone with multi-provider support
Lobe Chat - Modern chat framework with plugin ecosystem (docs)
NextChat - Cross-platform ChatGPT UI (docs)
Perplexica - AI-powered search engine, open-source Perplexity alternative
big-AGI - AI suite for professionals
Lollms WebUI - Multi-model web interface
ChatOllama - Chatbot with knowledge bases
Bionic GPT - On-premise AI platform
Chatbot UI - ChatGPT-style web interface
Hollama - Minimal web interface
Chatbox - Desktop and web AI client
chat - Chat web app for teams
Ollama RAG Chatbot - Chat with multiple PDFs using RAG
Tkinter-based client - Python desktop client

Desktop

Dify.AI - LLM app development platform
AnythingLLM - All-in-one AI app for Mac, Windows, and Linux
Maid - Cross-platform mobile and desktop client
Witsy - AI desktop app for Mac, Windows, and Linux
Cherry Studio - Multi-provider desktop client
Ollama App - Multi-platform client for desktop and mobile
PyGPT - AI desktop assistant for Linux, Windows, and Mac
Alpaca - GTK4 client for Linux and macOS
SwiftChat - Cross-platform including iOS, Android, and Apple Vision Pro
Enchanted - Native macOS and iOS client
RWKV-Runner - Multi-model desktop runner
Ollama Grid Search - Evaluate and compare models
macai - macOS client for Ollama and ChatGPT
AI Studio - Multi-provider desktop IDE
Reins - Parameter tuning and reasoning model support
ConfiChat - Privacy-focused with optional encryption
LLocal.in - Electron desktop client
MindMac - AI chat client for Mac
Msty - Multi-model desktop client
BoltAI for Mac - AI chat client for Mac
IntelliBar - AI-powered assistant for macOS
Kerlig AI - AI writing assistant for macOS
Hillnote - Markdown-first AI workspace
Perfect Memory AI - Productivity AI personalized by screen and meeting history

Mobile

Ollama Android Chat - One-click Ollama on Android

SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.

Code Editors & Development

Cline - VS Code extension for multi-file/whole-repo coding
Continue - Open-source AI code assistant for any IDE
Void - Open source AI code editor, Cursor alternative
Copilot for Obsidian - AI assistant for Obsidian
twinny - Copilot and Copilot chat alternative
gptel Emacs client - LLM client for Emacs
Ollama Copilot - Use Ollama as GitHub Copilot
Obsidian Local GPT - Local AI for Obsidian
Ellama Emacs client - LLM tool for Emacs
orbiton - Config-free text editor with Ollama tab completion
AI ST Completion - Sublime Text 4 AI assistant
VT Code - Rust-based terminal coding agent with Tree-sitter
QodeAssist - AI coding assistant for Qt Creator
AI Toolkit for VS Code - Microsoft-official VS Code extension
Open Interpreter - Natural language interface for computers

Libraries & SDKs

LiteLLM - Unified API for 100+ LLM providers
Semantic Kernel - Microsoft AI orchestration SDK
LangChain4j - Java LangChain (example)
LangChainGo - Go LangChain (example)
Spring AI - Spring framework AI support (docs)
LangChain and LangChain.js with example
Ollama for Ruby - Ruby LLM library
any-llm - Unified LLM interface by Mozilla
OllamaSharp for .NET - .NET SDK
LangChainRust - Rust LangChain (example)
Agents-Flex for Java - Java agent framework (example)
Elixir LangChain - Elixir LangChain
Ollama-rs for Rust - Rust SDK
LangChain for .NET - .NET LangChain (example)
chromem-go - Go vector database with Ollama embeddings (example)
LangChainDart - Dart LangChain
LlmTornado - Unified C# interface for multiple inference APIs
Ollama4j for Java - Java SDK
Ollama for Laravel - Laravel integration
Ollama for Swift - Swift SDK
LlamaIndex and LlamaIndexTS - Data framework for LLM apps
Haystack - AI pipeline framework
Firebase Genkit - Google AI framework
Ollama-hpp for C++ - C++ SDK
PromptingTools.jl - Julia LLM toolkit (example)
Ollama for R - rollama - R SDK
Portkey - AI gateway
Testcontainers - Container-based testing
LLPhant - PHP AI framework

Frameworks & Agents

AutoGPT - Autonomous AI agent platform
crewAI - Multi-agent orchestration framework
Strands Agents - Model-driven agent building by AWS
Cheshire Cat - AI assistant framework
any-agent - Unified agent framework interface by Mozilla
Stakpak - Open source DevOps agent
Hexabot - Conversational AI builder
Neuro SAN - Multi-agent orchestration (docs)

RAG & Knowledge Bases

RAGFlow - RAG engine based on deep document understanding
R2R - Open-source RAG engine
MaxKB - Ready-to-use RAG chatbot
Minima - On-premises or fully local RAG
Chipper - AI interface with Haystack RAG
ARGO - RAG and deep research on Mac/Windows/Linux
Archyve - RAG-enabling document library
Casibase - AI knowledge base with RAG and SSO
BrainSoup - Native client with RAG and multi-agent automation

Bots & Messaging

LangBot - Multi-platform messaging bots with agents and RAG
AstrBot - Multi-platform chatbot with RAG and plugins
Discord-Ollama Chat Bot - TypeScript Discord bot
Ollama Telegram Bot - Telegram bot
LLM Telegram Bot - Telegram bot for roleplay

Terminal & CLI

aichat - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
oterm - Terminal client for Ollama
gollama - Go-based model manager for Ollama
tlm - Local shell copilot
tenere - TUI for LLMs
ParLlama - TUI for Ollama
llm-ollama - Plugin for Datasette's LLM CLI
ShellOracle - Shell command suggestions
LLM-X - Progressive web app for LLMs
cmdh - Natural language to shell commands
VT - Minimal multimodal AI chat app

Productivity & Apps

AppFlowy - AI collaborative workspace, self-hostable Notion alternative
Screenpipe - 24/7 screen and mic recording with AI-powered search
Vibe - Transcribe and analyze meetings
Page Assist - Chrome extension for AI-powered browsing
NativeMind - Private, on-device browser AI assistant
Ollama Fortress - Security proxy for Ollama
1Panel - Web-based Linux server management
Writeopia - Text editor with Ollama integration
QA-Pilot - GitHub code repository understanding
Raycast extension - Ollama in Raycast
Painting Droid - Painting app with AI integrations
Serene Pub - AI roleplaying app
Mayan EDMS - Document management with Ollama workflows
TagSpaces - File management with AI tagging

Observability & Monitoring

Opik - Debug, evaluate, and monitor LLM applications
OpenLIT - OpenTelemetry-native monitoring for Ollama and GPUs
Lunary - LLM observability with analytics and PII masking
Langfuse - Open source LLM observability
HoneyHive - AI observability and evaluation for agents
MLflow Tracing - Open source LLM observability

Database & Embeddings

pgai - PostgreSQL as a vector database (guide)
MindsDB - Connect Ollama with 200+ data platforms
chromem-go - Embeddable vector database for Go (example)
Kangaroo - AI-powered SQL client

Infrastructure & Deployment

Cloud

Google Cloud
Fly.io
Koyeb
Harbor - Containerized LLM toolkit with Ollama as default backend

Package Managers

putyy/res-downloader

视频号、小程序、抖音、快手、小红书、直播流、m3u8、酷狗、QQ音乐等常见网络资源下载!

res-downloader

📖 中文 | English

📢 项目状态

首先感谢大家对本项目的关注和支持 ❤️

由于个人事务原因，近期能够投入到项目维护的时间比较有限，因此Issue回复、PR Review以及版本发布的速度可能会比以前慢一些。

在此欢迎社区开发者一起参与建设，如果你在使用过程中发现问题，或者有功能改进建议，欢迎提交Issue；如果愿意贡献代码，也非常欢迎提交 Pull Request。

提交代码前请阅读： Contributing Guide

非常感谢每一位使用者、反馈者和贡献者的支持！！！

🎉 爱享素材下载器

一款基于 Go + Wails 的跨平台资源下载工具，简洁易用，支持多种资源嗅探与下载。

✨ 功能特色

🚀 简单易用：操作简单，界面清晰美观
🖥️ 多平台支持：Windows / macOS / Linux
🌐 多资源类型支持：视频 / 音频 / 图片 / m3u8 / 直播流等
📱 平台兼容广泛：支持微信视频号、小程序、抖音、快手、小红书、酷狗音乐、QQ音乐等
🌍 代理抓包：支持设置代理获取受限网络下的资源

📚 文档 & 版本

📘 在线文档
💬 加入交流群
🧩 最新版｜ Mini版使用默认浏览器展示UI ｜ Electron旧版支持Win7

群满时可加微信 AmorousWorld，请备注“github”

🧩 下载地址

🆕 GitHub 下载
🆕 蓝奏云下载（密码：9vs5）
⚠️ Win7 用户请下载 2.3.0 版本

🖼️ 预览

🚀 使用方法

请按以下步骤操作以正确使用软件：

安装时务必 允许安装证书文件 并 允许网络访问
打开软件 → 首页左上角点击 “启动代理”
选择要获取的资源类型（默认全部）
在外部打开资源页面（如视频号、小程序、网页等）
返回软件首页，即可看到资源列表

❓ 常见问题

📺 m3u8 视频资源

在线预览：m3u8play
视频下载：m3u8-down

📡 直播流资源

推荐使用 OBS 进行录制（教程请百度）

🐢 下载慢、大文件失败？

推荐工具：
- Neat Download Manager
- Motrix
视频号资源下载后可在操作项点击 视频解密（视频号）

🧩 软件无法拦截资源？

检查是否正确设置系统代理：
地址：127.0.0.1 端口：8899

🌐 关闭软件后无法上网？

手动关闭系统代理设置

🧠 更多问题

💡 实现原理 & 初衷

本工具通过代理方式实现网络抓包，并筛选可用资源。与 Fiddler、Charles、浏览器 DevTools 原理类似，但对资源进行了更友好的筛选、展示和处理，大幅度降低了使用门槛，更适合大众用户使用。

⚠️ 免责声明

本软件仅供学习与研究用途，禁止用于任何商业或违法用途。
如因此产生的任何法律责任，概与作者无关！

mostlygeek/llama-swap

Reliable model swapping for any local OpenAI/Anthropic compatible server - llama.cpp, vllm, etc

llama-swap

Run multiple generative AI models on your machine and hot-swap between them on demand. llama-swap works with any OpenAI and Anthropic API compatible server and is used by thousands of people to power their local AI workflows.

Built in Go for performance and simplicity, llama-swap has zero dependencies and is incredibly easy to set up. Get started in minutes - just one binary and one configuration file.

Features:

✅ Easy to deploy and configure: one binary, one configuration file. no external dependencies
✅ On-demand model switching for many local AI servers (llama.cpp + forks, vllm, stable-diffusion.cpp, audio.cpp, ComfyUI, etc.)
- future proof, upgrade your inference servers at any time.
✅ OpenAI API supported endpoints:
- v1/completions
- v1/chat/completions
- v1/responses
- v1/embeddings
- v1/models - list available models
- v1/audio/speech (#36)
- v1/audio/transcriptions (docs)
- v1/audio/voices
- v1/images/generations
- v1/images/edits
✅ Anthropic API supported endpoints:
- v1/messages
- v1/messages/count_tokens
✅ llama-server (llama.cpp) supported endpoints
- v1/rerank, v1/reranking, /rerank
- /infill - for code infilling
- /completion - for completion endpoint
- /models - list available models. same behavior as v1/models
- /props - requires ?model={model_id} query parameter to be provided. The autoload parameter is not supported and will be ignored.
✅ SDAPI via stable-diffusion.cpp's server
- /sdapi/v1/txt2img
- /sdapi/v1/img2img
- /sdapi/v1/loras - requires model in request body to fetch the correct loras
✅ audio.cpp supported extra endpoints
- /audioapi/v1/tasks/run
✅ /comfyui/ - ComfyUI custom endpoint (#1001) for more reliable swapping
✅ llama-swap API
- /ui - web UI
- /upstream/:model_id - direct access to upstream server (demo)
- /running - list currently running models (#61)
- POST /api/models/unload - manually unload all running models (#58)
- POST /api/models/unload/:model_id - unload a specific model
- GET /api/profiles - list configured profiles and the active selection
- PUT /api/profiles/active - activate a profile or select none
- /logs - remote log monitoring
  - GET /logs returns buffered plain text logs.
    - If Accept: text/html is sent, /logs redirects to /ui/.
  - GET /logs/stream keeps the connection open for live log streaming.
    - Stream endpoints send buffered history first by default; add ?no-history to stream only new lines.
  - GET /logs/stream/proxy streams proxy logs only.
  - GET /logs/stream/upstream streams upstream process logs only.
  - GET /logs/stream/{model_id} streams logs for one model (including IDs with slashes, like author/model).
- /health - just returns "OK"
- /metrics - system and GPU metrics for prometheus
✅ API Key support - define keys to restrict access to API endpoints
✅ Customization
- Switch model ID routing at runtime with profiles
- Run concurrent models with a custom DSL swap matrix (#643)
- Automatic unloading of models after timeout by setting a ttl
- Docker and Podman support using cmd and cmdStop together
- Preload models on startup with hooks (#235)
- Apply filters to requests to control inference with stripParams, setParams and setParamsByID

Web UI

llama-swap includes a real time web interface with a playground for testing out all sorts of local models:

View detailed token metrics:

Inspect request and responses:

Manually load and unload models:

Real time log streaming:

Installation

llama-swap can be installed in multiple ways

Docker
Homebrew (macOS and Linux)
MacPorts (macOS)
WinGet
From release binaries
From source

Docker Install (download images)

Two types of container images are built nightly for llama-swap:

A unified container with llama-server, ik-llama-server, stable-diffusion.cpp, whisper.cpp and llama-swap built from source. This is only available for cuda and vulkan but has more capabilities. This one is recommended for use.
A legacy image that is based on llama.cpp's images and llama-swap copied into the container. Use this one if you prefer to stay close to llama.cpp's container images.

Unified container (Recommended)

$ docker pull ghcr.io/mostlygeek/llama-swap:unified-cuda

# run with a custom configuration and models directory
$ docker run -it --rm --runtime nvidia -p 9292:8080 \
 -v /path/to/models:/models \
 -v /path/to/custom/config.yaml:/etc/llama-swap/config/config.yaml \
 ghcr.io/mostlygeek/llama-swap:unified-cuda

Legacy container

$ docker pull ghcr.io/mostlygeek/llama-swap:cuda

# run with a custom configuration and models directory
$ docker run -it --rm --runtime nvidia -p 9292:8080 \
 -v /path/to/models:/models \
 -v /path/to/custom/config.yaml:/app/config.yaml \
 ghcr.io/mostlygeek/llama-swap:cuda

more examples

# pull latest images per platform
docker pull ghcr.io/mostlygeek/llama-swap:cpu
docker pull ghcr.io/mostlygeek/llama-swap:cuda
docker pull ghcr.io/mostlygeek/llama-swap:vulkan
docker pull ghcr.io/mostlygeek/llama-swap:intel
docker pull ghcr.io/mostlygeek/llama-swap:musa

# tagged llama-swap, platform and llama-server version images
docker pull ghcr.io/mostlygeek/llama-swap:v166-cuda-b6795

# non-root cuda
docker pull ghcr.io/mostlygeek/llama-swap:cuda-non-root

Homebrew Install (macOS/Linux)

brew tap mostlygeek/llama-swap
brew install llama-swap
llama-swap --config path/to/config.yaml --listen localhost:8080

MacPorts (macOS)

Note

Maintained by MacPorts community - llama-swap port. It is not an official part of llama-swap.

sudo port install llama-swap
llama-swap --config path/to/config.yaml --listen localhost:8080

WinGet Install (Windows)

Note

WinGet is maintained by community contributor Dvd-Znf (#327). It is not an official part of llama-swap.

# install
C:\> winget install llama-swap

# upgrade
C:\> winget upgrade llama-swap

Pre-built Binaries

Binaries are available on the release page for Linux, Mac, Windows and FreeBSD.

Building from source

Building requires Go and Node.js (for UI).
git clone https://github.com/mostlygeek/llama-swap.git
make clean all
look in the build/ subdirectory for the llama-swap binary

Configuration

# minimum viable config.yaml

models:
  model1:
    cmd: llama-server --port ${PORT} --model /path/to/model.gguf

That's all you need to get started:

models - holds all model configurations
model1 - the ID used in API calls
cmd - the command to run to start the server.
${PORT} - an automatically assigned port number

Almost all configuration settings are optional and can be added one step at a time:

Advanced features
- matrix to run concurrent models with a custom swap logic DSL
- hooks to run things on startup
- macros reusable snippets
Model customization
- ttl to automatically unload models
- unloadTimeout to tune graceful unloads (manual, API and ttl expiry)
- aliases to use familiar model names (e.g., "gpt-4o-mini")
- env to pass custom environment variables to inference servers
- cmdStop gracefully stop Docker/Podman containers
- useModelName to override model names sent to upstream servers
- ${PORT} automatic port variables for dynamic port assignment
- filters rewrite parts of requests before sending to the upstream server

See the configuration documentation for all options.

How does llama-swap work?

When a request is made to an OpenAI compatible endpoint, llama-swap will extract the model value and load the appropriate server configuration to serve it. If the wrong upstream server is running, it will be replaced with the correct one. This is where the "swap" part comes in. The upstream server is automatically swapped to handle the request correctly.

In the most basic configuration llama-swap handles one model at a time. For more advanced use cases, using a matrix allows multiple models to be loaded at the same time. You have complete control over how your system resources are used.

Reverse Proxy Configuration (nginx)

If you deploy llama-swap behind nginx, disable response buffering for streaming endpoints. By default, nginx buffers responses which breaks Server‑Sent Events (SSE) and streaming chat completion. (#236)

Recommended nginx configuration snippets:

# SSE for UI events/logs
location /api/events {
    proxy_pass http://your-llama-swap-backend;
    proxy_buffering off;
    proxy_cache off;
}

# Streaming chat completions (stream=true)
location /v1/chat/completions {
    proxy_pass http://your-llama-swap-backend;
    proxy_buffering off;
    proxy_cache off;
}

As a safeguard, llama-swap also sets X-Accel-Buffering: no on SSE responses. However, explicitly disabling proxy_buffering at your reverse proxy is still recommended for reliable streaming behavior.

Monitoring Logs on the CLI

# sends up to the last 10KB of logs
$ curl http://host/logs

# streams combined logs
curl -Ns http://host/logs/stream

# stream llama-swap's proxy status logs
curl -Ns http://host/logs/stream/proxy

# stream logs from upstream processes that llama-swap loads
curl -Ns http://host/logs/stream/upstream

# stream logs only from a specific model
curl -Ns http://host/logs/stream/{model_id}

# stream and filter logs with linux pipes
curl -Ns http://host/logs/stream | grep 'eval time'

# appending ?no-history will disable sending buffered history first
curl -Ns 'http://host/logs/stream?no-history'

Do I need to use llama.cpp's server (llama-server)?

Any OpenAI compatible server would work. llama-swap was originally designed for llama-server and it is the best supported.

For Python based inference servers like vllm or tabbyAPI it is recommended to run them via podman or docker. This provides clean environment isolation as well as responding correctly to SIGTERM signals for proper shutdown.

kenn-io/agentsview

Local-first session search, analytics, insights, and token use statistics for coding agents, supporting Claude Code, Codex, and more than 20 other agents.

agentsview

Browse, search, and track costs across all your AI coding agents. One binary, no accounts, everything local.

Install

# macOS / Linux
curl -fsSL https://agentsview.io/install.sh | bash

# Windows
powershell -ExecutionPolicy ByPass -c "irm https://agentsview.io/install.ps1 | iex"

Or download the desktop app (macOS / Windows) from GitHub Releases or via homebrew: brew install --cask agentsview

Or run the published Docker image:

docker run --rm -p 127.0.0.1:8080:8080 \
  -v agentsview-data:/data \
  -v "$HOME/.claude/projects:/agents/claude:ro" \
  -v "$HOME/.forge:/agents/forge:ro" \
  -e CLAUDE_PROJECTS_DIR=/agents/claude \
  -e FORGE_DIR=/agents/forge \
  ghcr.io/kenn-io/agentsview:latest

Quick Start

agentsview serve           # start the server in the foreground
agentsview daemon start    # start the writable SQLite daemon
agentsview daemon status   # show daemon status
agentsview daemon restart  # restart from current configuration
agentsview daemon stop     # stop the writable daemon
agentsview session list    # read from the daemon if warm, otherwise SQLite
agentsview usage daily     # print daily cost summary

On first run, agentsview discovers sessions from every supported agent on your machine, syncs them into a local SQLite database, and serves a web UI at http://127.0.0.1:8080.

For Devin CLI, point DEVIN_DIR or devin_dirs at the local root that contains cli/ — for example ~/Library/Application Support/devin on macOS, ~/.local/share/devin on Linux, or a redacted path like .../Application Support/devin. AgentsView reads session data under <root>/cli/... and intentionally ignores copied config or OAuth paths. Do not paste tokens, OAuth files, or other secrets into bug reports.

Claude and Codex sources can also be configured as s3:// roots, so a central AgentsView instance can read sessions that other machines push to S3-compatible object storage. Add those roots to claude_project_dirs or codex_sessions_dirs; AgentsView lists object metadata and only downloads changed sessions during sync. S3 change detection uses size, modified time, and available object fingerprints such as ETag, version ID, or checksums.

The desktop app and freshness-sensitive CLI commands share a detached local daemon. Read-only CLI commands attach to it when it is already running, but fall back to direct read-only SQLite on a cold archive so one-off scripts stay fast. Commands that need fresh data or need to write, such as sync, usage, token-use, pg push, and duckdb push, auto-start the daemon when needed.

Use agentsview daemon start when you want to start the writable SQLite daemon explicitly. It loads the normal effective configuration from config.toml and supported environment variables; daemon start and daemon restart accept no serve-specific flags. Background daemons self-exit after an idle period unless a client request or daemon-owned job is active.

The existing agentsview serve --background, agentsview serve status, and agentsview serve stop commands remain available. Use serve --background when a one-off daemon needs a serve-only flag, such as --no-sync or an unauthenticated non-loopback --host override.

Remote / forwarded access

agentsview binds to loopback and validates the request Host header to guard against DNS-rebinding attacks. When you reach it through SSH port-forwarding, a reverse proxy, or a remote dev environment (exe.dev, Codespaces, Coder, WSL2), the browser sends a Host that the server does not recognize, so API requests such as /api/v1/settings are rejected with 403 Forbidden.

To fix this, restart the server with --public-url set to the exact origin you open in the browser:

# Browser opens http://127.0.0.1:18080 via `ssh -L 18080:127.0.0.1:8080 host`
agentsview serve --public-url http://127.0.0.1:18080

# Browser opens a forwarded hostname
agentsview serve --public-url https://your-workspace.exe.dev

Use --public-origin (repeatable or comma-separated) to trust additional browser origins. If you expose the UI beyond loopback, also enable --require-auth.

Docker

The container image defaults to local agentsview serve. Set PG_SERVE=1 to switch the startup command to agentsview pg serve instead.

docker-compose.prod.yaml is included as a production example:

docker compose -f docker-compose.prod.yaml up -d

The included compose file persists the agentsview data directory in a named volume and mounts Claude, Codex, Forge, and OpenCode session roots read-only. The container runs as root, so prefer a named volume for /data over a host bind mount; if you do bind-mount, pre-create the directory with the desired ownership to avoid root-owned files in your home directory.

The examples publish the UI on loopback only (127.0.0.1). If you need to expose it beyond localhost, enable --require-auth and publish the port intentionally.

Important: a containerized agentsview instance can only discover agent sessions from directories you explicitly mount into the container. If you do not mount an agent's session directory and point the matching env var at it, that agent will not appear in the UI.

Example PostgreSQL-backed startup:

docker run --rm -p 127.0.0.1:8080:8080 \
  -e PG_SERVE=1 \
  -e AGENTSVIEW_PG_URL='postgres://user:password@postgres.example.com:5432/agentsview?sslmode=require' \
  ghcr.io/kenn-io/agentsview:latest

Example DuckDB mirror startup:

# Populate /data/sessions.duckdb from the mounted SQLite archive.
docker run --rm \
  -v agentsview-data:/data \
  -v "$HOME/.claude/projects:/agents/claude:ro" \
  -e CLAUDE_PROJECTS_DIR=/agents/claude \
  ghcr.io/kenn-io/agentsview:latest duckdb push --full

# Serve the populated mirror read-only.
docker run --rm -p 127.0.0.1:8080:8080 \
  -v agentsview-data:/data \
  ghcr.io/kenn-io/agentsview:latest duckdb serve

Example Quack startup:

# Expose the local DuckDB mirror over Quack from the host/container.
QUACK_TOKEN="$(openssl rand -base64 32)"
docker run --rm -p 127.0.0.1:9494:9494 \
  -v agentsview-data:/data \
  ghcr.io/kenn-io/agentsview:latest \
  duckdb quack serve \
    --bind quack:0.0.0.0:9494 \
    --token "$QUACK_TOKEN" \
    --allow-insecure

# Serve the web UI from a remote Quack endpoint.
# The client url uses the native quack:HOST:PORT form; the Quack extension
# does not accept quack:http:// or quack:https:// urls. A non-loopback host
# needs --allow-insecure.
docker run --rm -p 127.0.0.1:8080:8080 \
  -e AGENTSVIEW_DUCKDB_URL='quack:duckdb.example.com:9494' \
  -e AGENTSVIEW_DUCKDB_TOKEN="$QUACK_TOKEN" \
  ghcr.io/kenn-io/agentsview:latest duckdb serve --allow-insecure

Keep Quack on loopback or behind TLS. Plain HTTP Quack on a non-loopback bind requires --allow-insecure and should only be used behind a trusted tunnel or reverse proxy.

Token Usage and Cost Tracking

agentsview usage is a fast, local replacement for ccusage and similar tools. It tracks token consumption and compute costs across all your coding agents -- not just Claude Code. Because session data is already indexed in SQLite, queries are over 100x faster than tools that re-parse raw session files on every run.

# Daily cost summary (default: last 30 days)
agentsview usage daily

# Per-model breakdown
agentsview usage daily --breakdown

# Filter by agent and date range
agentsview usage daily --agent claude --since 2026-04-01

# One-line summary for shell prompts / status bars
agentsview usage daily --all --json
agentsview usage statusline

Features:

Automatic pricing via LiteLLM rates (with offline fallback)
Authoritative Copilot CLI billing totals when session logs provide them
Prompt-caching-aware cost calculation (cache creation / read tokens)
Per-model breakdown with --breakdown
Date filtering (--since, --until, --all), agent filtering (--agent)
JSON output (--json) for scripting
Timezone-aware date bucketing (--timezone)
Works standalone -- no server required, just run the command

Per-Session Details

agentsview session usage <id> prints per-session token statistics plus a cost estimate for a single session. The output reports the session's total output tokens and peak context tokens, plus a cost estimate (cost) when pricing is available for the session's model(s) (has_cost). Cost is computed from input/output and cache tokens internally, but only the output-token and peak-context totals are reported alongside the cost.

# Print token usage and cost for a specific session
agentsview session usage <id>

# JSON output for scripting
agentsview session usage <id> --format json

The same per-session usage data is available from the REST API:

GET /api/v1/sessions/{id}/usage

The response includes the session_id, agent, project, total_output_tokens, peak_context_tokens, has_token_data, cost, has_cost, models, and unpriced_models fields from the CLI JSON schema. Machine-readable money is always an integer microdollar object, for example {"cost":{"microdollars":2410000}}; CLI tables and labels render that value as ordinary dollars. HTTP responses also include server_running: true. Existing sessions return 200 even when token or cost data is absent; missing sessions return 404.

The deprecated alias agentsview token-use <id> remains available for compatibility and now also reports cost estimates.

Session Stats

agentsview stats emits window-scoped analytics over recorded sessions: totals, archetypes (automation vs. quick/standard/deep/marathon), distributions for session duration, user-message count, peak context, and tools-per-turn, plus cache economics, tool/model/agent mix, and a temporal hourly breakdown. The --format json output follows a versioned v1 schema (schema_version: 1) suitable for downstream consumers.

By default, stats only reads the local SQLite archive. Git-derived outcome metrics are opt-in because they can be slow or brittle on large/missing repos: use --include-git-outcomes for commits/LOC/files changed, and --include-github-outcomes for GitHub PR counts via gh (this also enables git outcomes).

# Human-readable summary over the last 28 days
agentsview stats

# Machine-readable JSON over a fixed date range
agentsview stats --format json --since 2026-04-01 --until 2026-04-15

# Restrict to one agent and inspect the schema
agentsview stats --format json --agent claude | jq '.schema_version'

# Include expensive local git outcome metrics explicitly
agentsview stats --include-git-outcomes

Session Browser

Dashboard	Session viewer

Search	Activity heatmap

Full-text search across all message content (FTS5)
Semantic search (opt-in) -- index session content with any OpenAI-compatible embeddings endpoint and search by meaning with agentsview session search --semantic or --hybrid; every content-search match cites the conversation unit it came from (docs)
Token usage and cost dashboard -- per-session and per-model cost breakdowns, daily spend charts, all in the web UI
Analytics dashboard -- activity heatmaps, tool usage, velocity metrics, project breakdowns
Recent Edits feed -- the files your agents changed most recently across every session, grouped by project and path, each linking to the message that made the change
Data workspace -- inspect project inventory and observed folders, preview reclassification impact, and manage worktree mapping rules
Recall corpus browser -- explore experimental distilled knowledge and jump from entries to their supporting transcript evidence
Live updates via SSE as active sessions receive new messages
Keyboard-first navigation (j/k/[/], Cmd+K search, ? for all shortcuts)
Export sessions as HTML or publish to GitHub Gist

Supported Agents

agentsview discovers sessions from all of these. Aider is opt-in because it has no central session directory; set AIDER_DIR or aider_dirs to enable it. Amp support is deprecated because current Amp releases may store threads server-side and leave only local stubs; agentsview can still parse historical local Amp thread JSON files.

Agent	Session Directory
Aider	`<repo>/.aider.chat.history.md` (per repo; opt in with `AIDER_DIR` or `aider_dirs`)
Amp (deprecated)	`~/.local/share/amp/threads/` (historical local thread JSON only)
Antigravity	`~/.gemini/antigravity/`
Antigravity CLI	`~/.gemini/antigravity-cli/` (see note below)
Claude Code	`~/.claude/projects/`
OpenClaude	`~/.openclaude/projects/`
Claude Cowork	`~/Library/Application Support/Claude/local-agent-mode-sessions/` (macOS)
Codex	`~/.codex/sessions/`
Copilot CLI	`~/.copilot/`
Devin CLI	`~/.local/share/devin/` (Linux), `~/Library/Application Support/devin/` (macOS); point `DEVIN_DIR` / `devin_dirs` at the root that contains `cli/`
Cortex Code	`~/.snowflake/cortex/conversations/`
Cursor	`~/.cursor/projects/`
DeepSeek TUI	`~/.codewhale/sessions/`, `~/.deepseek/sessions/`
DeepSeek Harness	`~/.dsh/sessions/` (or `$DSH_HOME/sessions/`)
Forge	`~/.forge/`
Gemini CLI	`~/.gemini/`
Goose	`~/.local/share/goose/sessions/` (macOS and Linux), `%APPDATA%\\Block\\goose\\data\\sessions\\` (Windows)
gptme	`~/.local/share/gptme/logs/`
Grok	`~/.grok/sessions/`
Hermes Agent	`~/.hermes/sessions/`
iFlow	`~/.iflow/projects/`
Kilo	`~/.local/share/kilo/`
Kilo (legacy)	`~/Library/Application Support/Code/User/globalStorage/kilocode.kilo-code/` (macOS), `~/.config/Code/User/globalStorage/kilocode.kilo-code/` (Linux)
Kimi	`~/.kimi/sessions/`
Kimi Work	`~/Library/Application Support/kimi-desktop/daimon-share/daimon/runtime/kimi-code/home/sessions/` (macOS)
Kiro CLI	`~/.kiro/sessions/cli/`, `~/.local/share/kiro-cli/`
Kiro IDE	`~/Library/Application Support/Kiro/` (macOS)
MiMoCode	`~/.local/share/mimocode/`
Mistral Vibe	`~/.vibe/logs/session/`
OpenClaw	`~/.openclaw/agents/`
OpenCode	`~/.local/share/opencode/`
OpenHands CLI	`~/.openhands/conversations/`
OhMyPi	`~/.omp/agent/sessions/`
Omnigent	`~/.omnigent/chat.db`
Pi	`~/.pi/agent/sessions/`
Prime Agent	`~/.prime/agent/sessions/`
Poolside	`~/Library/Application Support/poolside/trajectories/` (macOS), `~/.local/state/poolside/trajectories/` (Linux), `%APPDATA%\\poolside\\trajectories\\` (Windows)
Piebald	`~/.local/share/piebald/`
Posit Assistant	`~/.posit/assistant/workspaces/`
Positron Assistant	`~/Library/Application Support/Positron/User/` (macOS)
QClaw	`~/.qclaw/agents/`
Qoder	`~/.qoder/projects/`, `~/.qoderwork/projects/`
Qwen Code	`~/.qwen/projects/`
QwenPaw	`~/.copaw/workspaces/`, `~/.qwenpaw/workspaces/`
Reasonix	`~/.reasonix/`, `%APPDATA%\\reasonix\\` (Windows)
RooCode	`~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/` (macOS), `~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/` (Linux), `%APPDATA%\\Code\\User\\globalStorage\\rooveterinaryinc.roo-cline\\` (Windows)
VSCode Copilot	`~/Library/Application Support/Code/User/` (macOS)
Visual Studio Copilot	`%LOCALAPPDATA%\\Temp\\VSGitHubCopilotLogs\\traces\\` (Windows), `~/Library/Caches/VSGitHubCopilotLogs/traces/` (macOS), `~/.cache/VSGitHubCopilotLogs/traces/` (Linux)
Windsurf	`~/Library/Application Support/Windsurf/User/` (macOS), `~/.config/Windsurf/User/` (Linux), `%APPDATA%\\Windsurf\\User\\` (Windows)
Trae	`%APPDATA%\\Trae\\User\\` (Windows), `~/Library/Application Support/Trae/User/` (macOS), `~/.config/Trae/User/` (Linux)
TraeX (TRAE CLI)	`~/.trae/cli/sessions/`, `~/.trae/cli/archived_sessions/`
Warp	`~/.warp/` (platform-dependent)
WorkBuddy	`~/.workbuddy/projects/`
ZCode	`~/.zcode/cli/db/`, `~/.zcode/cli/`
Zed	`~/Library/Application Support/Zed/` (macOS)
Zencoder	`~/.zencoder/sessions/`

Grok sessions are read from summary.json (title, timestamps, project), optional signals.json (token counters), and chat_history.jsonl when present for the full transcript (user turns, assistant replies, thinking, and tool calls). If chat_history.jsonl is missing, AgentsView falls back to summary-only mode. Set GROK_DIR or grok_dirs to override the default directory.

Goose sessions are read from its shared SQLite sessions.db, including transcript content, thinking, tool calls and results, session relationships, models, token usage, and recorded costs. Set GOOSE_PATH_ROOT to a Goose path root (sessions are read from <root>/data/sessions/), or goose_dirs to one or more data or sessions directories.

Each directory can be overridden with an environment variable. See the configuration docs for details. Cursor attribution stats are a live, machine-local read from ~/.cursor/ai-tracking/ai-code-tracking.db by default and can be redirected with AGENTSVIEW_CURSOR_ATTRIBUTION_DB; they are not synced or aggregated through PostgreSQL.

Aider: per-repo Markdown logs

Aider has no central session store; it writes one .aider.chat.history.md Markdown log per repository, and one log accumulates many runs (one per aider launch, delimited by # aider chat started at ... headers). agentsview indexes each run as its own session.

AgentsView does not scan for Aider logs by default. Earlier builds attempted an always-on bounded scan of the home directory, but that was not trustworthy: desktop launches and background usage refreshes could still trigger macOS privacy prompts for protected folders. To enable Aider, point AIDER_DIR (or the aider_dirs config key) at a code root you explicitly want scanned. The scan descends at most four levels below each configured root, skips vendor/build/VCS directories by name (node_modules, target, .git, Library, go, .cargo, and similar), and stops after a two-second wall-clock budget. On macOS, broad home roots still skip protected top-level folders unless one of those folders is configured directly. The live file watcher only watches configured Aider roots shallowly; new repos are picked up by the periodic sync, which runs every 15 minutes.

Because the format is Markdown-derived, roles are reconstructed from line prefixes and there are no per-message timestamps; a run's start time comes from its # aider chat started at ... header (written in local time, assumed UTC).

JetBrains Copilot via exporter

JetBrains IDEs store Copilot chat in a Nitrite database that agentsview does not read directly. The supported path today is to export those sessions to Copilot JSONL with copilot-jetbrains-exporter, then point agentsview at that output directory.

# Export JetBrains Copilot sessions to JSONL
copilot-jetbrains-exporter --output ~/.copilot/jetbrains-sessions

# Tell agentsview to index the exported sessions
export COPILOT_DIR=~/.copilot/jetbrains-sessions

Or in ~/.agentsview/config.toml:

copilot_dirs = ["~/.copilot/jetbrains-sessions"]

Re-run the exporter after new JetBrains Copilot sessions if you want agentsview to pick up fresh conversations from that source.

Antigravity CLI: high-resolution transcripts

Antigravity CLI sessions appear in two on-disk formats: newer releases store conversation trajectories as SQLite .db files, older releases used AES-GCM-encrypted .pb files. For either format, the full transcript -- structured tool calls, results, reasoning, and diffs -- comes from a <uuid>.trajectory.json sidecar. Without a covering sidecar, agentsview falls back to summary mode: a heuristic decode of the raw .db steps (prompts and tool-call names only), or for .pb sessions your prompts from history.jsonl plus any plain-text artifacts under brain/ (plans, walkthroughs, checkpoints). Summary-mode sessions show a "Summary mode" badge in the detail header that links here.

To unlock full transcripts for .db and .pb sessions alike, run agy-reader alongside agentsview. agy-reader talks to the local Antigravity daemon, decrypts each conversation, and writes a <uuid>.trajectory.json sidecar next to the source file. agentsview's file watcher detects the sidecar automatically and parses it in place of summary mode -- no agentsview restart needed.

go install github.com/mjacobs/agy-reader@latest

# Generate sidecars for existing sessions...
agy-reader --sync

# ...or keep them fresh as you work.
agy-reader --watch

agy-reader auto-discovers the Antigravity daemon URL by parsing ~/.gemini/antigravity-cli/cli.log. If discovery fails (e.g. the log has rotated), the command prints platform-specific instructions for locating the port and exporting ANTIGRAVITY_DAEMON_URL manually.

Sidecars stay on your machine. agentsview makes no outbound request to produce or read them, and treats sidecars as untrusted structured input -- see SECURITY.md for the trust model.

Kilo vs Kilo (legacy).

Kilo is the OpenCode-based CLI/editor core (~/.local/share/kilo/kilo.db); it covers both the Kilo CLI and the rebuilt Kilo Code VS Code extension (after March 2026), which shares that same database. Kilo (legacy) is the legacy RooCode-derived VS Code extension that wrote per-task JSON under kilocode.kilo-code/tasks/.

Filesystem Session Sync

One primary AgentsView instance can ingest native agent session directories copied or mounted from other machines without PostgreSQL:

[[session_sources]]
agent = "copilot"
dir = "/srv/session-archive/buildbox/copilot"
machine = "buildbox"

Structured sources are additive to existing copilot_dirs, claude_project_dirs, and other per-agent settings. They label sessions by source machine without namespacing native session IDs. Transport source session files only -- never copy sessions.db or its WAL files. Machine labels are captured at first ingestion; ordinary sync and agentsview sync --full preserve the stored label. Changing attribution for existing sessions is not currently supported.

See the Filesystem Session Sync guide for Git, rsync, shared-mount, freshness, and operational guidance.

PostgreSQL Sync

Push session data to a shared PostgreSQL instance for team dashboards:

agentsview pg push             # push local data to the default PG target
agentsview pg push archive     # push to one named PG target
agentsview pg push --all       # push every configured PG target sequentially
agentsview pg status           # show status for the default PG target
agentsview pg status archive   # show status for one named PG target
agentsview pg status --all     # show status for every configured PG target
agentsview pg serve            # serve web UI from the default PG target (read-only)

Single-target configs still use the legacy [pg] block. To manage more than one PostgreSQL destination, define named [pg.NAME] blocks and set default_pg when more than one target exists:

default_pg = "work"

[pg.work]
url = "postgres://user:pass@work-db/agentsview"
machine_name = "laptop"

[pg.archive]
url = "postgres://user:pass@archive-db/agentsview"
machine_name = "laptop-archive"
exclude_projects = ["scratch"]

Named target names are normalized case-insensitively. all, local, and the legacy [pg] field names url, schema, machine_name, allow_insecure, projects, and exclude_projects cannot be used for [pg.NAME].

AGENTSVIEW_PG_URL, AGENTSVIEW_PG_SCHEMA, and AGENTSVIEW_PG_MACHINE still work, but in named-target mode they apply only to the effective default target. They do not rewrite every named [pg.NAME] entry.

Automatic push (background service)

To keep a shared PostgreSQL database current without running pg push by hand, run the auto-push daemon. It watches your session directories and pushes shortly after new sessions are recorded, with a periodic floor as a safety net:

agentsview pg push --watch                 # foreground, Ctrl-C to stop
agentsview pg push archive --watch         # watch one named PG target
agentsview pg push --watch --debounce 1m   # custom coalesce window
agentsview pg push --watch --interval 5m   # custom floor interval

--watch follows the default PG target unless you pass one target name. --all --watch is rejected; multi-target background watch remains out of scope for now.

The daemon reads the same [pg] config as pg push, so the PostgreSQL DSN must be set in your config file (or an environment variable it expands). Protect the config file, since it holds credentials:

chmod 600 ~/.agentsview/config.toml

To run it unattended as an OS service (launchd on macOS, systemd --user on Linux):

agentsview pg service install     # generate the unit, enable + start it
agentsview pg service status      # show manager status
agentsview pg service logs -f     # follow the service log
agentsview pg service uninstall   # stop and remove

pg serve and pg service always use the effective default PG target. In named-target mode, set default_pg to choose which target those long-running commands use.

Linux headless machines: systemd --user services stop at logout and do not start at boot unless lingering is enabled for your user. install detects this and prints the command; you can also run it yourself:

loginctl enable-linger "$USER"

See PostgreSQL docs for setup and configuration.

DuckDB Mirror and Quack

DuckDB support is a mirror backend, not a replacement for the local SQLite archive. agentsview serve still performs primary ingestion into SQLite. Use DuckDB when you want a portable analytics file, read-only local serving from a mirror, or remote read access through DuckDB's Quack protocol.

agentsview duckdb push          # mirror SQLite into DuckDB
agentsview duckdb status        # show mirror sync status
agentsview duckdb serve         # serve web UI from DuckDB (read-only)
agentsview duckdb quack serve   # expose the local DuckDB file over Quack

agentsview duckdb serve reads [duckdb].path or AGENTSVIEW_DUCKDB_PATH. To serve from a remote Quack endpoint, set AGENTSVIEW_DUCKDB_URL and AGENTSVIEW_DUCKDB_TOKEN instead. Quack is still a new DuckDB protocol, so agentsview keeps conservative defaults: local Quack serving binds to loopback, requires a token, and rejects non-loopback plain HTTP unless --allow-insecure is explicit. For remote use, prefer a TLS URL or put Quack behind an authenticated tunnel/proxy.

Backend modes:

SQLite: primary local archive, file sync, FTS5 search, and writable UI.
PostgreSQL: optional shared team backend; push from SQLite, serve read-only.
DuckDB: optional mirror file or Quack endpoint; push from SQLite, serve read-only.

Troubleshooting:

If duckdb push fails to open the mirror, confirm the binary was built with the DuckDB Go driver for your platform and that AGENTSVIEW_DUCKDB_PATH points to a writable file location.
If Quack commands fail with extension errors, update the agentsview binary so the embedded DuckDB runtime includes the Quack extension.
If a remote attach fails, check the token, the quack: URL, TLS/proxy termination, and whether the server was intentionally started with --allow-insecure for plain non-loopback binds.
DuckDB search currently uses substring/regex fallback behavior. SQLite FTS5 remains the indexed search path for primary local serving.

Privacy

agentsview sends a limited anonymous daemon_active telemetry ping to PostHog when the server starts and every 24 hours while it runs, using a stable random install ID as the event DistinctId. The event includes application=agentsview, app version, commit, OS, and CPU architecture, with $process_person_profile=false and $geoip_disable=true. It does not include session, project, prompt, file path, account, or machine identity. Disable telemetry with AGENTSVIEW_TELEMETRY_ENABLED=0 or TELEMETRY_ENABLED=0. Telemetry is also hard-disabled in Go test binaries, regardless of environment.

All session data stays on your machine. The server binds to 127.0.0.1 by default. The update check is optional and can be disabled with --no-update-check.

Documentation

Full docs at agentsview.io: Quick Start -- Usage Guide -- CLI Reference -- Configuration -- Filesystem Sync -- Architecture

Development

Requires Go 1.26+ (CGO), Node.js 22+.

make dev            # Go server (dev mode)
make frontend-dev   # Vite+ dev server (run alongside make dev)
make build          # build binary with embedded frontend
make install        # install to ~/.local/bin

make test           # Go tests (CGO_ENABLED=1 -tags "fts5")
make bench-backends # compare SQLite, DuckDB, and PostgreSQL store reads
make lint           # golangci-lint + NilAway
make nilaway        # NilAway through custom golangci-lint
make e2e            # Playwright E2E tests

make bench-backends requires Docker. It starts a PostgreSQL container with testcontainers, mirrors the same SQLite fixture into DuckDB and PostgreSQL, and benchmarks the shared db.Store read queries for relative comparison. The default fixture is 1,000 sessions and 64,000 messages; use BENCH_BACKENDS_SESSIONS and BENCH_BACKENDS_MESSAGES_PER_SESSION to scale it. When the Docker CLI uses a non-default socket, export DOCKER_HOST for that socket before running the benchmark.

Pre-commit and pre-push hooks via prek: run make lint-tools and make install-hooks after cloning (requires prek and uv).

Project Layout

cmd/agentsview/     CLI entrypoint
internal/           Go packages (config, db, parser, server, sync, postgres)
frontend/           Svelte 5 SPA (Vite+, TypeScript)
desktop/            Tauri desktop wrapper

Acknowledgements

Inspired by claude-history-tool by Andy Fischer and claude-code-transcripts by Simon Willison.

License

MIT

harness/harness

Harness Open Source is an end-to-end developer platform with Source Control Management, CI/CD Pipelines, Hosted Developer Environments, and Artifact Registries.

Harness

Harness Open Source is an open source development platform packed with the power of code hosting, automated DevOps pipelines, hosted development environments (Gitspaces), and artifact registries.

Overview

Harness Open source is an open source development platform packed with the power of code hosting, automated DevOps pipelines, Gitspaces, and artifact registries.

Running Harness locally

The latest publicly released docker image can be found on harness/harness.

To install Harness yourself, simply run the command below. Once the container is up, you can visit http://localhost:3000 in your browser.

docker run -d \
  -p 3000:3000 \
  -p 3022:3022 \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /tmp/harness:/data \
  --name harness \
  --restart always \
  harness/harness

The Harness image uses a volume to store the database and repositories. It is highly recommended to use a bind mount or named volume as otherwise all data will be lost once the container is stopped.

See developer.harness.io to learn how to get the most out of Harness.

Where is Drone?

Harness Open Source represents a massive investment in the next generation of Drone. Where Drone focused solely on continuous integration, Harness adds source code hosting, developer environments (gitspaces), and artifact registries; providing teams with an end-to-end, open source DevOps platform.

The goal is for Harness to eventually be at full parity with Drone in terms of pipeline capabilities, allowing users to seamlessly migrate from Drone to Harness.

But, we expect this to take some time, which is why we took a snapshot of Drone as a feature branch drone (README) so it can continue development.

As for Harness, the development is taking place on the main branch.

For more information on Harness, please visit developer.harness.io.

For more information on Drone, please visit drone.io.

Harness Open Source Development

Pre-Requisites

Install the latest stable version of Node and Go version 1.20 or higher, and then install the below Go programs. Ensure the GOPATH bin directory is added to your PATH.

Install protobuf

Check if you've already installed protobuf protoc --version
If your version is different than v3.21.11, run brew unlink protobuf
Get v3.21.11 curl -s https://raw.githubusercontent.com/Homebrew/homebrew-core/9de8de7a533609ebfded833480c1f7c05a3448cb/Formula/protobuf.rb > /tmp/protobuf.rb
Install it brew install /tmp/protobuf.rb
Check out your version protoc --version

Install protoc-gen-go and protoc-gen-go-rpc:

Install protoc-gen-go v1.28.1 go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28.1 (Note that this will install a binary in $GOBIN so make sure $GOBIN is in your $PATH)
Install protoc-gen-go-grpc v1.2.0 go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2.0

$ make dep
$ make tools

Build

First step is to build the user interface artifacts:

$ pushd web
$ yarn install
$ yarn build
$ popd

After that, you can build the Harness binary:

$ make build

Run

This project supports all operating systems and architectures supported by Go. This means you can build and run the system on your machine; docker containers are not required for local development and testing.

To start the server at localhost:3000, simply run the following command:

./gitness server .local.env

Docker Configuration for Pipelines

Harness pipelines run inside Docker containers. The application automatically negotiates the Docker API version with your Docker daemon, so it works with various Docker versions including Docker Desktop, Rancher Desktop, Colima, and native Docker on Linux.

Docker Socket Location

By default, Harness expects the Docker socket at /var/run/docker.sock. If you're using an alternative Docker runtime, you may need to configure the socket location:

Runtime	Socket Location	Configuration
Docker Desktop	`/var/run/docker.sock`	Works by default
Rancher Desktop	`~/.rd/docker.sock`	Create symlink or set `GITNESS_DOCKER_HOST`
Colima	`~/.colima/default/docker.sock`	Create symlink or set `GITNESS_DOCKER_HOST`
Linux (native)	`/var/run/docker.sock`	Works by default

Option 1: Create a symlink (recommended)

# For Rancher Desktop
sudo ln -sf ~/.rd/docker.sock /var/run/docker.sock

# For Colima
sudo ln -sf ~/.colima/default/docker.sock /var/run/docker.sock

Option 2: Set environment variable

Add to your .local.env:

# For Rancher Desktop
GITNESS_DOCKER_HOST=unix:///Users/<username>/.rd/docker.sock

# For Colima
GITNESS_DOCKER_HOST=unix:///Users/<username>/.colima/default/docker.sock

Pinning Docker API Version

The application automatically negotiates the API version with your Docker daemon. If you need to pin a specific version (e.g., for compatibility testing), you can set:

GITNESS_DOCKER_API_VERSION=1.45

Auto-Generate Harness API Client used by UI using Swagger

Please make sure to update the autogenerated client code used by the UI when adding new rest APIs.

To regenerate the code, please execute the following steps:

Regenerate swagger with latest Harness binary ./gitness swagger > web/src/services/code/swagger.yaml
navigate to the web folder and run yarn services

The latest API changes should now be reflected in web/src/services/code/index.tsx

Run Registry Conformance Tests

make conformance-test

For running conformance tests with existing running service, use:

make hot-conformance-test

User Interface

This project includes a full user interface for interacting with the system. When you run the application, you can access the user interface by navigating to http://localhost:3000 in your browser.

REST API

This project includes a swagger specification. When you run the application, you can access the swagger specification by navigating to http://localhost:3000/swagger in your browser (for raw yaml see http://localhost:3000/openapi.yaml). For registry endpoints, currently swagger is located on different endpoint http://localhost:3000/registry/swagger/ (for raw json see http://localhost:3000/registry/swagger.json). These will be later moved to the main swagger endpoint.

For testing, it's simplest to just use the cli to create a token (this requires Harness server to run):

# LOGIN (user: admin, pw: changeit)
$ ./gitness login

# GENERATE PAT (1 YEAR VALIDITY)
$ ./gitness user pat "my-pat-uid" 2592000

The command outputs a valid PAT that has been granted full access as the user. The token can then be send as part of the Authorization header with Postman or curl:

$ curl http://localhost:3000/api/v1/user \
-H "Authorization: Bearer $TOKEN"

CLI

This project includes VERY basic command line tools for development and running the service. Please remember that you must start the server before you can execute commands.

For a full list of supported operations, please see

$ ./gitness --help

Contributing

Refer to CONTRIBUTING.md

License

Apache License 2.0, see LICENSE.

knadh/listmonk

High performance, self-hosted, newsletter and mailing list manager with a modern dashboard. Single binary app.

listmonk is a standalone, self-hosted, newsletter and mailing list manager. It is fast, feature-rich, and packed into a single binary. It uses a PostgreSQL database as its data store.

Visit listmonk.app for more info. Check out the live demo.

Installation

Docker

The latest image is available on DockerHub at listmonk/listmonk:latest. Download and use the sample docker-compose.yml.

# Download the compose file to the current directory.
curl -LO https://github.com/knadh/listmonk/raw/master/docker-compose.yml

# Run the services in the background.
docker compose up -d

Visit http://localhost:9000

See installation docs

Binary

Download the latest release and extract the listmonk binary.
./listmonk --new-config to generate config.toml. Edit it.
./listmonk --install to setup the Postgres DB (or --upgrade to upgrade an existing DB. Upgrades are idempotent and running them multiple times have no side effects).
Run ./listmonk and visit http://localhost:9000

See installation docs

Developers

listmonk is free and open source software licensed under AGPLv3. If you are interested in contributing, refer to the developer setup. The backend is written in Go and the frontend is Vue with Buefy for UI.

License

listmonk is licensed under the AGPL v3 license.

ViRb3/wgcf

🚤 Cross-platform, unofficial CLI for Cloudflare Warp

wgcf

wgcf is an unofficial, cross-platform CLI for Cloudflare Warp

Features

Register new account
Change license key to use existing Warp+ subscription
Generate WireGuard profile
Check account status
Print trace information to debug Warp/Warp+ status

Download

You can find pre-compiled binaries on the releases page.

Usage

Run wgcf in a terminal without any arguments to display the help screen. All commands and parameters are documented.

Register new account

Run the following command in a terminal:

wgcf register

The new account will be saved under wgcf-account.toml

Generate WireGuard profile

Run the following command in a terminal:

wgcf generate

The WireGuard profile will be saved under wgcf-profile.conf. For more information on how to use it, please check the official WireGuard Quick Start.

Maximum transmission unit (MTU)

To ensure maximum compatibility, the generated profile will have a MTU of 1280, just like the official Android app. If you are experiencing performance issues, you may be able to improve your speed by increasing this value. For more information, please check #40.

Add a license key

If you have an existing Warp+ subscription, for example on your phone, you can bind the account generated by this tool to your phone's account, sharing its Warp+ status. Please note that there is a limit of 5 maximum devices linked at a time. You can remove linked devices from the 1.1.1.1 app on your phone.

Caution

Only subscriptions purchased directly from the official 1.1.1.1 app are supported. Keys obtained by any other means, including referrals, will not work and will not be supported.

First, get your Warp+ account license key. To view it on Android:

Open the 1.1.1.1 app
Click on the hamburger menu button in the top-right corner
Navigate to: Account > Key

Now, back to wgcf.

Warning

There's a bug on Cloudflare's side that prevents existing accounts from getting Warp+ even after you bind a correct license key. If you have ever connected to Warp VPN, then your account is affected. You will need to make a new account via:

wgcf register

Then immediately proceed with the steps below, without running any other commands. For more details, check !85

Run the following commands:

wgcf update --license-key "YOUR_LICENSE_KEY_GOES_HERE"
wgcf generate

Check device status

Run the following command in a terminal:

wgcf status

Verify Warp/Warp+ works

Connect to the WireGuard profile generated by this tool, then run:

wgcf trace

If you look at the last line, it should say warp=on or warp=plus, depending on whether you have Warp or Warp+ respectively.

Warning

If you're seeing warp=on even after you bound a Warp+ license key, you are likely experiencing a known bug, please refer to the Add a license key section.

Development

The API client code is auto-generated from the OpenAPI spec openapi-spec.yml and stored under the openapi/ package. Do not touch any code under that package, instead, change the spec file and regenerate the API client code. To do this, install openapi-generator, then run:

go generate

Notice of Non-Affiliation and Disclaimer

We are not affiliated, associated, authorized, endorsed by, or in any way officially connected with Cloudflare, or any of its subsidiaries or its affiliates. The official Cloudflare website can be found at https://www.cloudflare.com/.

The names Cloudflare Warp and Cloudflare as well as related names, marks, emblems and images are registered trademarks of their respective owners.

XTLS/Xray-core

Xray, Penetrates Everything. Also the best v2ray-core. Where the magic happens. An open platform for various uses.

Project X

Project X originates from XTLS protocol, providing a set of network tools such as Xray-core and REALITY.

README is open, so feel free to submit your project here.

Donation & NFTs

Collect a Project X NFT to support the development of Project X!

TRX(Tron)/USDT/USDC: TNrDh5VSfwd4RPrwsohr6poyNTfFefNYan
TON: UQApeV-u2gm43aC1uP76xAC1m6vCylstaN1gpfBmre_5IyTH
BTC: 1JpqcziZZuqv3QQJhZGNGBVdCBrGgkL6cT
XMR: 4ABHQZ3yJZkBnLoqiKvb3f8eqUnX4iMPb6wdant5ZLGQELctcerceSGEfJnoCk6nnyRZm73wrwSgvZ2WmjYLng6R7sR67nq
SOL/USDT/USDC: 3x5NuXHzB5APG6vRinPZcsUv5ukWUY1tBGRSJiEJWtZa
ETH/USDT/USDC: 0xDc3Fe44F0f25D13CACb1C4896CD0D321df3146Ee
Project X NFT: https://opensea.io/item/ethereum/0x5ee362866001613093361eb8569d59c4141b76d1/1
VLESS NFT: https://opensea.io/collection/vless
REALITY NFT: https://opensea.io/item/ethereum/0x5ee362866001613093361eb8569d59c4141b76d1/2
Related links: VLESS Post-Quantum Encryption, XHTTP: Beyond REALITY, Announcement of NFTs by Project X

License

Mozilla Public License Version 2.0

Documentation

Project X Official Website

Project X

Project X Channel

Project VLESS (Русский)

Project XHTTP (Persian)

Installation

Linux Script
- XTLS/Xray-install (Official)
- tempest (supports systemd and OpenRC; Linux-only)
Docker
- ghcr.io/xtls/xray-core (Official)
- teddysun/xray
- wulabing/xray_docker
Web Panel
- Remnawave
- 3X-UI
- PasarGuard
- Xray-UI
- X-Panel
- Marzban
- Hiddify
- TX-UI
- CELERITY
One Click
Magisk
- Magic_V2Ray
- Xray_For_Magisk
Homebrew
- brew install xray

Usage

GUI Clients

OpenWrt
Asuswrt-Merlin
- XRAYUI
- fancyss
Windows
Android
- v2rayNG
- X-flutter
- SaeedDev94/Xray
- SimpleXray
- XrayFA
- AnyPortal
- OneXray
- AsteriskNG
iOS & macOS arm64 & tvOS
- Happ | Happ RU | Happ tvOS
- Streisand
- OneXray
- INCY
macOS arm64 & x64
- Happ | Happ RU
- V2rayU
- V2RayXS
- Furious
- OneXray
- GoXRay
- AnyPortal
- v2rayN
- GenyConnect
- INCY
Linux
- v2rayA
- Furious
- GorzRay
- GoXRay
- AnyPortal
- v2rayN
- GenyConnect
- OneXray
HarmonyOS
- Hey

Others that support VLESS, XTLS, REALITY, XUDP, PLUX...

iOS & macOS arm64 & tvOS
- Anywhere
- Shadowrocket
- Loon
- Egern
- Quantumult X
Xray Tools
- xray-knife
- xray-checker
Xray Wrapper
XrayR
- XrayR-release
- XrayR-V2Board
Cores

Contributing

Code of Conduct

Credits

Xray-core v1.0.0 was forked from v2fly-core 9a03cc5, and we have made & accumulated a huge number of enhancements over time, check the release notes for each version.
For third-party projects used in Xray-core, check your local or the latest go.mod.

Bundled Third-Party Components Redistribution

Certain optional features dynamically load third-party components. These optional components are separate works distributed under their own licenses, and are bundled into the ZIP package for ease of use. Users may replace these components under the licenses from these components.

These components include:

Wintun

This distribution contains unmodified official precompiled and pre-signed Wintun binaries.

Project: Wintun
Copyright: Copyright (C) 2018-2021 WireGuard LLC. All Rights Reserved.
Redistribution License: Prebuilt Binaries License (PBL) bundled with official precompiled and pre-signed binaries from wintun.net
Component(s): wintun.dll
Source: https://www.wintun.net/
Included in:
- Windows x86 (windows-32, win7-32)
- Windows x86-64 (windows-64, win7-64)
- Windows AArch64 (windows-arm64)
Notes: Wintun is an optional runtime-loaded component only used for TUN inbound functionality on supported Windows platforms.

One-line Compilation

Windows (PowerShell)

$env:CGO_ENABLED=0
go build -o xray.exe -trimpath -buildvcs=false -ldflags="-s -w -buildid=" -v ./main

Linux / macOS

CGO_ENABLED=0 go build -o xray -trimpath -buildvcs=false -ldflags="-s -w -buildid=" -v ./main

Reproducible Releases

Make sure that you are using the same Go version, and remember to set the git commit id (7 bytes):

CGO_ENABLED=0 go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid=" -v ./main

For Android:

GOOS=android GOARCH=arm64 CGO_ENABLED=1 CC=/path/to/aarch64-linux-android24-clang go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid= -checklinkname=0" -v ./main
GOOS=android GOARCH=amd64 CGO_ENABLED=1 CC=/path/to/x86_64-linux-android24-clang go build -o xray -trimpath -buildvcs=false -gcflags="all=-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid= -checklinkname=0" -v ./main

If you are compiling a 32-bit MIPS/MIPSLE target, use this command instead:

CGO_ENABLED=0 go build -o xray -trimpath -buildvcs=false -gcflags="-l=4" -ldflags="-X github.com/xtls/xray-core/core.build=REPLACE -s -w -buildid=" -v ./main

Stargazers over time

mudler/LocalAI

LocalAI is the open-source AI engine. Run any model - LLMs, vision, voice, image, video - on any hardware. No GPU required.

LocalAI is the open-source AI engine. Run any model - LLMs, vision, voice, image, video - on any hardware. No GPU required.

A small core, not a bundle. Each backend wraps a best-in-class engine (llama.cpp, vLLM, whisper.cpp, stable-diffusion, MLX...) in its own image, pulled only when a model needs it. You install nothing you don't use.

Composable by design: backends are separate and pulled on demand, so you install only what your model needs
Open and extensible: load any model, or build your own backend in any language against an open interface
Drop-in API compatibility: OpenAI, Anthropic, and ElevenLabs APIs across every backend
Any model, any modality: LLMs, vision, voice, image, and video behind one API
Any hardware: NVIDIA, AMD, Intel, Apple Silicon, Vulkan, or CPU-only
Multi-user ready: API key auth, user quotas, role-based access
Built-in AI agents: autonomous agents with tool use, RAG, MCP, and skills
Privacy-first: your data never leaves your infrastructure

Created by Ettore Di Giacinto and maintained by the LocalAI team.

📖 Documentation | 💬 Discord | 💻 Quickstart | 🖼️ Models | ❓FAQ

Guided tour

https://github.com/user-attachments/assets/08cbb692-57da-48f7-963d-2e7b43883c18

Click to see more!

Quickstart

macOS

Note: The DMG is not signed by Apple. After installing, run: sudo xattr -d com.apple.quarantine /Applications/LocalAI.app. See #6268 for details.

Containers (Docker, podman, ...)

Already ran LocalAI before? Use docker start -i local-ai to restart an existing container.

CPU only:

docker run -ti --name local-ai -p 8080:8080 localai/localai:latest

NVIDIA GPU:

# CUDA 13
docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-13

# CUDA 12
docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-gpu-nvidia-cuda-12

# NVIDIA Jetson ARM64 (CUDA 12, for AGX Orin and similar)
docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-nvidia-l4t-arm64

# NVIDIA Jetson ARM64 (CUDA 13, for DGX Spark)
docker run -ti --name local-ai -p 8080:8080 --gpus all localai/localai:latest-nvidia-l4t-arm64-cuda-13

AMD GPU (ROCm):

docker run -ti --name local-ai -p 8080:8080 --device=/dev/kfd --device=/dev/dri --group-add=video localai/localai:latest-gpu-hipblas

Intel GPU (oneAPI):

docker run -ti --name local-ai -p 8080:8080 --device=/dev/dri/card1 --device=/dev/dri/renderD128 localai/localai:latest-gpu-intel

Vulkan GPU:

docker run -ti --name local-ai -p 8080:8080 localai/localai:latest-gpu-vulkan

Loading models

# From the model gallery (see available models with `local-ai models list` or at https://models.localai.io)
local-ai run llama-3.2-1b-instruct:q4_k_m
# From Huggingface
local-ai run huggingface://TheBloke/phi-2-GGUF/phi-2.Q8_0.gguf
# From the Ollama OCI registry
local-ai run ollama://gemma:2b
# From a YAML config
local-ai run https://gist.githubusercontent.com/.../phi-2.yaml
# From a standard OCI registry (e.g., Docker Hub)
local-ai run oci://localai/phi-2:latest

To work with a running LocalAI server from the terminal, start the built-in agent from another shell. It answers questions, reads your files and runs commands on your machine, asking you to approve anything that changes state. Inside a session, /models lists installed models and /model <name> switches between them. See the Terminal agent docs.

# Terminal 1
local-ai run llama-3.2-1b-instruct:q4_k_m

# Terminal 2
local-ai chat --model llama-3.2-1b-instruct:q4_k_m

Automatic Backend Detection: LocalAI automatically detects your GPU capabilities and downloads the appropriate backend. For advanced options, see GPU Acceleration.

For more details, see the Getting Started guide.

Latest News

June 2026: New native biometric backends from the LocalAI team: voice-detect.cpp for speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion) and face-detect.cpp for face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace). Both are from-scratch C++/ggml engines with no Python or onnxruntime at inference, self-contained GGUF weights, bit-exact parity with the reference, and GPU cuDNN parity, replacing the heavier Python insightface and speaker-recognition backends (PR #10441).
June 2026: New realtime voice assistant demo (a tiny Go client for the Realtime API with a full talk-back voice loop and tool calling), plus streaming of the realtime LLM / TTS / transcription pipeline stages and configurable WebRTC ICE candidates.
June 2026: Big speech push: the parakeet.cpp ASR engine gains NeMo-faithful segment timestamps, a multilingual streaming Nemotron-3.5 model, dynamic batching for concurrent transcription and CUDA graphs; the new CrispASR backend adds multi-architecture ASR + TTS, and 60 Piper TTS voices across 42 languages land in the gallery (plus per-request TTS instructions and params).
June 2026: New backends and models: locate-anything.cpp for open-vocabulary object detection via ggml, Ideogram4 image generation in stablediffusion-ggml, llama.cpp video input, and the Gemma 4 QAT family with MTP speculative-decoding pairs. Plus an interactive CLI chat mode and RAG source citations in agent responses.
June 2026: Distributed mode hardening: prefix-cache-aware routing, a production-ready request router with auto-sized embedding/rerank batches, ds4 layer-split distributed inference, NATS JWT auth + TLS/mTLS, and resumable file uploads.
May 2026: LocalAI 4.3.0 - llama.cpp prompt cache on by default (repeated system prompts collapse from minutes to seconds), keyless cosign signing of backend OCI images, per-API-key + per-user usage attribution, Distributed v3 with per-request replica routing. Release notes
May 2026: LocalAI 4.2.0 - LocalAI sees and hears: voice recognition, face recognition + antispoofing liveness, speaker diarization. Plus drop-in Ollama API, video generation, redesigned UI with i18n + admin-configurable branding, vLLM at feature parity with llama.cpp, and 11 new backends. Release notes
April 2026: LocalAI 4.1.0 - LocalAI becomes a control tower: distributed cluster mode with VRAM-aware smart routing + autoscaling, multi-user platform with OIDC and API keys, per-user quotas with predictive analytics, in-UI fine-tuning with TRL (auto-export to GGUF), on-the-fly quantization backend, visual pipeline editor. Release notes
March 2026: LocalAI 4.0.0 - native agentic orchestration with the new Agenthub community hub, full React UI rewrite with Canvas mode, MCP Apps + client-side with tool streaming, WebRTC realtime audio, MLX-distributed. Release notes
February 2026: Realtime API for audio-to-audio with tool calling, ACE-Step 1.5 support
January 2026: LocalAI 3.10.0 — Anthropic API support, Open Responses API, video & image generation (LTX-2), unified GPU backends, tool streaming, Moonshine, Pocket-TTS. Release notes
December 2025: Dynamic Memory Resource reclaimer, Automatic multi-GPU model fitting (llama.cpp), Vibevoice backend
November 2025: Import models via URL, Multiple chats and history
October 2025: Model Context Protocol (MCP) support for agentic capabilities
September 2025: New Launcher for macOS and Linux, extended backend support for Mac and Nvidia L4T, MLX-Audio, WAN 2.2
August 2025: MLX, MLX-VLM, Diffusers, llama.cpp now supported on Apple Silicon
July 2025: All backends migrated outside the main binary — lightweight, modular architecture

For older news and full release notes, see GitHub Releases and the blog.

Features

Text generation (llama.cpp, transformers, vllm ... and more)
Text to Audio
Audio to Text
Image generation
OpenAI-compatible tools API
Realtime API (Speech-to-speech)
Embeddings generation
Constrained grammars
Download models from Huggingface
Vision API
Object Detection
Reranker API
P2P Inferencing
Distributed Mode — Horizontal scaling with PostgreSQL + NATS
Model Context Protocol (MCP)
Built-in Agents — Autonomous AI agents with tool use, RAG, skills, SSE streaming, and Agent Hub
Backend Gallery — Install/remove backends on the fly via OCI images
Voice Activity Detection (Silero-VAD)
Integrated WebUI

Supported Backends & Acceleration

LocalAI supports 60+ backends including llama.cpp, vLLM, SGLang, transformers, whisper.cpp, diffusers, MLX, MLX-VLM, and many more. Hardware acceleration is available for NVIDIA (CUDA 12/13), AMD (ROCm), Intel (oneAPI/SYCL), Apple Silicon (Metal), Vulkan, and NVIDIA Jetson (L4T). All backends can be installed on-the-fly from the Backend Gallery.

See the full Backend & Model Compatibility Table and GPU Acceleration guide.

Backends built by us

Most backends wrap a best-in-class upstream engine. A handful of them are native C/C++/GGML engines (no Python at inference) developed and maintained by the LocalAI project itself:

Backend	What it does
vllm.cpp	From-scratch C++20 port of vLLM for text generation: paged KV cache, continuous batching, prefix caching, safetensors + GGUF loading, engine-enforced structured output, on CPU, CUDA, Metal and Vulkan. Also serves MiniMax-H3 joint video+audio generation
parakeet.cpp	C++/GGML port of NVIDIA NeMo Parakeet ASR (tdt/ctc/rnnt/hybrid), with cache-aware streaming transcription
moss-transcribe.cpp	C++/GGML port of OpenMOSS MOSS-Transcribe-Diarize: joint long-form transcription, speaker diarization and timestamping in a single pass
moss-tts.cpp	C++/GGML port of the OpenMOSS MOSS-TTS family: text-to-speech (MOSS-TTS-Local v1.5, 48 kHz stereo) with reference-audio voice cloning, through the MOSS-Audio-Tokenizer neural codec
magpie-tts.cpp	C++/GGML port of NVIDIA's Magpie TTS Multilingual 357M: 22.05 kHz mono text-to-speech in 5 voices and 9+ languages, with the NanoCodec neural codec and tokenizer/G2P embedded in a single GGUF
ced.cpp	C++/GGML port of the CED audio-tagging models: sound-event classification (527-class AudioSet) over REST and the realtime API for live recognition
voice-detect.cpp	Speaker recognition and voice analysis (ECAPA-TDNN, WeSpeaker, ERes2Net, CAM++, wav2vec2 age/gender/emotion), replacing the Python speaker-recognition backend
voxtral-tts.c	Mistral Voxtral-4B-TTS text-to-speech in pure C: 20 preset voices across 9 languages, 24 kHz WAV output, no dependencies beyond libc
vibevoice.cpp	Native port of Microsoft VibeVoice for TTS (voice cloning) and long-form ASR with speaker diarization
rf-detr.cpp	Native RF-DETR object detection and instance segmentation
locate-anything.cpp	Open-vocabulary object detection and visual grounding (LocateAnything-3B)
depth-anything.cpp	Depth Anything 3 monocular metric depth + camera pose estimation
face-detect.cpp	Face detection, recognition, demographics and anti-spoofing (SCRFD/ArcFace, YuNet/SFace), replacing the Python insightface backend
free-splatter.cpp	Pose-free 3D reconstruction (FreeSplatter): turns a handful of plain photos into 3D Gaussians, no camera poses or GPU required
trellis2.cpp	C++/GGML port of Microsoft TRELLIS.2: single-image to textured 3D mesh (GLB with PBR materials)
privacy-filter.cpp	Standalone GGML PII/NER token-classification engine powering LocalAI's PII redaction tier
LocalVQE	Joint acoustic echo cancellation, noise suppression, and dereverberation
local-store	Local-first vector database for embeddings (shipped in-tree)

We also maintain apex-quant, a per-tensor, per-layer quantization recipe for Mixture-of-Experts models that exploits their structural sparsity to produce GGUFs matching or beating Q8_0 quality - and they run out of the box on stock llama.cpp.

Resources

Documentation
LLM fine-tuning guide
Build from source
Kubernetes installation
Integrations & community projects
Installation video walkthrough
Blog: release write-ups, benchmarks and engineering notes
Examples — including the realtime voice assistant demo (Go client for the Realtime API with tool calling)

Team

LocalAI is maintained by a small team of humans, together with the wider community of contributors.

Ettore Di Giacinto — original author and project lead
Richard Palethorpe — maintainer

A huge thank you to everyone who contributes code, reviews PRs, files issues, and helps users in Discord — LocalAI is a community-driven project and wouldn't exist without you. See the full contributors list.

Citation

If you utilize this repository, data in a downstream project, please consider citing it with:

@misc{localai,
  author = {Ettore Di Giacinto},
  title = {LocalAI: The free, Open source OpenAI alternative},
  year = {2023},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/go-skynet/LocalAI}},

License

LocalAI is a community-driven project created by Ettore Di Giacinto and maintained by the LocalAI team.

MIT - Author Ettore Di Giacinto mudler@localai.io

Acknowledgements

LocalAI couldn't have been built without the help of great software already available from the community. Thank you!

llama.cpp
https://github.com/tatsu-lab/stanford_alpaca
https://github.com/cornelk/llama-go for the initial ideas
https://github.com/antimatter15/alpaca.cpp
https://github.com/EdVince/Stable-Diffusion-NCNN
https://github.com/ggerganov/whisper.cpp
https://github.com/rhasspy/piper
exo for the MLX distributed auto-parallel sharding implementation

Contributors

This is a community project, a special thanks to our contributors!

velero-io/velero

Backup and migrate Kubernetes applications and their persistent volumes

Overview

Velero (formerly Heptio Ark) gives you tools to back up and restore your Kubernetes cluster resources and persistent volumes. You can run Velero with a public cloud platform or on-premises.

Velero lets you:

Take backups of your cluster and restore in case of loss.
Migrate cluster resources to other clusters.
Replicate your production cluster to development and testing clusters.

Velero consists of:

A server that runs on your cluster
A command-line client that runs locally

Documentation

The documentation provides a getting started guide and information about building from source, architecture, extending Velero and more.

Please use the version selector at the top of the site to ensure you are using the appropriate documentation for your version of Velero.

Troubleshooting

If you encounter issues, review the troubleshooting docs, file an issue, or talk to us on the #velero channel on the Kubernetes Slack server.

Contributing

If you are ready to jump in and test, add code, or help with documentation, follow the instructions on our Start contributing documentation for guidance on how to setup Velero for development.

Changelog

See the list of releases to find out about feature changes.

Velero compatibility matrix

The following is a list of the supported Kubernetes versions for each Velero version.

Velero version	Expected Kubernetes version compatibility	Tested on Kubernetes version
1.18	1.18-latest	1.33.7, 1.34.1, and 1.35.0
1.17	1.18-latest	1.31.7, 1.32.3, 1.33.1, and 1.34.0
1.16	1.18-latest	1.31.4, 1.32.3, and 1.33.0
1.15	1.18-latest	1.28.8, 1.29.8, 1.30.4 and 1.31.1
1.14	1.18-latest	1.27.9, 1.28.9, and 1.29.4

Velero supports IPv4, IPv6, and dual stack environments. Support for this was tested against Velero v1.8.

The Velero maintainers are continuously working to expand testing coverage, but are not able to test every combination of Velero and supported Kubernetes versions for each Velero release. The table above is meant to track the current testing coverage and the expected supported Kubernetes versions for each Velero version.

If you are interested in using a different version of Kubernetes with a given Velero version, we'd recommend that you perform testing before installing or upgrading your environment. For full information around capabilities within a release, also see the Velero release notes or Kubernetes release notes. See the Velero support page for information about supported versions of Velero.

For each release, Velero maintainers run the test to ensure the upgrade path from n-2 minor release. For example, before the release of v1.10.x, the test will verify that the backup created by v1.9.x and v1.8.x can be restored using the build to be tagged as v1.10.x.

Cloud Native Computing Foundation

Velero is a Cloud Native Computing Foundation sandbox project.

Copyright Contributors to Velero, established as Velero a Series of LF Projects, LLC. For website terms of use, trademark policy and other project policies please see https://lfprojects.org/policies/.

superplanehq/superplane

The open source control plane for agentic engineering.

SuperPlane

SuperPlane is an open source automation engine for AI-driven engineering.

It lets you orchestrate engineering workflows across the tools you use — such as Git, LLMs, CI/CD, observability, incident tools, and infrastructure — with durable execution, approvals, and operational UI.

SuperPlane executes your processes deterministically, providing the exact guardrails both humans and AI need to safely interact with your systems.

Project status

SuperPlane is in beta. Self-host the core engine (installation guide) or use SuperPlane Cloud for managed runners and one-click app installs. Core primitives and integrations are maturing; breaking changes are possible. Report issues on GitHub.

What it does

SuperPlane orchestrates your existing stack into git-backed apps with durable execution — workflows too complex for a single script or CI job.

Apps: A deployable unit combining a workflow graph, custom console UI, app-scoped memory, and deterministic execution. Versioned in git (canvas.yaml, console.yaml); defines guardrails for AI agents and human operators.
Event-driven orchestration: Multi-step workflows across your Git, CI/CD, observability, incident tools, and notifications — triggered by webhooks, schedules, and tool events, with approvals, policy checks, and human-in-the-loop steps.
Console dashboards: Define your own per-app operational UI as a dynamic grid of panels. Use it to display KPIs, tables, charts, runbooks, pinned nodes, and workflow controls, backed by live data from memory, runs, and executions.
Agents & operators: Built-in per-app agent to design workflows and debug runs; CLI and skills for external coding agents. Same RBAC on all paths.

How it works

Canvases: A graph of steps and their dependencies; a single canvas can express multiple workflows and run them concurrently.
Components: Each node is a trigger or action, built-in or integration-backed that performs a specific task (for example: deploy a service, open an incident, post a notification, wait for a condition, require approval, etc.).
Events & triggers: Incoming events match triggers and start runs with the event payload as input.
Runs & durable execution: Runs, run items, and payloads are tracked across restarts; failed steps can resume without custom retry logic.
Memory: App-scoped JSON storage that persists across runs.

Example use cases

A few concrete things teams build with SuperPlane:

PR preview environments: on pull request, provision an ephemeral environment, run tests, and post the live URL back to the PR.
Policy-gated production deploy: when CI finishes green, hold outside business hours, require on-call + product approval, then trigger the deploy.
Progressive delivery (10% → 50% → 100%): deploy in waves, wait/verify at each step, and rollback on failure with an approval gate.
Release train with a multi-repo ship set: wait for tags/builds from a set of services, fan-in once all are ready, then dispatch a coordinated deploy.
“First 5 minutes” incident triage: on incident created, fetch context in parallel (recent deploys + health signals), generate an evidence pack, and open an issue.

Quick start

Local (demo container):

docker pull ghcr.io/superplanehq/superplane-demo:stable
docker run --rm -p 3000:3000 -v spdata:/app/data -ti ghcr.io/superplanehq/superplane-demo:stable

Open http://localhost:3000.

Cloud: Sign up at app.superplane.com (cloud beta overview).

For a guided first workflow, see the quick start guide.

Supported Integrations

SuperPlane integrates with the tools you already use. Each integration provides triggers (events that start workflows) and components (actions you can run).

View the full list in our documentation. Missing a provider? Open an issue.

AI & LLM

Version Control & CI/CD

Cloud & Infrastructure

AWS ECR	AWS Lambda	AWS CodeArtifact	AWS CloudWatch	AWS SNS
GCP Cloud Build	GCP Cloud Functions	GCP Compute	Cloudflare	DigitalOcean
DockerHub	Hetzner Cloud	Azure	OCI	Coolify

Observability

DataDog	Dash0	Grafana	Honeycomb	Logfire	New Relic	Prometheus
Elastic	Sentry

Incident Management

Communication

Ticketing

Jira	ServiceNow

Developer Tools

Security

RBAC and API keys for programmatic access — see access control and API keys
Secrets stored encrypted — see secrets

Production installation

Footprint: PostgreSQL, RabbitMQ, and the SuperPlane application (bundled in the single-host Docker Compose installer). Deploy on a single Linux host or Kubernetes (GKE, EKS) with external PostgreSQL. See the installation overview for topology-specific upgrade paths.

Single Host Installation — AWS EC2, GCP Compute Engine, Hetzner, DigitalOcean, Linode, or any Linux server
Kubernetes Installation — GKE, EKS, or any Kubernetes cluster

Installation admins can enable private network access during owner setup or later in /admin/settings when SuperPlane needs to reach tools inside a VPC, private Kubernetes cluster, or another closed network. Environment variables still take precedence: set BLOCKED_HTTP_HOSTS or BLOCKED_PRIVATE_IP_RANGES to override the UI-controlled policy, and set either variable to an empty value to disable that specific block list entirely.

Contributing

We welcome your bug reports, ideas for improvement, and focused PRs.

Read the Contributing Guide to get started.
Issues: use GitHub issues for bugs and feature requests.

License

Apache License 2.0. See LICENSE.

Community

Discord - Join our community for discussions, questions, and collaboration
X - Follow us for updates and announcements

seakee/CPA-Manager-Plus

A self-hosted CPA / CLIProxyAPI management panel and AI gateway observability dashboard for requests, usage, cost, quota, failures, and account health.

CPA Manager Plus

A self-hosted CPA / CLIProxyAPI management panel and AI gateway observability dashboard for requests, usage, cost, quota, failures, and account health.

Operate providers, credentials, OAuth, plugins, and configuration while keeping persistent request history, cost analytics, and account automation in local storage.

中文｜ Live Demo ｜ Documentation ｜ Install

What Can CPAMP Help You Answer?

Why are requests failing? Inspect failure rates, status codes, affected models/accounts, and redacted evidence in persistent request history.
Where is the cost going? Break down tokens and estimated cost by model, provider, account, API key, project, channel, and time range.
Are accounts and quotas healthy? Review credential state, quota windows, reset evidence, and controlled automation for Codex and xAI accounts.

Screenshots

Dashboard	Request Monitoring
Usage Analytics	Account Health

Which Panel Should You Choose?

CPA / CLIProxyAPI can serve either the official Management Center or the CPAMP Lightweight Panel directly on :8317. The lightweight panel replaces the official UI without adding another service. Deploy CPAMP Full Mode when you also need persistent observability and long-running operations.

Option	Best for	Entry
Official CLI Proxy API Management Center	Keeping the upstream UI maintained by the CPA project	CPA `:8317/management.html`
CPAMP Lightweight Panel	Replacing only the UI without another service or database	CPA `:8317/management.html`
CPAMP Full Mode	Request history, cost analytics, inspection, and automation	Manager Server `:18317/management.html`

See Choosing A CPA Panel for the comparison, or install the CPAMP Lightweight Panel directly in CPA.

Core Capabilities

CPA Gateway Management

Manage CPA provider configurations, including Gemini, Codex, Claude, Vertex, xAI, and OpenAI-compatible providers.
Maintain auth files, OAuth logins, API keys, model aliases, priorities, plugins, logs, and system settings.
Import official Sub2API OpenAI OAuth exports and split multiple accounts into separate CPA Codex auth files.

Request Monitoring And Failure Diagnosis

Persist requests from the CPA usage queue in local SQLite and search account, client API key, and realtime request views.
Inspect status, latency, token, cache, trace, and redacted failure evidence without exposing raw failure bodies.
Export or import request history as JSONL.
Open the Monitoring Demo.

Cost And Usage Analytics

Break down calls, tokens, cost, latency, and failures by model, provider, account, credential, API key, project, channel, and time range.
Track input, output, reasoning, cache, service tier, and long-context pricing semantics.
Sync model prices from models.dev first, with LiteLLM and OpenRouter fallbacks plus local overrides for aliases or internal models.
Open the Usage Analytics Demo.

Account Health, Quota, And Automation

Inspect Codex and xAI accounts locally or on a Manager Server schedule.
Read quota windows, reset evidence, credential state, workspace state, and provider-specific health signals when available.
Apply controlled quota cooldowns and route credential failures into an account action queue for review and recovery.
Open the unified Accounts Demo.

Production Operations

Run CPAMP Full Mode as one Docker container or a native Linux, macOS, or Windows package for amd64/arm64; the full stack can run alongside CPA.
Keep request history, Manager configuration, automation state, and model prices in local files with no account registration or telemetry SDK.
Back up SQLite files together with data.key to preserve encrypted CPA Management Keys.

Want to preview the interface first? Open the Live Demo. The demo uses fictional data only. It is not a deployment or runtime mode and cannot connect to, manage, or monitor a real CPA instance.

CPAMP manages and observes traffic through CPA / CLIProxyAPI. It is not a replacement proxy and does not forward model traffic by itself.

Quick Start

Installer

For a guided full-stack or CPAMP-only deployment:

curl -fsSLO https://raw.githubusercontent.com/seakee/CPA-Manager-Plus/main/bin/install-cpamp.sh
bash install-cpamp.sh

Preview without deploying:

CPAMP_DRY_RUN=1 bash install-cpamp.sh

See One-Click Installer for upgrade, repair, and admin-key recovery behavior.

CPA + CPAMP Together

services:
  cli-proxy-api:
    image: eceasy/cli-proxy-api:latest
    restart: unless-stopped
    ports:
      - '8317:8317'
    volumes:
      - cpa-data:/app/data

  cpa-manager-plus:
    image: seakee/cpa-manager-plus:latest
    restart: unless-stopped
    ports:
      - '18317:18317'
    volumes:
      - cpa-manager-plus-data:/data

volumes:
  cpa-data:
  cpa-manager-plus-data:

docker compose up -d

Open http://<host>:18317/management.html, retrieve the CPAMP Admin Key from the Manager Server log, then enter the CPA URL and CPA Management Key during setup.

CPAMP Only

If CPA is already running:

docker run -d \
  --name cpa-manager-plus \
  --restart unless-stopped \
  -p 18317:18317 \
  -v cpa-manager-plus-data:/data \
  seakee/cpa-manager-plus:latest

Recommended CPA version: v7.1.39+. The HTTP usage queue needs v6.10.8+.

Documentation

Task	Guide
Choose the right panel and deployment mode	Choosing A CPA Panel
Replace the official UI without deploying another service	CPAMP Lightweight Panel
Install and complete first setup	Getting Started
Understand supported features and modes	Capability Matrix
Understand runtime ports, keys, and request flow	Runtime Model
Configure providers, credentials, quota, and plugins	AI Providers, Accounts, Plugin Management
Operate Manager Server, backups, upgrades, and migrations	Manager Server Guide
Back up data or recover a lost admin key	Backup And Restore, Reset Admin Key
Migrate from the legacy CPA-Manager	Migration From CPA-Manager
Diagnose empty monitoring or queue problems	Troubleshooting

Data, Privacy, And Security

CPAMP does not phone home, include analytics SDKs, or require account registration.
External calls are limited to the CPA gateway and integrations you explicitly configure or trigger, such as OAuth, provider checks, plugin releases, and model price sync.
Request history, configuration, model prices, inspection history, and automation state stay in local files.
CPA Management Keys are encrypted before SQLite persistence; backups require the SQLite files and data.key.
Normal APIs and JSONL exports expose redacted failure summaries, never raw failure bodies or stored raw JSON.
CPAMP is intended for traffic and credentials you are authorized to operate.

Development

npm install
npm run dev
npm run type-check
npm run lint
npm run test
npm run build
npm run docs:build

Manager Server:

cd apps/manager-server
go test ./...
go test -race ./...
go vet ./...
go run ./cmd/cpa-manager-plus

Build the Docker stack locally:

docker compose -f docker-compose.manager.yml up --build

Release

npm run build creates a single-file apps/web/dist/index.html.
bin/release/package-native.sh embeds the panel into native packages.
Create release notes through release/<version> -> dev -> main, then push a strict vX.Y.Z or prerelease tag from the verified main promotion merge.
npm run release:validate -- --tag <tag> --content-only checks the three required release files before a tag is created.
.github/workflows/release.yml offers a workflow_dispatch dry-run from main; it validates and builds without publishing a GitHub Release, container image, or Telegram message.
Release assets include management.html, native packages, and Docker images for linux/amd64 and linux/arm64.
Release publishing is serialized and has no automatic commit-log fallback; missing or mismatched notes fail closed. See docs/release.md for recovery and required repository protections.

Acknowledgements

Thanks to CLIProxyAPI and the official CLI Proxy API Management Center for the runtime and WebUI foundation.
Thanks to the Linux.do community for project promotion and feedback.

License

Gitlawb/zero

The coding agent that answers to you, your model, your machine, your rules.

A terminal coding agent you own.

English | 中文

Zero is an AI coding agent for your local terminal. It can inspect a repository, edit files, run commands, use browser/terminal helpers, and keep durable local sessions while you choose the model and the permission level.

zero
zero exec "fix the failing test in ./pkg"
zero exec --output-format stream-json < turns.jsonl

Why Zero

Use the model you want. Bring OpenAI, Anthropic, Gemini, Groq, OpenRouter, DeepSeek, Mistral, xAI, Qwen, Kimi, GitHub Models, Ollama, LM Studio, or any OpenAI-/Anthropic-compatible endpoint.
Stay in control. File writes, shell commands, network access, and out-of-workspace writes go through Zero's permission and sandbox policy.
Works in the terminal. The TUI has model/provider pickers, image input, slash commands, live plan/tool rendering, scrollback, themes, and resume/fork support.
Works without the TUI. zero exec is scriptable, supports text/JSON/ stream-JSON I/O, isolated worktrees, spec-first runs, and meaningful exit codes for CI.
Keeps context local. Sessions are stored on disk, searchable, resumable, and never uploaded as telemetry by Zero.
Extensible when you need it. Use MCP servers, skills, plugins, hooks, and specialist subagents from the same CLI.

Install

npm

npm install -g @gitlawb/zero
zero

The npm package is a small wrapper whose platform build (Linux and macOS on x64/arm64, Windows on x64 — including the browser/terminal control helpers) installs as an optional dependency straight from the npm registry — no install scripts, no downloads outside npm. Bun, pnpm, and yarn work the same way with no trust or approval steps. Installs that skip optional dependencies (--omit=optional) still work: the wrapper fetches the binary from the matching GitHub Release whenever it is missing. Windows on ARM runs the x64 build under emulation. See docs/NPM_PACKAGING.md for how the package is put together.

Install scripts

Linux/macOS:

curl -fsSL https://raw.githubusercontent.com/Gitlawb/zero/main/scripts/install.sh | bash

Windows PowerShell:

irm https://raw.githubusercontent.com/Gitlawb/zero/main/scripts/install.ps1 | iex

From source

Source builds require Go 1.26.5+.

git clone https://github.com/Gitlawb/zero.git
cd zero
go run ./cmd/zero

Release installers and the npm wrapper require published GitHub Release assets. If you are testing before the first public release, build from source:

go build -o zero ./cmd/zero

On Linux, build the sandbox helper too if you want native sandboxing:

go build -o zero-linux-sandbox ./cmd/zero-linux-sandbox
go build -o zero-seccomp ./cmd/zero-seccomp   # optional compatibility wrapper

Put zero and zero-linux-sandbox in the same directory on PATH (~/.local/bin is a good default). macOS does not need an extra helper binary. Windows source builds can use the main zero.exe as their sandbox helper; release archives still ship standalone Windows helper executables.

More install details: docs/INSTALL.md.

First Run

Start the TUI:

zero

The setup wizard helps you pick a provider and model. You can also configure providers from the command line:

zero setup
zero providers list
zero models list
zero doctor

For API providers, set the matching environment variable before setup or enter the key in the wizard:

export OPENAI_API_KEY=sk-...
export ANTHROPIC_API_KEY=...
export GEMINI_API_KEY=...
export AIMLAPI_API_KEY=...
export LONGCAT_API_KEY=...
export FIREWORKS_API_KEY=...
export MINIMAX_API_KEY=...
export MINIMAXI_API_KEY=...

To configure AI/ML API directly, run:

zero providers setup aimlapi --set-active

To configure Meituan LongCat (LongCat-2.0) directly, run:

zero providers setup longcat --set-active

To configure Fireworks AI directly, run:

zero providers setup fireworks --set-active

MiniMax presets use the Anthropic-compatible endpoints for the global and China regions:

zero providers add minimax --set-active
zero providers add minimaxi-cn --set-active

To use the OpenAI-compatible endpoints instead, add a custom compatible profile for the required region:

zero providers add custom-openai-compatible \
  --name minimax-openai \
  --model MiniMax-M3 \
  --base-url https://api.minimax.io/v1 \
  --api-key-env MINIMAX_API_KEY \
  --set-active

zero providers add custom-openai-compatible \
  --name minimax-cn-openai \
  --model MiniMax-M3 \
  --base-url https://api.minimaxi.com/v1 \
  --api-key-env MINIMAXI_API_KEY \
  --set-active

For local models, run Ollama or LM Studio and then use zero setup or zero providers detect.

Daily Use

Interactive TUI

zero

Useful controls:

Control	Action
`Enter`	send the prompt
`/`	open slash-command suggestions
`Ctrl+X` then letter	common slash commands (e.g. `m` → `/model`; `Ctrl+X` `?` for full list)
`Ctrl+P` / `Ctrl+N`	previous / next item in menus (arrows still work)
`Shift+Tab`	cycle permission mode
`Ctrl+B`	show/hide the sidebar
`Ctrl+C`	cancel, exit, or return from a `/btw` conversation

Common slash commands:

Command	Purpose
`/model`, `/provider`	switch the active model/provider
`/spec`, `/plan`	draft and review a plan before building
`/image`	attach an image for vision-capable models
`/resume`, `/rewind`	continue or roll back local sessions
`/new`	start a fresh session in place (previous session stays on disk)
`/btw [question]`	ask in an isolated fork without adding the side conversation to the main session
`/loop`	repeat a prompt or custom `/command` on an interval (`/loop 5m /babysit-prs`) or self-paced
`/compact`, `/context`	manage context usage
`/permissions`, `/tools`	inspect available tools and policy
`/add-dir`	allow an extra write directory for this session
`/theme`, `/doctor`, `/config`	adjust appearance and inspect setup

Headless `exec`

zero exec "explain internal/agent/loop.go"
zero exec --model claude-sonnet-4.5 "refactor the config loader"
zero exec --use-spec "add rate limiting to the API client"
zero exec --worktree "try the migration in an isolated worktree"
zero exec --resume
zero exec --fork <session-id> "try the other approach"

Programmatic use:

zero exec --input-format stream-json --output-format stream-json < turns.jsonl

The stream-JSON contract is documented in docs/STREAM_JSON_PROTOCOL.md.

Safety Model

Zero is designed to make side effects visible.

Workspace reads are allowed by default.
File writes are limited to the workspace unless you grant another directory.
Shell commands, network access, destructive commands, and elevated actions are permission-gated.
--add-dir <path> and /add-dir <path> grant additional write roots without giving the agent the whole filesystem.
Unsafe/autonomous modes are explicit opt-ins.
Secrets are redacted from tool output and logs where Zero controls the surface.

Example:

zero --add-dir ../docs-site
zero exec --add-dir ../shared "update both repos"

Sandbox behavior can be inspected with:

zero sandbox policy
zero sandbox grants list

Web And Local Control

Zero includes local file/search/edit/shell tools, web_fetch for public URLs, and MCP support for additional tools.

For local dev servers, use shell commands such as curl through exec_command so the normal sandbox and permission policy applies. Long-running commands stay attached to a background terminal session and can be listed or stopped from the TUI.

The npm package also includes browser and terminal helper packages used by local browser/terminal tools. Source builds can use the same helpers when they are on PATH or configured in Zero's local-control settings.

Common Commands

zero                  interactive TUI
zero exec             one-shot or scripted agent run
zero setup            first-run provider setup
zero auth             OAuth/login helpers for supported providers
zero models           model registry and capabilities
zero providers        provider profiles and detection
zero doctor           setup, key, and connectivity checks
zero context          context-budget report
zero repo-map         deterministic repository map
zero repo-info        local repository summary
zero search | find    search local session history
zero sessions         inspect, resume, fork, and rewind sessions
zero spec             manage spec-mode drafts
zero specialist       manage specialist subagents
zero skills           manage markdown instruction skills
zero plugins          manage plugins
zero hooks            manage lifecycle hooks
zero mcp              manage MCP servers and tools
zero serve --mcp      expose Zero tools over MCP stdio
zero sandbox          inspect sandbox policy and grants
zero worktrees        prepare isolated git worktrees
zero verify           detect and run local verification checks
zero changes          inspect and commit local git changes
zero usage            token usage and estimated cost
zero cron             scheduled agent jobs
zero update --check   check for newer releases
zero upgrade          download, verify, and install the latest release

Extending Zero

Project and personal instructions

Zero appends project-specific guidance to the system prompt from the first AGENTS.md, ZERO.md, or .zero/AGENTS.md file found in each directory from the git root down to your current working directory (checked in that order per directory). Files are injected general-to-specific, capped at 8 KiB per file and 32 KiB total.

A personal ZERO.md under config.UserConfigDir()/zero/ZERO.md ($XDG_CONFIG_HOME/zero/ZERO.md or ~/.config/zero/ZERO.md on Linux/macOS, %AppData%\Roaming\zero\ZERO.md on Windows) applies across every workspace, ahead of any project guidelines.

Plugins

Plugins are discovered from ~/.config/zero/plugins/<name>/plugin.json (user scope — $XDG_CONFIG_HOME or ~/.config on every OS, independent of the config.UserConfigDir() path used above) and <cwd>/.zero/plugins/<name>/plugin.json (project scope — resolved from the current working directory, not the repo root), and managed with zero plugins. A manifest can declare:

tools — custom tools (command, args, inputSchema, and a permission of prompt or deny; allow is honored only when manifest tool auto-approval is enabled)
hooks — commands run on beforeTool, afterTool, sessionStart, or sessionEnd
prompts and skills — additional prompt/skill files

MCP servers (zero mcp) and standalone markdown skills (zero skills) use the same extension points and can also be wired up outside of a plugin manifest.

Appearance And Accessibility

Control	Effect
`NO_COLOR=<anything>`	disables color output
`ZERO_THEME=<name>`	selects the startup theme (`auto`, `dark`, `light`, or a color theme like `dracula`, `nord`, `gruvbox`, `tokyo-night`, `catppuccin`, `one-dark`, `solarized-dark`, `rose-pine`, `everforest`, `neon`, `solarized-light`, `dune`)
`--theme <name>`	selects the TUI theme from the CLI (same names)
`/theme`	opens the theme picker inside the TUI (live preview; `/theme <name>` switches directly)
`ZERO_NO_FADE=1`	disables streaming fade animation

Meaning does not rely on color alone; diffs, permissions, and statuses also use text or glyph markers.

Development

go test ./...
go run ./cmd/zero-release build
go run ./cmd/zero-release smoke
go run ./cmd/zero-perf-bench

Experimental: ZERO_OPENAI_TURN_SESSION=1 enables the optimized OpenAI turn session (background connection prewarm + request-prefix telemetry) for headless zero exec runs against official OpenAI profiles. Off by default; 0/false disable. A/B-benchmark it by running the same zero-perf-bench suite with the variable unset and set.

Code Quality and Security Checks

Before committing any changes, ensure all Go code quality and security checks pass. The make targets below pin each tool to this module's Go version, so they load correctly even when your default go toolchain is older — running the plain go run ...@version form yourself can select the tool module's own (older) toolchain and fail to load this module instead.

Formatting: Run make fmt (or go fmt ./...).
Vetting: Run make vet (or go vet ./...).
Linting: Run make lint-static.
Vulnerability Scan: Run make vulncheck.

Use the repository-managed targets rather than globally installed binaries: the targets apply the module's required Go toolchain as well as the reviewed, pinned tool versions.

The installed binaries land in $GOBIN when it is set, otherwise in $GOPATH/bin (default ~/go/bin). That directory must be on your PATH to run them directly. If it isn't, add it:

gobin="$(go env GOBIN)"; [ -z "$gobin" ] && gobin="$(go env GOPATH)/bin"
case ":$PATH:" in *":$gobin:"*) ;; *) export PATH="$PATH:$gobin" ;; esac

Cross-Compile Examples

go run ./cmd/zero-release build --goos linux --goarch amd64
go run ./cmd/zero-release build --goos windows --goarch amd64 --output dist/zero.exe

Documentation

Community

Real-time chat happens on the Discord server.

Questions, setup help, ideas, and sharing all live in GitHub Discussions:

Category	Use it for
Q&A	Setup help, provider/model configuration, "how do I" questions
Ideas	Feature proposals and design discussion before any PR
Show and tell	Your skills, plugins, MCP setups, themes, and workflows
Announcements	Releases and project news from the maintainers

For a good Q&A answer fast, include zero --version, your OS and install method, the provider/model in use, and zero doctor output. See SUPPORT.md. Bugs belong in issues; security reports follow SECURITY.md, never a public thread.

Contributing

Contributions are welcome. Read CONTRIBUTING.md, run the relevant tests, and open a focused pull request.

Security reports should follow SECURITY.md.

License

Zero is released under the MIT License.

vllm-project/semantic-router

A programmable Mixture-of-Models router for heterogeneous LLM inference

Make Your Mixture-of-Models Programmable.

Documentation | Playground | Blog | Publications | Hugging Face

About

vLLM Semantic Router is a programmable routing layer for building Mixture-of-Models systems across heterogeneous LLM infrastructure. It evaluates request signals, user preferences, and application policies to select—or compose—the right model path for each request.

Use it to improve quality, cost, latency, privacy, and safety without hard-coding routing logic into applications.

Dimension	Fragmented today	With vLLM SR
Models	Models specialize in different work.	Compose personalized model paths.
Compute	GPUs, accelerators, edge, and cloud coexist.	Route across heterogeneous compute.
Location	Inference spans edge, private, and cloud.	Keep data within its boundaries.
Preference	"Best" changes by user and workload.	Make every preference executable.

Explore how it works →

Getting Started

Install

curl -fsSL https://vllm-sr.ai/install.sh | bash

For platform notes, detailed setup options, and troubleshooting, see the Installation Guide.

Online playground credentials

Username: love@vllm-sr.ai
Password: vllm-sr

Latest News

[2026/07/21] New Blog: Beyond a Single Model: Building Mixture-of-Models Systems with vLLM Semantic Router
[2026/06/29] New Blog: Micro-Agent: Beat Frontier Models with Collaboration inside Model API
[2026/06/16] New Blog: Beyond One Model: Fusion in vLLM Semantic Router
[2026/06/05] v0.3 Released: vLLM Semantic Router v0.3 Themis: From Signals to Stateful Production Routing

Earlier announcements

[2026/03/24] Vision Paper Released: The Workload-Router-Pool Architecture for LLM Inference Optimization
[2026/03/10] v0.2 Released: vLLM Semantic Router v0.2 Athena Release
[2026/02/27] White Paper Released: Signal Driven Decision Routing for Mixture-of-Modality Models
[2026/01/05] Iris v0.1 Released: vLLM Semantic Router v0.1 Iris: The First Major Release
[2025/12/16] Collaboration: AMD × vLLM Semantic Router: Building the System Intelligence Together
[2025/12/15] New Blog: Token-Level Truth: Real-Time Hallucination Detection for Production LLMs
[2025/11/19] New Blog: Signal-Decision Driven Architecture: Reshaping Semantic Routing at Scale
[2025/11/03] Paper Published: Category-Aware Semantic Caching for Heterogeneous LLM Workloads
[2025/10/27] New Blog: Scaling Semantic Routing with Extensible LoRA
[2025/10/12] Paper Accepted: When to Reason: Semantic Router for vLLM
[2025/10/08] Collaboration: vLLM Semantic Router with vLLM Production Stack Team.
[2025/09/01] Released the project: vLLM Semantic Router: Next Phase in LLM inference.

More announcements are available on the Blog and Publications pages.

Community

For questions, feedback, or to contribute, please join the #semantic-router channel in vLLM Slack.

Community Meetings

We host community meetings on the first and third Tuesday of each month to sync with contributors across different time zones:

First Tuesday of the month: 9:00-10:00 AM EST (accommodates US EST, EU, and Asia Pacific contributors)
Third Tuesday of the month: 1:00-2:00 PM EST (accommodates US EST and California contributors)
Meeting recordings: YouTube

Contributing

If you want to contribute, start with CONTRIBUTING.md.

For repository-native development workflow and validation commands, use AGENTS.md as the entrypoint and tools/agent/docs/README.md as the canonical index.

Citation

If you find Semantic Router helpful in your research or projects, please consider citing it:

@misc{semanticrouter2025,
  title={vLLM Semantic Router},
  author={vLLM Semantic Router Team},
  year={2025},
  howpublished={\url{https://github.com/vllm-project/semantic-router}},
}

GitHub Go Daily Trending Repositories

aldinokemal/go-whatsapp-web-multidevice

Golang WhatsApp - Built with Go for efficient memory use

Support for ARM & AMD Architecture along with MCP Support

Support n8n package (n8n.io)

Breaking Changes

Feature

Configuration

Environment Variables

Available Environment Variables

Requirements

System Requirements

Platform Support

Dependencies (without docker)

How to use

Basic

Docker (you don't need to install in required)

Build your own binary

Cross-Compile for Raspberry Pi (ARM)

MCP Server (Model Context Protocol)

Available MCP Tools

Device selection

MCP Configuration

Migrating from the standalone MCP mode

Production Mode REST (docker)

Production Mode REST (docker compose)

Production Mode (binary)

Current API

MCP (Model Context Protocol) API

HTTP REST API

User Interface

MCP UI

Web dashboard (gowa-ui)

Mac OS NOTE

Important

ollama/ollama

Ollama

Download

macOS

Windows

Linux

Docker

Libraries

Community

Get started

Coding

AI assistant

Chat with a model

REST API

Python

JavaScript

Supported backends

Documentation

Community Integrations

Chat Interfaces

Web

Desktop

Mobile

Code Editors & Development

Libraries & SDKs

Frameworks & Agents

RAG & Knowledge Bases

Bots & Messaging

Terminal & CLI

Productivity & Apps

Observability & Monitoring

Database & Embeddings

Infrastructure & Deployment

Cloud

Package Managers

putyy/res-downloader

res-downloader

📖 中文 | English

📢 项目状态

🎉 爱享素材下载器

✨ 功能特色

📚 文档 & 版本

🧩 下载地址

🖼️ 预览

🚀 使用方法

Support for `ARM` & `AMD` Architecture along with `MCP` Support