A single Python process that gives you an OpenAI-compatible chat API, a React web console, a multi-agent runtime, RAG, long-term memory, a code sandbox, and 30+ tools — and the whole thing is one repo, one make up, one python -m data_ai.core.api.server.

I built this because every "AI platform" demo I saw needed four containers and a half-day of YAML to even boot. I wanted something I could git clone and have running before my coffee got cold.

• Single agent, multi-agent teams. Consensus (LLM synthesis, vote, semantic), reflection, iteration limits. The agent loop is real — every tool call hits a real adapter; the failures are real too.
• 19 LLM providers behind one registry. OpenAI, Anthropic, Google, Azure, Bedrock, DeepSeek, SiliconFlow, Qwen, Zhipu, Moonshot, Yi, Baichuan, Doubao, StepFun, Ollama, vLLM, LM Studio, and a built-in offline model for tests.
• 30+ tools for file I/O, Python / Bash / Node sandbox, browser automation, web search, PDF / Word / Excel / PPT, data analysis.
• RAG + memory in the same process. In-memory, FAISS, Chroma, or LanceDB. Long-term memory is wired into the chat loop, not bolted on after the fact.
• ContextStore — named, file-backed, JSON-tree project memory. Save drafts, outlines, character sheets; diff them across commits; never lose them inside a chat session.
• 4 ready-made enterprise presets (customer service, finance analyst, secretary, novel writer) so you don't start from a blank system prompt.

cp .env.example .env
# add your OPENAI_API_KEY
make up
# open http://localhost:3000

That's the whole on-ramp. Everything else is in docs/.

DATA-AI is a single backend process that exposes a chat-compatible HTTP API plus a static web UI. It is meant to be self-hosted: clone, set an API key, run python -m data_ai.core.api.server, and you have a working multi-model agent in under a minute.

The interesting parts:

• Real agent runtime. Single agents and multi-agent teams, with consensus (LLM synthesis, majority vote, semantic), reflection, and iteration limits. Not a prompt wrapper.
• 19 LLM providers behind one registry. OpenAI, Anthropic, Google, Azure, AWS Bedrock, DeepSeek, SiliconFlow, Qwen, Zhipu, Moonshot, Yi, Baichuan, Doubao, StepFun, Ollama, vLLM, LM Studio, plus a built-in offline model for tests and demos.
• 30+ tools. File ops, Python / Bash / Node sandbox, browser automation, web search, PDF / Word / Excel / PPT processing, data analysis, system tools.
• RAG and memory in the same process. In-memory, FAISS, Chroma, or LanceDB. Long-term memory with summarization is wired into the chat loop, not bolted on.
• ContextStore — named, file-backed project memory. Save / load / version / search any long text (drafts, outlines, character sheets) in a transparent JSON tree, git-friendly, decoupled from chat sessions. See core/context_store.py.
• Four ready-made enterprise agent presets. Customer service, finance analyst, secretary, and novel writer. Each ships with a tuned system prompt, scoped tool list, and default context namespace. Load with one line: plugins/agents/.
• Colloquial-Chinese intent normalizer. Lightweight typo / filler / mixed-language fixes (e.g. 帐单→账单, 给我弄→帮我, 打开 app→打开 应用) applied before intent matching. See _normalize_colloquial.
• One-shot sandbox setup. bash scripts/setup_sandbox.sh installs every system package, Python lib, and CJK font DATA-AI needs in a fresh container.
• A web console that actually works. Vite + React 19, SSE streaming chat, dark / light theme, English / 简体中文 switchable from the topbar, no telemetry.

The backend is small enough to read in an afternoon. The interesting files are src/data_ai/core/llm/manager.py (the LLM registry), src/data_ai/core/agent/base.py (the agent loop), and src/data_ai/core/api/server.py (the HTTP surface — 70+ routes).

pip install -e .
data-ai chat --model offline-chat

offline-chat is built in, so this works with no API key. You get a REPL that exercises the agent loop, tool registry, and memory.

# 1) Backend — http://127.0.0.1:8000
pip install -e .
# 如遇 FastAPI 0.115+ 的 "Status code 204 must not have a response body" 启动失败,
# 跑一次兼容性补丁 (幂等, 打过会跳过):
# make patch
python -m data_ai.core.api.server
# 2) Frontend — http://127.0.0.1:5173
cd web
npm install
npm run dev

Open http://127.0.0.1:5173. The default page is the Chat Console: pick a model, send a message, watch it stream token by token.

To use a real provider, set its env var before starting the backend:

export DEEPSEEK_API_KEY="sk-..." # any of OPENAI_*, ANTHROPIC_*, DEEPSEEK_*, ...
# or set DATA_AI_API_KEYS to enable inbound auth
export DATA_AI_API_KEYS="any-token"
# or skip auth in dev
export DATA_AI_DEV_MODE=true

See docs/INSTALLATION.md and docs/CONFIGURATION.md for the full reference.

Switch UI language from the topbar — supports English and 简体中文 without a reload.

• Global: OpenAI, Anthropic, Google Gemini, Azure OpenAI, AWS Bedrock
• Chinese: DeepSeek, Qwen, Zhipu, Moonshot, Yi, Baichuan, Doubao, StepFun, SiliconFlow
• Local / self-hosted: Ollama, vLLM, LM Studio
• Built-in: offline-chat, offline-fast, offline-mini — templated replies, used for CI, tests, and demos. No external call.

All Chinese / global providers except Anthropic and Google are OpenAI-compatible and share a single client implementation with auto-detected base_url. See PROVIDER_DEFAULT_BASE_URL.

The server auto-registers a model for any of these env vars on startup (see the lifespan hook in src/data_ai/core/api/server.py):

• BaseAgent with tool calling, reflection, iteration control
• Self-Reflection (P0-2): LLM 评估自己答案的 confidence,issues 注入回 messages
• Checkpoint 持久化 (P1-1): 每轮 iteration 自动存盘, 支持 resume, gzip 压缩
• Human-in-the-Loop (P1-2): 危险工具触发暂停, 等人工 approve / reject (5min 超时自动 reject)
• Sub-Agent 委派 (P1-3): delegate(query, role) spawn sub-agent, 套 preset (customer_service / finance_analyst / secretary / novel_writer), delegate_many 并行
• Tool Retry (P1-4): 异常分类 (retryable / permanent), 指数退避 + jitter, 防 thundering herd
• AgentTeam with LLM synthesis / majority vote / semantic / concatenation consensus
• Sequential thinking and closed-loop learning are part of the same loop, not a separate "mode"

• File ops: read / write / search / replace / batch
• Code execution: Python sandbox, Bash, Node.js with real stdout capture
• Browser automation: navigation, click, screenshot, form filling (Playwright, optional)
• Documents: PDF, Word, Excel, PPT, Markdown, HTML
• Data analysis: Pandas, Matplotlib, Plotly
• Office workflows with real .docx / .pptx / .xlsx / .pdf round-trip

• Loaders: PDF, Word, Markdown, HTML, TXT
• Splitters: recursive character, token-based
• Stores: in-memory, FAISS, Chroma, LanceDB
• Retrieval: similarity, MMR diversity, with citations

• Session / semantic / short-term / long-term
• Automatic summarization when the window grows
• Closed-loop: execute → evaluate → extract → retrieve

Three production tiers, all shipped and self-hostable. Each tier maps to a recurring customer pain point (audit gap, access control, compliance, business continuity, contractual SLA).

All three tiers share the same shape:

• Pure-Python core under data_ai.core.<module>/ — usable from from data_ai.core.tenants import get_tenant_store without the API
• REST surface mounted under /v1/... (see api/extensions.py)
• Typed Python SDK client (from data_ai.sdk_client import DataAIClient)
• Typed TypeScript client (web/src/lib/api/client.ts)
• Web console page + sidebar entry + i18n strings
• Unit tests under tests/test_enterprise_tier*.py (current: 423 passing)

src/data_ai/
├── core/
│ ├── llm/manager.py LLM registry, 19 providers, streaming
│ ├── agent/base.py BaseAgent, AgentTeam, consensus
│ ├── api/server.py FastAPI app, 70+ routes
│ ├── api/extensions.py Resource routers (agents, memory, ...)
│ ├── api/auth.py Bearer-key verification
│ ├── tool/ 30+ tools
│ ├── memory/ Short / long-term memory
│ ├── rag/ Loaders, splitters, vector stores
│ ├── sandbox/ Local + docker sandbox
│ ├── office/ Word / PPT / Excel / PDF processors
│ └── i18n/ catalog + locale negotiation
├── utils/ config, exceptions, logging, platform
├── cli/ typer commands (data-ai ...)
└── __main__.py data-ai entry point

See docs/ARCHITECTURE.md for the long version.

A short version — the full reference is in docs/CONFIGURATION.md.

A TOML file at config/config.toml works too — see config/config.example.toml for the template.

• Sandboxed code execution with CPU / memory / time limits
• Strict / moderate / permissive policy presets
• Bearer-key auth on every route by default
• Skill execution is gated behind an explicit env var so a default install cannot shell out even if the auth is bypassed
• No telemetry, no phone-home, no third-party requests outside the providers you configure

DATA-AI is suitable for self-hosting and experimentation. It is not a managed SaaS. The breaking-change rate is roughly once a month while the agent API stabilizes.

Enterprise governance is delivered in numbered tiers. Tier 1, 2, and 3 are shipped (see Enterprise Governance above). Future tiers are listed here so customers and contributors can plan ahead.

Track the latest tier progress in ROADMAP.md (kept in sync with each tier commit).

See CONTRIBUTING.md. The short version: fork, branch, make install-dev, make test, open a PR. Keep changes small and falsifiable.

MIT.