RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
feat: add DaoXE as an OpenAI-compatible model provider (#19560)
Seven5ef628396fca
diff --git a/conf/llm_factories.json b/conf/llm_factories.jsonindex 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.jsonnew file mode 100644index 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.mdxindex 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.gonew file mode 100644index 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.gonew file mode 100644index 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.goindex 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[stringreturn NewCoHereModel(baseURL, urlSuffix), nilcase "cometapi":return NewCometAPIModel(baseURL, urlSuffix), nil+ case "daoxe":+ return NewDaoxeModel(baseURL, urlSuffix), nilcase "fish audio":return NewFishAudioModel(baseURL, urlSuffix), nilcase "mistral":diff --git a/rag/llm/chat_model.py b/rag/llm/chat_model.pyindex 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.pyindex 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.pyindex 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.svgnew file mode 100644index 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.tsxindex 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.tsindex 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',