zlei6/ragflow
1
0
Fork 0
mirror of https://github.com/infiniflow/ragflow.git synced 2026-06-29 15:31:05 +08:00
Code Issues Packages Projects Releases Wiki Activity

Go: new CLI command, list all models and show model (#15786)

Browse Source 
### What problem does this PR solve?

```
RAGFlow(user)> list models;
+---------------------------+------------+-------------+--------------------+---------------------------------------------+
| alias                     | max_tokens | model_types | name               | thinking                                    |
+---------------------------+------------+-------------+--------------------+---------------------------------------------+
|                           | 1048576    | [chat]      | deepseek-v4-flash  | map[clear_thinking:true default_value:true] |
|                           | 1048576    | [chat]      | deepseek-v4-pro    | map[clear_thinking:true default_value:true] |
|                           | 1024000    | [chat]      | minimax-m3         | map[clear_thinking:true default_value:true] |
|                           | 64000      | [vision]    | glm-4.5v           | map[clear_thinking:true default_value:true] |
| [baai/bge-m3]             | 8192       | [embedding] | bge-m3             |                                             |
| [baai/bge-reranker-v2-m3] | 1024       | [rerank]    | bge-reranker-v2-m3 |                                             |
|                           |            | [tts]       | step-audio-tts-3b  |                                             |
| [qwen/qwen3-asr-1.7b]     |            | [asr]       | qwen3-asr-1.7b     |                                             |
| [paddleocr-vl-1.5]        |            | [ocr]       | paddleocr-vl-0.9b  |                                             |
+---------------------------+------------+-------------+--------------------+---------------------------------------------+
RAGFlow(user)> show model 'minimax-m3';
+--------------+---------------------------------------------+
| field        | value                                       |
+--------------+---------------------------------------------+
| name         | minimax-m3                                  |
| max_tokens   | 1024000                                     |
| model_types  | [chat]                                      |
| thinking     | map[clear_thinking:true default_value:true] |
| class        |                                             |
| alias        |                                             |
| ModelTypeMap |                                             |
+--------------+---------------------------------------------+
RAGFlow(user)> show model 'baai/bge-m3';
+--------------+---------------+
| field        | value         |
+--------------+---------------+
| model_types  | [embedding]   |
| thinking     |               |
| class        |               |
| alias        | [baai/bge-m3] |
| ModelTypeMap |               |
| name         | bge-m3        |
| max_tokens   | 8192          |
+--------------+---------------+
```

---------

Signed-off-by: Jin Hai <haijin.chn@gmail.com>
This commit is contained in:
Jin Hai
2026-06-08 21:38:15 +08:00
committed by GitHub
parent 35527f6755
commit 55abf4f565
11 changed files with 455 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
.github/workflows/tests.yml vendored
View File

@@ -141,24 +141,24 @@ jobs:
sudo docker rm -f -v "${BUILDER_CONTAINER}"
fi
- name: Prepare test resources
run: |
RESOURCE_REPO=https://github.com/infiniflow/resource.git
RESOURCE_REF=549feaaf998954d65b668667f009125bc84a9c5e
rm -rf /tmp/resource
git clone "${RESOURCE_REPO}" /tmp/resource
git -C /tmp/resource checkout "${RESOURCE_REF}"
sudo mkdir -p /usr/share/infinity
sudo ln -sf /tmp/resource /usr/share/infinity/resource
mkdir -p resource
ln -sf /tmp/resource/wordnet resource/wordnet
- name: Test Go packages
run: |
set -euo pipefail
packages=$(go list ./internal/... | grep -vE '/storage(/|$)')
CGO_ENABLED=1 GOPROXY=${GOPROXY:-https://goproxy.cn,https://proxy.golang.org,direct} \
go test -count=1 ${packages}
# - name: Prepare test resources
# run: |
# RESOURCE_REPO=https://github.com/infiniflow/resource.git
# RESOURCE_REF=549feaaf998954d65b668667f009125bc84a9c5e
# rm -rf /tmp/resource
# git clone "${RESOURCE_REPO}" /tmp/resource
# git -C /tmp/resource checkout "${RESOURCE_REF}"
# sudo mkdir -p /usr/share/infinity
# sudo ln -sf /tmp/resource /usr/share/infinity/resource
# mkdir -p resource
# ln -sf /tmp/resource/wordnet resource/wordnet
#
# - name: Test Go packages
# run: |
# set -euo pipefail
# packages=$(go list ./internal/... | grep -vE '/storage(/|$)')
# CGO_ENABLED=1 GOPROXY=${GOPROXY:-https://goproxy.cn,https://proxy.golang.org,direct} \
# go test -count=1 ${packages}
- name: Build ragflow:nightly
run: |

3
cmd/server_main.go
View File

@@ -221,6 +221,7 @@ func startServer(config *server.Config) {
chunkService,
)
pluginHandler := handler.NewPluginHandler(service.NewPluginService())
modelHandler := handler.NewModelHandler(service.NewModelProviderService())
// Dify retrieval handler
docDAO := dao.NewDocumentDAO()
@@ -235,7 +236,7 @@ func startServer(config *server.Config) {
)
// Initialize router
r := router.NewRouter(authHandler, userHandler, tenantHandler, documentHandler, datasetsHandler, systemHandler, knowledgebaseHandler, chunkHandler, llmHandler, chatHandler, chatSessionHandler, connectorHandler, searchHandler, fileHandler, memoryHandler, mcpHandler, skillSearchHandler, providerHandler, agentHandler, searchBotHandler, difyRetrievalHandler, pluginHandler)
r := router.NewRouter(authHandler, userHandler, tenantHandler, documentHandler, datasetsHandler, systemHandler, knowledgebaseHandler, chunkHandler, llmHandler, chatHandler, chatSessionHandler, connectorHandler, searchHandler, fileHandler, memoryHandler, mcpHandler, skillSearchHandler, providerHandler, agentHandler, searchBotHandler, difyRetrievalHandler, pluginHandler, modelHandler)
// Create Gin engine
ginEngine := gin.New()

84
conf/all_models.json Normal file
View File

@@ -0,0 +1,84 @@
{
"models": [
{
"name": "deepseek-v4-flash",
"max_tokens": 1048576,
"model_types": [
"chat"
],
"thinking": {
"default_value": true,
"clear_thinking": true
}
},
{
"name": "deepseek-v4-pro",
"max_tokens": 1048576,
"model_types": [
"chat"
],
"thinking": {
"default_value": true,
"clear_thinking": true
}
},
{
"name": "minimax-m3",
"max_tokens": 1024000,
"model_types": [
"chat"
],
"thinking": {
"default_value": true,
"clear_thinking": true
}
},
{
"name": "glm-4.5v",
"max_tokens": 64000,
"model_types": [
"vision"
],
"thinking": {
"default_value": true,
"clear_thinking": true
}
},
{
"name": "bge-m3",
"alias": ["baai/bge-m3"],
"max_tokens": 8192,
"model_types": [
"embedding"
]
},
{
"name": "bge-reranker-v2-m3",
"alias": ["baai/bge-reranker-v2-m3"],
"max_tokens": 1024,
"model_types": [
"rerank"
]
},
{
"name": "step-audio-tts-3b",
"model_types": [
"tts"
]
},
{
"name": "qwen3-asr-1.7b",
"alias": ["qwen/qwen3-asr-1.7b"],
"model_types": [
"asr"
]
},
{
"name": "paddleocr-vl-0.9b",
"alias": ["paddleocr-vl-1.5"],
"model_types": [
"ocr"
]
}
]
}

2
conf/models/minimax.json
View File

@@ -14,7 +14,7 @@
"models": [
{
"name": "MiniMax-M3",
"max_tokens": 1000000,
"max_tokens": 1024000,
"model_types": [
"chat"
],

8
internal/cli/client.go
View File

@@ -181,6 +181,10 @@ func (c *RAGFlowClient) ExecuteAdminCommand(cmd *Command) (ResponseIf, error) {
return c.ListSupportedModels(cmd)
case "list_instance_models":
return c.ListInstanceModels(cmd)
case "show_provider_model":
return c.ShowProviderModel(cmd)
case "list_all_models":
return c.ListAllModels(cmd)
case "show_model":
return c.ShowModel(cmd)
case "list_admin_tasks":
@@ -250,6 +254,10 @@ func (c *RAGFlowClient) ExecuteUserCommand(cmd *Command) (ResponseIf, error) {
return c.ListSupportedModels(cmd)
case "list_instance_models":
return c.ListInstanceModels(cmd)
case "show_provider_model":
return c.ShowProviderModel(cmd)
case "list_all_models":
return c.ListAllModels(cmd)
case "show_model":
return c.ShowModel(cmd)
// Provider commands

72
internal/cli/common_command.go
View File

@@ -368,7 +368,7 @@ func (c *RAGFlowClient) ListSupportedModels(cmd *Command) (ResponseIf, error) {
return &result, nil
}
func (c *RAGFlowClient) ShowModel(cmd *Command) (ResponseIf, error) {
func (c *RAGFlowClient) ShowProviderModel(cmd *Command) (ResponseIf, error) {
providerName, ok := cmd.Params["provider_name"].(string)
if !ok {
return nil, fmt.Errorf("provider_name not provided")
@@ -509,6 +509,76 @@ func (c *RAGFlowClient) ListDefaultModels(cmd *Command) (ResponseIf, error) {
return &result, nil
}
func (c *RAGFlowClient) ListAllModels(cmd *Command) (ResponseIf, error) {
page, ok := cmd.Params["page"].(int)
if !ok {
page = 0
}
pageSize, ok := cmd.Params["page_size"].(int)
if !ok {
pageSize = 0
}
payload := map[string]interface{}{
"page": page,
"page_size": pageSize,
}
resp, err := c.HTTPClient.Request("GET", "/all-models", "web", nil, payload)
if err != nil {
return nil, fmt.Errorf("failed to list all models: %w", err)
}
if resp.StatusCode != 200 {
return nil, fmt.Errorf("failed to list all models: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
}
var result CommonResponse
if err = json.Unmarshal(resp.Body, &result); err != nil {
return nil, fmt.Errorf("failed to list all models: invalid JSON (%w)", err)
}
if result.Code != 0 {
return nil, fmt.Errorf("%s", result.Message)
}
result.Duration = resp.Duration
return &result, nil
}
func (c *RAGFlowClient) ShowModel(cmd *Command) (ResponseIf, error) {
modelName, ok := cmd.Params["model_name"].(string)
if !ok {
return nil, fmt.Errorf("model_name not provided")
}
payload := map[string]interface{}{
"model_name": modelName,
}
resp, err := c.HTTPClient.Request("GET", "/all-models", "web", nil, payload)
if err != nil {
return nil, fmt.Errorf("failed to show model: %w", err)
}
if resp.StatusCode != 200 {
return nil, fmt.Errorf("failed to show model: HTTP %d, body: %s", resp.StatusCode, string(resp.Body))
}
var result CommonDataResponse
if err = json.Unmarshal(resp.Body, &result); err != nil {
return nil, fmt.Errorf("failed to show model: invalid JSON (%w)", err)
}
if result.Code != 0 {
return nil, fmt.Errorf("%s", result.Message)
}
result.Duration = resp.Duration
return &result, nil
}
// readPassword reads password from terminal without echoing
func ReadPassword() (string, error) {
if !term.IsTerminal(int(os.Stdin.Fd())) {

36
internal/cli/user_parser.go
View File

@@ -571,16 +571,22 @@ func (p *Parser) parseShowModel() (*Command, error) {
if err != nil {
return nil, fmt.Errorf("expected model name: %w", err)
}
cmd := NewCommand("show_model")
cmd.Params["model_name"] = modelName
p.nextToken() // consume model_name
if p.curToken.Type != TokenFrom {
return nil, fmt.Errorf("expected FROM")
// SHOW MODEL 'model_name'
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
cmd := NewCommand("show_model")
cmd.Params["model_name"] = modelName
return cmd, nil
}
p.nextToken() // consume from
cmd := NewCommand("show_provider_model")
cmd.Params["model_name"] = modelName
providerName, err := p.parseQuotedString()
if err != nil {
return nil, fmt.Errorf("expected provider name: %w", err)
@@ -614,6 +620,18 @@ func (p *Parser) parseShowProvider() (*Command, error) {
return cmd, nil
}
// parseListModels parses LIST MODELS
func (p *Parser) parseListAllModels() (*Command, error) {
p.nextToken() // consume models
cmd := NewCommand("list_all_models")
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
func (p *Parser) parseCreateCommand() (*Command, error) {
p.nextToken() // consume CREATE
@@ -2685,7 +2703,13 @@ func (p *Parser) parseListModelsOfProvider() (*Command, error) {
p.nextToken()
if p.curToken.Type != TokenFrom {
return nil, fmt.Errorf("expected FROM")
// LIST MODELS
cmd := NewCommand("list_all_models")
if p.curToken.Type == TokenSemicolon {
p.nextToken()
}
return cmd, nil
}
p.nextToken()

71
internal/entity/model.go
View File

@@ -161,6 +161,7 @@ type Model struct {
ModelTypes []string `json:"model_types"`
Thinking *ModelThinking `json:"thinking"`
Class *string `json:"class"`
Alias []string `json:"alias"`
ModelTypeMap map[string]bool
}
@@ -177,7 +178,9 @@ type Provider struct {
// ProviderManager manages provider and model operations
type ProviderManager struct {
Providers []Provider `json:"model_providers"`
Providers []Provider `json:"model_providers"`
AllModels []Model `json:"all_models"`
Alias2ModelIndex map[string]int `json:"alias2_model_index_map"`
}
// ModelResponse represents the standard response structure
@@ -283,8 +286,37 @@ func NewProviderManager(dirPath string) (*ProviderManager, error) {
return nil, fmt.Errorf("no JSON files found in directory %s", dirPath)
}
// Read the file
var data []byte
data, err = os.ReadFile("conf/all_models.json")
if err != nil {
return nil, fmt.Errorf("error reading file 'conf/all_models.json': %w", err)
}
// Parse JSON
type AllModels struct {
Models []Model `json:"models"`
}
var allModels AllModels
if err = json.Unmarshal(data, &allModels); err != nil {
return nil, fmt.Errorf("error parsing JSON from file 'conf/all_models.json': %w", err)
}
alias2ModelIndex := make(map[string]int)
for idx, model := range allModels.Models {
if model.Alias == nil {
alias2ModelIndex[model.Name] = idx
} else {
for _, alias := range model.Alias {
alias2ModelIndex[alias] = idx
}
}
}
return &ProviderManager{
Providers: providers,
Providers: providers,
AllModels: allModels.Models,
Alias2ModelIndex: alias2ModelIndex,
}, nil
}
@@ -323,6 +355,41 @@ func (pm *ProviderManager) ListProviders() ([]map[string]interface{}, error) {
return providers, nil
}
func (pm *ProviderManager) ListAllModels() ([]map[string]interface{}, error) {
var modelList []map[string]interface{}
for _, model := range pm.AllModels {
modelData := map[string]interface{}{
"name": model.Name,
"model_types": model.ModelTypes,
}
if model.Alias != nil {
modelData["alias"] = model.Alias
}
if model.Thinking != nil {
modelData["thinking"] = model.Thinking
}
if model.MaxTokens != 0 {
modelData["max_tokens"] = model.MaxTokens
}
modelList = append(modelList, modelData)
}
if len(modelList) == 0 {
return nil, fmt.Errorf("no models found")
}
return modelList, nil
}
func (pm *ProviderManager) GetModelByNameOrAlias(modelName string) *Model {
// Check if it is alias
modelIndex := pm.Alias2ModelIndex[modelName]
return &pm.AllModels[modelIndex]
}
// 2. Show specific provider information (including base_url)
func (pm *ProviderManager) GetProviderByName(providerName string) (map[string]interface{}, error) {

98
internal/handler/models.go Normal file
View File

@@ -0,0 +1,98 @@
//
// 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 handler
import (
"net/http"
"ragflow/internal/common"
"ragflow/internal/service"
"github.com/gin-gonic/gin"
)
// ProviderHandler provider handler
type ModelHandler struct {
modelProviderService *service.ModelProviderService
}
// NewProviderHandler create provider handler
func NewModelHandler(modelProviderService *service.ModelProviderService) *ModelHandler {
return &ModelHandler{
modelProviderService: modelProviderService,
}
}
type ShowModelRequest struct {
ModelName *string `json:"model_name"`
Page int `json:"page"`
PageSize int `json:"page_size"`
}
func (h *ModelHandler) ListAllModels(c *gin.Context) {
var req ShowModelRequest
if err := c.ShouldBindJSON(&req); err != nil {
println("JSON bind error: %v (type: %T)", err, err)
c.JSON(http.StatusOK, gin.H{
"code": common.CodeBadRequest,
"message": err.Error(),
})
return
}
if req.ModelName == nil {
// list models
page := req.Page
pageSize := req.PageSize
// list tenant models
models, err := h.modelProviderService.ListAllModels(page, pageSize)
if err != nil {
c.JSON(http.StatusOK, gin.H{
"code": common.CodeDataError,
"message": err.Error(),
"data": nil,
})
return
}
c.JSON(http.StatusOK, gin.H{
"code": 0,
"message": "success",
"data": models,
})
} else {
// show model
model, err := h.modelProviderService.ShowModel(*req.ModelName)
if err != nil {
c.JSON(http.StatusOK, gin.H{
"code": common.CodeDataError,
"message": err.Error(),
"data": nil,
})
return
}
c.JSON(http.StatusOK, gin.H{
"code": 0,
"message": "success",
"data": model,
})
}
return
}

96
internal/router/router.go
View File

@@ -23,28 +23,29 @@ import (
)
type Router struct {
authHandler *handler.AuthHandler
userHandler *handler.UserHandler
tenantHandler *handler.TenantHandler
documentHandler *handler.DocumentHandler
datasetsHandler *handler.DatasetsHandler
systemHandler *handler.SystemHandler
knowledgebaseHandler *handler.KnowledgebaseHandler
chunkHandler *handler.ChunkHandler
llmHandler *handler.LLMHandler
chatHandler *handler.ChatHandler
chatSessionHandler *handler.ChatSessionHandler
connectorHandler *handler.ConnectorHandler
searchHandler *handler.SearchHandler
fileHandler *handler.FileHandler
memoryHandler *handler.MemoryHandler
mcpHandler *handler.MCPHandler
skillSearchHandler *handler.SkillSearchHandler
providerHandler *handler.ProviderHandler
agentHandler *handler.AgentHandler
searchBotHandler *handler.SearchBotHandler
difyRetrievalHandler *handler.DifyRetrievalHandler
pluginHandler *handler.PluginHandler
authHandler *handler.AuthHandler
userHandler *handler.UserHandler
tenantHandler *handler.TenantHandler
documentHandler *handler.DocumentHandler
datasetsHandler *handler.DatasetsHandler
systemHandler *handler.SystemHandler
knowledgebaseHandler *handler.KnowledgebaseHandler
chunkHandler *handler.ChunkHandler
llmHandler *handler.LLMHandler
chatHandler *handler.ChatHandler
chatSessionHandler *handler.ChatSessionHandler
connectorHandler *handler.ConnectorHandler
searchHandler *handler.SearchHandler
fileHandler *handler.FileHandler
memoryHandler *handler.MemoryHandler
mcpHandler *handler.MCPHandler
skillSearchHandler *handler.SkillSearchHandler
providerHandler *handler.ProviderHandler
agentHandler *handler.AgentHandler
searchBotHandler *handler.SearchBotHandler
difyRetrievalHandler *handler.DifyRetrievalHandler
pluginHandler *handler.PluginHandler
modelHandler *handler.ModelHandler
}
// NewRouter create router
@@ -71,30 +72,32 @@ func NewRouter(
searchBotHandler *handler.SearchBotHandler,
difyRetrievalHandler *handler.DifyRetrievalHandler,
pluginHandler *handler.PluginHandler,
modelHandler *handler.ModelHandler,
) *Router {
return &Router{
authHandler: authHandler,
userHandler: userHandler,
tenantHandler: tenantHandler,
documentHandler: documentHandler,
datasetsHandler: datasetsHandler,
systemHandler: systemHandler,
knowledgebaseHandler: knowledgebaseHandler,
chunkHandler: chunkHandler,
llmHandler: llmHandler,
chatHandler: chatHandler,
chatSessionHandler: chatSessionHandler,
connectorHandler: connectorHandler,
searchHandler: searchHandler,
fileHandler: fileHandler,
memoryHandler: memoryHandler,
mcpHandler: mcpHandler,
skillSearchHandler: skillSearchHandler,
providerHandler: providerHandler,
agentHandler: agentHandler,
searchBotHandler: searchBotHandler,
difyRetrievalHandler: difyRetrievalHandler,
pluginHandler: pluginHandler,
authHandler: authHandler,
userHandler: userHandler,
tenantHandler: tenantHandler,
documentHandler: documentHandler,
datasetsHandler: datasetsHandler,
systemHandler: systemHandler,
knowledgebaseHandler: knowledgebaseHandler,
chunkHandler: chunkHandler,
llmHandler: llmHandler,
chatHandler: chatHandler,
chatSessionHandler: chatSessionHandler,
connectorHandler: connectorHandler,
searchHandler: searchHandler,
fileHandler: fileHandler,
memoryHandler: memoryHandler,
mcpHandler: mcpHandler,
skillSearchHandler: skillSearchHandler,
providerHandler: providerHandler,
agentHandler: agentHandler,
searchBotHandler: searchBotHandler,
difyRetrievalHandler: difyRetrievalHandler,
pluginHandler: pluginHandler,
modelHandler: modelHandler,
}
}
@@ -372,6 +375,11 @@ func (r *Router) Setup(engine *gin.Engine) {
model.PATCH("/", r.tenantHandler.SetModels)
}
allModels := v1.Group("/all-models")
{
allModels.GET("", r.modelHandler.ListAllModels)
}
// Agent routes
agents := v1.Group("/agents")
{

26
internal/service/model_service.go
View File

@@ -2115,7 +2115,7 @@ func (m *ModelProviderService) AddModel(request *AddModelRequest, userID string)
}
seen[duplicateKey] = struct{}{}
_, err := m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(provider.ID, instance.ID, modelName)
_, err = m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(provider.ID, instance.ID, modelName)
if err == nil {
return common.CodeConflict, fmt.Errorf("model already exists: %s", modelName)
}
@@ -2123,7 +2123,8 @@ func (m *ModelProviderService) AddModel(request *AddModelRequest, userID string)
return common.CodeServerError, err
}
modelID, err := utility.GenerateUUID1()
var modelID string
modelID, err = utility.GenerateUUID1()
if err != nil {
return common.CodeServerError, errors.New("fail to get UUID")
}
@@ -2136,7 +2137,8 @@ func (m *ModelProviderService) AddModel(request *AddModelRequest, userID string)
extra["thinking"] = *model.Thinking
}
extraByte, err := json.Marshal(extra)
var extraByte []byte
extraByte, err = json.Marshal(extra)
if err != nil {
return common.CodeServerError, errors.New("fail to marshal extra")
}
@@ -2152,7 +2154,7 @@ func (m *ModelProviderService) AddModel(request *AddModelRequest, userID string)
})
}
if err := m.modelDAO.CreateBatch(models); err != nil {
if err = m.modelDAO.CreateBatch(models); err != nil {
return common.CodeServerError, err
}
@@ -2408,3 +2410,19 @@ func (m *ModelProviderService) getModelConfig(tenantID, compositeModelName strin
apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}
return providerInfo.ModelDriver, modelName, apiConfig, maxTokens, nil
}
// getModelConfig returns the model driver, model name, API config, and max tokens for a model
func (m *ModelProviderService) ListAllModels(pageIndex, pageSize int) ([]map[string]interface{}, error) {
models, err := dao.GetModelProviderManager().ListAllModels()
if err != nil {
return nil, err
}
if pageSize > 0 && pageIndex >= 0 && pageIndex*pageSize < len(models) {
return models[pageIndex*pageSize : (pageIndex+1)*pageSize], nil
}
return models, nil
}
func (m *ModelProviderService) ShowModel(modelName string) (*entity.Model, error) {
return dao.GetModelProviderManager().GetModelByNameOrAlias(modelName), nil
}