Attu - The AI Workbench for Milvus

Attu is an AI-native management tool for Milvus vector databases. Connect to multiple Milvus clusters from a single instance, browse collections, run vector searches, manage backups, monitor health, and chat with an AI agent that understands your data.

Available as a web app (Docker, Kubernetes, or a standalone server package) or desktop app (macOS, Linux, Windows).

---

What's New in v3.0

Attu 3.0 expands the visual experience for Milvus 3.0 while retaining compatibility with Milvus 2.6.0+ and Zilliz Cloud. Highlights include:

• External Collections and Snapshots - Explore Parquet and Iceberg data without copying it into Milvus, refresh external schemas and data, and browse or restore Collection Snapshots.
• Text and Schema Evolution - Work with Milvus TEXT fields, add or remove supported fields, edit descriptions, and manage Function Fields from the Schema page.
• Search and Analytics - Run Query and Search aggregations, group and order results, paginate large result sets, and apply Function Score reranking.
• MinHash Deduplication - Configure MinHash Function Fields and MINHASH_LSH indexes to find near-duplicate documents from raw text.
• Analyzers and File Resources - Register reusable dictionaries, stop-word lists, synonym lists, and tokenizer resources.
• Collection and Data Management - Load or release individual partitions, configure entity-level TTL, export complete Collections, and import large files in chunks.

See the Attu v3.0.0 release notes for details.

---

Quick Start

Docker (recommended)

docker run -d --name attu \
  -p 3000:3000 \
  -e MILVUS_ADDRESS=host.docker.internal:19530 \
  -v attu-data:/data \
  zilliz/attu:v3.0.0

Open http://localhost:3000 and connect to Zilliz Cloud or an open-source Milvus 2.6.0+ or 3.x instance.

The Docker image stores its SQLite database at /data/attu.db by default. The -v attu-data:/data volume persists your saved connections, agent conversations, and preferences across container restarts.

The image runs as the non-root node user (uid=1000, gid=1000), so named volumes are recommended. If you use a host bind mount such as ./attu-data:/data, prepare the directory before starting Attu:

mkdir -p ./attu-data
sudo chown -R 1000:1000 ./attu-data

On SELinux-enabled hosts, also add the :Z mount option: ./attu-data:/data:Z.

Docker Compose (Milvus + Attu)

services:
  milvus:
    # Use a supported Milvus 2.6.x or 3.x image.
    image: milvusdb/milvus:<supported-tag>
    ports:
      - "19530:19530"
      - "9091:9091"
    command: milvus run standalone
    volumes:
      - milvus-data:/var/lib/milvus

  attu:
    image: zilliz/attu:v3.0.0
    ports:
      - "3000:3000"
    environment:
      - MILVUS_ADDRESS=milvus:19530
    volumes:
      - attu-data:/data
    depends_on:
      - milvus

volumes:
  milvus-data:
  attu-data:

docker compose up -d

Attu v3.0 supports Zilliz Cloud and open-source Milvus 2.6.0+ and 3.x. Milvus 2.5.x and earlier are not supported.

Desktop App

Download the latest release for your platform:

macOS note: If you see "attu.app is damaged and cannot be opened", run:

sudo xattr -rd com.apple.quarantine /Applications/Attu.app

Standalone Server Package

The v3.0.0 release includes a non-Docker, non-Electron server package for Linux x64. It requires Node.js 24.x and includes the Attu server bundle and bin/milvus-backup.

curl -LO https://github.com/zilliztech/attu/releases/download/v3.0.0/attu-server-3.0.0-linux-x64-node24.tar.gz
tar -xzf attu-server-3.0.0-linux-x64-node24.tar.gz
cd attu-server-3.0.0-linux-x64-node24
./bin/attu-server

Open http://localhost:3080. The launcher defaults to 0.0.0.0:3080. Set HOST, PORT, ATTU_DATA_DIR, or ATTU_DB_PATH to customize the runtime paths and listener.

---

Features

Multi-Cluster Management

Connect to multiple Milvus instances from a single Attu deployment. Add, edit, and switch between connections in the sidebar. Each cluster has its own dedicated workspace with independent monitoring, agent sessions, and preferences, ideal for managing dev, staging, and production environments side by side.

Data Explorer

Browse databases and collections, view and edit data inline, import/export in CSV, JSON, and Parquet formats.

Vector Search

Interactive vector similarity search with configurable embedding providers (OpenAI, Cohere, Jina, VoyageAI, and more).

AI Agent

Chat-driven Milvus management with 50+ tools. Create collections, run queries, manage users, and analyze performance through natural language.

Supports: OpenAI, Anthropic Claude, DeepSeek, Google Gemini, OpenRouter, and custom API endpoints.

Cluster Overview & Monitoring

Real-time cluster health, Prometheus metrics dashboard with 16+ metrics, and interactive topology visualization.

Backup & Restore

Full and incremental backups with support for S3, MinIO, GCS, and Azure Blob Storage. Download backups as ZIP or restore from uploaded archives.

REST API Playground

Interactive API testing environment scoped to your connection, database, and collection.

And More

• RBAC Management - Create and manage users, roles, and privilege groups.
• Resource Groups - Configure resource allocation across nodes.
• Slow Request Analysis - Identify bottlenecks with cluster-wide slow query inspection.
• Configuration & Environment Viewer - Inspect runtime configs and environment variables.
• Task Queue - Monitor background operations for imports, exports, backups, restores, and copy jobs.
• Audit Logs - Review write operations initiated from the Attu UI or server functions.
• Internationalization - English and Chinese language support.

---

Deployment

Runtime Configuration

Pre-configured Connection

Set MILVUS_ADDRESS to automatically create a default connection on startup. This is useful for Kubernetes and Docker Compose deployments where Attu is co-deployed with Milvus.

docker run -d \
  --name attu \
  -p 3000:3000 \
  -v attu-data:/data \
  -e MILVUS_ADDRESS=milvus:19530 \
  zilliz/attu:v3.0.0

MILVUS_SSL is enabled automatically when any MILVUS_TLS_* certificate, server name, or skip-check variable is set.

MILVUS_ADDRESS must be reachable from the Attu container. 127.0.0.1 or localhost usually points to the container itself, so use a Docker service name, Kubernetes service name, or host.docker.internal.

Local Login

Attu server deployments run with local login enabled by default. The first visit shows a one-time setup form for creating the first admin account. Desktop/Electron builds run in single-user mode and do not support Attu multi-user login.

ATTU_ADMIN_USER=admin \
ATTU_ADMIN_PASSWORD='Change-me-please-123' \
pnpm --filter @attu/app dev --host 127.0.0.1

Set ATTU_AUTH_MODE=none to keep a server deployment in single-user mode. This is intended for local development or deployments protected by another access layer.

If the only admin password is lost, restart Attu once with a recovery password:

ATTU_ADMIN_RESET_USER=admin \
ATTU_ADMIN_RESET_PASSWORD='New-change-me-123' \
pnpm --filter @attu/app start

When exactly one active admin exists, ATTU_ADMIN_RESET_USER can be omitted. Remove the reset variables after signing in because Attu applies them on startup and clears existing sessions for that admin.

Audit Logs

Attu records audit logs for write operations initiated from the Attu UI or server functions. These logs are stored in Attu's SQLite database and are separate from Milvus native logs. Read-only browsing, search, and query operations are not audited.

Audited actions include connection management, database and collection management, schema and metadata changes, data writes, index and partition operations, user and role administration, resource group changes, AI configuration changes, and import/export/backup/restore task starts.

Each audit record includes the connection, actor, action, resource type/name, database name, success/failure status, error message, metadata, and timestamp. Sensitive metadata fields are redacted before storage when their key contains values such as password, token, secret, apiKey, privateKey, cert, certificate, or credential.

Audit retention defaults to 90 days. Set ATTU_AUDIT_RETENTION_DAYS to change the retention window; set it to 0 or a negative value to disable automatic pruning.

Outbound Requests and SSRF Protection

Attu validates outbound HTTP/HTTPS targets when saving or testing embedding and LLM service configurations, and again when sending requests. A security-policy rejection can therefore happen before the service is contacted.

Docker and standalone server deployments enforce SSRF protection by default in production. Private and loopback addresses, including 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.0/8, and private IPv6 addresses, require explicit permission. Domains are checked against their resolved IP addresses, so an internal DNS name does not bypass the policy.

Desktop behavior depends on the installed version. If a local or LAN service is blocked, use the per-host allowlist below. As of September 8, 2026, the change to allow local and LAN services by default on desktop has not been released; do not assume the published v3.0.0 build includes it. That change also covers domains resolving to private addresses; explicitly configured strict mode will still take precedence.

Metadata service hostnames and metadata/link-local addresses, such as metadata.google.internal and 169.254.169.254, remain blocked even when allowlisted. Only HTTP and HTTPS URLs are accepted, and credentials embedded in URLs are rejected.

For example, ATTU_SSRF_ALLOWLIST=embedding.company.local,192.168.1.100 permits either host. Prefer specific hosts; use a CIDR range only when the whole range is intended to be accessible.

Docker

Add the allowlist to the Attu container's environment and recreate the container with its existing data volume:

docker run -d --name attu \
  -p 3000:3000 \
  -v attu-data:/data \
  -e ATTU_SSRF_ALLOWLIST=embedding.company.local,192.168.1.100 \
  zilliz/attu:v3.0.0

The example starts a new container; stop and remove the previous container of the same name first, retaining its data volume. For Docker Compose or Kubernetes, set the same variable in the Attu service/container environment and recreate or roll out the workload.

The service must also be reachable from inside the container. If using host.docker.internal, allowlist that hostname; Linux Docker Engine typically also requires --add-host=host.docker.internal:host-gateway. An allowlist changes permission, not DNS resolution or network routing.

Desktop

Fully quit Attu, including any running background instance, then launch it with the environment variable. Replace the host and executable path with your actual values.

macOS:

ATTU_SSRF_ALLOWLIST=embedding.company.local,192.168.1.100 \
/Applications/Attu.app/Contents/MacOS/Attu

Windows PowerShell:

$env:ATTU_SSRF_ALLOWLIST = "embedding.company.local,192.168.1.100"
& "C:\path\to\Attu.exe"

Linux AppImage:

ATTU_SSRF_ALLOWLIST=embedding.company.local,192.168.1.100 \
./attu-3.0.0-x86_64.AppImage

These examples apply to launches from that terminal environment; launching Attu later from its usual icon does not retain the setting. For the standalone server package, set the same variable before running ./bin/attu-server.

Troubleshooting

The default organization inherits deployment permission; additional organizations can have stricter private-target policies. Server logs record rejections as Blocked outbound request, with the request context, target host/port, and reason. For embedding configuration operations, the context is embedding_config.create, embedding_config.update, or embedding_config.test.

TLS / SSL

Attu supports one-way TLS and mutual TLS (mTLS) for Milvus gRPC connections.

• One-way TLS: Attu verifies the Milvus server certificate. A custom CA/root certificate is optional.
• Mutual TLS (mTLS): Attu verifies the Milvus server certificate and sends a client certificate/key to Milvus.
• Server name override: Set MILVUS_TLS_SERVER_NAME or the UI field when the certificate hostname differs from the address host.
• Skip certificate verification: MILVUS_TLS_SKIP_CERT_CHECK=true is insecure and intended only for local testing. It is not supported with mTLS.

You can configure TLS certificates in the Attu UI by uploading PEM files or by entering paths readable by the Attu server/container. Uploaded PEM content is stored in Attu's SQLite connection record, so Docker and Kubernetes deployments do not need certificate volume mounts for that flow.

One-way TLS with mounted certificate paths:

docker run -d \
  --name attu \
  -p 3000:3000 \
  -v attu-data:/data \
  -v "$PWD/certs:/etc/attu/certs:ro" \
  -e MILVUS_ADDRESS=milvus.example.com:19530 \
  -e MILVUS_SSL=true \
  -e MILVUS_TLS_ROOT_CERT_PATH=/etc/attu/certs/ca.pem \
  -e MILVUS_TLS_SERVER_NAME=milvus.example.com \
  zilliz/attu:v3.0.0

Mutual TLS with mounted certificate paths:

docker run -d \
  --name attu \
  -p 3000:3000 \
  -v attu-data:/data \
  -v "$PWD/certs:/etc/attu/certs:ro" \
  -e MILVUS_ADDRESS=milvus.example.com:19530 \
  -e MILVUS_SSL=true \
  -e MILVUS_TLS_ROOT_CERT_PATH=/etc/attu/certs/ca.pem \
  -e MILVUS_TLS_PRIVATE_KEY_PATH=/etc/attu/certs/client.key \
  -e MILVUS_TLS_CERT_CHAIN_PATH=/etc/attu/certs/client.pem \
  -e MILVUS_TLS_SERVER_NAME=milvus.example.com \
  zilliz/attu:v3.0.0

See Run Attu with local Milvus mutual TLS in Docker for a complete local mTLS setup, including certificate generation, Milvus Docker Compose configuration, and verification.

Kubernetes

kubectl apply -f https://raw.githubusercontent.com/zilliztech/attu/main/deploy/attu-k8s-deploy.yaml

Edit the YAML to set MILVUS_ADDRESS to your Milvus service name (e.g., my-release-milvus:19530).

Nginx Reverse Proxy

See the nginx deployment guide.

---

Compatibility

Attu v3.0 supports Zilliz Cloud and open-source Milvus 2.6.0+ and 3.x. Milvus 2.5.x and earlier are not supported.

External Collections, Snapshots, TEXT fields, MinHash, entity-level TTL, aggregation, ordering, and some schema operations require Milvus 3.x. Attu adapts the available actions to the connected Milvus version and configuration.

TEXT fields and External Collections require Storage V3. If Storage V3 is disabled, set common.storage.useLoonFFI=true in Milvus and restart the service. External Collection data remains read-only in Attu.

---

FAQ

I can't connect to Milvus from Docker

Make sure MILVUS_ADDRESS is reachable from inside the container. Use the Docker service name, not localhost. See #161.

macOS says the app is damaged

Run sudo xattr -rd com.apple.quarantine /Applications/Attu.app in Terminal.

How do I update?

Docker: pull the latest image and restart. Desktop: the app checks for updates automatically on launch.

---

Resources

• Milvus Documentation
• Milvus Python SDK
• Milvus Java SDK
• Milvus Go SDK
• Milvus Node.js SDK

Community

Join the Milvus Discord to ask questions, share feedback, and connect with other users.

License

Attu was open source under the Apache License 2.0 through version v2.5.12. Starting from version v2.6.0, Attu is proprietary software. See LICENSE_PROPRIETARY.txt for details.