Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

feat: add DaoXE as an OpenAI-compatible model provider (#19560)

Seven5ef628396fca
diff --git a/conf/llm_factories.json b/conf/llm_factories.json
index 764a3ce552..172049ab65 100644
--- a/conf/llm_factories.json
+++ b/conf/llm_factories.json
@@ -2047,6 +2047,14 @@
"status": "1",
"llm": []
},
+ {
+ "name": "DaoXE",
+ "logo": "",
+ "tags": "LLM,TEXT EMBEDDING",
+ "status": "1",
+ "llm": [],
+ "rank": "885"
+ },
{
"name": "DeepSeek",
"logo": "",
diff --git a/conf/models/daoxe.json b/conf/models/daoxe.json
new file mode 100644
index 0000000000..86607433d4
--- /dev/null
+++ b/conf/models/daoxe.json
@@ -0,0 +1,13 @@
+{
+ "name": "DaoXE",
+ "url": {
+ "default": "https://api.daoxe.com/v1"
+ },
+ "url_suffix": {
+ "chat": "chat/completions",
+ "models": "models",
+ "embedding": "embeddings"
+ },
+ "class": "daoxe",
+ "models": []
+}
diff --git a/docs/guides/models/supported_models.mdx b/docs/guides/models/supported_models.mdx
index b34d5e2c65..ee2cb9903f 100644
--- a/docs/guides/models/supported_models.mdx
+++ b/docs/guides/models/supported_models.mdx
@@ -33,6 +33,7 @@ A complete list of model providers supported by RAGFlow, which will continue to
| Bedrock | `https://aws.amazon.com/bedrock/` |
| Cohere | `https://cohere.com` |
| CometAPI | `https://cometapi.com` |
+| DaoXE | `https://daoxe.com` |
| DeepInfra | `https://deepinfra.com` |
| DeepSeek | `https://www.deepseek.com` |
| DeerAPI | `https://deerapi.com` |
diff --git a/internal/entity/models/daoxe.go b/internal/entity/models/daoxe.go
new file mode 100644
index 0000000000..65628fc2d6
--- /dev/null
+++ b/internal/entity/models/daoxe.go
@@ -0,0 +1,43 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package models
+
+// DaoxeModel implements DaoXE's OpenAI-compatible chat and model-list APIs.
+// DaoXE speaks the OpenAI wire format without deviation, so the embedded
+// OpenAIAPICompatibleModel covers every call and nothing is overridden beyond
+// the driver's own identity. The live catalog is account-scoped, so model
+// listing reads GET /v1/models from the gateway instead of a static list.
+type DaoxeModel struct {
+ *OpenAIAPICompatibleModel
+}
+
+// NewDaoxeModel creates a DaoXE model driver.
+func NewDaoxeModel(baseURL map[string]string, urlSuffix URLSuffix) *DaoxeModel {
+ return &DaoxeModel{
+ OpenAIAPICompatibleModel: NewOpenAIAPICompatibleModel(baseURL, urlSuffix),
+ }
+}
+
+// Name returns the model driver name.
+func (m *DaoxeModel) Name() string {
+ return "DaoXE"
+}
+
+// NewInstance creates a new DaoXE driver bound to the given base URL.
+func (m *DaoxeModel) NewInstance(baseURL map[string]string) ModelDriver {
+ return NewDaoxeModel(baseURL, m.baseModel.URLSuffix)
+}
diff --git a/internal/entity/models/daoxe_test.go b/internal/entity/models/daoxe_test.go
new file mode 100644
index 0000000000..4b30c7248c
--- /dev/null
+++ b/internal/entity/models/daoxe_test.go
@@ -0,0 +1,68 @@
+package models
+
+import (
+ "encoding/json"
+ "net/http"
+ "net/http/httptest"
+ "ragflow/internal/common"
+ "testing"
+)
+
+func newDaoxeForTest(baseURL string) *DaoxeModel {
+ return NewDaoxeModel(
+ map[string]string{"default": baseURL},
+ URLSuffix{Chat: "chat/completions", Models: "models", Embedding: "embeddings"},
+ )
+}
+
+func TestDaoxeName(t *testing.T) {
+ if got := newDaoxeForTest("http://unused").Name(); got != "DaoXE" {
+ t.Errorf("Name()=%q", got)
+ }
+}
+
+func TestDaoxeFactory(t *testing.T) {
+ driver, err := NewModelFactory().CreateModelDriver("daoxe", map[string]string{"default": "http://unused"}, URLSuffix{})
+ if err != nil {
+ t.Fatalf("CreateModelDriver: %v", err)
+ }
+ if _, ok := driver.(*DaoxeModel); !ok {
+ t.Fatalf("driver type=%T, want *DaoxeModel", driver)
+ }
+ if _, ok := driver.NewInstance(map[string]string{"default": "http://other"}).(*DaoxeModel); !ok {
+ t.Fatal("NewInstance did not return *DaoxeModel")
+ }
+}
+
+// DaoXE is a hosted gateway, so unlike a local server it must receive the
+// tenant's key as a bearer token on every call.
+func TestDaoxeChatSendsAPIKey(t *testing.T) {
+ withSSRFBypass(t)
+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if r.URL.Path != "/chat/completions" {
+ t.Errorf("path=%s", r.URL.Path)
+ }
+ if got, want := r.Header.Get("Authorization"), "Bearer "+testAPIKey; got != want {
+ t.Errorf("Authorization=%q, want %q", got, want)
+ }
+ _ = json.NewEncoder(w).Encode(map[string]any{
+ "id": "chat-daoxe",
+ "choices": []map[string]any{{"message": map[string]any{"content": "pong"}}},
+ "usage": map[string]any{"prompt_tokens": 3, "completion_tokens": 5, "total_tokens": 8},
+ })
+ }))
+ defer srv.Close()
+
+ usage := &common.ModelUsage{}
+ resp, err := newDaoxeForTest(srv.URL).ChatWithMessages(
+ t.Context(), "gpt-4o", []Message{{Role: "user", Content: "ping"}},
+ &APIConfig{ApiKey: &testAPIKey}, nil, usage,
+ )
+ if err != nil {
+ t.Fatalf("ChatWithMessages: %v", err)
+ }
+ if *resp.Answer != "pong" {
+ t.Errorf("Answer=%q", *resp.Answer)
+ }
+ assertModelUsage(t, usage, 3, 5, 8)
+}
diff --git a/internal/entity/models/factory.go b/internal/entity/models/factory.go
index 537348318c..d7e0fc9f59 100644
--- a/internal/entity/models/factory.go
+++ b/internal/entity/models/factory.go
@@ -87,6 +87,8 @@ func (f *ModelFactory) CreateModelDriver(providerName string, baseURL map[string
return NewCoHereModel(baseURL, urlSuffix), nil
case "cometapi":
return NewCometAPIModel(baseURL, urlSuffix), nil
+ case "daoxe":
+ return NewDaoxeModel(baseURL, urlSuffix), nil
case "fish audio":
return NewFishAudioModel(baseURL, urlSuffix), nil
case "mistral":
diff --git a/rag/llm/chat_model.py b/rag/llm/chat_model.py
index 4ff504ffb3..a9ec216f47 100644
--- a/rag/llm/chat_model.py
+++ b/rag/llm/chat_model.py
@@ -3015,6 +3015,24 @@ class RAGconChat(Base):
super().__init__(key, model_name, base_url, **kwargs)
+class DaoXEChat(Base):
+ """DaoXE OpenAI-compatible chat adapter.
+
+ DaoXE is a hosted multi-model gateway speaking the OpenAI wire format, so
+ the standard OpenAI client path covers every call. The base URL is
+ tenant-configurable because DaoXE is also self-hostable behind custom
+ domains.
+ """
+
+ _FACTORY_NAME = "DaoXE"
+
+ def __init__(self, key, model_name, base_url, **kwargs):
+ if not base_url:
+ raise ValueError("url cannot be None")
+ model_name = model_name.split("___")[0]
+ super().__init__(key, model_name, base_url, **kwargs)
+
+
class NewAPIChat(Base):
_FACTORY_NAME = "New API"
diff --git a/rag/llm/embedding_model.py b/rag/llm/embedding_model.py
index 0399f2ad11..c41cb31d78 100644
--- a/rag/llm/embedding_model.py
+++ b/rag/llm/embedding_model.py
@@ -1491,6 +1491,18 @@ class PerplexityEmbed(Base):
return np.array(embds[0]), cnt
+class DaoXEEmbed(OpenAIEmbed):
+ """DaoXE OpenAI-compatible embeddings."""
+
+ _FACTORY_NAME = "DaoXE"
+
+ def __init__(self, key, model_name, base_url):
+ if not base_url:
+ raise ValueError("url cannot be None")
+ self.client = OpenAI(api_key=key, base_url=base_url)
+ self.model_name = model_name.split("___")[0]
+
+
class NewAPIEmbed(OpenAIEmbed):
_FACTORY_NAME = "New API"
diff --git a/rag/llm/model_meta.py b/rag/llm/model_meta.py
index bf93bd6184..00e7109007 100644
--- a/rag/llm/model_meta.py
+++ b/rag/llm/model_meta.py
@@ -1187,6 +1187,18 @@ class ApiRoute(OpenAIAPICompatible):
return f"{self._BASE_URL}/models"
+class DaoXE(OpenAIAPICompatible):
+ """DaoXE catalog lister.
+
+ The live catalog is account-scoped and changes over time, so the list is
+ read from the gateway's own ``/v1/models`` endpoint (inherited behavior)
+ rather than pinned in ``conf/models/daoxe.json``, which stays empty on
+ purpose.
+ """
+
+ _FACTORY_NAME = "DaoXE"
+
+
class NewAPI(OpenAIAPICompatible):
_FACTORY_NAME = "New API"
diff --git a/web/src/assets/svg/llm/daoxe.svg b/web/src/assets/svg/llm/daoxe.svg
new file mode 100644
index 0000000000..3638a28adc
--- /dev/null
+++ b/web/src/assets/svg/llm/daoxe.svg
@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 192 192" width="192" height="192">
+ <image width="192" height="192" xlink:href="data:image/png;base64,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"/>
+</svg>
diff --git a/web/src/components/svg-icon.tsx b/web/src/components/svg-icon.tsx
index 71d40ae91c..7763c886ec 100644
--- a/web/src/components/svg-icon.tsx
+++ b/web/src/components/svg-icon.tsx
@@ -95,6 +95,7 @@ const svgIcons = [
LLMFactory.RAGcon,
LLMFactory.SoMark,
LLMFactory.NewAPI,
+ LLMFactory.DaoXE,
LLMFactory.Astraflow,
LLMFactory.AstraflowCN,
LLMFactory.FuturMix,
diff --git a/web/src/constants/llm.ts b/web/src/constants/llm.ts
index dff4e24e1a..367797cafe 100644
--- a/web/src/constants/llm.ts
+++ b/web/src/constants/llm.ts
@@ -103,6 +103,7 @@ export enum LLMFactory {
Qiniu = 'Qiniu',
TokenHub = 'TokenHub',
NewAPI = 'New API',
+ DaoXE = 'DaoXE',
FunASR = 'FunASR',
AIMLAPI = 'aimlapi.com',
GreenPT = 'GreenPT',
@@ -193,6 +194,7 @@ export const IconMap = {
[LLMFactory.TokenHub]: 'tokenhub',
[LLMFactory.SoMark]: 'somark',
[LLMFactory.NewAPI]: 'new-api',
+ [LLMFactory.DaoXE]: 'daoxe',
[LLMFactory.FunASR]: 'funasr',
[LLMFactory.AIMLAPI]: 'aimlapi',
[LLMFactory.GreenPT]: 'greenpt',
@@ -225,6 +227,7 @@ export const APIMapUrl = {
[LLMFactory.GreenPT]: 'https://greenpt.ai',
[LLMFactory.Synthorai]: 'https://synthorai.io',
[LLMFactory.ApiRoute]: 'https://www.api-route.com',
+ [LLMFactory.DaoXE]: 'https://daoxe.com',
[LLMFactory.MWS]:
'https://mws.ru/docs/cloud-platform/gpt/general/inference-text.html',
[LLMFactory.Anthropic]: 'https://console.anthropic.com/settings/keys',