NEWZero PolarDB-X is now in public beta. Instant database, no sign-up required.
100% MySQL Compatible · Unified Single-Node & Distributed

PolarDB-X Zero

100% MySQL Compatible, Unified Single-Node & Distributed Architecture

Get a disposable PolarDB-X distributed database in one API call. No sign-up, no config, start instantly.

Read https://zero.polardbx.com/SKILL.md and follow the instructions to create a database using PolarDB-X Zero.

Why PolarDB-X Zero?

Built on PolarDB-X's unified single-node and distributed architecture, 100% MySQL compatible, providing an instant database experience for AI-native workflows.

⚡

Unified Single & Distributed

One database engine, seamlessly switch between single-node and distributed clusters. Full distributed transactions, horizontal elastic scaling, no architectural compromise.

🗃️

100% MySQL Compatible

Full MySQL protocol and syntax support. JOINs, transactions, stored procedures, triggers — all compatible. Any MySQL client or driver works out of the box.

⏳

Disposable Instances

On-demand database instances. Perfect for CI tests, demos, Agent sessions, or short-term experiments. Automatically cleaned up on expiry.

🔒

Zero Configuration

No sign-up, no credit card, no config. One API call gets you a full distributed database.

Use Cases

A 100% MySQL-compatible distributed database, ready to use instantly. Here are typical applications for PolarDB-X Zero.

🧠
Agent Memory

AI Agent Memory Database

Built-in vector indexing, natively compatible with Mem0 and other AI memory frameworks. Store Agent state, user preferences, and vector memories in a single MySQL database — relational queries and semantic search in one place.

🚀
Rapid Dev

App Development with Instant Database

Got an idea? Start building immediately without setting up a database. One call gets you a full MySQL database — focus on business logic, leave infrastructure to us.

🔗
AI IDE Integration

Seamless Use in Qoder, Cursor & OpenClaw

Through MCP protocol or SKILL instructions, AI coding assistants can automatically create and connect to databases. Get a real MySQL environment anytime during coding, without leaving your IDE.

📦
Ephemeral DB

Ephemeral Database Workflows

Quickly create isolated sandboxes for tutorials, demos, benchmark frameworks, and short-term testing. Full MySQL compatibility, auto-cleanup when done.

MCP Server

Give any AI agent persistent MySQL databases through the Model Context Protocol. Install the MCP server and connect from your favorite IDE.

1Install
bash
pip install polardbx-zero-mcp
2Configure Your IDE

Qoder / Cursor / Windsurf / Claude Desktop — add to MCP config:

json
{
  "mcpServers": {
    "polardbx": {
      "command": "polardbx-zero-mcp"
    }
  }
}
🔧
10 MCP Tools
Instance management, SQL, stateful connections
⚡
Zero Config
No API key required — just install and connect
🔒
MySQL Protocol
Real MySQL wire protocol with SSL

CLI Quick Start

Three steps, under a minute.

1Create Instance
bash
curl -s -X POST https://zero.polardbx.com/api/v1/instances \
  -H 'Content-Type: application/json' \
  -d '{"tag":"quickstart","ttlMinutes":43200}' | tee pxz.json | jq .
2Export Connection String
bash
export MYSQL_URL="$(jq -r '.instance.connectionString' pxz.json)"
3Connect & Use
bash
eval $(jq -r '.instance.connection | "mysql -h \(.host) -P \(.port) -u \(.username) -p\(.password)"' pxz.json)
# Or use $MYSQL_URL directly in your code

API Reference

One endpoint, no auth required, get a database instantly.

POST/api/v1/instances
Request
{
  "tag": "my-agent",      // Optional, caller tag
  "edition": "enterprise", // Optional, standard or enterprise, default standard
  "ttlMinutes": 43200,     // Optional, custom TTL (minutes), default 30 days, must be ≤ 43200 (30 days)
  "whitelistIp": "1.2.3.4"  // Optional, comma-separated IPv4/CIDR whitelist
}
200Response
Response
{
  "instance": {
    "id": "pxz_a1b2c3d4e5f6",
    "connection": {
      "host": "pxc-xxxxx.polardbx.rds.aliyuncs.com",
      "port": 3306,
      "username": "polardbx_root",
      "password": "Px$9aB3cD7eF1gH",
      "database": ""
    },
    "connectionString": "mysql://polardbx_root:...@pxc-xxxxx:3306",
    "createdAt": "2026-03-20T10:30:00.000Z",
    "expiresAt": "2026-03-27T10:30:00.000Z",
    "ttlDays": 0,
    "ttlMinutes": 43200,
    "status": "ready"
  }
}

Vector Search in Action

PolarDB-X has built-in HNSW vector indexing, supporting up to 16,383 dimensions, enabling semantic search directly in standard SQL.

Send the following instruction to Qoder, OpenClaw, or other AI Agents to complete all steps automatically:

text
Read https://playbook.polardbx.com/vector.md and follow the instructions
📏
16,383 Dims
Industry-leading max vector dimensions
⚡
HNSW + SIMD
AVX512 / NEON hardware acceleration
🔄
SQL Native
Mix vector search with relational queries
AI 记忆存储 · 兼容 mem0ai SDK

🧠 Mem0 Memory Storage

Built on PolarDB-X vector engine, providing out-of-the-box long-term memory storage for AI Agents.

Agent 使用

Read https://zero.polardbx.com/MEM0_SKILL.md and follow the instructions to get a Mem0 memory storage instance using PolarDB-X Zero.

Why Mem0 on PolarDB-X Zero?

Built on PolarDB-X vector engine, providing out-of-the-box long-term memory storage for AI Agents.

🧠

AI Memory Storage

A memory layer designed for AI Agents. Store user preferences, conversation history, and context to give your Agent persistent memory.

🐍

mem0ai SDK Compatible

Fully compatible with the mem0ai Python SDK. No code changes needed — pip install mem0ai and connect.

🔍

Semantic Search

Built-in vector indexing with semantic similarity search. Recall relevant memories using natural language queries.

⚡

Instant Setup

Get a Mem0 instance in one API call. No need to deploy Redis, Qdrant, or other dependencies — works out of the box.

Three Steps to Start

From getting an instance to storing your first memory, in under a minute.

1

Get Instance

Through Agent instructions or API call, instantly get a Mem0 storage instance with API Key and connection info.

2

Connect SDK

Use the mem0ai Python SDK, configure API Key and Host to connect — fully compatible with the official Mem0 platform.

3

Store & Search

Add memories and search related memories via SDK. Organize memories by user, agent, session, and more.

SDK Example

Use the mem0ai Python SDK to add long-term memory to your Agent in just a few lines of code.

python
from mem0 import MemoryClient

# Connect to your Mem0 instance on PolarDB-X Zero
client = MemoryClient(
    api_key="your-api-key",
    host="https://your-instance.zero.polardbx.com"
)

# Add a memory
client.add(
    "I prefer dark mode and Python for coding",
    user_id="alice"
)

# Search memories
results = client.search(
    "What are alice's preferences?",
    user_id="alice"
)

Compatibility & Specs

Enterprise-grade memory storage service built on PolarDB-X vector engine.

mem0ai SDK

Fully compatible with mem0ai Python SDK

24h Free Trial

Free to use, no sign-up required

Vector + Relational

Semantic search and structured queries in one

Context0 · AI Agent Context Storage

Context0 — Your AI Context Workspace

Persistent context storage for AI Agents and humans — knowledge management and intelligent retrieval in one place

Supported Agent Types

⚡ Codex🤖 Claude Code🔷 Qoder🏢 QoderWork🪽 Hermes

Read https://zero.polardbx.com/context0/SKILL.md and follow the instructions to install and use ctxdb0 with your Context0 workspace.

Nine Core Capabilities

From knowledge storage to intelligent retrieval — full coverage of AI Agent context management

📚

Knowledge Base & RAG

Vector + full-text hybrid retrieval

🧪

LLM Wiki Distillation

Auto-distill knowledge into structured Wiki

🕸️

Knowledge Graph & GraphRAG

Entity-relation modeling + graph-enhanced retrieval

🎨

Multimodal Ingestion

Unified storage for text/code/image/audio

🔼

Memory Promotion (3-Tier)

Short-term → Long-term → Knowledge auto-promotion

🔀

Hybrid Recall (RRF)

Multi-path recall + reciprocal rank fusion

🗜️

Token Compression

Intelligent summarization to reduce context cost

⚙️

Programmable Pipelines

Custom memory processing pipelines

🔒

Enterprise Isolation

Workspace-level data & resource isolation

Use Cases

From coding assistants to enterprise knowledge — Context0 powers diverse AI applications

AI Coding

AI Coding Assistant

Let Codex/Claude Code remember your repo context

Knowledge

Knowledge Management

Team knowledge accumulation, auto-organization, smart retrieval

Support

Customer Service

Multi-turn memory, customer profiling, precise responses

Analytics

Data Analysis

Insight accumulation, pattern memory, report generation

My Workspaces

Manage your provisioned Context0 workspaces

PXBaas · Instant provisioning

⚡ PXBaas

Get a PXBaas instance in one click — no sign-up required. Experience a Backend-as-a-Service (PXBaas) platform built on PolarDB-X, with authentication, realtime subscriptions, RESTful API, file storage, edge functions and more.

Read https://zero.polardbx.com/BAAS-SKILL.md and follow the instructions to provision a PXBaas instance using PolarDB-X Zero.

langfuse SDK compatible

See every LLM call

PXFuse records every reasoning step, every token and every cent your agent spends. langfuse SDK compatible — three lines of config to connect.

Supported Agent Types

⚡ Codex🤖 Claude Code🔷 Qoder🏢 QoderWork🪽 Hermes

Read https://zero.polardbx.com/pxfuse/SKILL.md and follow the instructions to set up observability for your LLM app with your PXFuse project.

This is what one agent call looks like in PXFuse

trace / a3f1c8e2-7b04-4d19
total 1,240ms1,589 tokenscost $0.0125
agent.run1240ms
└ retrieve.docs180ms
└ llm.chat620ms
└ tool.weather150ms
└ llm.summarise210ms
gpt-4o · 1,203 tok · $0.0121gpt-4o-mini · 386 tok · $0.0004

Three lines to connect

PXFuse speaks the langfuse protocol — swap three environment variables and you are done

.env
LANGFUSE_BASEURL=https://pxfuse.example.com
LANGFUSE_HOST=https://pxfuse.example.com
LANGFUSE_PUBLIC_KEY=pk-lf-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
LANGFUSE_SECRET_KEY=sk-lf-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Sample values below. Claim a project and your real credentials appear here automatically.

My Projects

Manage your provisioned PXFuse projects

Capability Map

Trace · Measure · Evaluate · Govern — four layers converging on production quality

📊

Tracing

Tracing

Full-path traceability

  • Full-path call tracing
  • Nested span hierarchy
  • Session context linking
  • Error and retry annotation
📈

Metrics

Metrics

Calls quantified as metrics

  • Throughput, latency, error rate
  • Token usage and cost accounting
  • Model, project, user drill-down
  • Custom metric ingestion
🧪

Evaluation

Evaluation

Output quality made measurable

  • Human annotation and scoring
  • LLM-as-judge scoring
  • Badcase-driven datasets
  • Cross-version regression
🛡️

Governance

Governance

Changes controlled and reversible

  • Prompt version control
  • Staged rollout and rollback
  • Project-level data isolation
  • Per-project key authorization

From connect to operate

Four steps that turn LLM app quality into a loop you can keep iterating on

🔌

Connect

Drop in the host and key pair — calls report automatically, no logic changes

🔍

Debug

Expand your agent's multi-step tool calls and see exactly where it stalled

⚡

Optimise

Surface the slow, expensive calls, then go back and tune prompts and models

📊

Operate

Sample, score, regress badcases — let the data decide the next revision

PXFS · Agent File Service

A database-native file system for AI Agents: PXFS

PolarDB-X FileSystem (PXFS) mounts a standard file system on top of PolarDB-X. Files gain transactional durability, point-in-time history and content dedup — no code changes, just plain files.

  • Standard NFS v4.1 file interface — Agents read and write plain files, no SDK required
  • Every write is durable in the database, with per-file atomic commits and time-travel views
  • Dedicated instance per claim: exclusive PolarDB-X Enterprise base + PXFS, destroyed on release

Read https://zero.polardbx.com/pxfs/SKILL.md and follow the instructions to mount a PXFS workspace.

PXFS Instance

Beta

Claim a dedicated PXFS + PolarDB-X Enterprise stack from the warm pool

Loading...

Mount in 3 steps

Run a token tunnel sidecar, then mount PXFS as a local NFS volume.

Linux (Docker)
# 1. 保存访问 Token(600 权限,不进 shell history)
printf '%s' '<YOUR_ACCESS_TOKEN>' > ./pxfs-token && chmod 600 ./pxfs-token

# 2. 启动 sidecar 隧道(TLS + SCRAM,本地监听 127.0.0.1:12050)
docker run -d --name pxfs-sidecar \
  --network host --restart unless-stopped \
  --mount type=bind,src=$PWD/pxfs-token,dst=/etc/pxfs/token,readonly \
  -e PXFS_LISTEN=127.0.0.1:12050 \
  -e PXFS_TUNNEL_ENDPOINT='pxc-xxxxxxxxwn-pfs-pub.polarxpxfs.example.aliyuncs.com:12049' \
  -e PXFS_TOKEN_FILE=/etc/pxfs/token \
  reg.docker.alibaba-inc.com/apsaradb/pxfs-sidecar:latest

# 3. 挂载 NFS(见 mount 页签)

The commands use placeholder values. Claim an instance above and the real endpoint and token will be filled in automatically.

What you get

A standard file system with database superpowers.

📁

Standard Interface

POSIX / NFS

Plain files, zero code changes

  • NFS v4.1 protocol, kernel-native mount
  • Regular file APIs for any language
  • Works with Git, SQLite and existing tools
  • Per-user home and shared directories
🗄️

Database-native

Transactional

Files stored in PolarDB-X

  • Per-file atomic commit
  • Microsecond-level time travel views
  • .versions / .snapshot virtual directories
  • Content-addressed dedup across files
🔐

Secure Access

Token Tunnel

One token, one identity

  • TCP/TLS tunnel with SCRAM-SHA-256
  • Tenant / identity / token isolation
  • IP whitelist on the public endpoint
  • Revocation takes effect immediately
🤖

Agent-ready

For AI Agents

Built as Agent workspace

  • Workspace per Agent identity
  • Official file-system Skill built in
  • SQLite on PXFS supported
  • Quota and rate limits per tenant

Instance lifecycle

Claim, mount, build — the platform reclaims everything at expiry.

🎫

Claim

Take a prewarmed dedicated PXFS + PolarDB-X Enterprise stack from the pool; endpoint and access token are issued to you.

🔌

Mount

Start the sidecar tunnel with your token and mount PXFS as a local NFS volume on Linux or macOS.

📂

Build

Point your Agent's home at the mount. Files are durable, versioned and queryable in the database.

♻️

Release

Release manually or let the TTL expire — the whole stack is destroyed and never reused.

PXSearch · Intelligent Search Engine

A search engine you can use right away: Search

PolarDB-X Search is a standalone, OpenSearch 3.0-compatible search engine. Inverted indexes, vector kNN, BM25 hybrid ranking and Dashboards are all ready — one claim gets you a public REST endpoint and a dedicated account.

  • Standard OpenSearch REST API — any HTTP client connects directly, no SDK required
  • Chinese analyzers, vector kNN and hybrid search out of the box, a natural fit for RAG
  • Dedicated cluster per claim: public endpoint + private account + IP whitelist, destroyed on release

How this differs from the Vector section on the home page: there you query vector columns with SQL inside PolarDB-X, which suits existing business tables; here you get a standalone search engine, which suits full-text-first workloads that need BM25 and vector scores blended together.

Read https://zero.polardbx.com/pxsearch/SKILL.md and follow the instructions to claim a PXSearch cluster.

PXSearch Cluster

Beta

Claim a dedicated OpenSearch-compatible cluster from the warm pool

Loading...

Search in 4 steps

Create an index, bulk load, run full-text search, then vector and hybrid search — all with plain curl.

1. Create index
export PXS_URL='http://pxs-xxxxxxxx-pub.polarxsearch.rds.aliyuncs.com:9200'
export PXS_AUTH='<USERNAME>:<PASSWORD>'

# 连通性自检:返回集群名与版本即为地址和账号可用
curl -sS -u "$PXS_AUTH" "$PXS_URL"

# 建索引:开 kNN + 中文分词 + 4 维向量字段
# 集群至少 2 个数据节点,replicas=1 有地方放,health 能到 green
curl -sS -u "$PXS_AUTH" -XPUT "$PXS_URL/docs" \
  -H 'Content-Type: application/json' -d '{
  "settings": { "index": { "knn": true, "number_of_shards": 1, "number_of_replicas": 1 } },
  "mappings": { "properties": {
    "title":   { "type": "text", "analyzer": "ik_max_word" },
    "content": { "type": "text", "analyzer": "ik_max_word" },
    "embedding": {
      "type": "knn_vector", "dimension": 4,
      "method": { "name": "hnsw", "engine": "faiss", "space_type": "l2" }
    }
  } }
}'

The commands use placeholder values. Claim a cluster above and the real endpoint and credentials will be filled in automatically.

What you get

A complete search engine, with full-text and vectors in the same index.

🔍

Full-text Search

Full-text

Inverted indexes and analyzers

  • ik_max_word / ik_smart Chinese analyzers
  • BM25 relevance scoring with custom boosts
  • Highlighting, aggregations, sorting, pagination
  • Synonyms, stopwords and custom dictionaries
🧭

Vector Search

Vector kNN

Native knn_vector field type

  • HNSW graph index on faiss / nmslib
  • l2 / cosine / inner-product distances
  • Filtered kNN queries supported
  • Vectors stored beside structured fields
🤖

Hybrid & AI

Hybrid & RAG

Blend both recall paths in one query

  • Weighted fusion of BM25 and vector scores
  • Drop-in retrieval layer for RAG
  • Standard REST — works with LangChain and friends
  • Official search Skill built in for Agents
📊

Dashboards & Ops

Dashboards

Web console included

  • Dev Tools console for ad-hoc queries
  • Discover for browsing docs and fields
  • Visualize for charts and dashboards
  • IP whitelist on the public endpoint

Cluster lifecycle

Claim, index, search — the platform reclaims everything at expiry.

🎫

Claim

Take a prewarmed dedicated cluster from the pool; the public REST endpoint, account credentials and Dashboards URL are issued to you.

🗂️

Index

Create an index with curl: attach an analyzer to text fields and declare knn_vector for vectors. Note that knn can only be enabled at index creation time.

🔍

Search

Use full-text, vector or hybrid queries — or open Dashboards for interactive exploration.

♻️

Destroy

Release manually or let the TTL expire — the whole cluster is destroyed and never reused.

Note: TTL expiry is a hard delete, not a shutdown. The cluster, its indices and all data are destroyed and cannot be recovered — never keep this as the only copy of data you care about.

FAQ