diff --git a/NOTICE b/NOTICE
index e1015a9c..b5a09205 100644
--- a/NOTICE
+++ b/NOTICE
@@ -24,6 +24,31 @@ https://github.com/MAX-API-Next/MAX-API
Modified versions must not misrepresent the origin of the software and must
mark their changes in accordance with AGPLv3 Section 7(c).
+==== Preserved New API Upstream Notice ====
+
+new-api
+Copyright (c) QuantumNous and contributors.
+
+This project includes software derived from New API, which is licensed under
+the GNU Affero General Public License v3.0. The following additional terms from
+the New API NOTICE are preserved:
+
+Pursuant to Section 7(b) of the GNU Affero General Public License version 3,
+the following reasonable legal notice and author attribution must be preserved
+by modified versions in the Appropriate Legal Notices and in any prominent
+about, legal, footer, or attribution location presented by the user interface:
+
+"Frontend design and development by New API contributors."
+
+Modified versions that present a user interface must also preserve a visible
+link to the original project in a prominent about, legal, footer, or
+attribution location:
+
+https://github.com/QuantumNous/new-api
+
+Modified versions must not misrepresent the origin of the software and must
+mark their changes in accordance with AGPLv3 Section 7(c).
+
==== Third-Party Notices ====
This product includes third-party open source software. Copyright notices and
diff --git a/README.en.md b/README.en.md
index 67e8ad3a..0b69f8b8 100644
--- a/README.en.md
+++ b/README.en.md
@@ -1,10 +1,14 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**AI Models and Agents governance, intelligent operations, and open collaboration infrastructure for the AGI application era**
+
+**MAX API 2.0: entering the intelligent operations era · evolving from a unified model gateway to AGI-native governance and operations**
-🍥 **AI Model Governance, AgentOps, and AGI Application Service Infrastructure**
+[View the MAX API 2.0 Preview release notes](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
-
----
-
-## 📝 Project Description
-
-MAX API is an AI model governance, AgentOps, and application service infrastructure project initiated, maintained, and operated long term by AGI enthusiasts from research institutions and universities. It provides developers, researchers, teams, and organizations with a stable and reusable service layer. The project focuses on the operational problems that appear after AI applications move into real use: more models, frequent upstream API changes, longer Agent call chains, and rising pressure around cost and auditability. MAX API provides a unified access, authentication, routing, billing, observability, and governance layer between applications, Agents, users, organizations, and upstream model providers, helping AI applications run with greater stability and control.
-
-In practice, MAX API is more than a request forwarder. It is an operable gateway for AI-ready applications and Agent workloads, bringing protocol normalization, provider differences, traffic bursts, long streaming responses, large request bodies, multi-node cache, cost audit, and performance observability under one governance boundary.
-
-Ongoing investment areas:
-
-- **AI model governance**: continuously tracks model updates, API changes, parameter differences, pricing rules, and task protocols across OpenAI, Azure OpenAI, AWS Bedrock, Vertex AI, Ollama, and domestic platforms such as DeepSeek, Qwen / Alibaba Cloud Model Studio, Zhipu GLM, Kimi, Doubao / Volcano Engine, Tencent Hunyuan, Baidu ERNIE / Qianfan, iFlytek Spark, MiniMax, 01.AI, and SiliconFlow. It also tracks application and multimodal ecosystems such as Dify, RAGFlow, Kling, and Seedance, bringing distributed model capabilities into unified governance through channels, model mapping, protocol conversion, path overrides, and configurable task protocols.
-- **AI Agent governance / AgentOps**: improves token governance, model access control, call tracing, cost attribution, failure diagnosis, and log audit around Agent, workflow, and tool-calling scenarios, while reserving unified governance boundaries for MCP-style tools and services.
-- **Channel configuration governance**: provides a channel capability matrix and configuration validation in channel creation and editing views, showing capabilities such as `chat/completions`, `responses`, `embeddings`, `rerank`, `video tasks`, and model discovery, while warning about common risks such as Base URL, JSON configuration, Vertex AI region, Codex credentials, and video task placeholders.
-- **Operations and cost governance**: continuously improves channel routing, retry, rate limiting, pre-charge, failure refund, log observability, cost statistics, and operations analysis. Text and multimodal token scenarios can use expression-based billing and unified JSON configuration, while asynchronous video tasks can use parameterized rate-cards, making model and Agent costs easier to understand, calculate, and maintain in batches.
-
-> [!IMPORTANT]
-> - When providing public generative AI services, users should comply with applicable regulatory requirements and independently complete filings, licensing, content safety, real-name verification, log retention, tax, payment, and upstream authorization obligations required by their jurisdiction.
-> - Sensitive capabilities such as log audit and content retention should only be enabled when there is a lawful basis, clear notice, permission isolation, and proper data security measures.
-> - MAX API provides a gateway governance layer for model and Agent workloads. It does not provide upstream model accounts, API keys, foundation model training, or replace Agent orchestration/application frameworks such as Dify, LangChain, or MCP Server.
-
----
-
-## 🚦 Release Channels
-
-Current MAX API releases are divided into stable releases and Preview releases. Preview releases make new capabilities and fixes available early so the community and deployment operators can validate compatibility, stability, and security in real environments. A stable release is published after the corresponding Preview release has run stably for 1 week, reducing production upgrade risk and improving system safety and reliability.
-
-Production deployments should prefer stable releases. Use Preview releases in test or canary environments when you need to validate new features, fixes, or compatibility changes early, and prepare database backups and rollback plans before upgrading.
-
----
-
-## 🎯 Project Positioning
-
-In the AGI application era, MAX API focuses on open AI model governance and AI Agent governance infrastructure, building the service, governance, and operations layer that helps developers and organizations run AI applications and Agent workloads reliably:
-
-- **Model governance plane**: unified management for model entry points, channels, providers, protocol formats, model mappings, pricing rules, task protocols, and multimodal APIs.
-- **AgentOps control plane**: does not replace Agent orchestration frameworks; instead it provides token governance, model access control, call logs, cost tracking, failure diagnosis, and operations analysis at the gateway layer.
-- **Channel configuration plane**: reduces misconfiguration risk when adding upstream channels, migrating providers, or maintaining non-standard APIs through capability matrices, form validation, model discovery, and protocol templates.
-- **Protocol and provider adaptation layer**: continuously tracks official overseas APIs, domestic model platform APIs, and OpenAI-compatible / non-standard interface changes, then normalizes them into stable application-side APIs.
-- **Cost, quota, and reliability governance**: supports channel routing, weighted distribution, retry, rate limiting, pre-charge, failure refund, expression billing, fixed pricing, task rate-cards, multiplier billing, and usage statistics.
-- **Performance and scalability governance**: uses Redis / in-memory cache, model request rate limits, streaming timeouts and large-response buffers, request body limits, disk cache, Pyroscope profiling, and graceful shutdown to support stable single-node and multi-node deployments.
-- **Organization operations and audit layer**: provides user management, group management, private deployment, data retention, audit, and continuous operations optimization for teams, research institutions, enterprises, and community services.
-- **Reusable governance templates**: accumulates channel templates, task protocol templates, pricing configuration, deployment practices, and operations experience to reduce onboarding cost for new models, providers, and Agent scenarios.
-
----
-
-## 🧠 Governance Framework
-
-MAX API brings AI model and AI Agent execution into a configurable, observable, accountable, and auditable governance framework.
-
-| Governance object | MAX API capabilities | Goal |
-|----------|-------------------|------|
-| Model assets | Model lists, model mapping, model groups, model restrictions, pricing rules, and multimodal API management | Help organizations know which models exist, who can use them, how they are billed, and how to switch them |
-| Upstream channels | Provider channels, weights, groups, status, keys, Base URL, path overrides, capability matrix, configuration validation, model discovery, and failure retry | Reduce risks from single-provider outages, price changes, rate limits, misconfiguration, or API changes |
-| Protocol formats | OpenAI Compatible, Responses, Claude Messages, Gemini, Realtime, generic video task protocol, and protocol conversion | Let applications face stable interfaces instead of directly handling provider-specific protocol differences |
-| Agent tokens | API keys, token groups, model scopes, quota limits, expiration, and access control | Assign independent, revocable, and quota-limited credentials to Agents, workflows, and tool calls |
-| Usage and cost | Request logs, usage statistics, expression billing, tiered billing JSON, task rate-cards, pre-charge, and failure refund | Attribute model costs to users, groups, tokens, models, channels, and nodes |
-| Asynchronous tasks | Video task submission, polling, status mapping, result proxying, and task billing | Govern long-running, multi-state, multi-provider multimodal tasks uniformly |
-| Audit and security | Admin-side log audit, error logs, request limits, streaming timeout, login, and permission control | Provide controlled audit boundaries in private deployment and compliance scenarios; sensitive content audit is managed under Security & Limits |
-| Organization operations | Users, groups, balance, payment, system settings, dashboards, and operations configuration | Support continuous operations for teams, research institutions, enterprises, or community services |
-
----
-
-## 🧩 Use Cases
-
-- **Internal AI model governance platform**: centrally manage users, tokens, models, channels, groups, permissions, pricing, and billing so each team does not repeatedly integrate and maintain upstream services.
-- **Runtime and governance base for Agent applications**: provide a stable model gateway, token isolation, cost control, call observability, failure diagnosis, and audit foundation for Agents, workflows, and tool-calling applications.
-- **Domestic model and multi-provider adaptation center**: continuously track domestic and overseas model platform APIs and pricing changes, reducing adaptation cost through channel configuration, model mapping, path overrides, and protocol templates.
-- **Multimodal task governance platform**: unify access to text, images, videos, audio, embeddings, rerank, and realtime conversation APIs, with status, result proxying, and billing governance for asynchronous tasks.
-- **Model and Agent cost accounting platform**: allocate quotas, calculate fees, summarize bills, and analyze costs by user, token, model, channel, and group.
-- **Private and compliance-oriented operations environment**: suitable for teams or organizations that need to independently manage keys, data, permissions, logs, audit, and billing strategies.
-
----
-
-## 🚀 Quick Start
-
-SQLite is used by default, so local evaluation does not require an external database.
-
-> [!WARNING]
-> SQLite is intended only for local evaluation, development, and small-scale testing. It is not recommended for production: concurrent requests, multi-instance deployments, large log or usage datasets, database migrations, backup and restore operations, and long transactions can cause lock contention, blocked writes, slow or failed migrations, and other availability or data-maintenance problems. Use MySQL ≥ 5.7.8 or PostgreSQL ≥ 9.6 with a reliable backup and recovery plan in production.
-
-```bash
-# 1. Pull the image
-docker pull cscitechtop/max-api:latest
-
-# 2. Start the service and persist data under ./data
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
-
-# 3. Open the console
-# Visit http://localhost:3000 in your browser
-```
-
-Production deployment should use Docker Compose and explicitly configure the database, Redis, session secret, encryption secret, and log directory.
-
-```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
-
-# Modify database, Redis passwords, and environment variables in docker-compose.yml as needed
-docker compose up -d
-```
-
-> [!WARNING]
-> If you operate this project as a public generative AI service or API service, complete upstream authorization, filing, content safety, real-name verification, log retention, tax, payment, and user agreement obligations first.
-
----
-
-## ✨ Key Capabilities
-
-### AI Model Governance
-
-| Capability | Description |
-|------|------|
-| Unified model entry point | Supports OpenAI-compatible APIs, Responses, Claude Messages, Gemini, Realtime, and other protocol entries so applications can access models through one gateway |
-| Multi-provider model pool | Supports OpenAI, Azure, Claude, Gemini, AWS Bedrock, Vertex AI, and Ollama; continuously tracks and includes adapters or compatible access for DeepSeek, Qwen, Zhipu GLM, Kimi, Doubao, Tencent Hunyuan, ERNIE, iFlytek Spark, MiniMax, 01.AI, SiliconFlow, and other domestic platforms |
-| Upstream ecosystem adaptation | Supports governance for interfaces related to Codex, Dify, RAGFlow, Kling, Seedance, and other application, Agent, and multimodal platforms, bringing model calls, workflow calls, and asynchronous tasks into one gateway |
-| Model mapping and access scope | Supports per-channel model lists, model mapping, user groups, token groups, and model restrictions, allowing different teams, applications, or Agents to use different model sets |
-| Channel capability matrix | Channel editing view shows capability status for `chat/completions`, `responses`, `Claude Messages`, `Gemini native`, `embeddings`, `images`, `audio`, `rerank`, `video tasks`, `model discovery`, and more |
-| Channel configuration validation | Checks API Key, model list, Base URL, extra configuration, JSON objects, Vertex AI region, Codex credentials, model discovery capability, and video task path placeholders before saving |
-| Multimodal model governance | Supports chat, images, video, audio, embeddings, rerank, realtime conversation, and submission/polling/status mapping/result proxying for asynchronous video tasks |
-| Generic video task protocol | Allows task submission, query, progress, status mapping, error message, and result URL paths from different video upstreams to be configured uniformly in a channel; request-body passthrough and rewrites use the existing channel settings; default paths are `/v1/videos/create` and `/v1/videos/{task_id}` |
-| Protocol conversion and custom upstreams | Supports conversion and adaptation among OpenAI Compatible, Responses, Chat Completions, Claude Messages, Gemini, and other formats, as well as legally authorized upstream URLs, path overrides, and task protocol parsing rules |
-
-### AI Agent Governance / AgentOps
-
-| Capability | Description |
-|------|------|
-| Agent token isolation | Create independent API keys for Agents, workflows, plugins, tool calls, or users, with model scope, quota, expiration, and group settings |
-| Model access control | Control which models an Agent can call, which channels it can use, and how much quota it can consume through users, tokens, groups, model restrictions, and channel policies |
-| Call-chain observability | Provides request logs, usage statistics, channel hits, latency, errors, and retry information to diagnose Agent failures, cost anomalies, and upstream instability |
-| Cost attribution | Tracks cost and usage by model, channel, user, group, token, and node, making it easier to calculate costs for different Agents, business lines, or deployment nodes |
-| Admin audit | Private deployments can enable admin-side log audit according to compliance requirements; normal user log APIs filter admin-only audit fields |
-| Operations dashboard | Provides admin-facing analytics, user management, channel management, system settings, and operations analysis |
-
-### Cost, Billing, and Reliability Governance
-
-**Model pricing expressions**
-
-- **One expression = the complete pricing rule for one token model**: tiered pricing, cache hits, image/audio token items, time-based discounts, and dynamic markups based on request headers or parameters can all be written in one line.
-- **Prices are real prices**: coefficients can be entered directly as USD per million tokens. `p * 2.5` means USD 2.5 per million input tokens. Traditional multiplier mode remains compatible.
-- **Visual + raw editing modes**: fill in prices and conditions visually or edit expressions directly, with built-in templates for common models.
-- **Unified JSON batch maintenance**: maintain `{ enabled, expr }` rules for multiple models in one `Tiered billing JSON` window; saving atomically updates `billing_mode` and `billing_expr`.
-- **Automatic token normalization**: separates cache, image, audio, and other subcategories from input/output according to upstream format and variables used by the expression, preventing double billing; logs can show the matched pricing tier and details.
-
-**Task billing, traditional billing, and reliability**
-
-- Supports parameterized rate-card billing for asynchronous tasks such as video, matching prices by model, vendor, duration, quality, audio, video input, and other fields. `task_billing_setting.rate_cards` can be maintained as JSON and split by `vendor` for providers such as Sora, Veo, Seedance, and Kling.
-- Compatible with usage-based, per-call, cache-hit, model multiplier, group multiplier, and channel multiplier billing modes.
-- Supports pre-charge, failure refund, exception handling, and consumption logs for long-running Agent call chains and asynchronous multimodal tasks.
-- Supports weighted channel routing, failure retry, disabled-channel bypass, and model-level routing to reduce upstream impact on applications and Agents.
-- Supports Redis and in-memory cache for single-node and multi-node deployments.
-
-### Performance and Scalability Governance
-
-| Capability | Description |
-|------|------|
-| Cache and multi-node scaling | Single-node deployments can use in-memory cache, while multi-node deployments can use Redis; user, token, channel affinity, and quota-related caches reduce repeated database reads, while `SESSION_SECRET`, `CRYPTO_SECRET`, and `NODE_NAME` keep sessions, encryption, and log attribution consistent |
-| Rate limits and capacity protection | Supports global API / Web rate limits, critical endpoint limits, search limits, model request limits, and group-specific model request quotas; counters can use Redis or memory |
-| Streaming and large-request controls | Supports `STREAMING_TIMEOUT`, `STREAM_SCANNER_MAX_BUFFER_MB`, `MAX_REQUEST_BODY_MB`, `MAX_FILE_DOWNLOAD_MB`, and related settings for long streams, large SSE lines, decompressed request bodies, and remote file downloads |
-| Relay connection tuning | Supports `RELAY_TIMEOUT`, `RELAY_IDLE_CONN_TIMEOUT`, `RELAY_MAX_IDLE_CONNS`, and `RELAY_MAX_IDLE_CONNS_PER_HOST` for upstream HTTP timeout and connection-pool behavior |
-| Disk cache and performance observability | System performance settings can enable disk cache for large request bodies and configure cache threshold and capacity; operations endpoints can inspect / clear disk cache, and Pyroscope can collect CPU, memory, goroutine, mutex, and block profiles |
-| Graceful shutdown and data flush | Shutdown supports `SHUTDOWN_TIMEOUT_SECONDS` and `QUOTA_DATA_CACHE_SAVE_TIMEOUT_SECONDS` so the process can close HTTP handling and save quota cache before exit when possible |
-
-### Security and Organization Management
-
-- Supports JWT, WebAuthn/Passkeys, OAuth, OIDC, Telegram, Discord, LinuxDO, and other login methods.
-- Supports administrator, normal user, group, token, and model access control.
-- Supports request body size limits, streaming timeout control, error logs, and runtime health checks.
-- Supports unified session secret, encryption secret, and Redis shared cache for multi-node deployments.
-
----
-
-## 🆚 Why Use a Gateway
+
-| Dimension | Direct official SDK / API integration | Through MAX API gateway |
-|------|------------------------|-------------------|
-| Model access | One SDK, authentication flow, and parameter set per provider | One model entry point, one integration, multi-model reuse |
-| Model governance | Model lists, pricing, permissions, and channels scattered across platforms | Unified model, channel, mapping, group, quota, and pricing rule management |
-| Agent access | Agents directly hold upstream keys, making revocation and quota control difficult | Assign independent tokens to Agents with model, quota, expiration, and group limits |
-| Protocol differences | Applications adapt Claude, Gemini, Responses, and other formats themselves | Gateway handles protocol conversion and provider adaptation |
-| Failure handling | Applications implement retry, fallback, and error normalization themselves | Channel failure retry, weighted routing, and error handling are built in |
-| Performance and scaling | Applications handle timeouts, rate limits, connection pools, and cache themselves | Gateway centralizes streaming timeouts, request limits, Redis / in-memory cache, connection-pool tuning, and performance observability |
-| Cost statistics | Bills are scattered across providers and hard to attribute by user or Agent | Unified quota, billing, usage statistics, and consumption logs, attributable by token and model |
-| Audit boundary | Application-side logging is fragmented and retention/permission policies differ | Unified admin audit entry with normal user logs filtering admin-only fields |
-| Private deployment | Keys, logs, and billing strategies are scattered | Self-hosted control over keys, data, logs, and policies |
+
---
-## 🧭 Architecture Overview
-
-MAX API uses a layered architecture. Application, SDK, or Agent requests enter through a unified entry point, pass through routing, middleware, controllers, and business services, and are finally adapted by the relay layer to the corresponding upstream provider. The data and cache layers provide persistence and acceleration for model governance, Agent token governance, billing, logs, audit, and task status.
-
-```mermaid
-flowchart LR
- Client[Client / SDK / Agent] --> Router[Router Routing]
- Router --> MW[Middleware Auth · Rate Limit · Dispatch · Logs]
- MW --> Ctrl[Controller Request Handlers]
- Ctrl --> Svc[Service Model Governance · AgentOps · Billing Audit]
- Svc --> Relay[Relay Proxy / Protocol Conversion]
- Relay --> Adapters[Channel Adapters OpenAI · Claude · Gemini · Domestic Platforms · Custom Upstreams]
- Adapters --> Upstream[(Upstream Model Services)]
- Svc --> Model[Model GORM]
- Model --> DB[(SQLite · MySQL · PostgreSQL)]
- Svc --> Cache[(Redis · In-memory Cache)]
-```
-
-### Directory Structure
-
-| Directory | Responsibility |
-|------|------|
-| `router/` | HTTP routing, including API, relay, dashboard, and web entries |
-| `controller/` | Request handlers for parameter parsing, authenticated business entry points, and response wrapping |
-| `service/` | Business logic including model governance, AgentOps, logs, billing, audit, tasks, channels, and system settings |
-| `model/` | Data models and database access, based on GORM and compatible with SQLite, MySQL, and PostgreSQL |
-| `relay/` | AI API relay, protocol conversion, and provider adaptation |
-| `relay/channel/` | Provider adapters such as openai, claude, gemini, aws, and more |
-| `middleware/` | Authentication, rate limiting, CORS, logs, request distribution, and context handling |
-| `setting/` | Model pricing, task billing, operations, system, security, and performance settings |
-| `common/` | Shared utilities for JSON, encryption, Redis, rate limiting, environment variables, and more |
-| `dto/` / `types/` | Type definitions for requests, responses, errors, and relay formats |
-| `constant/` | API types, channel types, context keys, and other constants |
-| `i18n/` / `oauth/` / `pkg/` | Backend i18n, OAuth implementations, and internal packages |
-| `web/` | Frontend theme container; the default theme is under `web/default/` |
-
-### Technology Stack
-
-| Layer | Technology |
-|------|------|
-| Backend | Go 1.25+, Gin, GORM v2 |
-| Frontend | React 19, TypeScript, Rsbuild, Base UI, Tailwind CSS |
-| Package management | Bun workspace |
-| Database | SQLite / MySQL ≥ 5.7.8 / PostgreSQL ≥ 9.6 |
-| Cache | Redis + in-memory cache |
-| Authentication | JWT, WebAuthn/Passkeys, OAuth, OIDC |
+MAX API sits between applications, Agents, and upstream model services as a unified model gateway, governance control plane, and operations entry point. The MAX-API-Next community builds the project around practical AGI engineering and welcomes developers, researchers, enterprise engineering teams, university technology enthusiasts, and open-source contributors. Our goal is to provide the model access, permissions, cost controls, Evidence, intelligent operations, and safety foundations that real AGI applications require.
----
+In the AGI field, we will **continuously deliver advanced and verifiable technology, turn real production problems into open engineering capabilities, and build a community for shared research and contribution.**
-## 🤖 AI Model and Interface Support
+## 🌐 Join the MAX-API-Next community
-> Actual available models depend on your upstream authorization, channel configuration, model mapping, and provider support. MAX API focuses on bringing these capabilities into unified governance; it does not provide upstream model services itself.
+MAX API is more than a code repository. It is a long-term open collaboration around AI Models, Agents, AgentOps, and AGI engineering. Whether you operate a model gateway, build Agents, adapt new models, research evaluation and governance, or improve documentation and localization, you are welcome to join the community and contribute.
-| Type | Description |
-|------|------|
-| OpenAI-Compatible | Compatible APIs such as Chat Completions, Embeddings, Images, and Audio, usable as a general model entry point for most applications and Agents |
-| OpenAI Responses | Responses-format requests, relay, and Responses ↔ Chat Completions compatibility conversion for gradually adopting newer OpenAI application protocols |
-| Claude Messages | Conversion between Claude Messages and OpenAI-compatible formats to reduce multi-protocol maintenance on the application side |
-| Google Gemini | Gemini chat, text, and `/v1/responses` compatibility conversion |
-| Azure OpenAI | Azure OpenAI and Realtime related APIs |
-| AWS Bedrock | Bedrock Runtime model access |
-| Upstream platforms and application ecosystem | AWS, Azure, Vertex, Ollama, Codex, Dify, RAGFlow, Kling, Seedance, and similar platforms or applications can be governed according to channel capabilities |
-| Domestic models and platforms | Built-in adapters or compatible access for DeepSeek, Qwen / Alibaba Cloud Model Studio, Zhipu GLM, Kimi, Doubao / Volcano Engine, Tencent Hunyuan, Baidu ERNIE / Qianfan, iFlytek Spark, MiniMax, 01.AI, SiliconFlow, and more |
-| `rerank` | Reranking models such as Cohere and Jina for retrieval augmentation and Agent retrieval chains |
-| Midjourney / Suno / Dify | Adapters for image, music, workflow, and related services |
-| Video task APIs | Supports submission, body passthrough or parameter overrides, polling, status mapping, result proxying, and parameterized billing for video generation tasks such as `/v1/videos/create` and `/v1/videos/{task_id}` |
-| Custom upstreams | Supports legally authorized upstream URLs, protocol adaptation rules, Responses / Chat conversion, path overrides, status mapping, error message paths, and task result parsing |
+**Join the community to follow releases, model and protocol changes, deployment practices, troubleshooting knowledge, and opportunities to build together.**
-### Main Supported Interfaces
+
-
-View interface categories
-
-- Chat: `/v1/chat/completions`
-- Responses: `/v1/responses`
-- Images: `/v1/images/*`
-- Audio: `/v1/audio/*`
-- Video: `/v1/videos/*`
-- Embeddings: `/v1/embeddings`
-- Rerank: `/v1/rerank`
-- Realtime conversation: OpenAI Realtime-compatible APIs
-- Claude Messages: Claude native-format entry
-- Gemini: Google Gemini format entry
+| Community entry | Purpose |
+|---|---|
+| [MAX-API-Next on GitHub](https://github.com/MAX-API-Next) | Follow community projects, technical direction, and open collaboration |
+| [MAX API Issues](https://github.com/MAX-API-Next/MAX-API/issues) | Report reproducible problems, propose improvements, and share compatibility changes |
+| [MAX API Releases](https://github.com/MAX-API-Next/MAX-API/releases) | Follow stable and Preview releases |
+| [Ask DeepWiki](https://deepwiki.com/MAX-API-Next/MAX-API) | Search and understand the codebase quickly |
+| Technical and ecosystem cooperation | Contact `maxapi@max-api.ai` |
-
+### Contributors we are looking for
-### Reasoning Effort Support
+- **Model and protocol contributors**: adapt new models, providers, Reasoning behavior, tool calling, and multimodal task protocols.
+- **Agent and application developers**: share integration and governance practices for Dify, RAGFlow, Codex, MCP, workflows, and research Agents.
+- **Reliability and security engineers**: strengthen cross-database tests, asynchronous task recovery, settlement safety, cache consistency, and permission boundaries.
+- **Documentation and community contributors**: improve deployment guides, FAQs, examples, translations, reproducible experiments, and contributor onboarding.
+- **Researchers and evaluation developers**: help build Evidence, Evaluators, Detectors, Runbooks, and controlled-autonomy designs.
-View example model names
-
-**OpenAI series:**
+View collaboration areas, principles, and ways to participate
-- `o3-mini-high`
-- `o3-mini-medium`
-- `o3-mini-low`
-- `gpt-5-high`
-- `gpt-5-medium`
-- `gpt-5-low`
+| Collaboration area | Example contributions |
+|---|---|
+| Model and provider ecosystem | Model/protocol adapters, compatibility tests, model-list and deprecation changes, channel templates |
+| AgentOps and AGI application governance | Agent integration examples, token and permission boundaries, cost governance, operational practices |
+| SmartOps and Evidence | Sanitized incident samples, metric definitions, alert rules, data-quality notes, diagnosis and evaluation methods |
+| Reliability, billing, and security | Idempotent settlement, asynchronous recovery, cross-database regression tests, cache consistency, high-risk operation verification |
+| Documentation, tutorials, and localization | Deployment tutorials, architecture docs, FAQs, case studies, translations, contributor guides |
-**Claude thinking models:**
+Please provide a minimal reproduction, version, environment, sanitized logs, or test evidence whenever possible. Protocol, database, and user-contract changes should document compatibility, migration, and rollback paths. Do not submit real API keys, customer data, raw payment records, private logs, or unauthorized data. Contributions involving money, security, credentials, production data, or automated execution require stricter testing, independent review, and a clearly accountable owner.
-- `claude-3-7-sonnet-20250219-thinking`
+You can start by:
-**Gemini series:**
-
-- `gemini-2.5-flash-thinking`
-- `gemini-2.5-flash-nothinking`
-- `gemini-2.5-pro-thinking`
-- `gemini-2.5-pro-thinking-128`
-- You can also append `-low`, `-medium`, or `-high` to Gemini model names to control reasoning effort.
+1. Reporting a reproducible problem, protocol difference, or model compatibility change.
+2. Adding a failing test, cross-database case, frontend regression, or sanitized Evidence to an existing issue.
+3. Improving model/channel configuration, deployment instructions, FAQs, architecture documentation, or translations.
+4. Sharing sanitized Agent integration, cost governance, SmartOps, or private deployment practices.
+5. Proposing an Evaluator, Detector, Runbook, or controlled-autonomy design with explicit capability and risk boundaries.
----
-
-## 🔧 Governance Configuration
-
-### Recommended Initial Governance Setup
-
-1. After deployment, enter the console and create or confirm the administrator account.
-2. Configure system settings, user registration policy, login methods, and security limits.
-3. Add upstream channels and fill in legally authorized API keys, Base URL, model lists, model mappings, and channel settings.
-4. Configure user groups, token groups, model restrictions, quota policies, and pricing rules according to your organization structure.
-5. Create independent tokens for applications, Agents, or workflows, and configure model scope and quotas by business line, environment, or risk level.
-6. Configure failure retry, log recording, cache strategy, and consumption statistics in operations settings.
-7. If admin-side content audit is needed, enable it under "System Settings → Security & Limits → Log Audit" under proper compliance conditions, and ensure "Record quota usage (Log Maintenance)" is enabled.
-
-### Channel Capability Matrix and Configuration Validation
-
-When creating or editing a channel, the system displays a capability matrix and realtime validation results according to the channel type. Interface names in the matrix keep their original technical wording, such as `chat/completions`, `responses`, `embeddings`, `rerank`, and `video tasks`, while descriptions explain what the channel can handle.
-
-Validation covers common issues including:
-
-- Missing API Key for new channels, empty model list, or missing Base URL / extra configuration when required.
-- Base URL incorrectly ending with `/v1`, causing the system to append upstream paths again.
-- `setting`, `param_override`, `header_override`, `settings`, and similar fields are not JSON objects.
-- Vertex AI region lacks `default`, or service account key is not valid JSON.
-- Codex channel credentials lack `access_token` or `account_id`.
-- Model discovery or automatic sync is enabled on a channel that does not support discovery.
-- Video task query path lacks one of `{task_id}`, `{operation_name}`, or `{upstream_task_id}`.
-
-### Generic Video Task Protocol
-
-Video model providers often differ in paths, task IDs, status fields, progress fields, error fields, and result URL fields. MAX API extends the task protocol capability from a single-model feature into a generic video task protocol for OpenAI, Ali, Gemini, MiniMax, Vertex AI, VolcEngine, Kling, Jimeng, Vidu, Doubao Video, Sora, and other video task channels.
-
-Supported configuration levels:
-
-- **Path override only**: configure only `submit_path` and `query_path`; the system still uses the official response parser of the corresponding channel. This is suitable for compatible channels that only change upstream paths.
-- **Full protocol parsing**: set `task_protocol = "generic_video_task"` and configure paths for task ID, status, progress, result URL, error message, and status mapping. This is suitable for non-standard video task responses.
-- **Request-body handling**: the generic video task protocol no longer defines a separate request-body generation mode. Use the channel-level `Pass Through Body` setting to forward client JSON as-is, and use the existing `Param Override` feature for field rewrites, defaults, or header coordination.
-
-Default task paths:
-
-```json
-{
- "task_protocol": "generic_video_task",
- "task_protocol_config": {
- "submit_path": "/v1/videos/create",
- "query_path": "/v1/videos/{task_id}",
- "task_id_path": "task_id",
- "status_path": "status",
- "progress_path": "progress",
- "result_url_paths": [
- "result.primary_url",
- "result.urls.0",
- "data.result.primary_url",
- "url",
- "video_url",
- "download_url"
- ],
- "error_message_path": "error_message",
- "status_map": {
- "queued": "QUEUED",
- "running": "IN_PROGRESS",
- "succeeded": "SUCCESS",
- "failed": "FAILURE"
- }
- }
-}
-```
-
-Query paths support `{task_id}`, `{operation_name}`, and `{upstream_task_id}`. `{operation_name}` can preserve multi-segment path values, which is suitable for Gemini / Vertex-style operation query APIs. Video content can be read through `/v1/videos/{task_id}/content`; when you need to hide upstream resource domains, let end users access this content proxy URL and combine it with authentication, SSRF protection, and allowed port configuration.
-
-### Billing JSON Maintenance
-
-Model billing in system settings supports two unified JSON maintenance entries:
+Companion documentation: [MAX-API-Docs](https://github.com/MAX-API-Next/MAX-API-Docs) (deployment, configuration, and usage guides).
-- **Tiered billing JSON**: maintain `{ enabled, expr }` configuration for multiple models in one `Tiered billing JSON` window; saving updates `billing_mode` and `billing_expr` together.
-- **Task rate-card JSON**: maintain asynchronous task billing rules through `task_billing_setting.rate_cards`, with `vendor` partitions for video models such as Sora, Veo, Seedance, and Kling.
+Model providers, Agent/workflow projects, open-source communities, researchers, and enterprise engineering teams are welcome to collaborate. Formal partnerships, joint announcements, or use of an institution's name require explicit authorization from both parties.
-Video models such as Seedance 2.0 can use request parameters such as resolution and video input in multiplier or rate-card billing. When using passthrough or parameter overrides, keep the final upstream request fields aligned with the billing fields.
+> [!IMPORTANT]
+> When offering generative AI services to the public, operators are responsible for upstream authorization, registration or licensing, content safety, identity verification, log retention, taxation, payments, user agreements, and any other obligations required in their jurisdiction. Enable log auditing and content retention only with a lawful basis, clear notice, permission isolation, and appropriate data-security controls.
-Example structure:
+
-```json
-{
- "model-name": {
- "enabled": true,
- "expr": "len <= 200000 ? tier(\"standard\", p * 3 + c * 15) : tier(\"long_context\", p * 6 + c * 22.5)"
- }
-}
-```
+## 🧠 Technical direction for AGI
-A task rate-card can match prices by request parameters:
-
-```json
-{
- "vendor/model-name": {
- "vendor": "kling",
- "unit": "second",
- "quantity_field": "duration",
- "default_quantity": 5,
- "strict": true,
- "defaults": {
- "quality": "std",
- "has_audio": "false"
- },
- "rows": [
- {
- "id": "std_no_audio",
- "match": {
- "quality": "std",
- "has_audio": "false"
- },
- "unit_price": 0.6
- }
- ]
- }
-}
-```
+AGI applications will not depend forever on one model, one protocol, or one-shot requests. They require cross-model reasoning, tool use, multimodal tasks, long-running execution, cost constraints, production Evidence, and recoverable failure handling. MAX API starts from these verifiable engineering problems to build an AI Models and Agents governance foundation.
-### Common Operations Entries
+| Technical direction | Current foundation | Value for AGI applications |
+|---|---|---|
+| Multi-model and multi-protocol access | OpenAI-Compatible APIs, Responses, Claude Messages, Gemini, Realtime, multimodal and asynchronous task protocols | Gives applications and Agents a relatively stable entry point while the model ecosystem continues to change |
+| Reasoning and tool-context compatibility | Reasoning Effort, tool definitions, Tool Calls, tool-response association, and multi-turn context conversion | Reduces loss of reasoning information and tool semantics when switching providers |
+| Governance control plane | Users, tokens, model scopes, groups, routing, rate limits, quotas, pricing, and administrator permissions | Creates separate identity, access, and budget boundaries for different Agents, environments, and tasks |
+| Recoverable billing and task lifecycle | Pre-charge, final settlement, idempotent records, failed-task refunds, asynchronous polling, and manual reconciliation states | Prevents duplicate charges, incorrect refunds, and untraceable results during long tasks, retries, and failure windows |
+| Evidence and intelligent operations | Logs, errors, retries, performance buckets, active alerts, channel/model performance, and settlement evidence | Grounds diagnosis, evaluation, and future Agent recommendations in traceable facts rather than prompt-only inference |
+| Security and organization governance | Passkeys, 2FA, scoped re-verification, session revocation, audit, and rate limits for sensitive operations | Preserves explicit accountability around high-risk configuration, credentials, and operations |
+| Controlled autonomy and engineering evolution | **Long-term blueprint**: Policy, Budget, Approval, Shadow, Canary, Rollback, and isolated Coding Workspaces | Requires automation to be evaluated, constrained, and audited before it can enter low-risk production actions |
-| Feature | Description |
-|------|------|
-| Channel management | Configure upstream providers, model mappings, channel weights, keys, protocol paths, and status, while using capability matrix and validation to catch risks early |
-| Models and pricing | Maintain model lists, model prices, expression billing, tiered billing JSON, task rate-card JSON, and model display information |
-| Token management | Create access tokens for applications, Agents, workflows, tool calls, or users and restrict models and quota |
-| User management | Manage users, groups, balance, permissions, and status |
-| Usage logs | View call records, consumption, latency, errors, channel hits, and admin-visible audit information |
-| System settings | Manage security limits, log audit, model pricing, task billing, operations strategy, log maintenance, payment, and site settings |
-| Dashboard | View total requests, model usage, consumption trends, channel status, and Agent token costs |
+### Technical principles
----
+- **Evidence before Action**: establish verifiable facts before diagnosis, recommendations, or automated actions.
+- **Governance before Autonomy**: identity, permissions, budgets, approval, audit, and rollback must precede autonomous capabilities.
+- **One Billing Truth**: production billing, quota, and settlement keep a single source of truth; Agents and plugins do not create a second accounting system.
+- **Compatibility by Design**: continue to support SQLite, MySQL, PostgreSQL, multiple provider protocols, and portable application contracts.
+- **Open Collaboration, Safe Boundaries**: open protocol adapters, tests, documentation, evaluations, and governance designs while keeping high-risk production, financial, credential, and release actions under explicit approval.
-## 🚢 Deployment
+### MAX API 2.0 technical highlights
-### Requirements
+- **Evidence-driven SmartOps**: brings resource alerts, channel/model performance, data-quality states, and billing-settlement evidence into one operations entry point while preserving the boundary between human review and real financial state.
+- **Continuous support for advanced model protocols**: improves Reasoning, cache keys, penalty parameters, tool definitions, and multi-turn Tool Context compatibility across Responses, Claude Messages, Gemini, and Ollama.
+- **Recoverable billing and asynchronous task semantics**: uses idempotent settlement, durable effects, task IDs, and explicit pending/manual states to prevent retries from causing duplicate charges, incorrect refunds, or lost tasks.
+- **Scoped re-verification for high-risk operations**: Passkeys, 2FA, Telegram, API Tokens, and session revocation use scope-bound step-up verification, while `session_generation` invalidates old sessions promptly.
+- **Cross-database support and continuous verification**: core data paths support SQLite, MySQL, and PostgreSQL; Go tests, frontend Bun tests, TypeScript type checks, JSON-wrapper rules, and synchronized test mirrors form the release gate.
-| Component | Requirement |
-|------|------|
-| Container engine | Docker / Docker Compose |
-| Local database | SQLite, only for local evaluation, development, or small-scale testing; mount `/data` when using Docker |
-| Production database | MySQL ≥ 5.7.8 or PostgreSQL ≥ 9.6 with a reliable backup and recovery plan |
-| Cache | In-memory cache for single-node deployments; Redis recommended for multi-node deployments |
-| Frontend build | Bun workspace; keep `web/package.json` and `web/bun.lock` |
-| Source build | Use the Go version declared in `go.mod` (currently Go 1.25.1+) with the repository `go.sum`; after dependency or security updates, run `go mod download`, `go mod verify`, and rebuild |
+## 💡 Why MAX API
-### Recommended Environment Variables
+| Dimension | Connecting directly to multiple providers | Using MAX API |
+|---|---|---|
+| Application integration | Maintain separate SDKs, protocols, authentication, and error formats | Use a relatively stable application-side entry point |
+| Model switching | Change code, credentials, and deployment configuration | Adjust channels, model mappings, groups, and routing |
+| Availability | Each application implements its own retry and upstream-failure handling | Configure weights, priorities, retries, and failover centrally |
+| Permissions and credentials | Credentials are scattered across applications and environment variables | Manage tokens, model scopes, quotas, and expiration centrally |
+| Cost accounting | Provider bills are fragmented and difficult to attribute | Track usage by user, token, model, channel, and group |
+| Troubleshooting | Logs are fragmented across providers | Observe requests, errors, retries, and latency at the gateway |
-
-View common environment variables
-
-| Variable | Description | Default |
-|--------|------|--------|
-| `SESSION_SECRET` | Session secret; required for multi-node deployments | - |
-| `CRYPTO_SECRET` | Encryption secret; required when using Redis or multi-node deployments | - |
-| `SQL_DSN` | Database connection string | - |
-| `REDIS_CONN_STRING` | Redis connection string | - |
-| `STREAMING_TIMEOUT` | Streaming response timeout in seconds | `300` |
-| `STREAM_SCANNER_MAX_BUFFER_MB` | Max per-line buffer for stream scanner; increase for large base64 image responses | `64` |
-| `MAX_REQUEST_BODY_MB` | Maximum request body size after decompression; returns `413` when exceeded | `32` |
-| `AZURE_DEFAULT_API_VERSION` | Default Azure API version | `2025-04-01-preview` |
-| `ERROR_LOG_ENABLED` | Error log switch | `false` |
-| `NODE_NAME` | Node name for multi-node log identification and asynchronous task settlement attribution | - |
-| `PYROSCOPE_URL` | Pyroscope service URL | - |
-| `PYROSCOPE_APP_NAME` | Pyroscope application name | `max-api` |
-| `PYROSCOPE_BASIC_AUTH_USER` | Pyroscope Basic Auth username | - |
-| `PYROSCOPE_BASIC_AUTH_PASSWORD` | Pyroscope Basic Auth password | - |
-| `PYROSCOPE_MUTEX_RATE` | Pyroscope mutex sampling rate | `5` |
-| `PYROSCOPE_BLOCK_RATE` | Pyroscope block sampling rate | `5` |
-| `HOSTNAME` | Hostname label for Pyroscope | `max-api` |
+In one sentence: **providers supply the models, Agent frameworks orchestrate the application, and MAX API provides unified access while enforcing governance boundaries.**
-
+## 🚀 Quick start
-### Docker Compose
+The local experience uses SQLite by default and requires only Docker:
```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
+MAX_API_IMAGE=cscitechtop/max-api:latest@sha256:006d5d86887a261baab4d71ec3797d429e3771a4836e5899734aee0e7f66f2ab
-# Modify docker-compose.yml:
-# - Change default PostgreSQL / MySQL / Redis passwords
-# - Set SESSION_SECRET, CRYPTO_SECRET, NODE_NAME as needed
-# - Use a reverse proxy and HTTPS in production
-docker compose up -d
-```
-
-### Docker Command
+docker pull "$MAX_API_IMAGE"
-**SQLite:**
-
-```bash
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
+docker run --name max-api -d --restart always -p 127.0.0.1:3000:3000 -e TZ=Asia/Shanghai -v ./data:/data "$MAX_API_IMAGE"
```
-**MySQL:**
+Open , then:
-```bash
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e SQL_DSN="root:123456@tcp(mysql:3306)/max-api" \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
-```
-
-### Build Image from Source
-
-```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
-docker build -t cscitechtop/max-api:latest .
-```
-
-> [!NOTE]
-> `Dockerfile` downloads Go modules during the image build. For host builds or dependency/security updates, keep `go.mod` and `go.sum` committed together, run `go mod download && go mod verify`, then rebuild the binary or image; use `docker build --pull --no-cache -t cscitechtop/max-api:latest .` when base images need to be refreshed.
+1. Create or confirm the administrator account.
+2. Add an upstream channel and API key that you are legally authorized to use.
+3. Create an access token and point your application's Base URL to MAX API.
> [!TIP]
-> The frontend uses Bun workspace. The build context must keep `web/package.json`, `web/bun.lock`, and `web/default/package.json`; otherwise `catalog:` dependencies cannot be resolved.
-
-### Multi-node Deployment Notes
-
+> Use stable releases in production. Preview releases are intended for testing and staged validation. Back up the database and prepare a rollback plan before upgrading.
+>
> [!WARNING]
-> - All nodes must use the same `SESSION_SECRET`; otherwise login state will be inconsistent across nodes.
-> - If shared Redis is used, all nodes must use the same `CRYPTO_SECRET`; otherwise encrypted data cannot be decrypted.
-> - Set a stable `NODE_NAME` for each node to locate source nodes in logs, audit information, and asynchronous task settlement.
-> - Production environments should use an external database, external Redis, HTTPS reverse proxy, and reliable backup strategy.
-
----
+> SQLite is suitable for local evaluation, development, and small-scale tests. For production, use MySQL or PostgreSQL versions that remain within the vendor's security-support lifecycle (MySQL 8.4 LTS and PostgreSQL 14+ are recommended), together with Redis, HTTPS, backups, and recovery procedures. Compatibility minimums remain MySQL ≥ 5.7.8 and PostgreSQL ≥ 9.6, but those versions are not recommended for production.
-## 🗺️ Roadmap
+## ✨ Current capabilities
-The following directions are planning items and may change based on maintenance cadence, real-world scenarios, and community needs. They are not time commitments.
+The following capabilities are available in the current system:
-- **Deeper model governance**: strengthen governance around model catalogs, pricing, permissions, mappings, capability tags, and provider changes.
-- **Deeper AgentOps**: optimize call chains, cost attribution, failure diagnosis, and governance for Agents, tool calls, workflows, and MCP-style tools/services.
-- **Multimodal task governance**: improve billing, rate limiting, status tracking, and result proxying for image, video, audio, and realtime interaction tasks.
-- **Protocol conversion enhancement**: continue improving conversion among OpenAI Compatible, Responses, Claude Messages, Gemini, and other protocols.
-- **Domestic model and platform tracking**: follow domestic model, cloud platform, pricing, and API protocol changes, and accumulate reusable channel, pricing, and task protocol configuration.
-- **Provider adaptation templating**: make path overrides, task protocols, status mapping, error parsing, and result parsing easier to configure and reuse.
-- **Governance audit and operations optimization**: improve request chains, cost tracking, error analysis, admin audit, log retention, and operations reports.
-- **Organization-level operations**: enhance multi-tenant, group, billing, permission, risk control, and private deployment experience.
+| Capability | Primary use |
+|---|---|
+| Unified model entry point | Connect OpenAI-Compatible APIs, Responses, Claude Messages, Gemini, Realtime, and multimodal task interfaces |
+| Multi-provider routing | Manage channels, weights, priorities, groups, model mappings, retries, and cross-provider failover |
+| Identity and access control | Manage users, tokens, model scopes, groups, quotas, expiration, rate limits, and administrator permissions |
+| Cost and billing | Support multipliers, fixed pricing, expression billing, asynchronous task rate-cards, pre-charge, settlement, and failed-task refunds |
+| Logs and audit | Inspect usage, errors, retries, and administrative operations by user, token, model, channel, group, and node |
+| Intelligent Operations Center | Review active alerts, channel performance, model performance, system information, and billing-settlement reconciliation evidence |
+| Private deployment | Support SQLite, MySQL, PostgreSQL, Redis, multiple nodes, and a separate log database |
+| Upstream extensibility | Support protocol adapters, path overrides, parameter/Header overrides, model discovery, and task-status mappings |
-Feature requests, issues, and improvement suggestions are welcome in [GitHub Issues](https://github.com/MAX-API-Next/MAX-API/issues).
+### Use cases
----
+- **Internal model gateway for a team or organization**: manage users, tokens, models, providers, permissions, and costs centrally.
+- **Runtime foundation for AI applications and Agents**: provide model access control, cost attribution, and failure diagnosis for applications, Agents, and workflows.
+- **Multi-provider resilience and migration**: reduce dependence on a single upstream through model mapping, weighted routing, retries, and staged switching.
+- **Multimodal task governance**: manage image, audio, video, embedding, reranking, and realtime conversation interfaces.
+- **Private and compliant operations**: retain control of credentials, data, logs, audit, pricing, and deployment environments.
-## ❓ FAQ
+## 🩺 Intelligent Operations Center
-
-Does MAX API provide model services or API keys?
+**The Intelligent Operations Center is a major MAX API 2.0 update and a key step from a unified model gateway toward AGI-native governance and operations infrastructure.**
-No. MAX API is a gateway governance layer for model and Agent workloads. It does not provide upstream model accounts, API keys, foundation model training, or model services. Users must obtain legally authorized upstream services themselves.
+It consolidates production observation, resource alerts, model and channel performance, system information, and billing-settlement reconciliation in one administrator entry point. The current capability focuses on seeing problems, preserving evidence, notifying administrators, and enabling controlled review. It is not an autonomous Agent that automatically changes channels, routing, balances, or hosts.
-
-
-
-How does MAX API relate to Agent frameworks?
+| Module | What it currently provides |
+|---|---|
+| Active alerts | Deduplicated alerts when CPU, memory, or disk on the current node remains above a threshold, plus recovery notifications; reuses existing administrator Email, Webhook, Bark, or Gotify configuration |
+| Channel performance | Requests and errors, consumed quota, estimated success rate, log latency, retries, probe latency, and latest observation time; detail view shows the channel's model and group performance over the last 24 hours |
+| Model performance | Aggregated channel count, requests and errors, consumed quota, estimated success rate, log latency, throughput, and retries; detail view includes group performance, latency trends, and availability trends |
+| Billing-settlement reconciliation | Shows `pending` / `manual` positive final settlements, unsettled funds, retry state, and error evidence; root administrators can configure the default user-blocking policy, and administrators can atomically review batches by `id + revision` and close alerts |
+| System information | Shows nodes, running instances, system tasks, and related information; this module continues to require super-administrator permission |
-MAX API does not replace Dify, LangChain, MCP Server, workflow engines, or business Agent applications. It sits between those applications and upstream model services, handling model access, token isolation, cost accounting, routing resilience, log observability, and admin audit.
-
-
-
-
-Why emphasize AI model governance?
+The Active Alerts page reads current alert state every five seconds but does not trigger new detection or remediation. Channel and model lists query the latest hour by default and accept a custom `1–168` hour window. They do not continuously rescan large log databases: queries run only when the administrator selects “Apply filters” or “Refresh,” and detail data loads on demand.
-In real organizations, a model is not just an API name. It also involves provider, pricing, context length, protocol format, permission scope, reliability, and audit boundaries. MAX API's value is to configure, observe, and account for these distributed variables uniformly.
+Billing-settlement reconciliation strictly separates financial recovery state from operational alert state. “Review and close” records the administrator review and closes the current alert; it does not mark a settlement as `applied` and does not change balances, applied deltas, or effect state. Batch review is bound to the current financial revision. If a record changes after refresh, the old selection becomes invalid, preventing action based on stale evidence.
-
+> [!NOTE]
+> Current production-performance views primarily aggregate existing Consume/Error logs and `perf_metrics`. Estimated success rate is not a complete Relay Attempt success rate, while throughput and trends are performance-bucket approximations. When logging is disabled, historical data is missing, collection is disabled, a window has no samples, or a query fails, the UI displays the corresponding data-quality state.
+>
+> Active alerts depend on performance monitoring and resource-threshold configuration. A threshold of `0` disables that resource alert, and two consecutive valid samples are required before an alert fires. Alert state and the notification queue exist only in the current process memory: they do not survive a restart, and multiple nodes do not merge them into a cross-node Incident. Channel, model, and system observation remains read-only. Settlement review only updates review metadata and the user-blocking policy; it does not perform financial settlement. The Intelligent Operations Center does not automatically test, disable, reweight, switch channels, or repair hosts.
-
-Which databases are supported?
+The value of this stage is to complete the loop of seeing problems, notifying administrators, presenting evidence, and enabling controlled review—creating a foundation for unified Evidence, diagnostic Agents, Evaluators, and controlled automation.
-SQLite, MySQL ≥ 5.7.8, and PostgreSQL ≥ 9.6 are supported. SQLite is suitable for local evaluation; MySQL or PostgreSQL with backups is recommended for production.
+## 🔌 Models, interfaces, and extensibility
-
+> Actual availability depends on your upstream authorization, channel configuration, model mapping, and provider support. MAX API governs these capabilities; it does not provide model services itself.
-
-Can I migrate from New API / One API?
+| Category | Interface or capability |
+|---|---|
+| General model interfaces | Chat Completions, Responses, Embeddings, Rerank, Images, Audio, and Video |
+| Native and realtime protocols | Claude Messages, Google Gemini, OpenAI Realtime, and related entry points |
+| Reasoning and tool calling | Reasoning Effort, function tools, Tool Call IDs, tool names, and multi-turn tool-response association, with protocol conversion based on upstream capability |
+| Asynchronous tasks | Task submission, polling, status mapping, result proxying, and parameterized billing |
+| Custom upstreams | Base URL, path, parameter, Header, status-field, and result-field mappings |
-The project is compatible with the main data structures of New API and the original One API, so existing data can usually be reused. Back up your database and verify channels, multipliers, users, tokens, and logs in a test environment before migration.
+Coverage includes OpenAI, Claude, Gemini, Azure, AWS Bedrock, Vertex AI, Ollama, and multiple domestic model platforms. MAX API can also govern Codex, Dify, RAGFlow, and multimodal task services. Exact support depends on the current release and channel type.
-
-
-
-What should I pay attention to in multi-node deployment?
+### System flow and technology stack
-Use the same `SESSION_SECRET` on all nodes. If shared Redis is used, also use the same `CRYPTO_SECRET`. Otherwise login state may be inconsistent, cached data may fail to decrypt, or task status may behave unexpectedly.
+
-
+```text
+Application / SDK / Agent
+ → Unified interface and identity authentication
+ → Model permissions, rate limits, budgets, and security checks
+ → Channel selection, mapping, and failure retry
+ → Upstream protocol adaptation
+ → Recoverable settlement, Evidence, logging, and audit
+ → Intelligent Operations Center and administrator governance
+```
-
-What if image generation, streaming responses, or large responses are truncated?
+The backend uses Go, Gin, and GORM. The frontend uses React 19, TypeScript, Base UI, and Tailwind CSS. The data layer supports SQLite, MySQL, and PostgreSQL, with optional Redis and a separate log database. Provider protocol adapters live in a dedicated Relay/Channel layer, billing and settlement remain inside a unified service boundary, and SmartOps presents read-only observation and constrained governance entry points.
-Increase `STREAM_SCANNER_MAX_BUFFER_MB`. 4K images, base64 images, and long streaming responses may require a larger scan buffer.
+## 🛡️ Governance and operations
-
+For production, configure the system in this order:
-
-What if a large request body returns 413?
+1. Configure login, security limits, and user-registration policy.
+2. Add legally authorized upstream channels and confirm model, capability, and protocol configuration.
+3. Configure groups, tokens, model scopes, quotas, and prices by team, business, or environment.
+4. Use a separate token for each application, Agent, or environment to avoid shared credentials and ambiguous cost attribution.
+5. Configure retries, logs, and alerts, then continuously observe the system through dashboards and the Intelligent Operations Center.
-Adjust `MAX_REQUEST_BODY_MB`. The limit is calculated based on the decompressed request body size to prevent very large requests or zip bombs from causing memory spikes.
+For channel capability validation, expression billing, generic task protocols, administrator audit, and performance settings, see the [documentation](https://docs.max-api.ai).
-
+## 🧭 Evolution roadmap
-
-Can users see input/output content in admin log audit?
+MAX API will continue to make **AI Models and Agents governance** its core. Starting from the unified gateway, intelligent operations, and recoverable settlement, it will gradually build Evidence, evaluation, policy, and controlled-execution capabilities for AGI applications. The long-term direction is not to let an unbounded Agent control production, but to create an engineering loop that is verifiable, approvable, stoppable, and reversible.
-Normal user log APIs filter admin-only fields, so normal users cannot see admin audit content in self-service usage logs. Database administrators, system administrators, or users with admin log API permissions may still access related data, so permissions must be strictly controlled according to compliance requirements.
+| Stage | Status | Focus |
+|---|---|---|
+| Unified gateway and intelligent operations | **Available now** | Access, authentication, routing, billing, logging, resource alerts, channel/model performance, system information, and billing-settlement reconciliation |
+| Evidence fact layer | **Near-term development** | Unify model requests, system logs, metrics, Tasks, routing, policies, settlement, and audit events behind sanitized, permission-limited, read-only Agent interfaces |
+| Open evaluation and governance templates | **Planned** | Build model/protocol compatibility tests, anonymized incident samples, evaluation sets, Runbooks, Detectors, and industry governance templates with the community |
+| Controlled autonomous operations | **Long-term blueprint** | Evaluate low-risk automated actions under Policy, Budget, Approval, Shadow, Canary, and Rollback constraints |
+| Controlled capability evolution | **Long-term blueprint** | Generate, test, and review candidate improvements inside isolated Coding Workspaces without directly modifying production |
+| AGI engineering loop | **Long-term direction** | Connect Evidence, evaluation, governance policies, human approval, and reversible execution into a verifiable loop |
-
+MAX API is not a foundation model and does not claim to have already achieved AGI or autonomous operations. Long-term capabilities will be validated gradually only after Evidence, permission, budget, approval, and rollback boundaries are in place.
-
-Why does Docker build report unresolved `catalog:` dependencies?
+## 🚢 Preview deployment
-The frontend uses Bun workspace, and `catalog:` dependencies are defined in `web/package.json`. Do not overwrite the workspace root `package.json` with `web/default/package.json` during build, and keep `web/bun.lock`.
+The following steps are for Preview testing and staged validation. For production, use a stable release and keep the same verification and rollback process.
-
+Docker Compose is recommended:
----
+```bash
+MAX_API_VERSION=v2.0.0-smartops.pre1
+MAX_API_COMMIT=b7096156549edc930ca244891afb1ba5632dbe8f
+git clone --branch "$MAX_API_VERSION" --depth 1 https://github.com/MAX-API-Next/MAX-API.git
+cd MAX-API
-## 🔗 Related Projects
+actual_commit="$(git rev-parse HEAD)"
+if [ "$actual_commit" != "$MAX_API_COMMIT" ]; then
+ echo "Unexpected commit: $actual_commit" >&2
+ exit 1
+fi
-| Project | Description |
-|------|------|
-| [One API](https://github.com/songquanpeng/one-api) | MIT License |
-| [New API](https://github.com/QuantumNous/new-api) | AGPLv3 License |
-| [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy) | Apache-2.0 License |
-| [Suno API](https://github.com/Suno-API/Suno-API) | MIT License |
+# Update database and Redis passwords and configure secrets in docker-compose.yml
+docker compose up -d
+```
-### Companion Tools
+### Deployment checklist
-| Project | Description |
-|------|------|
-| [max-api-key-tool](https://github.com/MAX-API-Next/MAX-API-key-tool) | Key quota lookup tool |
-| [max-api-horizon](https://github.com/MAX-API-Next/MAX-API-horizon) | High-performance optimized MAX API edition |
+| Component | Recommendation |
+|---|---|
+| Database | Use a MySQL or PostgreSQL release still covered by vendor security support (MySQL 8.4 LTS and PostgreSQL 14+ recommended), with backup and recovery configured |
+| Cache | In-memory cache is suitable for one node; Redis is recommended for multiple nodes |
+| Entry point | Configure an HTTPS reverse proxy, request-size limits, and trusted-network policy |
+| Secrets | Set a random `SESSION_SECRET` explicitly; `CRYPTO_SECRET` is an optional override that falls back to `SESSION_SECRET` when unset, and must be shared across Redis/multi-node deployments when set |
+| Nodes | Give every node a stable and unique `NODE_NAME` |
+| Logging | Configure `LOG_SQL_DSN`, cleanup, and retention based on compliance and operational requirements |
----
+Multi-node deployments must share `SESSION_SECRET` while using a different `NODE_NAME` for each node. `CRYPTO_SECRET` is an optional override that falls back to `SESSION_SECRET` when unset; if explicitly set, use the same value on every node. Use `LOG_SQL_DSN` for a separate log database and enable `ERROR_LOG_ENABLED` when error-performance statistics are needed. See the [documentation](https://docs.max-api.ai) for complete environment variables and source-build instructions.
-## 📚 Documentation and Support
-
-| Resource | Link |
-|------|------|
-| Official documentation | [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API) |
-| Issue tracker | [GitHub Issues](https://github.com/MAX-API-Next/MAX-API/issues) |
-| Latest releases | [Releases](https://github.com/MAX-API-Next/MAX-API/releases) |
-| DeepWiki | [Ask DeepWiki](https://deepwiki.com/MAX-API-Next/MAX-API) |
-
-### Derivative Use and Community Acknowledgement
-
-If you build a derivative version of this project for your own use, you are welcome to keep the project source or a community acknowledgement clearly visible on the homepage, in the footer, or on the About page by choosing either option below:
-
-- Link to the project: [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
-- Acknowledge the community: [MAX-API-Next](https://github.com/MAX-API-Next)
-
-Reference frontend embed code (React / Tailwind CSS; keep either item as needed):
-
-```tsx
-
-```
+## 🤝 Project origins, acknowledgements, and derivative use
-By meeting either attribution requirement above and keeping the link clearly visible, you automatically receive a temporary commercial license for this project, with no separate application or approval required. This is not a perpetual license and remains valid only while the display requirement continues to be met. Its validity period and any later changes are governed by the latest notice published in this README or by the official community.
+MAX API continues development from the open-source work of [One API](https://github.com/songquanpeng/one-api) and [New API](https://github.com/QuantumNous/new-api). We thank the upstream projects, their contributors, and everyone who contributes protocol adapters, tests, documentation, translations, and issue reports.
-This project is developed from [One API](https://github.com/songquanpeng/one-api) and [New API](https://github.com/QuantumNous/new-api). At this stage, MAX API builds on those foundations by strengthening its AI API gateway and governance capabilities, expanding features, and fixing bugs. Commercial use must also comply with the One API MIT License and the New API AGPLv3 License, subject to each upstream project's current `LICENSE` file. The temporary commercial license provided by this project does not replace or waive any upstream open-source license obligations.
+Under [NOTICE](./NOTICE) and AGPLv3 Section 7, a modified version that presents a user interface must keep all of the following in a prominent, visible About, legal, footer, or attribution location:
-If the display requirement is no longer met, or the temporary license expires, is amended, or is terminated by notice, you must comply with AGPLv3 or obtain separate written authorization. For a long-term commercial license, contact: maxapi@max-api.ai.
+- A link to the original MAX API project: [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- The exact MAX API NOTICE attribution: `Frontend design and development by MAX API contributors.`
+- A link to the upstream New API project: [QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- The exact New API NOTICE attribution: `Frontend design and development by New API contributors.`
+- A prominent statement that the version was modified, including a relevant modification date
-Issues, documentation improvements, provider adaptation experience, deployment practices, and code contributions are welcome.
+An acknowledgement of the [MAX-API-Next community](https://github.com/MAX-API-Next) is welcome as an optional addition, but it does not replace the required project links, exact attributions, or change marking.
----
+Continuing to meet these display and NOTICE requirements automatically grants a non-perpetual temporary commercial license without a separate application or approval. This additional permission covers only material that the MAX API project maintainers have the right to license and does not waive AGPLv3 or the licensing obligations of One API, New API, or other upstream projects. The latest conditions are governed by the formal README and official community notices.
## 📜 License
This project is licensed under the [GNU Affero General Public License v3.0 (AGPLv3)](./LICENSE).
-In addition to the default AGPLv3 license, self-use derivative projects that meet the “Derivative Use and Community Acknowledgement” conditions above automatically receive the non-perpetual temporary commercial license described there. This temporary license covers only additions and modifications that the MAX API project maintainers have the right to license; it does not include or replace licensing from upstream projects such as One API and New API.
-
-If you modify this project and provide it to users over a network, please understand and comply with AGPLv3 source availability obligations. For commercial cooperation, institutional cooperation, or other licensing questions, contact: maxapi@max-api.ai.
-
----
-
-## 🌟 Star History
+The temporary commercial license covers only additions and modifications that the MAX API project maintainers have the right to license. It does not include, replace, or waive the licensing obligations of One API, New API, or other upstream projects. Commercial use must also comply with the One API MIT License, the New API AGPLv3 License, and the latest license terms of each upstream project.
-
-
-[](https://star-history.com/#MAX-API-Next/MAX-API&Date)
-
-
+If you modify this project and provide it to users over a network, please understand and comply with AGPLv3 source-availability obligations. For a long-term commercial license, institutional cooperation, or other licensing questions, contact maxapi@max-api.ai.
---
@@ -767,9 +354,9 @@ If you modify this project and provide it to users over a network, please unders
### 💖 Thank you for using MAX API
-If this project helps you, please consider giving us a ⭐ Star.
+If this project helps you, please consider giving it a ⭐ Star, following Releases, reporting a reproducible Issue, or joining the MAX-API-Next community.
-**[Official Documentation](https://github.com/MAX-API-Next/MAX-API)** • **[Issues](https://github.com/MAX-API-Next/MAX-API/issues)** • **[Releases](https://github.com/MAX-API-Next/MAX-API/releases)**
+**[Project repository](https://github.com/MAX-API-Next/MAX-API)** • **[Contribute](https://github.com/MAX-API-Next/MAX-API/issues)** • **[Latest releases](https://github.com/MAX-API-Next/MAX-API/releases)** • **[MAX-API-Next community](https://github.com/MAX-API-Next)**
Built with ❤️ by MAX-API-Next
diff --git a/README.fr.md b/README.fr.md
index 55a4bd42..8dc19fff 100644
--- a/README.fr.md
+++ b/README.fr.md
@@ -1,10 +1,14 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**AI Models and Agents governance, exploitation intelligente et collaboration ouverte pour l'ère des applications AGI**
+
+**MAX API 2.0 : entrer dans l'ère de l'exploitation intelligente · évoluer d'une passerelle de modèles unifiée vers une infrastructure native de gouvernance et d'exploitation AGI**
-🍥 **Gouvernance des modèles IA, AgentOps et infrastructure de services pour applications AGI**
+[Consulter les notes de version MAX API 2.0 Preview](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
---
-## 📝 Description du projet
-
-MAX API est un projet d'infrastructure pour la gouvernance des modèles IA, l'AgentOps et les services applicatifs. Il est initié, maintenu et exploité sur le long terme par des passionnés d'AGI issus d'organismes de recherche et d'universités. Il fournit aux développeurs, chercheurs, équipes et organisations une couche de service stable et réutilisable. Le projet se concentre sur les problèmes d'exploitation qui apparaissent lorsque les applications IA passent en production : multiplication des modèles, évolution fréquente des API amont, chaînes d'appels Agent plus longues, pression accrue sur les coûts et l'audit. MAX API fournit une couche unifiée d'accès, d'authentification, de routage, de facturation, d'observabilité et de gouvernance entre applications, Agents, utilisateurs, organisations et fournisseurs de modèles.
-
-En pratique, MAX API n'est pas seulement un proxy de requêtes. C'est une passerelle exploitable pour applications AI-ready et charges Agent, qui regroupe normalisation des protocoles, différences fournisseurs, pics de trafic, longs flux streaming, gros corps de requête, cache multi-nœud, audit des coûts et observabilité des performances dans une même frontière de gouvernance.
-
-Axes d'investissement continus :
-
-- **Gouvernance des modèles IA** : suivi continu des mises à jour de modèles, des changements d'API, des différences de paramètres, des règles de prix et des protocoles de tâches chez OpenAI, Azure OpenAI, AWS Bedrock, Vertex AI, Ollama, ainsi que chez DeepSeek, Qwen / Alibaba Cloud Model Studio, Zhipu GLM, Kimi, Doubao / Volcano Engine, Tencent Hunyuan, Baidu ERNIE / Qianfan, iFlytek Spark, MiniMax, 01.AI, SiliconFlow et d'autres plateformes. Le projet suit aussi Dify, RAGFlow, Kling, Seedance et d'autres écosystèmes applicatifs ou multimodaux.
-- **Gouvernance AI Agent / AgentOps** : amélioration de la gouvernance des jetons, du contrôle d'accès aux modèles, du traçage des appels, de l'attribution des coûts, du diagnostic d'erreurs et de l'audit des journaux pour les Agents, workflows et appels d'outils.
-- **Gouvernance de configuration des canaux** : matrice de capacités et validation de configuration lors de la création ou modification des canaux, avec affichage de `chat/completions`, `responses`, `embeddings`, `rerank`, `video tasks`, découverte de modèles, et alertes sur Base URL, JSON, région Vertex AI, identifiants Codex ou placeholders de tâches vidéo.
-- **Optimisation opérationnelle et gouvernance des coûts** : routage, retry, limitation, préfacturation, remboursement en cas d'échec, observabilité, statistiques de coûts et analyse d'exploitation. Les scénarios token peuvent utiliser la facturation par expression et les scénarios de tâches asynchrones peuvent utiliser des rate-cards paramétrées.
-
-> [!IMPORTANT]
-> - Lors de la fourniture de services publics d'IA générative, les utilisateurs doivent respecter les obligations réglementaires applicables et gérer eux-mêmes les déclarations, licences, sécurité de contenu, vérification d'identité, conservation des journaux, fiscalité, paiement et autorisations amont requises dans leur juridiction.
-> - Les capacités sensibles comme l'audit des journaux et la conservation de contenu ne doivent être activées qu'avec une base légale, une information claire, une isolation des permissions et des mesures de sécurité des données.
-> - MAX API fournit une couche de gouvernance de passerelle pour les charges de travail de modèles et d'Agents. Il ne fournit pas de comptes amont, de clés API, d'entraînement de modèles de base, et ne remplace pas Dify, LangChain, MCP Server ni les frameworks d'orchestration d'Agents.
-
----
-
-## 🚦 Canaux de publication
+MAX API se place entre les applications, les Agents et les services de modèles en amont. Il sert de passerelle de modèles unifiée, de plan de contrôle de gouvernance et de point d'entrée pour l'exploitation. La communauté MAX-API-Next développe le projet autour de l'ingénierie AGI concrète et accueille les développeurs, chercheurs, équipes d'ingénierie en entreprise, passionnés de technologie dans les universités et contributeurs open source. Notre objectif est de construire les fondations dont les applications AGI ont réellement besoin : accès aux modèles, permissions, maîtrise des coûts, Evidence, exploitation intelligente et contrôles de sécurité.
-Les versions actuelles de MAX API sont divisées entre versions stables et versions Preview. Les versions Preview exposent plus tôt les nouvelles capacités et corrections afin que la communauté et les opérateurs puissent valider la compatibilité, la stabilité et la sécurité en environnement réel. Une version stable est publiée après 1 semaine de fonctionnement stable de la Preview correspondante, afin de réduire les risques de mise à niveau en production et d'améliorer la sécurité et la fiabilité du système.
+Dans le domaine de l'AGI, nous voulons **livrer en continu des technologies avancées et vérifiables, transformer les problèmes réels de production en capacités d'ingénierie ouvertes et bâtir une communauté de recherche et de contribution.**
-Pour la production, privilégiez les versions stables. Utilisez les versions Preview dans des environnements de test ou de canary lorsque vous devez valider à l'avance de nouvelles fonctionnalités, corrections ou évolutions de compatibilité, avec sauvegarde de base de données et plan de rollback avant mise à niveau.
+## 🌐 Rejoindre la communauté MAX-API-Next
----
-
-## 🎯 Positionnement du projet
-
-À l'ère des applications AGI, MAX API se concentre sur une infrastructure ouverte de gouvernance des modèles IA et des AI Agents, afin de construire une couche de service, de gouvernance et d'exploitation permettant aux développeurs et organisations d'exécuter durablement applications IA et charges Agent :
-
-- **Plan de gouvernance des modèles** : gestion unifiée des entrées de modèles, canaux, fournisseurs, protocoles, mappings, règles tarifaires, protocoles de tâches et interfaces multimodales.
-- **Plan de contrôle AgentOps** : ne remplace pas les frameworks d'orchestration Agent ; fournit au niveau passerelle la gouvernance des jetons, le contrôle d'accès aux modèles, les journaux d'appel, le suivi des coûts, le diagnostic d'anomalies et l'analyse opérationnelle.
-- **Plan de configuration des canaux** : réduit les risques de mauvaise configuration grâce aux matrices de capacités, validations de formulaires, découverte de modèles et modèles de protocole.
-- **Couche d'adaptation protocoles/fournisseurs** : suit les API officielles internationales, les plateformes de modèles chinoises et les API OpenAI-compatible / non standard, puis les normalise en interfaces applicatives stables.
-- **Gouvernance coût, quota et fiabilité** : routage de canaux, distribution pondérée, retry, limitation, préfacturation, remboursement d'échec, facturation par expression, prix fixes, rate-cards de tâches, multiplicateurs et statistiques d'usage.
-- **Gouvernance performance et scalabilité** : cache Redis / mémoire, limitation des requêtes modèles, timeouts streaming, tampons pour grandes réponses, limites de corps de requête, cache disque, profiling Pyroscope et arrêt gracieux pour les déploiements mono ou multi-nœuds.
-- **Couche d'exploitation et d'audit organisationnelle** : utilisateurs, groupes, déploiement privé, rétention des données, audit et optimisation continue.
-- **Modèles de gouvernance réutilisables** : capitalisation des templates de canaux, protocoles de tâches, configurations de prix, pratiques de déploiement et retours d'exploitation.
-
----
-
-## 🧠 Cadre de gouvernance
-
-MAX API place l'exécution des modèles IA et des AI Agents dans un cadre configurable, observable, calculable et auditable.
-
-| Objet gouverné | Capacités MAX API | Objectif |
-|----------|-------------------|------|
-| Actifs modèles | Listes de modèles, mappings, groupes, restrictions, règles de prix et gestion multimodale | Savoir quels modèles existent, qui peut les utiliser, comment ils sont facturés et comment les basculer |
-| Canaux amont | Fournisseurs, poids, groupes, état, clés, Base URL, overrides de chemins, matrice de capacités, validation, découverte et retry | Réduire les risques d'indisponibilité, hausse de prix, limites, erreurs de configuration ou changements d'API |
-| Formats de protocole | OpenAI Compatible, Responses, Claude Messages, Gemini, Realtime, protocole vidéo générique et conversions | Donner aux applications des interfaces stables plutôt que les exposer aux différences de fournisseurs |
-| Jetons Agent | API Key, groupes de jetons, périmètre de modèles, quotas, expiration et contrôle d'accès | Fournir aux Agents et workflows des identifiants indépendants, révocables et limitables |
-| Usage et coûts | Journaux, statistiques, facturation par expression, JSON par paliers, rate-card de tâches, préfacturation et remboursements | Attribuer les coûts par utilisateur, groupe, jeton, modèle, canal et nœud |
-| Tâches asynchrones | Soumission, polling, mapping d'état, proxy de résultat et facturation de tâches vidéo | Gouverner les tâches multimodales longues, multi-états et multi-fournisseurs |
-| Audit et sécurité | Audit admin, journaux d'erreurs, limites de requêtes, timeout streaming, login et permissions | Fournir une frontière d'audit contrôlée en déploiement privé et contexte conforme |
-| Exploitation organisationnelle | Utilisateurs, groupes, solde, paiement, paramètres système, tableaux de bord et configuration ops | Soutenir l'exploitation continue d'équipes, institutions, entreprises ou communautés |
-
----
-
-## 🧩 Cas d'usage
-
-- **Plateforme interne de gouvernance des modèles IA** : gestion centralisée des utilisateurs, jetons, modèles, canaux, groupes, permissions, prix et factures.
-- **Socle d'exécution et de gouvernance Agent** : passerelle de modèles, isolation des jetons, contrôle des coûts, observabilité, diagnostic et audit pour Agents, workflows et outils.
-- **Centre d'adaptation modèles chinois et multi-fournisseurs** : suivi des API et prix, réduction du coût d'adaptation via configuration de canaux, mappings, overrides de chemins et templates de protocole.
-- **Plateforme de gouvernance multimodale** : accès unifié au texte, image, vidéo, audio, embeddings, rerank et temps réel, avec gestion d'état, proxy de résultat et facturation pour les tâches asynchrones.
-- **Comptabilité des coûts modèles et Agents** : quotas, calcul de coûts, statistiques de facturation et analyse par utilisateur, jeton, modèle, canal et groupe.
-- **Environnement privé et conforme** : pour les équipes ou organisations qui doivent maîtriser clés, données, permissions, journaux, audit et stratégie tarifaire.
-
----
-
-## 🚀 Démarrage rapide
+MAX API est plus qu'un dépôt de code. C'est une collaboration ouverte de long terme autour des AI Models, Agents, AgentOps et de l'ingénierie AGI. Que vous exploitiez une passerelle de modèles, développiez des Agents, adaptiez de nouveaux modèles, travailliez sur l'évaluation et la gouvernance, ou amélioriez la documentation et les traductions, vous êtes les bienvenus.
-SQLite est utilisé par défaut ; aucun service de base de données externe n'est requis pour un essai local.
+**Rejoignez la communauté pour suivre les versions, les évolutions de modèles et de protocoles, les pratiques de déploiement, les pistes de diagnostic et les possibilités de contribution.**
-> [!WARNING]
-> SQLite est réservé à l'évaluation locale, au développement et aux tests à petite échelle. Son utilisation est déconseillée en production : les requêtes concurrentes, les déploiements multi-instances, les volumes importants de journaux ou de données d'usage, les migrations, les opérations de sauvegarde/restauration et les transactions longues peuvent provoquer des contentions de verrouillage, des écritures bloquées, des migrations lentes ou en échec, ainsi que des problèmes de disponibilité ou de maintenance des données. En production, utilisez MySQL ≥ 5.7.8 ou PostgreSQL ≥ 9.6 avec un plan fiable de sauvegarde et de restauration.
-
-```bash
-# 1. Récupérer l'image
-docker pull cscitechtop/max-api:latest
-
-# 2. Lancer le service et persister les données dans ./data
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
-
-# 3. Ouvrir la console
-# Navigateur : http://localhost:3000
-```
-
-Pour la production, utilisez Docker Compose et configurez explicitement base de données, Redis, secret de session, secret de chiffrement et répertoire de journaux.
-
-```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
-
-# Modifier docker-compose.yml selon les mots de passe et variables nécessaires
-docker compose up -d
-```
-
-> [!WARNING]
-> Si vous exploitez ce projet comme service public d'IA générative ou service API, finalisez d'abord les autorisations amont, obligations réglementaires, sécurité de contenu, vérification d'identité, conservation des journaux, fiscalité, paiement et conditions utilisateur.
-
----
-
-## ✨ Capacités clés
-
-### Gouvernance des modèles IA
-
-| Capacité | Description |
-|------|------|
-| Entrée modèle unifiée | Prend en charge OpenAI-compatible, Responses, Claude Messages, Gemini, Realtime et d'autres protocoles via une passerelle unique |
-| Pool multi-fournisseurs | OpenAI, Azure, Claude, Gemini, AWS Bedrock, Vertex AI, Ollama, et suivi/adaptation de DeepSeek, Qwen, Zhipu GLM, Kimi, Doubao, Hunyuan, ERNIE, iFlytek Spark, MiniMax, 01.AI, SiliconFlow, etc. |
-| Adaptation de l'écosystème amont | Gouvernance des interfaces Codex, Dify, RAGFlow, Kling, Seedance et autres plateformes applicatives, Agent ou multimodales |
-| Mapping et périmètre d'accès | Listes de modèles par canal, mappings, groupes utilisateur, groupes de jetons et restrictions de modèles |
-| Matrice de capacités des canaux | Affiche `chat/completions`, `responses`, `Claude Messages`, `Gemini native`, `embeddings`, `images`, `audio`, `rerank`, `video tasks`, `model discovery` |
-| Validation des canaux | Vérifie API Key, modèles, Base URL, configuration JSON, région Vertex AI, identifiants Codex, découverte de modèles et placeholders vidéo |
-| Gouvernance multimodale | Chat, image, vidéo, audio, embeddings, rerank, temps réel, et gestion des tâches asynchrones vidéo |
-| Protocole vidéo générique | Configure soumission, requête, progression, mapping d'état, erreur et chemins de résultats ; le passthrough et les réécritures du corps utilisent les paramètres de canal existants ; chemins par défaut `/v1/videos/create` et `/v1/videos/{task_id}` |
-| Conversion protocolaire et amonts personnalisés | Conversions OpenAI Compatible, Responses, Chat Completions, Claude Messages, Gemini, ainsi que URL amont autorisées, overrides et règles de parsing de tâches |
-
-### Gouvernance AI Agent / AgentOps
-
-| Capacité | Description |
-|------|------|
-| Isolation des jetons Agent | Créer des API Key indépendantes pour Agents, workflows, plugins, appels d'outils ou utilisateurs |
-| Contrôle d'accès modèle | Contrôler modèles, canaux et quota par utilisateur, jeton, groupe, restriction de modèle et politique de canal |
-| Observabilité de chaîne d'appels | Journaux, statistiques, canal touché, latence, erreurs et retries pour diagnostiquer les Agents |
-| Attribution des coûts | Statistiques par modèle, canal, utilisateur, groupe, jeton et nœud |
-| Audit administrateur | Audit côté admin en déploiement privé ; les API de journaux utilisateur filtrent les champs réservés aux administrateurs |
-| Tableau de bord ops | Analyses, gestion utilisateurs, gestion canaux, paramètres système et analyse d'exploitation |
-
-### Gouvernance des coûts, de la facturation et de la fiabilité
-
-**Expressions de prix des modèles**
-
-- **Une expression = une règle complète de tarification token** : paliers, cache hit, tokens image/audio, remises horaires et majorations dynamiques peuvent être décrits en une ligne.
-- **Le prix correspond au prix réel** : les coefficients peuvent représenter directement des dollars par million de tokens ; `p * 2.5` signifie 2,5 USD par million de tokens d'entrée. Le mode multiplicateur historique reste compatible.
-- **Édition visuelle + brute** : saisie guidée ou édition directe de l'expression, avec modèles prédéfinis.
-- **Maintenance JSON unifiée** : `Tiered billing JSON` maintient plusieurs `{ enabled, expr }` et met à jour `billing_mode` et `billing_expr` de manière atomique.
-- **Normalisation automatique des tokens** : sépare cache, image, audio et autres sous-catégories pour éviter la double facturation.
-
-**Facturation des tâches et fiabilité**
-
-- Rate-card paramétrée pour tâches asynchrones vidéo, avec prix selon modèle, `vendor`, durée, qualité, audio, entrée vidéo, etc. `task_billing_setting.rate_cards` peut séparer Sora, Veo, Seedance, Kling et autres fournisseurs.
-- Compatible avec facturation à l'usage, par appel, cache hit, multiplicateurs de modèle, groupe et canal.
-- Préfacturation, remboursement d'échec, traitement d'exceptions et journaux de consommation.
-- Routage pondéré, retry, contournement des canaux désactivés et routage par modèle.
-- Cache Redis et mémoire pour déploiement mono ou multi-nœud.
-
-### Gouvernance performance et scalabilité
-
-| Capacité | Description |
-|------|------|
-| Cache et extension multi-nœud | Déploiement mono-nœud avec cache mémoire, multi-nœud avec Redis ; les caches utilisateur, jeton, affinité de canal et quota réduisent les lectures répétées en base, tandis que `SESSION_SECRET`, `CRYPTO_SECRET` et `NODE_NAME` gardent sessions, chiffrement et attribution des journaux cohérents |
-| Limitation et protection de capacité | Limites globales API / Web, limites d'endpoints critiques, recherche, requêtes modèles et quotas par groupe ; compteurs via Redis ou mémoire |
-| Streaming et grandes requêtes | `STREAMING_TIMEOUT`, `STREAM_SCANNER_MAX_BUFFER_MB`, `MAX_REQUEST_BODY_MB`, `MAX_FILE_DOWNLOAD_MB` contrôlent longs flux, grandes lignes SSE, corps décompressés et téléchargements distants |
-| Réglage des connexions relais | `RELAY_TIMEOUT`, `RELAY_IDLE_CONN_TIMEOUT`, `RELAY_MAX_IDLE_CONNS` et `RELAY_MAX_IDLE_CONNS_PER_HOST` configurent timeouts et pool HTTP amont |
-| Cache disque et observabilité | Les paramètres de performance peuvent activer le cache disque pour grands corps, définir seuil et capacité ; les endpoints ops peuvent inspecter / nettoyer ce cache, et Pyroscope collecte CPU, mémoire, goroutines, mutex et block profiles |
-| Arrêt gracieux et persistance | `SHUTDOWN_TIMEOUT_SECONDS` et `QUOTA_DATA_CACHE_SAVE_TIMEOUT_SECONDS` aident à fermer HTTP et sauvegarder le cache quota avant sortie quand c'est possible |
-
-### Sécurité et gestion d'organisation
-
-- JWT, WebAuthn/Passkeys, OAuth, OIDC, Telegram, Discord, LinuxDO et autres méthodes de connexion.
-- Contrôle des administrateurs, utilisateurs, groupes, jetons et accès modèles.
-- Limites de taille de requête, timeout streaming, journaux d'erreurs et health checks.
-- Secret de session, secret de chiffrement et cache Redis partagé en multi-nœud.
-
----
-
-## 🆚 Pourquoi utiliser une passerelle
-
-| Dimension | SDK / API officiels en direct | Via la passerelle MAX API |
-|------|------------------------|-------------------|
-| Accès modèles | Un SDK, une auth et des paramètres par fournisseur | Entrée unique, intégration unique, réutilisation multi-modèles |
-| Gouvernance modèles | Modèles, prix, permissions et canaux dispersés | Gestion unifiée des modèles, canaux, mappings, groupes, quotas et prix |
-| Accès Agent | Les Agents détiennent directement les clés amont | Jetons indépendants avec limites de modèles, quota, expiration et groupe |
-| Différences de protocole | L'application adapte Claude, Gemini, Responses, etc. | La passerelle convertit les protocoles et adapte les fournisseurs |
-| Échecs | Retry, fallback et normalisation d'erreurs côté application | Retry de canaux, routage pondéré et traitement d'erreurs intégrés |
-| Performance et extension | L'application gère timeouts, limites, pools de connexions et cache | La passerelle centralise timeouts streaming, limites de requêtes, cache Redis / mémoire, réglage de pool et observabilité |
-| Coûts | Factures dispersées, attribution difficile | Quotas, facturation, statistiques et journaux unifiés par jeton et modèle |
-| Audit | Journaux applicatifs dispersés | Entrée d'audit admin unifiée, filtrage des champs admin pour utilisateurs |
-| Privé | Clés, journaux et stratégie tarifaire dispersés | Auto-hébergement et contrôle des clés, données, journaux et politiques |
-
----
-
-## 🧭 Vue d'ensemble de l'architecture
-
-MAX API utilise une architecture en couches : les requêtes des applications, SDK ou Agents entrent par une interface unifiée, passent par routeur, middleware, contrôleurs et services métier, puis sont adaptées par la couche relay vers le fournisseur amont. La couche données et cache assure persistance et accélération pour gouvernance de modèles, jetons Agent, facturation, journaux, audit et état des tâches.
-
-```mermaid
-flowchart LR
- Client[Client / SDK / Agent] --> Router[Router Routage]
- Router --> MW[Middleware Auth · Limite · Dispatch · Logs]
- MW --> Ctrl[Controller Handlers]
- Ctrl --> Svc[Service Gouvernance modèles · AgentOps · Audit facturation]
- Svc --> Relay[Relay Proxy / Conversion]
- Relay --> Adapters[Adaptateurs de canaux OpenAI · Claude · Gemini · Plateformes chinoises · Amonts personnalisés]
- Adapters --> Upstream[(Services de modèles amont)]
- Svc --> Model[Model GORM]
- Model --> DB[(SQLite · MySQL · PostgreSQL)]
- Svc --> Cache[(Redis · Cache mémoire)]
-```
-
-### Structure des répertoires
-
-| Répertoire | Rôle |
-|------|------|
-| `router/` | Routage HTTP : API, relay, dashboard et web |
-| `controller/` | Handlers, parsing des paramètres, entrées métier authentifiées et réponses |
-| `service/` | Logique métier : modèles, AgentOps, journaux, facturation, audit, tâches, canaux et configuration |
-| `model/` | Modèles de données et accès DB via GORM, compatible SQLite, MySQL, PostgreSQL |
-| `relay/` | Relay API IA, conversion de protocoles et adaptation fournisseur |
-| `relay/channel/` | Adaptateurs openai, claude, gemini, aws, etc. |
-| `middleware/` | Auth, limitation, CORS, logs, distribution de requêtes et contexte |
-| `setting/` | Prix modèles, facturation tâches, opérations, système, sécurité et performance |
-| `common/` | Utilitaires JSON, chiffrement, Redis, limitation et variables d'environnement |
-| `dto/` / `types/` | Types de requêtes, réponses, erreurs et formats relay |
-| `constant/` | Types d'API, types de canaux et clés de contexte |
-| `i18n/` / `oauth/` / `pkg/` | i18n backend, OAuth et packages internes |
-| `web/` | Conteneur du frontend ; thème par défaut dans `web/default/` |
-
-### Stack technique
-
-| Couche | Technologie |
-|------|------|
-| Backend | Go 1.25+, Gin, GORM v2 |
-| Frontend | React 19, TypeScript, Rsbuild, Base UI, Tailwind CSS |
-| Gestion de paquets | Bun workspace |
-| Base de données | SQLite / MySQL ≥ 5.7.8 / PostgreSQL ≥ 9.6 |
-| Cache | Redis + cache mémoire |
-| Authentification | JWT, WebAuthn/Passkeys, OAuth, OIDC |
-
----
-
-## 🤖 Prise en charge des modèles et interfaces IA
+
+ Groupe QQ : 950126533 •
+ Groupe WeChat : recherchez MAX-API
+
-> Les modèles réellement disponibles dépendent de vos autorisations amont, de la configuration des canaux, des mappings et du support fournisseur. MAX API gouverne ces capacités, mais ne fournit pas les services de modèles amont.
+| Point d'entrée | Utilité |
+|---|---|
+| [MAX-API-Next sur GitHub](https://github.com/MAX-API-Next) | Suivre les projets communautaires, les orientations techniques et la collaboration ouverte |
+| [Issues MAX API](https://github.com/MAX-API-Next/MAX-API/issues) | Signaler un problème reproductible, proposer une amélioration ou partager un changement de compatibilité |
+| [Versions MAX API](https://github.com/MAX-API-Next/MAX-API/releases) | Suivre les versions stables et Preview |
+| [Ask DeepWiki](https://deepwiki.com/MAX-API-Next/MAX-API) | Rechercher et comprendre rapidement le code |
+| Coopération technique et écosystème | Contacter `maxapi@max-api.ai` |
-| Type | Description |
-|------|------|
-| OpenAI-Compatible | Chat Completions, Embeddings, Images, Audio et interfaces compatibles |
-| OpenAI Responses | Requêtes Responses, relay et conversion compatible Responses ↔ Chat Completions |
-| Claude Messages | Conversion Claude Messages ↔ format OpenAI-compatible |
-| Google Gemini | Chat, texte et conversion compatible `/v1/responses` |
-| Azure OpenAI | Azure OpenAI et Realtime |
-| AWS Bedrock | Accès Bedrock Runtime |
-| Plateformes et applications amont | AWS, Azure, Vertex, Ollama, Codex, Dify, RAGFlow, Kling, Seedance, etc. |
-| Modèles et plateformes chinoises | DeepSeek, Qwen / Alibaba Cloud Model Studio, Zhipu GLM, Kimi, Doubao / Volcano Engine, Tencent Hunyuan, Baidu ERNIE / Qianfan, iFlytek Spark, MiniMax, 01.AI, SiliconFlow, etc. |
-| `rerank` | Modèles Cohere, Jina et autres pour RAG et chaînes de recherche Agent |
-| Midjourney / Suno / Dify | Adaptateurs image, musique et workflow |
-| API de tâches vidéo | `/v1/videos/create`, `/v1/videos/{task_id}` : soumission, passthrough du corps ou overrides de paramètres, polling, mapping d'état, proxy de résultat et facturation paramétrée |
-| Amonts personnalisés | URL autorisées, règles d'adaptation, conversion Responses / Chat, overrides, mapping d'état, chemin d'erreur et parsing de résultat |
+### Profils de contributeurs recherchés
-### Interfaces principales
+- **Contributeurs modèles et protocoles** : adaptation de nouveaux modèles et fournisseurs, Reasoning, appels d'outils et protocoles de tâches multimodales.
+- **Développeurs d'Agents et d'applications** : pratiques d'intégration et de gouvernance pour Dify, RAGFlow, Codex, MCP, workflows et Agents de recherche.
+- **Ingénieurs fiabilité et sécurité** : tests multi-bases, reprise des tâches asynchrones, sécurité des règlements, cohérence du cache et frontières de permissions.
+- **Contributeurs documentation et communauté** : guides de déploiement, FAQ, exemples, traductions, expériences reproductibles et accueil des nouveaux contributeurs.
+- **Chercheurs et développeurs d'évaluations** : Evidence, Evaluators, Detectors, Runbooks et architectures d'autonomie contrôlée.
-Voir les catégories
-
-- Chat : `/v1/chat/completions`
-- Responses : `/v1/responses`
-- Images : `/v1/images/*`
-- Audio : `/v1/audio/*`
-- Vidéo : `/v1/videos/*`
-- Embeddings : `/v1/embeddings`
-- Rerank : `/v1/rerank`
-- Realtime : interface compatible OpenAI Realtime
-- Claude Messages : entrée native Claude
-- Gemini : entrée format Google Gemini
+Voir les axes de collaboration, les principes et les façons de participer
-
+| Axe | Contributions possibles |
+|---|---|
+| Écosystème modèles et fournisseurs | Adaptateurs modèles/protocoles, tests de compatibilité, changements de listes et de dépréciation, modèles de canaux |
+| AgentOps et gouvernance des applications AGI | Exemples d'intégration Agent, frontières de jetons et de permissions, gouvernance des coûts, pratiques d'exploitation |
+| SmartOps et Evidence | Incidents anonymisés, définitions de métriques, règles d'alerte, qualité des données, méthodes de diagnostic et d'évaluation |
+| Fiabilité, facturation et sécurité | Règlement idempotent, reprise asynchrone, régressions multi-bases, cohérence du cache, vérification des opérations à risque |
+| Documentation, tutoriels et localisation | Déploiement, architecture, FAQ, cas d'usage, traductions et guides de contribution |
-### Prise en charge de Reasoning Effort
+Fournissez si possible une reproduction minimale, la version, l'environnement, des journaux anonymisés ou des preuves de test. Les changements de protocole, de base de données ou de contrat utilisateur doivent décrire la compatibilité, la migration et le rollback. Ne soumettez pas de véritables clés API, données clients, enregistrements bruts de paiement, journaux privés ou données non autorisées. Les contributions touchant aux fonds, à la sécurité, aux secrets, aux données de production ou à l'exécution automatisée exigent des tests plus stricts, une revue indépendante et un responsable clairement identifié.
-
-Voir des exemples de noms de modèles
+Vous pouvez commencer par :
-- `o3-mini-high`, `o3-mini-medium`, `o3-mini-low`
-- `gpt-5-high`, `gpt-5-medium`, `gpt-5-low`
-- `claude-3-7-sonnet-20250219-thinking`
-- `gemini-2.5-flash-thinking`, `gemini-2.5-flash-nothinking`, `gemini-2.5-pro-thinking`, `gemini-2.5-pro-thinking-128`
-- Les suffixes `-low`, `-medium`, `-high` peuvent aussi contrôler l'effort de raisonnement Gemini.
+1. Signaler un problème reproductible, une différence de protocole ou un changement de compatibilité d'un modèle.
+2. Ajouter à une issue un test en échec, un cas multi-base, une régression frontend ou une Evidence anonymisée.
+3. Améliorer la configuration des modèles/canaux, le déploiement, les FAQ, l'architecture ou les traductions.
+4. Partager des pratiques anonymisées d'intégration Agent, de gouvernance des coûts, de SmartOps ou de déploiement privé.
+5. Proposer un Evaluator, Detector, Runbook ou une architecture d'autonomie contrôlée avec des frontières de capacité et de risque explicites.
----
-
-## 🔧 Configuration de gouvernance
+Documentation associée : [MAX-API-Docs](https://github.com/MAX-API-Next/MAX-API-Docs) (guides de déploiement, de configuration et d'utilisation).
-### Configuration initiale recommandée
+Les fournisseurs de modèles, projets Agent/workflow, communautés open source, chercheurs et équipes d'ingénierie sont invités à collaborer. Les partenariats formels, annonces conjointes ou usages du nom d'une institution nécessitent l'autorisation explicite des deux parties.
-1. Après le déploiement, ouvrez la console et créez ou confirmez le compte administrateur.
-2. Configurez paramètres système, inscription, méthodes de connexion et limites de sécurité.
-3. Ajoutez les canaux amont avec API Key autorisée, Base URL, modèles, mappings et paramètres.
-4. Configurez groupes utilisateurs, groupes de jetons, restrictions de modèles, quotas et règles de prix.
-5. Créez des jetons indépendants pour applications, Agents ou workflows avec périmètre et quota.
-6. Configurez retry, journaux, cache et statistiques de consommation.
-7. Pour l'audit de contenu côté admin, activez « System Settings → Security & Limits → Log Audit » en contexte conforme, et vérifiez que « Record quota usage (Log Maintenance) » est activé.
-
-### Matrice de capacités et validation des canaux
-
-À la création ou modification d'un canal, le système affiche une matrice de capacités et des résultats de validation. Les noms techniques restent en anglais (`chat/completions`, `responses`, `embeddings`, `rerank`, `video tasks`) et les descriptions expliquent les usages.
-
-La validation couvre notamment : API Key manquante, liste de modèles vide, Base URL ou configuration requise absente, Base URL terminée par `/v1`, JSON non objet, région Vertex AI sans `default`, clé de service invalide, identifiants Codex incomplets, découverte de modèles non supportée, ou chemin de requête vidéo sans `{task_id}`, `{operation_name}` ou `{upstream_task_id}`.
-
-### Protocole générique de tâches vidéo
-
-Les fournisseurs vidéo diffèrent souvent par chemins, task ID, état, progression, erreurs et URL de résultat. MAX API généralise cette capacité aux canaux OpenAI, Ali, Gemini, MiniMax, Vertex AI, VolcEngine, Kling, Jimeng, Vidu, Doubao Video, Sora, etc.
-
-- **Override de chemins uniquement** : configurer `submit_path` et `query_path` tout en conservant le parseur officiel du canal.
-- **Parsing complet** : définir `task_protocol = "generic_video_task"` et configurer task ID, état, progression, URL de résultat, erreur et mapping d'état.
-- **Traitement du corps** : le protocole vidéo générique ne définit plus de mode de génération du corps séparé. Utilisez `Pass Through Body` au niveau du canal pour transmettre le JSON client tel quel, et `Param Override` pour les réécritures, valeurs par défaut ou coordinations de headers.
-
-Chemins par défaut :
-
-```json
-{
- "task_protocol": "generic_video_task",
- "task_protocol_config": {
- "submit_path": "/v1/videos/create",
- "query_path": "/v1/videos/{task_id}",
- "task_id_path": "task_id",
- "status_path": "status",
- "progress_path": "progress",
- "result_url_paths": ["result.primary_url", "result.urls.0", "data.result.primary_url", "url", "video_url", "download_url"],
- "error_message_path": "error_message",
- "status_map": { "queued": "QUEUED", "running": "IN_PROGRESS", "succeeded": "SUCCESS", "failed": "FAILURE" }
- }
-}
-```
+> [!IMPORTANT]
+> Lors de la fourniture au public de services d'IA générative, les opérateurs sont responsables des autorisations amont, déclarations ou licences, de la sécurité des contenus, de la vérification d'identité, de la conservation des journaux, de la fiscalité, des paiements, des conditions utilisateur et de toute obligation applicable dans leur juridiction. L'audit des journaux et la conservation de contenu ne doivent être activés qu'avec une base légale, une information claire, une isolation des permissions et des mesures adaptées de sécurité des données.
-Les chemins de requête prennent en charge `{task_id}`, `{operation_name}` et `{upstream_task_id}`. `{operation_name}` peut conserver des chemins multi-segments pour Gemini / Vertex. Le contenu vidéo peut être proxyfié via `/v1/videos/{task_id}/content` afin de masquer le domaine amont, avec authentification, protection SSRF et ports autorisés.
+
-### Maintenance JSON de la facturation
+## 🧠 Orientation technique pour l'AGI
-- **Tiered billing JSON** : maintient plusieurs règles `{ enabled, expr }` et synchronise `billing_mode` / `billing_expr`.
-- **Task rate-card JSON** : maintient `task_billing_setting.rate_cards` pour les tâches asynchrones, avec partition `vendor` pour Sora, Veo, Seedance, Kling, etc.
+Les applications AGI ne dépendront pas éternellement d'un seul modèle, d'un seul protocole ou de requêtes ponctuelles. Elles nécessitent raisonnement multi-modèles, appels d'outils, tâches multimodales, exécutions longues, contraintes de coûts, Evidence de production et gestion récupérable des échecs. MAX API part de ces problèmes d'ingénierie vérifiables pour construire une fondation d'AI Models and Agents governance.
-Les modèles vidéo comme Seedance 2.0 peuvent utiliser la résolution, l'entrée vidéo et d'autres paramètres de requête dans les multiplicateurs ou les rate-cards. Avec le passthrough ou les overrides de paramètres, gardez les champs finaux envoyés en amont alignés avec les champs de facturation.
+| Orientation technique | Fondations actuelles | Valeur pour les applications AGI |
+|---|---|---|
+| Accès multi-modèles et multi-protocoles | OpenAI Compatible, Responses, Claude Messages, Gemini, Realtime, protocoles multimodaux et tâches asynchrones | Offre aux applications et Agents un point d'entrée relativement stable malgré l'évolution de l'écosystème |
+| Compatibilité du raisonnement et du contexte d'outils | Reasoning Effort, définitions d'outils, Tool Calls, association des réponses d'outils et conversion de contexte multi-tour | Réduit la perte d'informations de raisonnement et de sémantique des outils lors d'un changement de fournisseur |
+| Plan de contrôle de gouvernance | Utilisateurs, jetons, périmètres de modèles, groupes, routage, limites, quotas, prix et permissions administrateur | Crée des frontières distinctes d'identité, d'accès et de budget pour chaque Agent, environnement et tâche |
+| Facturation récupérable et cycle de vie des tâches | Préfacturation, règlement final, enregistrements idempotents, remboursement des échecs, polling asynchrone et états de rapprochement manuel | Évite doublons de débit, remboursements erronés et résultats intraçables pendant les longues tâches, retries et fenêtres d'échec |
+| Evidence et exploitation intelligente | Journaux, erreurs, retries, buckets de performance, alertes actives, performance canal/modèle et preuves de règlement | Fonde diagnostic, évaluation et futures recommandations d'Agents sur des faits traçables plutôt que sur les seuls prompts |
+| Sécurité et gouvernance organisationnelle | Passkeys, 2FA, revérification par périmètre, révocation de session, audit et limitation des opérations sensibles | Maintient une responsabilité explicite autour des configurations, secrets et opérations à risque |
+| Autonomie contrôlée et évolution d'ingénierie | **Vision long terme** : Policy, Budget, Approval, Shadow, Canary, Rollback et Coding Workspaces isolés | Exige que l'automatisation soit évaluée, contrainte et auditée avant toute action de production à faible risque |
-```json
-{
- "model-name": {
- "enabled": true,
- "expr": "len <= 200000 ? tier(\"standard\", p * 3 + c * 15) : tier(\"long_context\", p * 6 + c * 22.5)"
- }
-}
-```
+### Principes techniques
-```json
-{
- "vendor/model-name": {
- "vendor": "kling",
- "unit": "second",
- "quantity_field": "duration",
- "default_quantity": 5,
- "strict": true,
- "defaults": { "quality": "std", "has_audio": "false" },
- "rows": [{ "id": "std_no_audio", "match": { "quality": "std", "has_audio": "false" }, "unit_price": 0.6 }]
- }
-}
-```
+- **Evidence before Action** : établir des faits vérifiables avant tout diagnostic, recommandation ou action automatisée.
+- **Governance before Autonomy** : identité, permissions, budgets, approbation, audit et rollback doivent précéder l'autonomie.
+- **One Billing Truth** : facturation, quota et règlement de production conservent une source de vérité unique ; Agents et plugins ne créent pas une seconde comptabilité.
+- **Compatibility by Design** : continuer à prendre en charge SQLite, MySQL, PostgreSQL, plusieurs protocoles fournisseurs et des contrats applicatifs portables.
+- **Open Collaboration, Safe Boundaries** : ouvrir les adaptateurs, tests, documents, évaluations et conceptions de gouvernance, tout en maintenant les opérations de production, financières, de secrets et de publication sous approbation explicite.
-### Entrées d'exploitation courantes
+### Points forts techniques de MAX API 2.0
-| Fonction | Description |
-|------|------|
-| Gestion des canaux | Fournisseurs, mappings, poids, clés, chemins, état, matrice et validation |
-| Modèles et prix | Modèles, prix, expressions, JSON par paliers, rate-cards et affichage |
-| Gestion des jetons | Jetons pour applications, Agents, workflows, outils ou utilisateurs |
-| Gestion utilisateurs | Utilisateurs, groupes, soldes, permissions et états |
-| Journaux d'usage | Appels, consommation, latence, erreurs, canaux et audit visible admin |
-| Paramètres système | Sécurité, audit, prix, tâches, opérations, logs, paiement et site |
-| Tableau de bord | Requêtes, usage modèles, consommation, état canaux et coûts des jetons Agent |
-
----
+- **Evidence-driven SmartOps** : regroupe alertes de ressources, performance canal/modèle, états de qualité des données et preuves de règlement dans un même point d'entrée, tout en conservant la frontière entre revue humaine et état financier réel.
+- **Évolution continue pour les protocoles de modèles avancés** : améliore Reasoning, clés de cache, paramètres de pénalité, définitions d'outils et Tool Context multi-tour pour Responses, Claude Messages, Gemini et Ollama.
+- **Sémantique récupérable de facturation et de tâches asynchrones** : règlement idempotent, effets persistants, identifiants de tâche et états pending/manual explicites empêchent les retries de créer doublons, remboursements incorrects ou pertes de tâche.
+- **Revérification par périmètre pour les opérations à risque** : Passkeys, 2FA, Telegram, API Tokens et révocation de session utilisent une scope-bound step-up verification ; `session_generation` invalide rapidement les anciennes sessions.
+- **Compatibilité multi-base et validation continue** : les chemins de données essentiels prennent en charge SQLite, MySQL et PostgreSQL ; tests Go, tests frontend Bun, vérification TypeScript, règle du wrapper JSON et synchronisation du miroir de tests constituent les barrières de publication.
-## 🚢 Déploiement
+## 💡 Pourquoi MAX API
-### Exigences
+| Dimension | Connexion directe à plusieurs fournisseurs | Avec MAX API |
+|---|---|---|
+| Intégration applicative | Maintenir des SDK, protocoles, authentifications et formats d'erreur distincts | Utiliser un point d'entrée applicatif relativement stable |
+| Changement de modèle | Modifier le code, les secrets et la configuration de déploiement | Ajuster les canaux, mappings, groupes et règles de routage |
+| Disponibilité | Chaque application gère ses retries et pannes amont | Centraliser poids, priorités, retries et bascules |
+| Permissions et secrets | Secrets dispersés dans les applications et variables d'environnement | Gérer jetons, périmètres de modèles, quotas et expirations au même endroit |
+| Comptabilité des coûts | Factures fournisseurs dispersées et difficiles à attribuer | Suivre l'usage par utilisateur, jeton, modèle, canal et groupe |
+| Diagnostic | Journaux fragmentés entre fournisseurs | Observer requêtes, erreurs, retries et latence au niveau de la passerelle |
-| Composant | Exigence |
-|------|------|
-| Moteur conteneur | Docker / Docker Compose |
-| Base locale | SQLite, uniquement pour l'évaluation locale, le développement ou les tests à petite échelle ; monter `/data` avec Docker |
-| Base de production | MySQL ≥ 5.7.8 ou PostgreSQL ≥ 9.6 avec un plan fiable de sauvegarde et de restauration |
-| Cache | Mémoire en mono-nœud, Redis recommandé en multi-nœud |
-| Build frontend | Bun workspace, conserver `web/package.json` et `web/bun.lock` |
-| Build source | Utiliser la version de Go déclarée dans `go.mod` (actuellement Go 1.25.1+) avec `go.sum` ; après une mise à jour de dépendances ou de sécurité, exécuter `go mod download`, `go mod verify`, puis reconstruire |
+En une phrase : **les fournisseurs livrent les modèles, les frameworks Agent orchestrent l'application et MAX API unifie l'accès tout en faisant respecter les frontières de gouvernance.**
-### Variables d'environnement recommandées
-
-
-Voir les variables courantes
-
-| Variable | Description | Défaut |
-|--------|------|--------|
-| `SESSION_SECRET` | Secret de session, requis en multi-nœud | - |
-| `CRYPTO_SECRET` | Secret de chiffrement, requis avec Redis ou multi-nœud | - |
-| `SQL_DSN` | Chaîne de connexion DB | - |
-| `REDIS_CONN_STRING` | Chaîne Redis | - |
-| `STREAMING_TIMEOUT` | Timeout streaming en secondes | `300` |
-| `STREAM_SCANNER_MAX_BUFFER_MB` | Buffer max par ligne pour streaming | `64` |
-| `MAX_REQUEST_BODY_MB` | Taille max du body décompressé | `32` |
-| `AZURE_DEFAULT_API_VERSION` | Version API Azure par défaut | `2025-04-01-preview` |
-| `ERROR_LOG_ENABLED` | Activation des journaux d'erreurs | `false` |
-| `NODE_NAME` | Nom du nœud pour logs multi-nœuds et attribution des règlements de tâches asynchrones | - |
-| `PYROSCOPE_URL` | URL Pyroscope | - |
-| `PYROSCOPE_APP_NAME` | Nom d'application Pyroscope | `max-api` |
-| `PYROSCOPE_BASIC_AUTH_USER` | Utilisateur Basic Auth | - |
-| `PYROSCOPE_BASIC_AUTH_PASSWORD` | Mot de passe Basic Auth | - |
-| `PYROSCOPE_MUTEX_RATE` | Taux mutex | `5` |
-| `PYROSCOPE_BLOCK_RATE` | Taux block | `5` |
-| `HOSTNAME` | Label hôte | `max-api` |
-
-
+## 🚀 Démarrage rapide
-### Docker Compose
+L'expérience locale utilise SQLite par défaut et ne nécessite que Docker :
```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
-# Modifier mots de passe, secrets et proxy HTTPS selon besoin
-docker compose up -d
-```
+MAX_API_IMAGE=cscitechtop/max-api:latest@sha256:006d5d86887a261baab4d71ec3797d429e3771a4836e5899734aee0e7f66f2ab
-### Docker
+docker pull "$MAX_API_IMAGE"
-```bash
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
+docker run --name max-api -d --restart always -p 127.0.0.1:3000:3000 -e TZ=Asia/Shanghai -v ./data:/data "$MAX_API_IMAGE"
```
-```bash
-docker run --name max-api -d --restart always \
- -p 3000:3000 \
- -e SQL_DSN="root:123456@tcp(mysql:3306)/max-api" \
- -e TZ=Asia/Shanghai \
- -v ./data:/data \
- cscitechtop/max-api:latest
-```
+Ouvrez ensuite , puis :
-### Construire depuis les sources
-
-```bash
-git clone https://github.com/MAX-API-Next/MAX-API.git
-cd MAX-API
-docker build -t cscitechtop/max-api:latest .
-```
-
-> [!NOTE]
-> `Dockerfile` télécharge les modules Go pendant la construction de l'image. Pour une construction locale ou après une mise à jour de dépendances / sécurité, conservez `go.mod` et `go.sum` ensemble, exécutez `go mod download && go mod verify`, puis reconstruisez le binaire ou l'image ; utilisez `docker build --pull --no-cache -t cscitechtop/max-api:latest .` lorsque les images de base doivent être rafraîchies.
+1. Créez ou confirmez le compte administrateur.
+2. Ajoutez un canal amont et une clé API que vous êtes légalement autorisé à utiliser.
+3. Créez un jeton d'accès et pointez la Base URL de votre application vers MAX API.
> [!TIP]
-> Le frontend utilise Bun workspace. Conservez `web/package.json`, `web/bun.lock` et `web/default/package.json`, sinon les dépendances `catalog:` ne seront pas résolues.
-
-### Notes multi-nœuds
-
+> Utilisez les versions stables en production. Les versions Preview sont destinées aux tests et à la validation progressive. Sauvegardez la base et préparez un rollback avant toute mise à niveau.
+>
> [!WARNING]
-> - Tous les nœuds doivent partager `SESSION_SECRET`.
-> - Avec Redis partagé, tous les nœuds doivent partager `CRYPTO_SECRET`.
-> - Définissez un `NODE_NAME` stable pour identifier les nœuds dans les logs, l'audit et les règlements de tâches asynchrones.
-> - En production, utilisez DB externe, Redis externe, HTTPS et sauvegardes fiables.
+> SQLite convient à l'évaluation locale, au développement et aux tests de petite taille. En production, utilisez des versions de MySQL ou PostgreSQL toujours couvertes par le support de sécurité du fournisseur (MySQL 8.4 LTS et PostgreSQL 14+ recommandés), avec Redis, HTTPS, sauvegardes et procédures de reprise. Les minimums de compatibilité restent MySQL ≥ 5.7.8 et PostgreSQL ≥ 9.6, mais ces versions ne sont pas recommandées en production.
----
+## ✨ Capacités actuelles
-## 🗺️ Feuille de route
+Les capacités suivantes sont disponibles dans le système actuel :
-- **Approfondissement de la gouvernance des modèles** : catalogue, prix, permissions, mappings, tags de capacités et changements fournisseurs.
-- **Approfondissement AgentOps** : chaînes d'appels, attribution des coûts, diagnostic, outils et services MCP-style.
-- **Gouvernance multimodale** : facturation, limitation, suivi d'état et proxy de résultats pour image, vidéo, audio et temps réel.
-- **Conversions de protocoles** : OpenAI Compatible, Responses, Claude Messages, Gemini et autres.
-- **Suivi des modèles et plateformes chinoises** : API, prix, protocoles, canaux, prix et tâches réutilisables.
-- **Templates fournisseurs** : overrides, protocoles, mapping d'état, parsing d'erreurs et résultats.
-- **Audit et opérations** : chaînes de requêtes, coûts, erreurs, audit admin, rétention et rapports.
-- **Opérations organisationnelles** : multi-tenant, groupes, facturation, permissions, contrôle des risques et déploiement privé.
+| Capacité | Usage principal |
+|---|---|
+| Point d'entrée modèles unifié | Connecter OpenAI Compatible, Responses, Claude Messages, Gemini, Realtime et les interfaces de tâches multimodales |
+| Routage multi-fournisseurs | Gérer canaux, poids, priorités, groupes, mappings, retries et bascule entre fournisseurs |
+| Identité et contrôle d'accès | Gérer utilisateurs, jetons, périmètres de modèles, groupes, quotas, expiration, limitations et permissions administrateur |
+| Coûts et facturation | Multiplicateurs, prix fixes, facturation par expression, rate-cards de tâches asynchrones, préfacturation, règlement et remboursement d'échec |
+| Journaux et audit | Consulter usage, erreurs, retries et opérations d'administration par utilisateur, jeton, modèle, canal, groupe et nœud |
+| Centre d'exploitation intelligente | Examiner alertes actives, performance des canaux et modèles, informations système et Evidence de rapprochement des règlements |
+| Déploiement privé | SQLite, MySQL, PostgreSQL, Redis, plusieurs nœuds et base de journaux séparée |
+| Extensibilité amont | Adaptateurs de protocole, overrides de chemin, paramètre/Header, découverte de modèles et mappings d'état de tâche |
-Les demandes et suggestions sont bienvenues dans [GitHub Issues](https://github.com/MAX-API-Next/MAX-API/issues).
+### Cas d'usage
----
+- **Passerelle interne pour une équipe ou organisation** : gérer utilisateurs, jetons, modèles, fournisseurs, permissions et coûts au même endroit.
+- **Fondation d'exécution pour applications IA et Agents** : contrôle d'accès aux modèles, attribution des coûts et diagnostic pour applications, Agents et workflows.
+- **Résilience et migration multi-fournisseurs** : réduire la dépendance à un seul amont grâce aux mappings, routage pondéré, retries et bascule progressive.
+- **Gouvernance des tâches multimodales** : gérer images, audio, vidéo, embeddings, reranking et conversation temps réel.
+- **Exploitation privée et conforme** : conserver la maîtrise des secrets, données, journaux, audits, prix et environnements de déploiement.
-## ❓ FAQ
+## 🩺 Centre d'exploitation intelligente
-MAX API fournit-il des services de modèles ou des clés API ?
+**Le Centre d'exploitation intelligente est une évolution majeure de MAX API 2.0 et une étape clé entre la passerelle de modèles unifiée et une infrastructure native de gouvernance et d'exploitation AGI.**
-Non. MAX API est une couche de gouvernance de passerelle. Il ne fournit pas de comptes, clés, entraînement ou services de modèles amont.
+Il regroupe l'observation de production, les alertes de ressources, la performance des modèles et canaux, les informations système et le rapprochement des règlements de facturation dans une entrée administrateur unique. La capacité actuelle vise à voir les problèmes, préserver les preuves, notifier les administrateurs et permettre une revue contrôlée. Ce n'est pas un Agent autonome qui modifie automatiquement canaux, routage, soldes ou hôtes.
-
-
-Quel est le lien avec les frameworks Agent ?
-
-MAX API ne remplace pas Dify, LangChain, MCP Server, moteurs de workflow ou applications Agent. Il se place entre eux et les modèles amont pour gérer accès, jetons, coûts, routage, logs et audit.
-
-
-
-Pourquoi parler de gouvernance de modèles IA ?
-
-Dans une organisation, un modèle implique fournisseur, prix, contexte, protocole, permissions, fiabilité et audit. MAX API unifie configuration, observation et calcul.
-
-
+| Module | Contenu actuellement fourni |
+|---|---|
+| Alertes actives | Alertes dédupliquées lorsque CPU, mémoire ou disque du nœud courant reste au-dessus d'un seuil, avec notification de rétablissement ; réutilise la configuration Email, Webhook, Bark ou Gotify de l'administrateur |
+| Performance des canaux | Requêtes et erreurs, quota consommé, taux de succès estimé, latence des journaux, retries, latence de probe et dernière observation ; le détail montre les performances modèles/groupes des dernières 24 heures |
+| Performance des modèles | Nombre de canaux, requêtes et erreurs, quota consommé, taux de succès estimé, latence des journaux, débit et retries ; le détail fournit performances par groupe, tendances de latence et de disponibilité |
+| Rapprochement des règlements | Affiche les règlements finaux positifs `pending` / `manual`, fonds non réglés, retries et preuves d'erreur ; les root administrators configurent la politique de blocage utilisateur par défaut et les administrateurs examinent atomiquement des lots par `id + revision` puis ferment les alertes |
+| Informations système | Affiche les nœuds, instances actives, tâches système et informations associées ; ce module exige toujours le rôle super-administrateur |
-Quelles bases de données sont supportées ?
+La page des alertes actives lit l'état toutes les cinq secondes, mais ne déclenche ni nouvelle détection ni réparation. Les listes de canaux et modèles interrogent la dernière heure par défaut et acceptent une fenêtre personnalisée de `1–168` heures. Elles ne rescannent pas continuellement de grandes bases de journaux : la requête s'exécute uniquement avec « Appliquer les filtres » ou « Actualiser », et les détails sont chargés à la demande.
-SQLite, MySQL ≥ 5.7.8 et PostgreSQL ≥ 9.6. SQLite convient aux essais ; MySQL ou PostgreSQL est recommandé en production.
+Le rapprochement des règlements sépare strictement l'état de reprise financière de l'état d'alerte opérationnelle. « Examiner et fermer » enregistre la revue et ferme l'alerte courante ; l'action ne marque pas le règlement comme `applied` et ne change ni le solde, ni l'écart appliqué, ni l'état de l'effet. La revue en lot est liée à la révision financière courante. Si un enregistrement change après actualisation, l'ancienne sélection devient invalide afin d'empêcher une action fondée sur une preuve obsolète.
-
-
-Peut-on migrer depuis New API / One API ?
-
-Les principales structures sont compatibles. Sauvegardez la base et vérifiez canaux, multiplicateurs, utilisateurs, jetons et journaux en environnement de test.
+> [!NOTE]
+> Les vues de performance de production agrègent principalement les journaux Consume/Error et `perf_metrics`. Le taux de succès estimé n'est pas un taux complet de Relay Attempt ; débit et tendances sont des approximations par bucket. Lorsque les journaux sont désactivés, l'historique absent, la collecte arrêtée, la fenêtre vide ou la requête en échec, l'interface affiche l'état de qualité des données correspondant.
+>
+> Les alertes actives dépendent du suivi de performance et des seuils de ressources. Un seuil à `0` désactive l'alerte correspondante et deux échantillons valides consécutifs sont requis avant déclenchement. L'état et la file de notifications ne résident que dans la mémoire du processus courant : ils ne survivent pas au redémarrage et plusieurs nœuds ne les fusionnent pas en Incident multi-nœud. L'observation des canaux, modèles et du système reste en lecture seule. La revue de règlement ne met à jour que les métadonnées de revue et la politique de blocage utilisateur ; elle n'exécute aucun règlement financier. Le Centre d'exploitation intelligente ne teste, désactive, repondère, bascule ou répare jamais automatiquement.
-
+Cette étape ferme d'abord la boucle « voir le problème, notifier l'administrateur, présenter les preuves, permettre une revue contrôlée », puis prépare une base pour Evidence unifiée, Agents de diagnostic, Evaluators et automatisation contrôlée.
-Points d'attention en multi-nœud ?
+## 🔌 Modèles, interfaces et extensibilité
-Utilisez le même `SESSION_SECRET` partout ; avec Redis partagé, utilisez aussi le même `CRYPTO_SECRET`.
+> La disponibilité réelle dépend de vos autorisations amont, de la configuration des canaux, des mappings de modèles et du support fournisseur. MAX API gouverne ces capacités ; il ne fournit pas lui-même de service de modèles.
-
+| Catégorie | Interface ou capacité |
+|---|---|
+| Interfaces générales | Chat Completions, Responses, Embeddings, Rerank, Images, Audio et Video |
+| Protocoles natifs et temps réel | Claude Messages, Google Gemini, OpenAI Realtime et entrées associées |
+| Raisonnement et appels d'outils | Reasoning Effort, outils fonctionnels, Tool Call IDs, noms d'outils et association multi-tour des réponses, avec conversion selon les capacités amont |
+| Tâches asynchrones | Soumission, polling, mapping d'état, proxy de résultat et facturation paramétrée |
+| Amonts personnalisés | Mappings de Base URL, chemin, paramètres, Header, champ d'état et champ de résultat |
-Réponses image, streaming ou grosses réponses tronquées ?
+La couverture inclut OpenAI, Claude, Gemini, Azure, AWS Bedrock, Vertex AI, Ollama et plusieurs plateformes de modèles chinoises. MAX API peut également gouverner Codex, Dify, RAGFlow et des services de tâches multimodales. Le périmètre exact dépend de la version et du type de canal.
-Augmentez `STREAM_SCANNER_MAX_BUFFER_MB`.
+### Flux système et stack technique
-
+
-Requête trop grande avec 413 ?
+```text
+Application / SDK / Agent
+ → Interface unifiée et authentification
+ → Permissions modèles, limites, budgets et contrôles de sécurité
+ → Sélection du canal, mapping et retry d'échec
+ → Adaptation du protocole amont
+ → Règlement récupérable, Evidence, journaux et audit
+ → Centre d'exploitation intelligente et gouvernance administrateur
+```
-Ajustez `MAX_REQUEST_BODY_MB`, calculé après décompression.
+Le backend utilise Go, Gin et GORM. Le frontend utilise React 19, TypeScript, Base UI et Tailwind CSS. La couche de données prend en charge SQLite, MySQL et PostgreSQL, avec Redis et une base de journaux séparée en option. Les adaptateurs fournisseurs vivent dans une couche Relay/Channel dédiée, la facturation et le règlement restent dans une frontière de service unifiée, et SmartOps expose des observations en lecture seule avec des entrées de gouvernance limitées.
-
+## 🛡️ Gouvernance et exploitation
-Les utilisateurs voient-ils les contenus d'audit admin ?
+Pour la production, configurez le système dans cet ordre :
-Les API de journaux utilisateur filtrent les champs réservés admin. Les administrateurs système ou DB peuvent toujours accéder aux données, donc les permissions doivent être strictement contrôlées.
+1. Configurer la connexion, les limites de sécurité et la politique d'inscription.
+2. Ajouter des canaux amont légalement autorisés et vérifier modèles, capacités et protocoles.
+3. Configurer groupes, jetons, périmètres de modèles, quotas et prix par équipe, activité ou environnement.
+4. Utiliser un jeton distinct par application, Agent ou environnement afin d'éviter le partage de secrets et l'ambiguïté d'attribution des coûts.
+5. Configurer retries, journaux et alertes, puis observer le système avec les tableaux de bord et le Centre d'exploitation intelligente.
-
+Pour la validation des capacités de canaux, la facturation par expression, les protocoles génériques de tâches, l'audit administrateur et les réglages de performance, consultez la [documentation](https://docs.max-api.ai).
-Pourquoi Docker signale des dépendances `catalog:` non résolues ?
+## 🧭 Feuille de route
-Le frontend utilise Bun workspace ; `catalog:` est défini dans `web/package.json`. Ne remplacez pas ce fichier par `web/default/package.json` et conservez `web/bun.lock`.
+MAX API continuera de placer **AI Models and Agents governance** au cœur du projet. À partir de la passerelle unifiée, de l'exploitation intelligente et du règlement récupérable, il développera progressivement les capacités Evidence, évaluation, Policy et exécution contrôlée pour les applications AGI. L'objectif n'est pas de laisser un Agent sans frontières contrôler la production, mais de construire une boucle d'ingénierie vérifiable, approuvable, arrêtable et réversible.
-
+| Étape | État | Priorité |
+|---|---|---|
+| Passerelle unifiée et exploitation intelligente | **Disponible** | Accès, authentification, routage, facturation, journaux, alertes de ressources, performance canal/modèle, informations système et rapprochement des règlements |
+| Couche factuelle Evidence | **Développement proche** | Unifier requêtes de modèles, journaux système, métriques, Tasks, routage, Policies, règlements et événements d'audit derrière des interfaces Agent anonymisées, limitées et en lecture seule |
+| Évaluations ouvertes et modèles de gouvernance | **Planifié** | Construire avec la communauté des tests de compatibilité, incidents anonymisés, jeux d'évaluation, Runbooks, Detectors et modèles de gouvernance métier |
+| Exploitation autonome contrôlée | **Vision long terme** | Évaluer des actions automatisées à faible risque sous contraintes Policy, Budget, Approval, Shadow, Canary et Rollback |
+| Évolution contrôlée des capacités | **Vision long terme** | Générer, tester et revoir des améliorations candidates dans des Coding Workspaces isolés sans modifier directement la production |
+| Boucle d'ingénierie AGI | **Orientation long terme** | Relier Evidence, évaluation, politiques de gouvernance, approbation humaine et exécution réversible dans une boucle vérifiable |
----
+MAX API n'est pas un modèle de fondation et ne prétend pas avoir déjà atteint l'AGI ni l'exploitation autonome. Les capacités de long terme ne seront validées progressivement qu'après mise en place des frontières d'Evidence, de permissions, de budget, d'approbation et de rollback.
-## 🔗 Projets connexes
+## 🚢 Déploiement Preview
-| Projet | Description |
-|------|------|
-| [One API](https://github.com/songquanpeng/one-api) | Licence MIT |
-| [New API](https://github.com/QuantumNous/new-api) | Licence AGPLv3 |
-| [Midjourney-Proxy](https://github.com/novicezk/midjourney-proxy) | Licence Apache-2.0 |
-| [Suno API](https://github.com/Suno-API/Suno-API) | Licence MIT |
+Les étapes suivantes servent aux tests et à la validation progressive de la version Preview. Pour la production, utilisez une version stable et conservez la même procédure de vérification et de retour arrière.
-### Outils associés
+Docker Compose est recommandé :
-| Projet | Description |
-|------|------|
-| [max-api-key-tool](https://github.com/MAX-API-Next/MAX-API-key-tool) | Outil de consultation de quota de clés |
-| [max-api-horizon](https://github.com/MAX-API-Next/MAX-API-horizon) | Édition MAX API optimisée hautes performances |
+```bash
+MAX_API_VERSION=v2.0.0-smartops.pre1
+MAX_API_COMMIT=b7096156549edc930ca244891afb1ba5632dbe8f
+git clone --branch "$MAX_API_VERSION" --depth 1 https://github.com/MAX-API-Next/MAX-API.git
+cd MAX-API
----
+actual_commit="$(git rev-parse HEAD)"
+if [ "$actual_commit" != "$MAX_API_COMMIT" ]; then
+ echo "Unexpected commit: $actual_commit" >&2
+ exit 1
+fi
-## 📚 Documentation et support
-
-| Ressource | Lien |
-|------|------|
-| Documentation officielle | [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API) |
-| Signalement | [GitHub Issues](https://github.com/MAX-API-Next/MAX-API/issues) |
-| Dernières versions | [Releases](https://github.com/MAX-API-Next/MAX-API/releases) |
-| DeepWiki | [Ask DeepWiki](https://deepwiki.com/MAX-API-Next/MAX-API) |
-
-### Développements dérivés et remerciements à la communauté
-
-Si vous développez une version dérivée de ce projet pour votre propre usage, vous pouvez afficher clairement la source du projet ou un remerciement à la communauté sur la page d'accueil, dans le pied de page ou sur la page « À propos », en choisissant l'une des options suivantes :
-
-- Ajouter le lien du projet : [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
-- Remercier la communauté : [MAX-API-Next](https://github.com/MAX-API-Next)
-
-Exemple de code d'intégration frontend (React / Tailwind CSS ; conservez l'un ou l'autre élément selon vos besoins) :
-
-```tsx
-
+# Modifier les mots de passe de base de données et Redis, puis configurer les secrets dans docker-compose.yml
+docker compose up -d
```
-En respectant l'une des exigences d'affichage ci-dessus et en maintenant le lien clairement visible, vous obtenez automatiquement une licence commerciale temporaire pour ce projet, sans demande ni approbation supplémentaire. Cette licence n'est pas permanente et reste valable uniquement tant que l'exigence d'affichage est respectée. Sa période de validité et toute modification ultérieure sont régies par le dernier avis publié dans ce README ou par la communauté officielle.
-
-Ce projet est développé à partir de [One API](https://github.com/songquanpeng/one-api) et de [New API](https://github.com/QuantumNous/new-api). À ce stade, MAX API s'appuie sur ces bases pour renforcer ses capacités de passerelle d'API d'IA et de gouvernance, enrichir ses fonctionnalités et corriger les anomalies. Toute utilisation commerciale doit également respecter la licence MIT de One API et la licence AGPLv3 de New API, conformément au fichier `LICENSE` actuellement publié par chaque projet en amont. La licence commerciale temporaire fournie par ce projet ne remplace ni ne supprime aucune obligation liée aux licences open source des projets en amont.
+### Vérifications de déploiement
-Si l'exigence d'affichage n'est plus respectée, ou si la licence temporaire expire, est modifiée ou prend fin par avis, vous devez respecter l'AGPLv3 ou obtenir une autorisation écrite distincte. Pour une licence commerciale à long terme, contactez : maxapi@max-api.ai.
+| Composant | Recommandation |
+|---|---|
+| Base de données | Utiliser une version de MySQL ou PostgreSQL toujours couverte par le support de sécurité du fournisseur (MySQL 8.4 LTS et PostgreSQL 14+ recommandés), avec sauvegarde et reprise configurées |
+| Cache | Le cache mémoire convient à un nœud ; Redis est recommandé pour plusieurs nœuds |
+| Point d'entrée | Configurer un reverse proxy HTTPS, des limites de taille et une politique de réseau de confiance |
+| Secrets | Définir explicitement un `SESSION_SECRET` aléatoire ; `CRYPTO_SECRET` est une surcharge facultative qui reprend `SESSION_SECRET` s'il est absent et doit être partagé entre Redis ou plusieurs nœuds lorsqu'il est défini |
+| Nœuds | Donner à chaque nœud un `NODE_NAME` stable et unique |
+| Journaux | Configurer `LOG_SQL_DSN`, nettoyage et rétention selon les exigences de conformité et d'exploitation |
-Contributions de code, documentation, expériences d'adaptation fournisseur et pratiques de déploiement sont bienvenues.
+Les déploiements multi-nœuds doivent partager `SESSION_SECRET`, tout en utilisant un `NODE_NAME` différent par nœud. `CRYPTO_SECRET` est une surcharge facultative qui reprend `SESSION_SECRET` s'il est absent ; s'il est défini explicitement, utilisez la même valeur sur chaque nœud. Utilisez `LOG_SQL_DSN` pour une base de journaux séparée et activez `ERROR_LOG_ENABLED` lorsque les statistiques de performance des erreurs sont nécessaires. Consultez la [documentation](https://docs.max-api.ai) pour toutes les variables d'environnement et les instructions de build depuis les sources.
----
+## 🤝 Origines du projet, remerciements et développements dérivés
-## 📜 Licence
+MAX API poursuit le travail open source de [One API](https://github.com/songquanpeng/one-api) et [New API](https://github.com/QuantumNous/new-api). Nous remercions les projets amont, leurs contributeurs et toutes les personnes qui apportent adaptateurs, tests, documentation, traductions et rapports d'incident.
-Ce projet est sous [GNU Affero General Public License v3.0 (AGPLv3)](./LICENSE).
+Conformément au fichier [NOTICE](./NOTICE) et à la section 7 de l'AGPLv3, toute version modifiée qui présente une interface utilisateur doit conserver tous les éléments suivants dans un emplacement À propos, juridique, de pied de page ou d'attribution clairement visible :
-Outre la licence AGPLv3 par défaut, les projets dérivés à usage propre qui respectent les conditions « Développements dérivés et remerciements à la communauté » ci-dessus reçoivent automatiquement la licence commerciale temporaire et non permanente qui y est décrite. Cette licence temporaire ne couvre que les ajouts et modifications que les responsables du projet MAX API sont en droit de concéder ; elle n'inclut ni ne remplace les licences des projets en amont tels que One API et New API.
+- Un lien vers le projet MAX API d'origine : [MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- L'attribution exacte du NOTICE de MAX API : `Frontend design and development by MAX API contributors.`
+- Un lien vers le projet amont New API : [QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- L'attribution exacte du NOTICE de New API : `Frontend design and development by New API contributors.`
+- Une mention explicite des modifications avec une date pertinente
-Si vous modifiez le projet et le fournissez aux utilisateurs via le réseau, comprenez et respectez les obligations AGPLv3 de disponibilité du code source. Pour coopération commerciale, institutionnelle ou autres questions de licence : maxapi@max-api.ai.
+Un remerciement à la [communauté MAX-API-Next](https://github.com/MAX-API-Next) peut être ajouté, mais il ne remplace ni les liens obligatoires vers les projets, ni les attributions exactes, ni le marquage des modifications.
----
+Le respect continu de ces exigences d'affichage et du NOTICE accorde automatiquement une licence commerciale temporaire non perpétuelle, sans demande ni approbation séparée. Cette autorisation supplémentaire couvre uniquement les éléments que les responsables du projet MAX API ont le droit de licencier et ne dispense pas des obligations de l'AGPLv3, de One API, de New API ou des autres projets amont. Les conditions les plus récentes sont celles du README officiel et des annonces de la communauté.
-## 🌟 Historique des étoiles
+## 📜 Licence
-
+Ce projet est distribué sous la [GNU Affero General Public License v3.0 (AGPLv3)](./LICENSE).
-[](https://star-history.com/#MAX-API-Next/MAX-API&Date)
+La licence commerciale temporaire couvre uniquement les ajouts et modifications que les responsables de MAX API ont le droit de licencier. Elle n'inclut, ne remplace et n'annule pas les obligations de licence de One API, New API ou d'autres projets amont. L'usage commercial doit également respecter la licence MIT de One API, la licence AGPLv3 de New API et les conditions de licence actuelles de chaque projet amont.
-
+Si vous modifiez ce projet et le fournissez à des utilisateurs via un réseau, veuillez comprendre et respecter les obligations de mise à disposition du code source prévues par l'AGPLv3. Pour une licence commerciale de long terme, une coopération institutionnelle ou toute question de licence, contactez maxapi@max-api.ai.
---
@@ -684,9 +354,9 @@ Si vous modifiez le projet et le fournissez aux utilisateurs via le réseau, com
### 💖 Merci d'utiliser MAX API
-Si ce projet vous aide, pensez à lui donner une ⭐ Star.
+Si ce projet vous aide, pensez à lui attribuer une ⭐ Star, suivre les Releases, signaler une Issue reproductible ou rejoindre la communauté MAX-API-Next.
-**[Documentation officielle](https://github.com/MAX-API-Next/MAX-API)** • **[Issues](https://github.com/MAX-API-Next/MAX-API/issues)** • **[Releases](https://github.com/MAX-API-Next/MAX-API/releases)**
+**[Dépôt du projet](https://github.com/MAX-API-Next/MAX-API)** • **[Contribuer](https://github.com/MAX-API-Next/MAX-API/issues)** • **[Dernières versions](https://github.com/MAX-API-Next/MAX-API/releases)** • **[Communauté MAX-API-Next](https://github.com/MAX-API-Next)**
Built with ❤️ by MAX-API-Next
diff --git a/README.ja.md b/README.ja.md
index 909493b8..e369fcf0 100644
--- a/README.ja.md
+++ b/README.ja.md
@@ -1,10 +1,14 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**AGI アプリケーション時代に向けた AI Models and Agents governance、インテリジェント運用、オープンコラボレーション基盤**
+
+**MAX API 2.0:インテリジェント運用の時代へ · 統一モデルゲートウェイから AGI ネイティブなガバナンス/運用基盤へ**
-🍥 **AI モデルガバナンス、AgentOps、AGI アプリケーションサービス基盤**
+[MAX API 2.0 Preview リリースノートを見る](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
+# docker-compose.yml のデータベース/Redis パスワードと秘密情報を変更
+docker compose up -d
```
-上記いずれかの表示要件を満たし、リンクを明確に表示し続けることで、申請や承認を別途行うことなく、本プロジェクトの一時的な商用ライセンスを自動的に取得できます。このライセンスは永久ライセンスではなく、表示要件を継続して満たしている期間に限り有効です。有効期間および今後の変更は、本 README または公式コミュニティで公開される最新のお知らせに従います。
+### デプロイチェック
-本プロジェクトは [One API](https://github.com/songquanpeng/one-api) および [New API](https://github.com/QuantumNous/new-api) をベースに開発されています。現段階の MAX API は、これらを基盤として AI API ゲートウェイおよびガバナンス機能の強化、機能拡張、バグ修正を継続しています。商用利用にあたっては、各上流プロジェクトが現在公開している `LICENSE` ファイルに従い、One API の MIT ライセンスおよび New API の AGPLv3 ライセンスも遵守する必要があります。本プロジェクトが提供する一時的な商用ライセンスは、上流プロジェクトのオープンソースライセンス上の義務を置き換えたり免除したりするものではありません。
+| コンポーネント | 推奨 |
+|---|---|
+| データベース | ベンダーのセキュリティサポート期間内にある MySQL(8.4 LTS 推奨)または PostgreSQL(14+ 推奨)を使用し、バックアップと復旧を構成 |
+| キャッシュ | 1 ノードではメモリキャッシュを利用可能。複数ノードでは Redis を推奨 |
+| エントリーポイント | HTTPS リバースプロキシ、リクエストサイズ制限、信頼済みネットワーク方針を設定 |
+| 秘密情報 | ランダムな `SESSION_SECRET` を明示設定。`CRYPTO_SECRET` は任意の上書き値で、未設定時は `SESSION_SECRET` を使用し、設定する場合は Redis/複数ノードで同じ値を共有 |
+| ノード | 各ノードに安定した一意の `NODE_NAME` を設定 |
+| ログ | コンプライアンスと運用要件に合わせて `LOG_SQL_DSN`、クリーンアップ、保持方針を設定 |
-表示要件を満たさなくなった場合、または一時的なライセンスが期限切れ、告知により変更もしくは終了した場合は、AGPLv3 に従うか、別途書面による許諾を取得する必要があります。長期商用ライセンスについては、maxapi@max-api.ai までお問い合わせください。
+複数ノードでは `SESSION_SECRET` を共有し、各ノードに異なる `NODE_NAME` を設定する必要があります。`CRYPTO_SECRET` は任意の上書き値で、未設定時は `SESSION_SECRET` を使用します。明示的に設定する場合は、すべてのノードで同じ値を使用してください。独立ログデータベースには `LOG_SQL_DSN` を使用し、エラー性能統計が必要な場合は `ERROR_LOG_ENABLED` を有効にしてください。すべての環境変数とソースビルド手順は[詳細ドキュメント](https://docs.max-api.ai)を参照してください。
-Issue、ドキュメント改善、プロバイダー適応経験、デプロイ方案、コード貢献を歓迎します。
+## 🤝 プロジェクトの由来、謝辞、二次開発
----
+MAX API は、[One API](https://github.com/songquanpeng/one-api) と [New API](https://github.com/QuantumNous/new-api) のオープンソース成果を基に開発を継続しています。上流プロジェクトと貢献者、プロトコル適応、テスト、ドキュメント、翻訳、Issue 報告に参加するすべてのコミュニティメンバーに感謝します。
-## 📜 ライセンス
+[NOTICE](./NOTICE) および AGPLv3 第 7 条に従い、ユーザーインターフェースを持つ変更版は、About、法的表示、フッター、または帰属表示の見やすい場所に、次のすべてを保持する必要があります:
-本プロジェクトは [GNU Affero General Public License v3.0 (AGPLv3)](./LICENSE) で提供されます。
+- MAX API の元プロジェクトへのリンク:[MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- MAX API NOTICE の正確な帰属表示:`Frontend design and development by MAX API contributors.`
+- 上流 New API プロジェクトへのリンク:[QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- New API NOTICE の正確な帰属表示:`Frontend design and development by New API contributors.`
+- 変更したことを示す明確な表示と、関連する変更日
-標準の AGPLv3 ライセンスに加え、上記「二次開発とコミュニティへの謝辞」の条件を満たす自己利用の二次開発プロジェクトには、そこで説明されている非永久の一時的な商用ライセンスが自動的に付与されます。この一時的なライセンスが対象とするのは、MAX API プロジェクト運営者がライセンスする権利を有する追加・変更部分のみであり、One API や New API などの上流プロジェクトのライセンスを含む、または代替するものではありません。
+[MAX-API-Next コミュニティ](https://github.com/MAX-API-Next)への謝辞は任意で追加できますが、必須のプロジェクトリンク、正確な帰属表示、変更表示の代わりにはなりません。
-本プロジェクトを変更し、ネットワーク経由でユーザーにサービスとして提供する場合は、AGPLv3 のソース提供義務などを理解し遵守してください。商用協力、機関協力、その他ライセンスに関する問い合わせは maxapi@max-api.ai までご連絡ください。
+これらの表示要件と NOTICE の要件を継続して満たすことで、別途申請や承認を待つことなく、非永続的な一時商用ライセンスが自動的に付与されます。この追加許諾は MAX API プロジェクト側がライセンスする権利を持つ部分だけを対象とし、AGPLv3、One API、New API、その他の上流プロジェクトのライセンス義務を免除しません。最新条件は正式 README と公式コミュニティの告知に従います。
----
-
-## 🌟 Star History
+## 📜 ライセンス
-
+本プロジェクトは [GNU Affero General Public License v3.0(AGPLv3)](./LICENSE) の下で提供されます。
-[](https://star-history.com/#MAX-API-Next/MAX-API&Date)
+一時商用ライセンスが対象とするのは、MAX API プロジェクト側がライセンスする権利を持つ追加・変更部分のみです。One API、New API、その他の上流プロジェクトのライセンス義務を含めたり、置き換えたり、免除したりするものではありません。商用利用では、One API の MIT ライセンス、New API の AGPLv3 ライセンス、および各上流プロジェクトの最新条件にも従ってください。
-
+本プロジェクトを変更し、ネットワーク経由でユーザーへ提供する場合は、AGPLv3 のソースコード提供義務を理解し、遵守してください。長期商用ライセンス、機関との協力、その他のライセンスに関する問い合わせは maxapi@max-api.ai までご連絡ください。
---
@@ -705,9 +354,9 @@ Issue、ドキュメント改善、プロバイダー適応経験、デプロイ
### 💖 MAX API をご利用いただきありがとうございます
-このプロジェクトが役に立った場合は、ぜひ ⭐ Star をお願いします。
+このプロジェクトが役に立った場合は、⭐ Star、Releases のフォロー、再現可能な Issue の報告、MAX-API-Next コミュニティへの参加をお願いします。
-**[公式ドキュメント](https://github.com/MAX-API-Next/MAX-API)** • **[Issues](https://github.com/MAX-API-Next/MAX-API/issues)** • **[Releases](https://github.com/MAX-API-Next/MAX-API/releases)**
+**[プロジェクトリポジトリ](https://github.com/MAX-API-Next/MAX-API)** • **[貢献する](https://github.com/MAX-API-Next/MAX-API/issues)** • **[最新リリース](https://github.com/MAX-API-Next/MAX-API/releases)** • **[MAX-API-Next コミュニティ](https://github.com/MAX-API-Next)**
Built with ❤️ by MAX-API-Next
diff --git a/README.md b/README.md
index 250aedbf..4bf56c80 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,14 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**面向 AGI 应用时代的 AI Models 与 Agents 治理、智能运维和开放协作基础设施**
+
+**MAX API 2.0:开启智能运维时代 · 从统一模型网关走向 AGI 原生治理与运营**
-🍥 **AI 模型治理、AgentOps 与 AGI 应用服务基础设施**
+[查看 MAX API 2.0 Preview 发布说明](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
-```
+## 🤝 项目来源、致谢与二次开发
-满足上述任一展示要求并保持链接清晰可见,即自动获得本项目的临时商用授权,无需另行申请或等待确认。该授权为非永久授权,仅在持续满足展示要求期间有效;有效期及后续调整以项目方在本 README 或官方社区发布的最新说明为准。
+MAX API 基于 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 的开源成果持续开发。感谢上游项目、贡献者,以及所有参与协议适配、测试、文档、翻译与问题反馈的社区成员。
-本项目基于 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 开发。现阶段,MAX API 主要在上述项目基础上持续增强 AI API 网关与治理能力、扩展功能并修复问题。商业使用本项目时,还须分别遵守 One API 的 MIT 许可证与 New API 的 AGPLv3 许可证,具体以各上游项目的 `LICENSE` 文件为准;本项目提供的临时商用授权不替代、也不免除相关上游项目的开源许可义务。
+根据 [NOTICE](./NOTICE) 和 AGPLv3 第 7 节,包含用户界面的修改版本必须在显著可见的“关于”、法律声明、页脚或署名位置同时保留:
-如不再满足展示要求,或临时授权到期、被公告调整或终止,仍需按 AGPLv3 或项目方另行书面授权使用本项目。如需长期商用授权,请联系:maxapi@max-api.ai。
+- MAX API 原项目链接:[MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- MAX API NOTICE 中的原文署名:`Frontend design and development by MAX API contributors.`
+- New API 上游项目链接:[QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- New API NOTICE 中的原文署名:`Frontend design and development by New API contributors.`
+- 明确的修改声明及相关修改日期
-欢迎提交 Issue、改进文档、补充供应商适配经验、完善部署方案或贡献代码。
+可以额外鸣谢 [MAX-API-Next 社区](https://github.com/MAX-API-Next),但社区鸣谢不能替代上述必需的项目链接、原文署名和变更标记。
----
+持续满足上述展示与 NOTICE 要求,即自动获得本项目的非永久临时商用授权,无需另行申请或等待确认;该授权仅覆盖 MAX API 项目方有权授权的部分,不免除 AGPLv3 或 One API、New API 等上游项目的许可义务。最新条件以正式 README 与社区公告为准。
## 📜 许可证
-本项目采用 [GNU Affero 通用公共许可证 v3.0 (AGPLv3)](./LICENSE) 授权。
-
-除默认的 AGPLv3 授权外,符合上文“二次开发与社区鸣谢”条件的自用二开项目,可按该说明自动获得非永久的临时商用授权。该临时授权仅覆盖 MAX API 项目方有权授权的新增与修改部分,并不包含或代替 One API、New API 等上游项目的许可授权。
+本项目采用 [GNU Affero 通用公共许可证 v3.0(AGPLv3)](./LICENSE) 授权。
-如果你修改并通过网络向用户提供本项目服务,请理解并遵守 AGPLv3 对应源码提供等义务。商业合作、机构合作或其他授权问题,请联系:maxapi@max-api.ai。
+临时商用授权仅覆盖 MAX API 项目方有权授权的新增与修改部分,不包含、替代或免除 One API、New API 等上游项目的许可义务。商业使用时,请同时遵守 One API 的 MIT 许可证、New API 的 AGPLv3 许可证及各上游项目的最新许可要求。
+如果你修改并通过网络向用户提供本项目服务,请理解并遵守 AGPLv3 对应的源码提供等义务。长期商用授权、机构合作或其他授权问题,请联系:maxapi@max-api.ai。
---
@@ -769,9 +356,9 @@ MAX API 不替代 Dify、LangChain、MCP Server、工作流引擎或业务 Agent
### 💖 感谢使用 MAX API
-如果这个项目对你有帮助,欢迎给我们一个 ⭐ Star。
+如果这个项目对你有帮助,欢迎给我们一个 ⭐ Star、关注 Releases、提交可复现 Issue,或参与 MAX-API-Next 社区共建。
-**[官方文档](https://github.com/MAX-API-Next/MAX-API)** • **[问题反馈](https://github.com/MAX-API-Next/MAX-API/issues)** • **[最新发布](https://github.com/MAX-API-Next/MAX-API/releases)**
+**[项目仓库](https://github.com/MAX-API-Next/MAX-API)** • **[参与共建](https://github.com/MAX-API-Next/MAX-API/issues)** • **[最新发布](https://github.com/MAX-API-Next/MAX-API/releases)** • **[MAX-API-Next 社区](https://github.com/MAX-API-Next)**
Built with ❤️ by MAX-API-Next
diff --git a/README.zh_CN.md b/README.zh_CN.md
index 6bd672dd..4bf56c80 100644
--- a/README.zh_CN.md
+++ b/README.zh_CN.md
@@ -1,10 +1,14 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**面向 AGI 应用时代的 AI Models 与 Agents 治理、智能运维和开放协作基础设施**
+
+**MAX API 2.0:开启智能运维时代 · 从统一模型网关走向 AGI 原生治理与运营**
-🍥 **AI 模型治理、AgentOps 与 AGI 应用服务基础设施**
+[查看 MAX API 2.0 Preview 发布说明](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
+# 修改 docker-compose.yml 中的数据库、Redis 密码和密钥
+docker compose up -d
```
-满足上述任一展示要求并保持链接清晰可见,即自动获得本项目的临时商用授权,无需另行申请或等待确认。该授权为非永久授权,仅在持续满足展示要求期间有效;有效期及后续调整以项目方在本 README 或官方社区发布的最新说明为准。
+### 部署检查
-本项目基于 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 开发。现阶段,MAX API 主要在上述项目基础上持续增强 AI API 网关与治理能力、扩展功能并修复问题。商业使用本项目时,还须分别遵守 One API 的 MIT 许可证与 New API 的 AGPLv3 许可证,具体以各上游项目的 `LICENSE` 文件为准;本项目提供的临时商用授权不替代、也不免除相关上游项目的开源许可义务。
+| 组件 | 建议 |
+|---|---|
+| 数据库 | 使用仍在供应商安全支持周期内的 MySQL(建议 8.4 LTS)或 PostgreSQL(建议 14+),并配置备份与恢复 |
+| 缓存 | 单机可使用内存缓存,多节点部署建议使用 Redis |
+| 入口 | 配置 HTTPS 反向代理、请求大小限制和可信网络策略 |
+| 密钥 | 显式配置随机 `SESSION_SECRET`;`CRYPTO_SECRET` 为可选覆盖项,未设置时回退到 `SESSION_SECRET`,如单独设置则需在 Redis/多节点场景统一 |
+| 节点 | 每个节点设置稳定且唯一的 `NODE_NAME` |
+| 日志 | 根据合规和运维需要配置 `LOG_SQL_DSN`、清理与保留策略 |
-如不再满足展示要求,或临时授权到期、被公告调整或终止,仍需按 AGPLv3 或项目方另行书面授权使用本项目。如需长期商用授权,请联系:maxapi@max-api.ai。
+多节点必须统一 `SESSION_SECRET`,并为每个节点使用不同的 `NODE_NAME`。`CRYPTO_SECRET` 为可选覆盖项,未设置时使用 `SESSION_SECRET`;如显式设置,则所有节点必须使用相同值。独立日志库使用 `LOG_SQL_DSN`;错误性能统计需要按需启用 `ERROR_LOG_ENABLED`。完整环境变量和源码构建说明见 [详细文档](https://docs.max-api.ai)。
-欢迎提交 Issue、改进文档、补充供应商适配经验、完善部署方案或贡献代码。
+## 🤝 项目来源、致谢与二次开发
----
+MAX API 基于 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 的开源成果持续开发。感谢上游项目、贡献者,以及所有参与协议适配、测试、文档、翻译与问题反馈的社区成员。
-## 📜 许可证
+根据 [NOTICE](./NOTICE) 和 AGPLv3 第 7 节,包含用户界面的修改版本必须在显著可见的“关于”、法律声明、页脚或署名位置同时保留:
-本项目采用 [GNU Affero 通用公共许可证 v3.0 (AGPLv3)](./LICENSE) 授权。
+- MAX API 原项目链接:[MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- MAX API NOTICE 中的原文署名:`Frontend design and development by MAX API contributors.`
+- New API 上游项目链接:[QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- New API NOTICE 中的原文署名:`Frontend design and development by New API contributors.`
+- 明确的修改声明及相关修改日期
-除默认的 AGPLv3 授权外,符合上文“二次开发与社区鸣谢”条件的自用二开项目,可按该说明自动获得非永久的临时商用授权。该临时授权仅覆盖 MAX API 项目方有权授权的新增与修改部分,并不包含或代替 One API、New API 等上游项目的许可授权。
+可以额外鸣谢 [MAX-API-Next 社区](https://github.com/MAX-API-Next),但社区鸣谢不能替代上述必需的项目链接、原文署名和变更标记。
-如果你修改并通过网络向用户提供本项目服务,请理解并遵守 AGPLv3 对应源码提供等义务。商业合作、机构合作或其他授权问题,请联系:maxapi@max-api.ai。
+持续满足上述展示与 NOTICE 要求,即自动获得本项目的非永久临时商用授权,无需另行申请或等待确认;该授权仅覆盖 MAX API 项目方有权授权的部分,不免除 AGPLv3 或 One API、New API 等上游项目的许可义务。最新条件以正式 README 与社区公告为准。
----
-
-## 🌟 Star History
+## 📜 许可证
-
+本项目采用 [GNU Affero 通用公共许可证 v3.0(AGPLv3)](./LICENSE) 授权。
-[](https://star-history.com/#MAX-API-Next/MAX-API&Date)
+临时商用授权仅覆盖 MAX API 项目方有权授权的新增与修改部分,不包含、替代或免除 One API、New API 等上游项目的许可义务。商业使用时,请同时遵守 One API 的 MIT 许可证、New API 的 AGPLv3 许可证及各上游项目的最新许可要求。
-
+如果你修改并通过网络向用户提供本项目服务,请理解并遵守 AGPLv3 对应的源码提供等义务。长期商用授权、机构合作或其他授权问题,请联系:maxapi@max-api.ai。
---
@@ -776,9 +356,9 @@ MAX API 不替代 Dify、LangChain、MCP Server、工作流引擎或业务 Agent
### 💖 感谢使用 MAX API
-如果这个项目对你有帮助,欢迎给我们一个 ⭐ Star。
+如果这个项目对你有帮助,欢迎给我们一个 ⭐ Star、关注 Releases、提交可复现 Issue,或参与 MAX-API-Next 社区共建。
-**[官方文档](https://github.com/MAX-API-Next/MAX-API)** • **[问题反馈](https://github.com/MAX-API-Next/MAX-API/issues)** • **[最新发布](https://github.com/MAX-API-Next/MAX-API/releases)**
+**[项目仓库](https://github.com/MAX-API-Next/MAX-API)** • **[参与共建](https://github.com/MAX-API-Next/MAX-API/issues)** • **[最新发布](https://github.com/MAX-API-Next/MAX-API/releases)** • **[MAX-API-Next 社区](https://github.com/MAX-API-Next)**
Built with ❤️ by MAX-API-Next
diff --git a/README.zh_TW.md b/README.zh_TW.md
index d998efab..dbb555bc 100644
--- a/README.zh_TW.md
+++ b/README.zh_TW.md
@@ -1,13 +1,17 @@
-
+# MAX API
-
+
-# MAX API
+
+
+**面向 AGI 應用時代的 AI Models and Agents governance、智慧運維與開放協作基礎設施**
+
+**MAX API 2.0:開啟智慧運維時代 · 從統一模型閘道走向 AGI 原生治理與營運**
-🍥 **AI 模型治理、AgentOps 與 AGI 應用服務基礎設施**
+[查看 MAX API 2.0 Preview 發布說明](https://github.com/MAX-API-Next/MAX-API/releases/tag/v2.0.0-smartops.pre1)
+# 修改 docker-compose.yml 中的資料庫、Redis 密碼和金鑰
+docker compose up -d
```
-滿足上述任一展示要求並保持連結清晰可見,即自動獲得本專案的臨時商用授權,無需另行申請或等待確認。該授權為非永久授權,僅在持續滿足展示要求期間有效;有效期及後續調整以專案方在本 README 或官方社群發布的最新說明為準。
+### 部署檢查
-本專案基於 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 開發。現階段,MAX API 主要在上述專案基礎上持續強化 AI API 閘道與治理能力、擴充功能並修正問題。商業使用本專案時,還須分別遵守 One API 的 MIT 許可證與 New API 的 AGPLv3 許可證,具體以各上游專案的 `LICENSE` 檔案為準;本專案提供的臨時商用授權不替代、也不免除相關上游專案的開源許可義務。
+| 元件 | 建議 |
+|---|---|
+| 資料庫 | 使用仍在供應商安全支援週期內的 MySQL(建議 8.4 LTS)或 PostgreSQL(建議 14+),並設定備份與復原 |
+| 快取 | 單機可使用記憶體快取,多節點部署建議使用 Redis |
+| 入口 | 設定 HTTPS 反向代理、請求大小限制和可信任網路策略 |
+| 金鑰 | 明確設定隨機 `SESSION_SECRET`;`CRYPTO_SECRET` 為可選覆寫項,未設定時回退到 `SESSION_SECRET`,如單獨設定則需在 Redis/多節點場景統一 |
+| 節點 | 每個節點設定穩定且唯一的 `NODE_NAME` |
+| 日誌 | 依合規和運維需要設定 `LOG_SQL_DSN`、清理與保留策略 |
-如不再滿足展示要求,或臨時授權到期、被公告調整或終止,仍需按 AGPLv3 或專案方另行書面授權使用本專案。如需長期商用授權,請聯絡:maxapi@max-api.ai。
+多節點必須統一 `SESSION_SECRET`,並為每個節點使用不同的 `NODE_NAME`。`CRYPTO_SECRET` 為可選覆寫項,未設定時使用 `SESSION_SECRET`;如明確設定,所有節點必須使用相同值。獨立日誌庫使用 `LOG_SQL_DSN`;錯誤效能統計需要按需啟用 `ERROR_LOG_ENABLED`。完整環境變數和原始碼建置說明請見[詳細文件](https://docs.max-api.ai)。
-歡迎提交 Issue、改進文檔、補充供應商適配經驗、完善部署方案或貢獻代碼。
+## 🤝 專案來源、致謝與二次開發
----
+MAX API 基於 [One API](https://github.com/songquanpeng/one-api) 和 [New API](https://github.com/QuantumNous/new-api) 的開源成果持續開發。感謝上游專案、貢獻者,以及所有參與協定適配、測試、文件、翻譯與問題回報的社群成員。
-## 📜 許可證
+根據 [NOTICE](./NOTICE) 與 AGPLv3 第 7 節,包含使用者介面的修改版本必須在清楚可見的「關於」、法律聲明、頁尾或署名位置同時保留:
-本專案采用 [GNU Affero 通用公共許可證 v3.0 (AGPLv3)](./LICENSE) 授權。
+- MAX API 原專案連結:[MAX-API-Next/MAX-API](https://github.com/MAX-API-Next/MAX-API)
+- MAX API NOTICE 中的原文署名:`Frontend design and development by MAX API contributors.`
+- New API 上游專案連結:[QuantumNous/new-api](https://github.com/QuantumNous/new-api)
+- New API NOTICE 中的原文署名:`Frontend design and development by New API contributors.`
+- 明確的修改聲明及相關修改日期
-除預設的 AGPLv3 授權外,符合上文「二次開發與社群鳴謝」條件的自用二開專案,可按該說明自動獲得非永久的臨時商用授權。該臨時授權僅涵蓋 MAX API 專案方有權授權的新增與修改部分,並不包含或代替 One API、New API 等上游專案的許可授權。
+可以額外鳴謝 [MAX-API-Next 社群](https://github.com/MAX-API-Next),但社群鳴謝不能取代上述必要的專案連結、原文署名和變更標記。
-如果你修改并通過網絡向使用者提供本專案服務,請理解并遵守 AGPLv3 對應源碼提供等義務。商業合作、機構合作或其他授權問題,請聯系:maxapi@max-api.ai。
+持續滿足上述展示與 NOTICE 要求,即自動取得本專案的非永久臨時商用授權,無需另外申請或等待確認;該授權僅涵蓋 MAX API 專案方有權授權的部分,不免除 AGPLv3 或 One API、New API 等上游專案的許可義務。最新條件以正式 README 與官方社群公告為準。
----
-
-## 🌟 Star History
+## 📜 許可證
-
+本專案採用 [GNU Affero 通用公共許可證 v3.0(AGPLv3)](./LICENSE) 授權。
-[](https://star-history.com/#MAX-API-Next/MAX-API&Date)
+臨時商用授權僅涵蓋 MAX API 專案方有權授權的新增與修改部分,不包含、取代或免除 One API、New API 等上游專案的許可義務。商業使用時,請同時遵守 One API 的 MIT 許可證、New API 的 AGPLv3 許可證及各上游專案的最新許可要求。
-