WeKnora/internal/handler/initialization.go

1857 lines
54 KiB
Go
Raw Normal View History

package handler
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"strings"
"sync"
"time"
"strconv"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/models/embedding"
"github.com/Tencent/WeKnora/internal/models/utils/ollama"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"github.com/Tencent/WeKnora/services/docreader/src/client"
"github.com/Tencent/WeKnora/services/docreader/src/proto"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
"github.com/ollama/ollama/api"
)
// DownloadTask 下载任务信息
type DownloadTask struct {
ID string `json:"id"`
ModelName string `json:"modelName"`
Status string `json:"status"` // pending, downloading, completed, failed
Progress float64 `json:"progress"`
Message string `json:"message"`
StartTime time.Time `json:"startTime"`
EndTime *time.Time `json:"endTime,omitempty"`
}
// 全局下载任务管理器
var (
downloadTasks = make(map[string]*DownloadTask)
tasksMutex sync.RWMutex
)
// InitializationHandler 初始化处理器
type InitializationHandler struct {
config *config.Config
tenantService interfaces.TenantService
modelService interfaces.ModelService
kbService interfaces.KnowledgeBaseService
kbRepository interfaces.KnowledgeBaseRepository
knowledgeService interfaces.KnowledgeService
ollamaService *ollama.OllamaService
docReaderClient *client.Client
}
// NewInitializationHandler 创建初始化处理器
func NewInitializationHandler(
config *config.Config,
tenantService interfaces.TenantService,
modelService interfaces.ModelService,
kbService interfaces.KnowledgeBaseService,
kbRepository interfaces.KnowledgeBaseRepository,
knowledgeService interfaces.KnowledgeService,
ollamaService *ollama.OllamaService,
docReaderClient *client.Client,
) *InitializationHandler {
return &InitializationHandler{
config: config,
tenantService: tenantService,
modelService: modelService,
kbService: kbService,
kbRepository: kbRepository,
knowledgeService: knowledgeService,
ollamaService: ollamaService,
docReaderClient: docReaderClient,
}
}
// InitializationRequest 初始化请求结构
type InitializationRequest struct {
2025-08-13 13:56:20 +00:00
// 前端传入的存储类型:cos 或 minio
StorageType string `json:"storageType"`
LLM struct {
Source string `json:"source" binding:"required"`
ModelName string `json:"modelName" binding:"required"`
BaseURL string `json:"baseUrl"`
APIKey string `json:"apiKey"`
} `json:"llm" binding:"required"`
Embedding struct {
Source string `json:"source" binding:"required"`
ModelName string `json:"modelName" binding:"required"`
BaseURL string `json:"baseUrl"`
APIKey string `json:"apiKey"`
Dimension int `json:"dimension"` // 添加embedding维度字段
} `json:"embedding" binding:"required"`
Rerank struct {
Enabled bool `json:"enabled"`
ModelName string `json:"modelName"`
BaseURL string `json:"baseUrl"`
APIKey string `json:"apiKey"`
} `json:"rerank"`
Multimodal struct {
Enabled bool `json:"enabled"`
VLM *struct {
ModelName string `json:"modelName"`
BaseURL string `json:"baseUrl"`
APIKey string `json:"apiKey"`
InterfaceType string `json:"interfaceType"` // "ollama" or "openai"
} `json:"vlm,omitempty"`
COS *struct {
SecretID string `json:"secretId"`
SecretKey string `json:"secretKey"`
Region string `json:"region"`
BucketName string `json:"bucketName"`
AppID string `json:"appId"`
PathPrefix string `json:"pathPrefix"`
} `json:"cos,omitempty"`
2025-08-13 13:56:20 +00:00
Minio *struct {
BucketName string `json:"bucketName"`
PathPrefix string `json:"pathPrefix"`
} `json:"minio,omitempty"`
} `json:"multimodal"`
DocumentSplitting struct {
ChunkSize int `json:"chunkSize" binding:"required,min=100,max=10000"`
ChunkOverlap int `json:"chunkOverlap" binding:"required,min=0"`
Separators []string `json:"separators" binding:"required,min=1"`
} `json:"documentSplitting" binding:"required"`
}
// CheckStatus 检查系统初始化状态
func (h *InitializationHandler) CheckStatus(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Checking system initialization status")
// 检查是否存在租户
tenant, err := h.tenantService.GetTenantByID(ctx, types.InitDefaultTenantID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"initialized": false,
},
})
return
}
// 如果没有租户,说明系统未初始化
if tenant == nil {
logger.Info(ctx, "No tenants found, system not initialized")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"initialized": false,
},
})
return
}
ctx = context.WithValue(ctx, types.TenantIDContextKey, types.InitDefaultTenantID)
// 检查是否存在模型
models, err := h.modelService.ListModels(ctx)
if err != nil || len(models) == 0 {
logger.Info(ctx, "No models found, system not initialized")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"initialized": false,
},
})
return
}
logger.Info(ctx, "System is already initialized")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"initialized": true,
},
})
}
// Initialize 执行系统初始化
func (h *InitializationHandler) Initialize(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Starting system initialization")
var req InitializationRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse initialization request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 验证多模态配置
if req.Multimodal.Enabled {
2025-08-13 13:56:20 +00:00
storageType := strings.ToLower(req.StorageType)
if req.Multimodal.VLM == nil {
logger.Error(ctx, "Multimodal enabled but missing VLM configuration")
c.Error(errors.NewBadRequestError("启用多模态时需要配置VLM信息"))
return
}
if req.Multimodal.VLM.InterfaceType == "ollama" {
req.Multimodal.VLM.BaseURL = os.Getenv("OLLAMA_BASE_URL") + "/v1"
}
if req.Multimodal.VLM.ModelName == "" || req.Multimodal.VLM.BaseURL == "" {
logger.Error(ctx, "VLM configuration incomplete")
c.Error(errors.NewBadRequestError("VLM配置不完整"))
return
}
2025-08-13 13:56:20 +00:00
switch storageType {
case "cos":
if req.Multimodal.COS == nil || req.Multimodal.COS.SecretID == "" || req.Multimodal.COS.SecretKey == "" ||
req.Multimodal.COS.Region == "" || req.Multimodal.COS.BucketName == "" ||
req.Multimodal.COS.AppID == "" {
logger.Error(ctx, "COS configuration incomplete")
c.Error(errors.NewBadRequestError("COS配置不完整"))
return
}
case "minio":
if req.Multimodal.Minio == nil || req.Multimodal.Minio.BucketName == "" ||
os.Getenv("MINIO_ACCESS_KEY_ID") == "" || os.Getenv("MINIO_SECRET_ACCESS_KEY") == "" {
logger.Error(ctx, "MinIO configuration incomplete")
c.Error(errors.NewBadRequestError("MinIO配置不完整"))
return
}
}
}
// 验证Rerank配置(如果启用)
if req.Rerank.Enabled {
if req.Rerank.ModelName == "" || req.Rerank.BaseURL == "" {
logger.Error(ctx, "Rerank configuration incomplete")
c.Error(errors.NewBadRequestError("启用Rerank时需要配置模型名称和Base URL"))
return
}
}
// 验证文档分割配置
if req.DocumentSplitting.ChunkOverlap >= req.DocumentSplitting.ChunkSize {
logger.Error(ctx, "Chunk overlap must be less than chunk size")
c.Error(errors.NewBadRequestError("分块重叠大小必须小于分块大小"))
return
}
if len(req.DocumentSplitting.Separators) == 0 {
logger.Error(ctx, "Document separators cannot be empty")
c.Error(errors.NewBadRequestError("文档分隔符不能为空"))
return
}
var err error
// 1. 处理租户 - 检查是否存在,不存在则创建
tenant, _ := h.tenantService.GetTenantByID(ctx, types.InitDefaultTenantID)
if tenant == nil {
logger.Info(ctx, "Tenant not found, creating tenant")
// 创建默认租户
tenant = &types.Tenant{
ID: types.InitDefaultTenantID,
Name: "Default Tenant",
Description: "System Default Tenant",
RetrieverEngines: types.RetrieverEngines{
Engines: []types.RetrieverEngineParams{
{
RetrieverType: types.KeywordsRetrieverType,
RetrieverEngineType: types.PostgresRetrieverEngineType,
},
{
RetrieverType: types.VectorRetrieverType,
RetrieverEngineType: types.PostgresRetrieverEngineType,
},
},
},
}
logger.Info(ctx, "Creating default tenant")
tenant, err = h.tenantService.CreateTenant(ctx, tenant)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("创建租户失败: " + err.Error()))
return
}
} else {
logger.Info(ctx, "Tenant exists, updating if needed")
// 更新租户信息(如果需要)
updated := false
if tenant.Name != "Default Tenant" {
tenant.Name = "Default Tenant"
updated = true
}
if tenant.Description != "System Default Tenant" {
tenant.Description = "System Default Tenant"
updated = true
}
if updated {
_, err = h.tenantService.UpdateTenant(ctx, tenant)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("更新租户失败: " + err.Error()))
return
}
logger.Info(ctx, "Tenant updated successfully")
}
}
// 创建带有租户ID的新上下文
newCtx := context.WithValue(ctx, types.TenantIDContextKey, types.InitDefaultTenantID)
// 2. 处理模型 - 检查现有模型并更新或创建
existingModels, err := h.modelService.ListModels(newCtx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
// 如果获取失败,继续执行创建流程
existingModels = []*types.Model{}
}
// 构建模型映射,按类型分组
modelMap := make(map[types.ModelType]*types.Model)
for _, model := range existingModels {
modelMap[model.Type] = model
}
// 要处理的模型配置
modelsToProcess := []struct {
modelType types.ModelType
name string
source types.ModelSource
description string
baseURL string
apiKey string
dimension int
}{
{
modelType: types.ModelTypeKnowledgeQA,
name: req.LLM.ModelName,
source: types.ModelSource(req.LLM.Source),
description: "LLM Model for Knowledge QA",
baseURL: req.LLM.BaseURL,
apiKey: req.LLM.APIKey,
},
{
modelType: types.ModelTypeEmbedding,
name: req.Embedding.ModelName,
source: types.ModelSource(req.Embedding.Source),
description: "Embedding Model",
baseURL: req.Embedding.BaseURL,
apiKey: req.Embedding.APIKey,
dimension: req.Embedding.Dimension,
},
}
// 如果启用Rerank,添加Rerank模型
if req.Rerank.Enabled {
modelsToProcess = append(modelsToProcess, struct {
modelType types.ModelType
name string
source types.ModelSource
description string
baseURL string
apiKey string
dimension int
}{
modelType: types.ModelTypeRerank,
name: req.Rerank.ModelName,
source: types.ModelSourceRemote,
description: "Rerank Model",
baseURL: req.Rerank.BaseURL,
apiKey: req.Rerank.APIKey,
})
}
// 如果启用多模态,添加VLM模型
if req.Multimodal.Enabled && req.Multimodal.VLM != nil {
modelsToProcess = append(modelsToProcess, struct {
modelType types.ModelType
name string
source types.ModelSource
description string
baseURL string
apiKey string
dimension int
}{
modelType: types.ModelTypeVLLM,
name: req.Multimodal.VLM.ModelName,
source: types.ModelSourceRemote,
description: "Vision Language Model",
baseURL: req.Multimodal.VLM.BaseURL,
apiKey: req.Multimodal.VLM.APIKey,
})
}
// 处理每个模型
var processedModels []*types.Model
for _, modelConfig := range modelsToProcess {
existingModel, exists := modelMap[modelConfig.modelType]
if exists {
// 更新现有模型
logger.Infof(ctx, "Updating existing model: %s (%s)",
modelConfig.name, modelConfig.modelType,
)
existingModel.Name = modelConfig.name
existingModel.Source = modelConfig.source
existingModel.Description = modelConfig.description
existingModel.Parameters = types.ModelParameters{
BaseURL: modelConfig.baseURL,
APIKey: modelConfig.apiKey,
EmbeddingParameters: types.EmbeddingParameters{
Dimension: modelConfig.dimension,
},
}
existingModel.IsDefault = true
existingModel.Status = types.ModelStatusActive
err := h.modelService.UpdateModel(newCtx, existingModel)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": modelConfig.name,
"model_type": modelConfig.modelType,
})
c.Error(errors.NewInternalServerError("更新模型失败: " + err.Error()))
return
}
processedModels = append(processedModels, existingModel)
} else {
// 创建新模型
logger.Infof(ctx,
"Creating new model: %s (%s)",
modelConfig.name, modelConfig.modelType,
)
newModel := &types.Model{
TenantID: types.InitDefaultTenantID,
Name: modelConfig.name,
Type: modelConfig.modelType,
Source: modelConfig.source,
Description: modelConfig.description,
Parameters: types.ModelParameters{
BaseURL: modelConfig.baseURL,
APIKey: modelConfig.apiKey,
EmbeddingParameters: types.EmbeddingParameters{
Dimension: modelConfig.dimension,
},
},
IsDefault: true,
Status: types.ModelStatusActive,
}
err := h.modelService.CreateModel(newCtx, newModel)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": modelConfig.name,
"model_type": modelConfig.modelType,
})
c.Error(errors.NewInternalServerError("创建模型失败: " + err.Error()))
return
}
processedModels = append(processedModels, newModel)
}
}
// 删除不需要的VLM模型(如果多模态被禁用)
if !req.Multimodal.Enabled {
if existingVLM, exists := modelMap[types.ModelTypeVLLM]; exists {
logger.Info(ctx, "Deleting VLM model as multimodal is disabled")
err := h.modelService.DeleteModel(newCtx, existingVLM.ID)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_id": existingVLM.ID,
})
// 记录错误但不阻止流程
logger.Warn(ctx, "Failed to delete VLM model, but continuing")
}
}
}
// 删除不需要的Rerank模型(如果Rerank被禁用)
if !req.Rerank.Enabled {
if existingRerank, exists := modelMap[types.ModelTypeRerank]; exists {
logger.Info(ctx, "Deleting Rerank model as rerank is disabled")
err := h.modelService.DeleteModel(newCtx, existingRerank.ID)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_id": existingRerank.ID,
})
// 记录错误但不阻止流程
logger.Warn(ctx, "Failed to delete Rerank model, but continuing")
}
}
}
// 3. 处理知识库 - 检查是否存在,不存在则创建,存在则更新
kb, err := h.kbService.GetKnowledgeBaseByID(newCtx, types.InitDefaultKnowledgeBaseID)
// 找到embedding模型ID和LLM模型ID
var embeddingModelID, llmModelID, rerankModelID, vlmModelID string
for _, model := range processedModels {
if model.Type == types.ModelTypeEmbedding {
embeddingModelID = model.ID
}
if model.Type == types.ModelTypeKnowledgeQA {
llmModelID = model.ID
}
if model.Type == types.ModelTypeRerank && req.Rerank.Enabled {
rerankModelID = model.ID
}
if model.Type == types.ModelTypeVLLM {
vlmModelID = model.ID
}
}
if kb == nil {
// 创建新知识库
logger.Info(ctx, "Creating default knowledge base")
kb = &types.KnowledgeBase{
ID: types.InitDefaultKnowledgeBaseID,
Name: "Default Knowledge Base",
Description: "System Default Knowledge Base",
TenantID: types.InitDefaultTenantID,
ChunkingConfig: types.ChunkingConfig{
ChunkSize: req.DocumentSplitting.ChunkSize,
ChunkOverlap: req.DocumentSplitting.ChunkOverlap,
Separators: req.DocumentSplitting.Separators,
EnableMultimodal: req.Multimodal.Enabled,
},
EmbeddingModelID: embeddingModelID,
SummaryModelID: llmModelID,
RerankModelID: rerankModelID,
VLMModelID: vlmModelID,
VLMConfig: types.VLMConfig{
ModelName: req.Multimodal.VLM.ModelName,
BaseURL: req.Multimodal.VLM.BaseURL,
APIKey: req.Multimodal.VLM.APIKey,
InterfaceType: req.Multimodal.VLM.InterfaceType,
},
2025-08-13 13:56:20 +00:00
}
switch req.StorageType {
case "cos":
if req.Multimodal.COS != nil {
kb.StorageConfig = types.StorageConfig{
Provider: req.StorageType,
BucketName: req.Multimodal.COS.BucketName,
AppID: req.Multimodal.COS.AppID,
PathPrefix: req.Multimodal.COS.PathPrefix,
SecretID: req.Multimodal.COS.SecretID,
SecretKey: req.Multimodal.COS.SecretKey,
Region: req.Multimodal.COS.Region,
}
}
case "minio":
if req.Multimodal.Minio != nil {
kb.StorageConfig = types.StorageConfig{
Provider: req.StorageType,
BucketName: req.Multimodal.Minio.BucketName,
PathPrefix: req.Multimodal.Minio.PathPrefix,
SecretID: os.Getenv("MINIO_ACCESS_KEY_ID"),
SecretKey: os.Getenv("MINIO_SECRET_ACCESS_KEY"),
}
}
}
_, err = h.kbService.CreateKnowledgeBase(newCtx, kb)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("创建知识库失败: " + err.Error()))
return
}
} else {
// 更新现有知识库
logger.Info(ctx, "Updating existing knowledge base")
// 检查是否有文件,如果有文件则不允许修改Embedding模型
knowledgeList, err := h.knowledgeService.ListKnowledgeByKnowledgeBaseID(
newCtx, types.InitDefaultKnowledgeBaseID,
)
hasFiles := err == nil && len(knowledgeList) > 0
// 先更新模型ID(直接在对象上)
kb.SummaryModelID = llmModelID
if req.Rerank.Enabled {
kb.RerankModelID = rerankModelID
} else {
kb.RerankModelID = "" // 清空Rerank模型ID
}
if req.Multimodal.Enabled {
kb.VLMModelID = vlmModelID
// 更新VLM配置
kb.VLMConfig = types.VLMConfig{
ModelName: req.Multimodal.VLM.ModelName,
BaseURL: req.Multimodal.VLM.BaseURL,
APIKey: req.Multimodal.VLM.APIKey,
InterfaceType: req.Multimodal.VLM.InterfaceType,
}
2025-08-13 13:56:20 +00:00
switch req.StorageType {
case "cos":
if req.Multimodal.COS != nil {
kb.StorageConfig = types.StorageConfig{
Provider: req.StorageType,
SecretID: req.Multimodal.COS.SecretID,
SecretKey: req.Multimodal.COS.SecretKey,
Region: req.Multimodal.COS.Region,
BucketName: req.Multimodal.COS.BucketName,
AppID: req.Multimodal.COS.AppID,
PathPrefix: req.Multimodal.COS.PathPrefix,
}
}
case "minio":
if req.Multimodal.Minio != nil {
kb.StorageConfig = types.StorageConfig{
Provider: req.StorageType,
BucketName: req.Multimodal.Minio.BucketName,
PathPrefix: req.Multimodal.Minio.PathPrefix,
SecretID: os.Getenv("MINIO_ACCESS_KEY_ID"),
SecretKey: os.Getenv("MINIO_SECRET_ACCESS_KEY"),
}
}
}
} else {
kb.VLMModelID = "" // 清空VLM模型ID
// 清空VLM配置
kb.VLMConfig = types.VLMConfig{}
2025-08-13 13:56:20 +00:00
kb.StorageConfig = types.StorageConfig{}
}
if !hasFiles {
kb.EmbeddingModelID = embeddingModelID
}
kb.ChunkingConfig = types.ChunkingConfig{
ChunkSize: req.DocumentSplitting.ChunkSize,
ChunkOverlap: req.DocumentSplitting.ChunkOverlap,
Separators: req.DocumentSplitting.Separators,
EnableMultimodal: req.Multimodal.Enabled,
}
// 更新基本信息和配置
err = h.kbRepository.UpdateKnowledgeBase(newCtx, kb)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("更新知识库配置失败: " + err.Error()))
return
}
// 如果需要更新模型ID,使用repository直接更新
if !hasFiles || kb.SummaryModelID != llmModelID {
// 刷新知识库对象以获取最新信息
kb, err = h.kbService.GetKnowledgeBaseByID(newCtx, types.InitDefaultKnowledgeBaseID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("获取更新后的知识库失败: " + err.Error()))
return
}
// 更新模型ID
kb.SummaryModelID = llmModelID
if req.Rerank.Enabled {
kb.RerankModelID = rerankModelID
} else {
kb.RerankModelID = "" // 清空Rerank模型ID
}
// 使用repository直接更新模型ID
err = h.kbRepository.UpdateKnowledgeBase(newCtx, kb)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("更新知识库模型ID失败: " + err.Error()))
return
}
logger.Info(ctx, "Model IDs updated successfully")
}
}
logger.Info(ctx, "System initialization completed successfully")
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "系统初始化成功",
"data": gin.H{
"tenant": tenant,
"models": processedModels,
"knowledge_base": kb,
},
})
}
// CheckOllamaStatus 检查Ollama服务状态
func (h *InitializationHandler) CheckOllamaStatus(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Checking Ollama service status")
2025-08-13 13:56:20 +00:00
// Determine Ollama base URL for display
baseURL := os.Getenv("OLLAMA_BASE_URL")
if baseURL == "" {
baseURL = "http://host.docker.internal:11434"
}
// 检查Ollama服务是否可用
err := h.ollamaService.StartService(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"available": false,
"error": err.Error(),
2025-08-13 13:56:20 +00:00
"baseUrl": baseURL,
},
})
return
}
version, err := h.ollamaService.GetVersion(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
version = "unknown"
}
logger.Info(ctx, "Ollama service is available")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"available": h.ollamaService.IsAvailable(),
"version": version,
2025-08-13 13:56:20 +00:00
"baseUrl": baseURL,
},
})
}
// CheckOllamaModels 检查Ollama模型状态
func (h *InitializationHandler) CheckOllamaModels(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Checking Ollama models status")
var req struct {
Models []string `json:"models" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse models check request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 检查Ollama服务是否可用
if !h.ollamaService.IsAvailable() {
err := h.ollamaService.StartService(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Ollama服务不可用: " + err.Error()))
return
}
}
modelStatus := make(map[string]bool)
// 检查每个模型是否存在
for _, modelName := range req.Models {
2025-08-13 13:56:20 +00:00
checkModelName := modelName
if !strings.Contains(modelName, ":") {
checkModelName = modelName + ":latest"
}
available, err := h.ollamaService.IsModelAvailable(ctx, checkModelName)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": modelName,
})
modelStatus[modelName] = false
} else {
modelStatus[modelName] = available
}
logger.Infof(ctx, "Model %s availability: %v", modelName, modelStatus[modelName])
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"models": modelStatus,
},
})
}
// DownloadOllamaModel 异步下载Ollama模型
func (h *InitializationHandler) DownloadOllamaModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Starting async Ollama model download")
var req struct {
ModelName string `json:"modelName" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse model download request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 检查Ollama服务是否可用
if !h.ollamaService.IsAvailable() {
err := h.ollamaService.StartService(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Ollama服务不可用: " + err.Error()))
return
}
}
// 检查模型是否已存在
available, err := h.ollamaService.IsModelAvailable(ctx, req.ModelName)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": req.ModelName,
})
c.Error(errors.NewInternalServerError("检查模型状态失败: " + err.Error()))
return
}
if available {
logger.Infof(ctx, "Model %s already exists", req.ModelName)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "模型已存在",
"data": gin.H{
"modelName": req.ModelName,
"status": "completed",
"progress": 100.0,
},
})
return
}
// 检查是否已有相同模型的下载任务
tasksMutex.RLock()
for _, task := range downloadTasks {
if task.ModelName == req.ModelName && (task.Status == "pending" || task.Status == "downloading") {
tasksMutex.RUnlock()
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "模型下载任务已存在",
"data": gin.H{
"taskId": task.ID,
"modelName": task.ModelName,
"status": task.Status,
"progress": task.Progress,
},
})
return
}
}
tasksMutex.RUnlock()
// 创建下载任务
taskID := uuid.New().String()
task := &DownloadTask{
ID: taskID,
ModelName: req.ModelName,
Status: "pending",
Progress: 0.0,
Message: "准备下载",
StartTime: time.Now(),
}
tasksMutex.Lock()
downloadTasks[taskID] = task
tasksMutex.Unlock()
// 启动异步下载
newCtx, cancel := context.WithTimeout(context.Background(), 12*time.Hour)
go func() {
defer cancel()
h.downloadModelAsync(newCtx, taskID, req.ModelName)
}()
logger.Infof(ctx, "Created download task for model: %s, task ID: %s", req.ModelName, taskID)
c.JSON(http.StatusOK, gin.H{
"success": true,
"message": "模型下载任务已创建",
"data": gin.H{
"taskId": taskID,
"modelName": req.ModelName,
"status": "pending",
"progress": 0.0,
},
})
}
// GetDownloadProgress 获取下载进度
func (h *InitializationHandler) GetDownloadProgress(c *gin.Context) {
taskID := c.Param("taskId")
if taskID == "" {
c.Error(errors.NewBadRequestError("任务ID不能为空"))
return
}
tasksMutex.RLock()
task, exists := downloadTasks[taskID]
tasksMutex.RUnlock()
if !exists {
c.Error(errors.NewNotFoundError("下载任务不存在"))
return
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": task,
})
}
// ListDownloadTasks 列出所有下载任务
func (h *InitializationHandler) ListDownloadTasks(c *gin.Context) {
tasksMutex.RLock()
tasks := make([]*DownloadTask, 0, len(downloadTasks))
for _, task := range downloadTasks {
tasks = append(tasks, task)
}
tasksMutex.RUnlock()
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": tasks,
})
}
2025-08-13 13:56:20 +00:00
// ListOllamaModels 列出已安装的 Ollama 模型
func (h *InitializationHandler) ListOllamaModels(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Listing installed Ollama models")
// 确保服务可用
if !h.ollamaService.IsAvailable() {
if err := h.ollamaService.StartService(ctx); err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("Ollama服务不可用: " + err.Error()))
return
}
}
models, err := h.ollamaService.ListModels(ctx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("获取模型列表失败: " + err.Error()))
return
}
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"models": models,
},
})
}
// downloadModelAsync 异步下载模型
func (h *InitializationHandler) downloadModelAsync(ctx context.Context,
taskID, modelName string,
) {
logger.Infof(ctx, "Starting async download for model: %s, task: %s", modelName, taskID)
// 更新任务状态为下载中
h.updateTaskStatus(taskID, "downloading", 0.0, "开始下载模型")
// 执行下载,带进度回调
err := h.pullModelWithProgress(ctx, modelName, func(progress float64, message string) {
h.updateTaskStatus(taskID, "downloading", progress, message)
})
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": modelName,
"task_id": taskID,
})
h.updateTaskStatus(taskID, "failed", 0.0, fmt.Sprintf("下载失败: %v", err))
return
}
// 下载成功
logger.Infof(ctx, "Model %s downloaded successfully, task: %s", modelName, taskID)
h.updateTaskStatus(taskID, "completed", 100.0, "下载完成")
}
// pullModelWithProgress 下载模型并提供进度回调
func (h *InitializationHandler) pullModelWithProgress(ctx context.Context,
modelName string,
progressCallback func(float64, string),
) error {
// 检查服务是否可用
if err := h.ollamaService.StartService(ctx); err != nil {
logger.ErrorWithFields(ctx, err, nil)
return err
}
// 检查模型是否已存在
available, err := h.ollamaService.IsModelAvailable(ctx, modelName)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
"model_name": modelName,
})
return err
}
if available {
progressCallback(100.0, "模型已存在")
return nil
}
logger.GetLogger(ctx).Infof("Pulling model %s...", modelName)
// 创建下载请求
pullReq := &api.PullRequest{
Name: modelName,
}
// 使用Ollama客户端的Pull方法,带进度回调
err = h.ollamaService.GetClient().Pull(ctx, pullReq, func(progress api.ProgressResponse) error {
var progressPercent float64 = 0.0
var message string = "下载中"
if progress.Total > 0 && progress.Completed > 0 {
progressPercent = float64(progress.Completed) / float64(progress.Total) * 100
message = fmt.Sprintf("下载中: %.1f%% (%s)", progressPercent, progress.Status)
} else if progress.Status != "" {
message = progress.Status
}
// 调用进度回调
progressCallback(progressPercent, message)
logger.Infof(ctx,
"Download progress for %s: %.2f%% - %s",
modelName, progressPercent, message,
)
return nil
})
if err != nil {
return fmt.Errorf("failed to pull model: %w", err)
}
return nil
}
// updateTaskStatus 更新任务状态
func (h *InitializationHandler) updateTaskStatus(
taskID, status string, progress float64, message string,
) {
tasksMutex.Lock()
defer tasksMutex.Unlock()
if task, exists := downloadTasks[taskID]; exists {
task.Status = status
task.Progress = progress
task.Message = message
if status == "completed" || status == "failed" {
now := time.Now()
task.EndTime = &now
}
}
}
// GetCurrentConfig 获取当前系统配置信息
func (h *InitializationHandler) GetCurrentConfig(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Getting current system configuration")
// 设置租户上下文
newCtx := context.WithValue(ctx, types.TenantIDContextKey, types.InitDefaultTenantID)
// 获取模型信息
models, err := h.modelService.ListModels(newCtx)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("获取模型列表失败: " + err.Error()))
return
}
// 获取知识库信息
kb, err := h.kbService.GetKnowledgeBaseByID(newCtx, types.InitDefaultKnowledgeBaseID)
if err != nil {
logger.ErrorWithFields(ctx, err, nil)
c.Error(errors.NewInternalServerError("获取知识库信息失败: " + err.Error()))
return
}
// 检查知识库是否有文件
knowledgeList, err := h.knowledgeService.ListPagedKnowledgeByKnowledgeBaseID(newCtx,
types.InitDefaultKnowledgeBaseID, &types.Pagination{
Page: 1,
PageSize: 1,
})
hasFiles := false
if err == nil && knowledgeList != nil && knowledgeList.Total > 0 {
hasFiles = true
}
// 构建配置响应
config := buildConfigResponse(models, kb, hasFiles)
logger.Info(ctx, "Current system configuration retrieved successfully")
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": config,
})
}
// buildConfigResponse 构建配置响应数据
func buildConfigResponse(models []*types.Model,
kb *types.KnowledgeBase, hasFiles bool,
) map[string]interface{} {
config := map[string]interface{}{
"hasFiles": hasFiles,
}
// 按类型分组模型
for _, model := range models {
switch model.Type {
case types.ModelTypeKnowledgeQA:
config["llm"] = map[string]interface{}{
"source": string(model.Source),
"modelName": model.Name,
"baseUrl": model.Parameters.BaseURL,
"apiKey": model.Parameters.APIKey,
}
case types.ModelTypeEmbedding:
config["embedding"] = map[string]interface{}{
"source": string(model.Source),
"modelName": model.Name,
"baseUrl": model.Parameters.BaseURL,
"apiKey": model.Parameters.APIKey,
"dimension": model.Parameters.EmbeddingParameters.Dimension,
}
case types.ModelTypeRerank:
config["rerank"] = map[string]interface{}{
"enabled": true,
"modelName": model.Name,
"baseUrl": model.Parameters.BaseURL,
"apiKey": model.Parameters.APIKey,
}
case types.ModelTypeVLLM:
if config["multimodal"] == nil {
config["multimodal"] = map[string]interface{}{
"enabled": true,
}
}
multimodal := config["multimodal"].(map[string]interface{})
multimodal["vlm"] = map[string]interface{}{
"modelName": model.Name,
"baseUrl": model.Parameters.BaseURL,
"apiKey": model.Parameters.APIKey,
"interfaceType": kb.VLMConfig.InterfaceType,
}
}
}
// 如果没有VLM模型,设置multimodal为disabled
if config["multimodal"] == nil {
config["multimodal"] = map[string]interface{}{
"enabled": false,
}
}
// 如果没有Rerank模型,设置rerank为disabled
if config["rerank"] == nil {
config["rerank"] = map[string]interface{}{
"enabled": false,
"modelName": "",
"baseUrl": "",
"apiKey": "",
}
}
// 添加知识库的文档分割配置
if kb != nil {
config["documentSplitting"] = map[string]interface{}{
"chunkSize": kb.ChunkingConfig.ChunkSize,
"chunkOverlap": kb.ChunkingConfig.ChunkOverlap,
"separators": kb.ChunkingConfig.Separators,
}
// 添加多模态的COS配置信息
2025-08-13 13:56:20 +00:00
if kb.StorageConfig.SecretID != "" {
if config["multimodal"] == nil {
config["multimodal"] = map[string]interface{}{
"enabled": true,
}
}
multimodal := config["multimodal"].(map[string]interface{})
2025-08-13 13:56:20 +00:00
multimodal["storageType"] = kb.StorageConfig.Provider
switch kb.StorageConfig.Provider {
case "cos":
multimodal["cos"] = map[string]interface{}{
"secretId": kb.StorageConfig.SecretID,
"secretKey": kb.StorageConfig.SecretKey,
"region": kb.StorageConfig.Region,
"bucketName": kb.StorageConfig.BucketName,
"appId": kb.StorageConfig.AppID,
"pathPrefix": kb.StorageConfig.PathPrefix,
}
case "minio":
multimodal["minio"] = map[string]interface{}{
"bucketName": kb.StorageConfig.BucketName,
"pathPrefix": kb.StorageConfig.PathPrefix,
}
}
}
}
return config
}
// RemoteModelCheckRequest 远程模型检查请求结构
type RemoteModelCheckRequest struct {
ModelName string `json:"modelName" binding:"required"`
BaseURL string `json:"baseUrl" binding:"required"`
APIKey string `json:"apiKey"`
}
// CheckRemoteModel 检查远程API模型连接
func (h *InitializationHandler) CheckRemoteModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Checking remote model connection")
var req RemoteModelCheckRequest
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse remote model check request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 验证请求参数
if req.ModelName == "" || req.BaseURL == "" {
logger.Error(ctx, "Model name and base URL are required")
c.Error(errors.NewBadRequestError("模型名称和Base URL不能为空"))
return
}
// 创建模型配置进行测试
modelConfig := &types.Model{
Name: req.ModelName,
Source: "remote",
Parameters: types.ModelParameters{
BaseURL: req.BaseURL,
APIKey: req.APIKey,
},
Type: "llm", // 默认类型,实际检查时不区分具体类型
}
// 检查远程模型连接
available, message := h.checkRemoteModelConnection(ctx, modelConfig)
logger.Info(ctx,
fmt.Sprintf(
"Remote model check completed: modelName=%s, baseUrl=%s, available=%v, message=%s",
req.ModelName, req.BaseURL, available, message,
),
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"available": available,
"message": message,
},
})
}
// TestEmbeddingModel 测试 Embedding 接口(本地或远程)是否可用
func (h *InitializationHandler) TestEmbeddingModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Testing embedding model connectivity and functionality")
var req struct {
Source string `json:"source" binding:"required"`
ModelName string `json:"modelName" binding:"required"`
BaseURL string `json:"baseUrl"`
APIKey string `json:"apiKey"`
Dimension int `json:"dimension"`
}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse embedding test request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 构造 embedder 配置
cfg := embedding.Config{
Source: types.ModelSource(strings.ToLower(req.Source)),
BaseURL: req.BaseURL,
ModelName: req.ModelName,
APIKey: req.APIKey,
TruncatePromptTokens: 256,
Dimensions: req.Dimension,
ModelID: "",
}
emb, err := embedding.NewEmbedder(cfg)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{"model": req.ModelName})
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{`available`: false, `message`: fmt.Sprintf("创建Embedder失败: %v", err), `dimension`: 0},
})
return
}
// 执行一次最小化 embedding 调用
sample := "hello"
vec, err := emb.Embed(ctx, sample)
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{"model": req.ModelName})
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{`available`: false, `message`: fmt.Sprintf("调用Embedding失败: %v", err), `dimension`: 0},
})
return
}
logger.Infof(ctx, "Embedding test succeeded, dim=%d", len(vec))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{`available`: true, `message`: fmt.Sprintf("测试成功,向量维度=%d", len(vec)), `dimension`: len(vec)},
})
}
// checkRemoteModelConnection 检查远程模型连接的内部方法
func (h *InitializationHandler) checkRemoteModelConnection(ctx context.Context,
model *types.Model,
) (bool, string) {
// 使用 /chat/completions 端点进行连接检查
// 发送一个简单的测试请求来验证连接和认证
client := &http.Client{
Timeout: 10 * time.Second,
}
// 构造测试请求
testEndpoint := ""
if model.Parameters.BaseURL != "" {
testEndpoint = model.Parameters.BaseURL + "/chat/completions"
}
// 构造测试请求体
testRequest := map[string]interface{}{
"model": model.Name,
"messages": []map[string]string{
{
"role": "user",
"content": "test",
},
},
"max_tokens": 1,
}
jsonData, err := json.Marshal(testRequest)
if err != nil {
return false, fmt.Sprintf("构造请求体失败: %v", err)
}
req, err := http.NewRequestWithContext(ctx, "POST", testEndpoint, bytes.NewBuffer(jsonData))
if err != nil {
return false, fmt.Sprintf("创建请求失败: %v", err)
}
// 添加认证头
if model.Parameters.APIKey != "" {
req.Header.Set("Authorization", "Bearer "+model.Parameters.APIKey)
}
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
return false, fmt.Sprintf("连接失败: %v", err)
}
defer resp.Body.Close()
// 检查响应状态
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
// 连接成功,模型可用
return true, "连接正常,模型可用"
} else if resp.StatusCode == 401 {
return false, "认证失败,请检查API Key"
} else if resp.StatusCode == 403 {
return false, "权限不足,请检查API Key权限"
} else if resp.StatusCode == 404 {
return false, "API端点不存在,请检查Base URL"
} else {
return false, fmt.Sprintf("API返回错误状态: %d", resp.StatusCode)
}
}
// checkModelExistence 检查指定模型是否在模型列表中存在
func (h *InitializationHandler) checkModelExistence(ctx context.Context,
resp *http.Response, modelName string) (bool, string) {
body, err := io.ReadAll(resp.Body)
if err != nil {
return true, "连接正常,但无法验证模型列表"
}
var modelsResp struct {
Data []struct {
ID string `json:"id"`
Object string `json:"object"`
} `json:"data"`
Object string `json:"object"`
}
// 尝试解析模型列表响应
if err := json.Unmarshal(body, &modelsResp); err != nil {
// 如果无法解析,可能是非标准API,只要连接成功就认为可用
return true, "连接正常"
}
// 检查模型是否在列表中
for _, model := range modelsResp.Data {
if model.ID == modelName {
return true, "连接正常,模型存在"
}
}
// 模型不在列表中,返回可用的模型建议
if len(modelsResp.Data) > 0 {
availableModels := make([]string, 0, min(3, len(modelsResp.Data)))
for i, model := range modelsResp.Data {
if i >= 3 {
break
}
availableModels = append(availableModels, model.ID)
}
return false, fmt.Sprintf("模型 '%s' 不存在,可用模型: %s", modelName, strings.Join(availableModels, ", "))
}
return false, fmt.Sprintf("模型 '%s' 不存在", modelName)
}
// min returns the minimum of two integers
func min(a, b int) int {
if a < b {
return a
}
return b
}
// checkRerankModelConnection 检查Rerank模型连接和功能的内部方法
func (h *InitializationHandler) checkRerankModelConnection(ctx context.Context,
modelName, baseURL, apiKey string) (bool, string) {
client := &http.Client{
Timeout: 15 * time.Second,
}
// 构造重排API端点
2025-08-10 13:45:55 +00:00
rerankEndpoint := baseURL + "/rerank"
// Mock测试数据
testQuery := "什么是人工智能?"
testPassages := []string{
"机器学习是人工智能的一个子领域,专注于算法和统计模型,使计算机系统能够通过经验自动改进。",
"深度学习是机器学习的一个子集,使用人工神经网络来模拟人脑的工作方式。",
}
// 构造重排请求
rerankRequest := map[string]interface{}{
"model": modelName,
"query": testQuery,
"documents": testPassages,
"truncate_prompt_tokens": 512,
}
jsonData, err := json.Marshal(rerankRequest)
if err != nil {
return false, fmt.Sprintf("构造请求失败: %v", err)
}
logger.Infof(ctx, "Rerank request: %s, modelName=%s, baseURL=%s, apiKey=%s",
string(jsonData), modelName, baseURL, apiKey)
req, err := http.NewRequestWithContext(
ctx, "POST", rerankEndpoint, strings.NewReader(string(jsonData)),
)
if err != nil {
return false, fmt.Sprintf("创建请求失败: %v", err)
}
// 添加认证头
if apiKey != "" {
req.Header.Set("Authorization", "Bearer "+apiKey)
}
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
return false, fmt.Sprintf("连接失败: %v", err)
}
defer resp.Body.Close()
// 读取响应
body, err := io.ReadAll(resp.Body)
if err != nil {
return false, fmt.Sprintf("读取响应失败: %v", err)
}
// 检查响应状态
if resp.StatusCode >= 200 && resp.StatusCode < 300 {
// 尝试解析重排响应
var rerankResp struct {
Results []struct {
Index int `json:"index"`
Document string `json:"document"`
RelevanceScore float64 `json:"relevance_score"`
} `json:"results"`
}
if err := json.Unmarshal(body, &rerankResp); err != nil {
// 如果无法解析标准重排响应,检查是否有其他格式
return true, "连接正常,但响应格式非标准"
}
// 检查是否返回了重排结果
if len(rerankResp.Results) > 0 {
return true, fmt.Sprintf("重排功能正常,返回%d个结果", len(rerankResp.Results))
} else {
return false, "重排接口连接成功,但未返回重排结果"
}
} else if resp.StatusCode == 401 {
return false, "认证失败,请检查API Key"
} else if resp.StatusCode == 403 {
return false, "权限不足,请检查API Key权限"
} else if resp.StatusCode == 404 {
return false, "重排API端点不存在,请检查Base URL"
} else if resp.StatusCode == 422 {
return false, fmt.Sprintf("请求参数错误: %s", string(body))
} else {
return false, fmt.Sprintf("API返回错误状态: %d, 响应: %s", resp.StatusCode, string(body))
}
}
// CheckRerankModel 检查Rerank模型连接和功能
func (h *InitializationHandler) CheckRerankModel(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Checking rerank model connection and functionality")
var req struct {
ModelName string `json:"modelName" binding:"required"`
BaseURL string `json:"baseUrl" binding:"required"`
APIKey string `json:"apiKey"`
}
if err := c.ShouldBindJSON(&req); err != nil {
logger.Error(ctx, "Failed to parse rerank model check request", err)
c.Error(errors.NewBadRequestError(err.Error()))
return
}
// 验证请求参数
if req.ModelName == "" || req.BaseURL == "" {
logger.Error(ctx, "Model name and base URL are required")
c.Error(errors.NewBadRequestError("模型名称和Base URL不能为空"))
return
}
// 检查Rerank模型连接和功能
available, message := h.checkRerankModelConnection(
ctx, req.ModelName, req.BaseURL, req.APIKey,
)
logger.Info(ctx,
fmt.Sprintf("Rerank model check completed: modelName=%s, baseUrl=%s, available=%v, message=%s",
req.ModelName, req.BaseURL, available, message,
),
)
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"available": available,
"message": message,
},
})
}
2025-08-13 13:56:20 +00:00
// 使用结构体解析表单数据
type testMultimodalForm struct {
VLMModel string `form:"vlm_model"`
VLMBaseURL string `form:"vlm_base_url"`
VLMAPIKey string `form:"vlm_api_key"`
VLMInterfaceType string `form:"vlm_interface_type"`
StorageType string `form:"storage_type"`
// COS 配置
COSSecretID string `form:"cos_secret_id"`
COSSecretKey string `form:"cos_secret_key"`
COSRegion string `form:"cos_region"`
COSBucketName string `form:"cos_bucket_name"`
COSAppID string `form:"cos_app_id"`
COSPathPrefix string `form:"cos_path_prefix"`
// MinIO 配置(当存储为 minio 时)
MinioBucketName string `form:"minio_bucket_name"`
MinioPathPrefix string `form:"minio_path_prefix"`
// 文档切分配置(字符串后续自行解析,以避免类型绑定失败)
ChunkSize string `form:"chunk_size"`
ChunkOverlap string `form:"chunk_overlap"`
SeparatorsRaw string `form:"separators"`
}
// TestMultimodalFunction 测试多模态功能
func (h *InitializationHandler) TestMultimodalFunction(c *gin.Context) {
ctx := c.Request.Context()
logger.Info(ctx, "Testing multimodal functionality")
2025-08-13 13:56:20 +00:00
var req testMultimodalForm
if err := c.ShouldBind(&req); err != nil {
logger.Error(ctx, "Failed to parse form data", err)
c.Error(errors.NewBadRequestError("表单参数解析失败"))
return
}
2025-08-13 13:56:20 +00:00
// ollama 场景自动拼接 base url
if req.VLMInterfaceType == "ollama" {
req.VLMBaseURL = os.Getenv("OLLAMA_BASE_URL") + "/v1"
}
2025-08-13 13:56:20 +00:00
req.StorageType = strings.ToLower(req.StorageType)
2025-08-13 13:56:20 +00:00
if req.VLMModel == "" || req.VLMBaseURL == "" {
logger.Error(ctx, "VLM model name and base URL are required")
c.Error(errors.NewBadRequestError("VLM模型名称和Base URL不能为空"))
return
}
2025-08-13 13:56:20 +00:00
switch req.StorageType {
case "cos":
2025-08-15 02:44:19 +00:00
logger.Infof(ctx, "COS config: Region=%s, Bucket=%s, App=%s, Prefix=%s",
req.COSRegion, req.COSBucketName, req.COSAppID, req.COSPathPrefix)
2025-08-13 13:56:20 +00:00
// 必填:SecretID/SecretKey/Region/BucketName/AppID;PathPrefix 可选
if req.COSSecretID == "" || req.COSSecretKey == "" ||
req.COSRegion == "" || req.COSBucketName == "" ||
req.COSAppID == "" {
logger.Error(ctx, "COS configuration is required")
c.Error(errors.NewBadRequestError("COS配置信息不能为空"))
return
}
case "minio":
logger.Infof(ctx, "MinIO config: Bucket=%s, PathPrefix=%s", req.MinioBucketName, req.MinioPathPrefix)
if req.MinioBucketName == "" {
logger.Error(ctx, "MinIO configuration is required")
c.Error(errors.NewBadRequestError("MinIO配置信息不能为空"))
return
}
default:
logger.Error(ctx, "Invalid storage type")
c.Error(errors.NewBadRequestError("无效的存储类型"))
return
}
logger.Infof(ctx, "VLM config: Model=%s, URL=%s, HasKey=%v, Type=%s",
2025-08-13 13:56:20 +00:00
req.VLMModel, req.VLMBaseURL, req.VLMAPIKey != "", req.VLMInterfaceType)
// 获取上传的图片文件
file, header, err := c.Request.FormFile("image")
if err != nil {
logger.Error(ctx, "Failed to get uploaded image", err)
c.Error(errors.NewBadRequestError("获取上传图片失败"))
return
}
defer file.Close()
// 验证文件类型
if !strings.HasPrefix(header.Header.Get("Content-Type"), "image/") {
logger.Error(ctx, "Invalid file type, only images are allowed")
c.Error(errors.NewBadRequestError("只允许上传图片文件"))
return
}
// 验证文件大小 (10MB)
if header.Size > 10*1024*1024 {
logger.Error(ctx, "File size too large")
c.Error(errors.NewBadRequestError("图片文件大小不能超过10MB"))
return
}
logger.Infof(ctx, "Processing image: %s, size: %d bytes", header.Filename, header.Size)
// 解析文档分割配置
2025-08-13 13:56:20 +00:00
chunkSize, err := strconv.Atoi(req.ChunkSize)
if err != nil || chunkSize < 100 || chunkSize > 10000 {
2025-08-13 13:56:20 +00:00
chunkSize = 1000
}
2025-08-13 13:56:20 +00:00
chunkOverlap, err := strconv.Atoi(req.ChunkOverlap)
if err != nil || chunkOverlap < 0 || chunkOverlap >= chunkSize {
2025-08-13 13:56:20 +00:00
chunkOverlap = 200
}
var separators []string
2025-08-13 13:56:20 +00:00
if req.SeparatorsRaw != "" {
if err := json.Unmarshal([]byte(req.SeparatorsRaw), &separators); err != nil {
separators = []string{"\n\n", "\n", "。", "!", "?", ";", ";"}
}
} else {
2025-08-13 13:56:20 +00:00
separators = []string{"\n\n", "\n", "。", "!", "?", ";", ";"}
}
// 读取图片文件内容
imageContent, err := io.ReadAll(file)
if err != nil {
logger.Error(ctx, "Failed to read image file", err)
c.Error(errors.NewBadRequestError("读取图片文件失败"))
return
}
// 调用多模态测试
startTime := time.Now()
2025-08-13 13:56:20 +00:00
result, err := h.testMultimodalWithDocReader(
ctx,
imageContent, header.Filename,
chunkSize, chunkOverlap, separators, &req,
)
processingTime := time.Since(startTime).Milliseconds()
if err != nil {
logger.ErrorWithFields(ctx, err, map[string]interface{}{
2025-08-13 13:56:20 +00:00
"vlm_model": req.VLMModel,
"vlm_base_url": req.VLMBaseURL,
"filename": header.Filename,
})
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"success": false,
"message": err.Error(),
"processing_time": processingTime,
},
})
return
}
logger.Info(ctx, fmt.Sprintf("Multimodal test completed successfully in %dms", processingTime))
c.JSON(http.StatusOK, gin.H{
"success": true,
"data": gin.H{
"success": true,
"caption": result["caption"],
"ocr": result["ocr"],
"processing_time": processingTime,
},
})
}
// testMultimodalWithDocReader 调用docreader服务进行多模态处理
2025-08-13 13:56:20 +00:00
func (h *InitializationHandler) testMultimodalWithDocReader(
ctx context.Context,
imageContent []byte, filename string,
chunkSize, chunkOverlap int, separators []string,
2025-08-13 13:56:20 +00:00
req *testMultimodalForm,
) (map[string]string, error) {
// 获取文件扩展名
fileExt := ""
if idx := strings.LastIndex(filename, "."); idx != -1 {
fileExt = strings.ToLower(filename[idx+1:])
}
// 检查docreader服务配置
if h.docReaderClient == nil {
return nil, fmt.Errorf("DocReader service not configured")
}
// 构造请求
request := &proto.ReadFromFileRequest{
FileContent: imageContent,
FileName: filename,
FileType: fileExt,
ReadConfig: &proto.ReadConfig{
ChunkSize: int32(chunkSize),
ChunkOverlap: int32(chunkOverlap),
Separators: separators,
EnableMultimodal: true, // 启用多模态处理
VlmConfig: &proto.VLMConfig{
2025-08-13 13:56:20 +00:00
ModelName: req.VLMModel,
BaseUrl: req.VLMBaseURL,
ApiKey: req.VLMAPIKey,
InterfaceType: req.VLMInterfaceType,
},
},
RequestId: ctx.Value(types.RequestIDContextKey).(string),
}
2025-08-13 13:56:20 +00:00
// 设置对象存储配置(通用)
switch strings.ToLower(req.StorageType) {
case "cos":
request.ReadConfig.StorageConfig = &proto.StorageConfig{
Provider: proto.StorageProvider_COS,
Region: req.COSRegion,
BucketName: req.COSBucketName,
AccessKeyId: req.COSSecretID,
SecretAccessKey: req.COSSecretKey,
AppId: req.COSAppID,
PathPrefix: req.COSPathPrefix,
}
case "minio":
request.ReadConfig.StorageConfig = &proto.StorageConfig{
Provider: proto.StorageProvider_MINIO,
BucketName: req.MinioBucketName,
PathPrefix: req.MinioPathPrefix,
AccessKeyId: os.Getenv("MINIO_ACCESS_KEY_ID"),
SecretAccessKey: os.Getenv("MINIO_SECRET_ACCESS_KEY"),
}
}
// 调用docreader服务
response, err := h.docReaderClient.ReadFromFile(ctx, request)
if err != nil {
return nil, fmt.Errorf("调用DocReader服务失败: %v", err)
}
if response.Error != "" {
return nil, fmt.Errorf("DocReader服务返回错误: %s", response.Error)
}
// 处理响应,提取Caption和OCR信息
result := make(map[string]string)
var allCaptions, allOCRTexts []string
for _, chunk := range response.Chunks {
if len(chunk.Images) > 0 {
for _, image := range chunk.Images {
if image.Caption != "" {
allCaptions = append(allCaptions, image.Caption)
}
if image.OcrText != "" {
allOCRTexts = append(allOCRTexts, image.OcrText)
}
}
}
}
// 合并所有Caption和OCR结果
result["caption"] = strings.Join(allCaptions, "; ")
result["ocr"] = strings.Join(allOCRTexts, "; ")
return result, nil
}