@@ -145,6 +150,7 @@ import ModelSettings from './ModelSettings.vue'
import OllamaSettings from './OllamaSettings.vue'
import McpSettings from './McpSettings.vue'
import WebSearchSettings from './WebSearchSettings.vue'
+import ChatHistorySettings from './ChatHistorySettings.vue'
import ParserEngineSettings from './ParserEngineSettings.vue'
import StorageEngineSettings from './StorageEngineSettings.vue'
@@ -172,6 +178,7 @@ const navItems = computed(() => [
},
{ key: 'ollama', icon: 'server', label: 'Ollama' },
{ key: 'websearch', icon: 'search', label: t('settings.webSearchConfig') },
+ { key: 'chathistory', icon: 'chat', label: t('chatHistorySettings.title') },
{
key: 'parser',
icon: 'file-search',
diff --git a/internal/application/repository/message.go b/internal/application/repository/message.go
index 0808e78b..68c5ea83 100644
--- a/internal/application/repository/message.go
+++ b/internal/application/repository/message.go
@@ -151,3 +151,96 @@ func (r *messageRepository) GetMessageByRequestID(
return &message, nil
}
+
+// SearchMessagesByKeyword searches messages by keyword (ILIKE) across sessions for a tenant
+func (r *messageRepository) SearchMessagesByKeyword(
+ ctx context.Context, tenantID uint64, keyword string, sessionIDs []string, limit int,
+) ([]*types.MessageWithSession, error) {
+ if limit <= 0 {
+ limit = 20
+ }
+
+ var results []*types.MessageWithSession
+
+ query := r.db.WithContext(ctx).
+ Table("messages").
+ Select("messages.*, sessions.title as session_title").
+ Joins("INNER JOIN sessions ON sessions.id = messages.session_id AND sessions.deleted_at IS NULL").
+ Where("sessions.tenant_id = ?", tenantID).
+ Where("messages.deleted_at IS NULL").
+ Where("messages.content ILIKE ?", "%"+keyword+"%")
+
+ if len(sessionIDs) > 0 {
+ query = query.Where("messages.session_id IN ?", sessionIDs)
+ }
+
+ if err := query.Order("messages.created_at DESC").Limit(limit).Find(&results).Error; err != nil {
+ return nil, err
+ }
+
+ return results, nil
+}
+
+// GetMessagesByKnowledgeIDs retrieves messages by their associated Knowledge IDs
+func (r *messageRepository) GetMessagesByKnowledgeIDs(
+ ctx context.Context, knowledgeIDs []string,
+) ([]*types.MessageWithSession, error) {
+ if len(knowledgeIDs) == 0 {
+ return nil, nil
+ }
+ var results []*types.MessageWithSession
+ if err := r.db.WithContext(ctx).
+ Table("messages").
+ Select("messages.*, sessions.title as session_title").
+ Joins("INNER JOIN sessions ON sessions.id = messages.session_id AND sessions.deleted_at IS NULL").
+ Where("messages.deleted_at IS NULL").
+ Where("messages.knowledge_id IN ?", knowledgeIDs).
+ Find(&results).Error; err != nil {
+ return nil, err
+ }
+ return results, nil
+}
+
+// GetMessagesByRequestIDs retrieves messages by their request IDs (used to fetch Q&A pair partners)
+func (r *messageRepository) GetMessagesByRequestIDs(
+ ctx context.Context, requestIDs []string,
+) ([]*types.MessageWithSession, error) {
+ if len(requestIDs) == 0 {
+ return nil, nil
+ }
+ var results []*types.MessageWithSession
+ if err := r.db.WithContext(ctx).
+ Table("messages").
+ Select("messages.*, sessions.title as session_title").
+ Joins("INNER JOIN sessions ON sessions.id = messages.session_id AND sessions.deleted_at IS NULL").
+ Where("messages.deleted_at IS NULL").
+ Where("messages.request_id IN ?", requestIDs).
+ Find(&results).Error; err != nil {
+ return nil, err
+ }
+ return results, nil
+}
+
+// GetKnowledgeIDsBySessionID retrieves all knowledge IDs for messages in a session
+func (r *messageRepository) GetKnowledgeIDsBySessionID(
+ ctx context.Context, sessionID string,
+) ([]string, error) {
+ var knowledgeIDs []string
+ if err := r.db.WithContext(ctx).
+ Model(&types.Message{}).
+ Where("session_id = ? AND knowledge_id != '' AND knowledge_id IS NOT NULL AND deleted_at IS NULL", sessionID).
+ Pluck("knowledge_id", &knowledgeIDs).Error; err != nil {
+ return nil, err
+ }
+ return knowledgeIDs, nil
+}
+
+// UpdateMessageKnowledgeID updates the knowledge_id field for a message
+func (r *messageRepository) UpdateMessageKnowledgeID(
+ ctx context.Context, messageID string, knowledgeID string,
+) error {
+ return r.db.WithContext(ctx).
+ Model(&types.Message{}).
+ Where("id = ?", messageID).
+ Update("knowledge_id", knowledgeID).Error
+}
diff --git a/internal/application/service/knowledge.go b/internal/application/service/knowledge.go
index a6e0930b..b2f42d75 100644
--- a/internal/application/service/knowledge.go
+++ b/internal/application/service/knowledge.go
@@ -1937,6 +1937,11 @@ func (s *knowledgeService) ProcessSummaryGeneration(ctx context.Context, t *asyn
return nil
}
+ if kb.SummaryModelID == "" {
+ logger.Errorf(ctx, "Knowledge base summary model ID is empty")
+ return nil
+ }
+
// Get knowledge
knowledge, err := s.repo.GetKnowledgeByID(ctx, payload.TenantID, payload.KnowledgeID)
if err != nil {
diff --git a/internal/application/service/message.go b/internal/application/service/message.go
index ea44c518..938f61ed 100644
--- a/internal/application/service/message.go
+++ b/internal/application/service/message.go
@@ -3,6 +3,9 @@ package service
import (
"context"
"errors"
+ "fmt"
+ "sort"
+ "strings"
"time"
"github.com/Tencent/WeKnora/internal/logger"
@@ -11,24 +14,33 @@ import (
)
// messageService implements the MessageService interface for managing messaging operations
-// It handles creating, retrieving, updating, and deleting messages within sessions
+// It handles creating, retrieving, updating, and deleting messages within sessions.
+// It reads the chat history knowledge base configuration from the tenant's ChatHistoryConfig,
+// which is managed via the settings UI.
type messageService struct {
- messageRepo interfaces.MessageRepository // Repository for message storage operations
- sessionRepo interfaces.SessionRepository // Repository for session validation
+ messageRepo interfaces.MessageRepository // Repository for message storage operations
+ sessionRepo interfaces.SessionRepository // Repository for session validation
+ tenantService interfaces.TenantService // Service for tenant operations (read ChatHistoryConfig)
+ kbService interfaces.KnowledgeBaseService // Service for knowledge base operations (search chat history KB)
+ knowService interfaces.KnowledgeService // Service for knowledge operations (index/delete passages)
+ modelService interfaces.ModelService // Service for model operations (rerank model)
}
// NewMessageService creates a new message service instance with the required repositories
-// Parameters:
-// - messageRepo: Repository for persisting and retrieving messages
-// - sessionRepo: Repository for validating session existence
-//
-// Returns an implementation of the MessageService interface
func NewMessageService(messageRepo interfaces.MessageRepository,
sessionRepo interfaces.SessionRepository,
+ tenantService interfaces.TenantService,
+ kbService interfaces.KnowledgeBaseService,
+ knowService interfaces.KnowledgeService,
+ modelService interfaces.ModelService,
) interfaces.MessageService {
return &messageService{
- messageRepo: messageRepo,
- sessionRepo: sessionRepo,
+ messageRepo: messageRepo,
+ sessionRepo: sessionRepo,
+ tenantService: tenantService,
+ kbService: kbService,
+ knowService: knowService,
+ modelService: modelService,
}
}
@@ -49,17 +61,10 @@ func sessionTenantIDForLookup(ctx context.Context) (uint64, bool) {
}
// CreateMessage creates a new message within an existing session
-// It validates that the session exists before creating the message
-// Parameters:
-// - ctx: Context containing tenant information
-// - message: The message to be created
-//
-// Returns the created message or an error if creation fails
func (s *messageService) CreateMessage(ctx context.Context, message *types.Message) (*types.Message, error) {
logger.Info(ctx, "Start creating message")
logger.Infof(ctx, "Creating message for session ID: %s", message.SessionID)
- // Check if the session exists to validate the message belongs to a valid session
tenantID := types.MustTenantIDFromContext(ctx)
logger.Infof(ctx, "Checking if session exists, tenant ID: %d, session ID: %s", tenantID, message.SessionID)
_, err := s.sessionRepo.Get(ctx, tenantID, message.SessionID)
@@ -68,7 +73,6 @@ func (s *messageService) CreateMessage(ctx context.Context, message *types.Messa
return nil, err
}
- // Create the message in the repository
logger.Info(ctx, "Session exists, creating message")
createdMessage, err := s.messageRepo.CreateMessage(ctx, message)
if err != nil {
@@ -83,17 +87,10 @@ func (s *messageService) CreateMessage(ctx context.Context, message *types.Messa
}
// GetMessage retrieves a specific message by its ID within a session
-// Parameters:
-// - ctx: Context containing tenant information
-// - sessionID: The ID of the session containing the message
-// - messageID: The ID of the message to retrieve
-//
-// Returns the requested message or an error if retrieval fails
func (s *messageService) GetMessage(ctx context.Context, sessionID string, messageID string) (*types.Message, error) {
logger.Info(ctx, "Start getting message")
logger.Infof(ctx, "Getting message, session ID: %s, message ID: %s", sessionID, messageID)
- // Verify the session exists before attempting to retrieve the message
tenantID := types.MustTenantIDFromContext(ctx)
logger.Infof(ctx, "Checking if session exists, tenant ID: %d", tenantID)
_, err := s.sessionRepo.Get(ctx, tenantID, sessionID)
@@ -102,7 +99,6 @@ func (s *messageService) GetMessage(ctx context.Context, sessionID string, messa
return nil, err
}
- // Retrieve the message from the repository
logger.Info(ctx, "Session exists, getting message")
message, err := s.messageRepo.GetMessage(ctx, sessionID, messageID)
if err != nil {
@@ -118,20 +114,12 @@ func (s *messageService) GetMessage(ctx context.Context, sessionID string, messa
}
// GetMessagesBySession retrieves paginated messages for a specific session
-// Parameters:
-// - ctx: Context containing tenant information
-// - sessionID: The ID of the session to get messages from
-// - page: The page number for pagination (0-based)
-// - pageSize: The number of messages per page
-//
-// Returns a slice of messages or an error if retrieval fails
func (s *messageService) GetMessagesBySession(ctx context.Context,
sessionID string, page int, pageSize int,
) ([]*types.Message, error) {
logger.Info(ctx, "Start getting messages by session")
logger.Infof(ctx, "Getting messages for session ID: %s, page: %d, pageSize: %d", sessionID, page, pageSize)
- // Verify the session exists before retrieving messages
tenantID := types.MustTenantIDFromContext(ctx)
logger.Infof(ctx, "Checking if session exists, tenant ID: %d", tenantID)
_, err := s.sessionRepo.Get(ctx, tenantID, sessionID)
@@ -140,7 +128,6 @@ func (s *messageService) GetMessagesBySession(ctx context.Context,
return nil, err
}
- // Retrieve paginated messages
logger.Info(ctx, "Session exists, getting messages")
messages, err := s.messageRepo.GetMessagesBySession(ctx, sessionID, page, pageSize)
if err != nil {
@@ -157,20 +144,12 @@ func (s *messageService) GetMessagesBySession(ctx context.Context,
}
// GetRecentMessagesBySession retrieves the most recent messages from a session
-// This is typically used for loading the initial conversation history
-// Parameters:
-// - ctx: Context containing tenant information
-// - sessionID: The ID of the session to get messages from
-// - limit: Maximum number of messages to retrieve
-//
-// Returns a slice of recent messages or an error if retrieval fails
func (s *messageService) GetRecentMessagesBySession(ctx context.Context,
sessionID string, limit int,
) ([]*types.Message, error) {
logger.Info(ctx, "Start getting recent messages by session")
logger.Infof(ctx, "Getting recent messages for session ID: %s, limit: %d", sessionID, limit)
- // Verify the session exists before retrieving messages (use SessionTenantID when set, e.g. pipeline with shared agent)
tenantID, ok := sessionTenantIDForLookup(ctx)
if !ok {
logger.Error(ctx, "Tenant ID not found in context for session lookup")
@@ -183,7 +162,6 @@ func (s *messageService) GetRecentMessagesBySession(ctx context.Context,
return nil, err
}
- // Retrieve the most recent messages
logger.Info(ctx, "Session exists, getting recent messages")
messages, err := s.messageRepo.GetRecentMessagesBySession(ctx, sessionID, limit)
if err != nil {
@@ -199,21 +177,12 @@ func (s *messageService) GetRecentMessagesBySession(ctx context.Context,
}
// GetMessagesBySessionBeforeTime retrieves messages sent before a specific time
-// This is typically used for pagination when scrolling through conversation history
-// Parameters:
-// - ctx: Context containing tenant information
-// - sessionID: The ID of the session to get messages from
-// - beforeTime: Timestamp to retrieve messages before
-// - limit: Maximum number of messages to retrieve
-//
-// Returns a slice of messages or an error if retrieval fails
func (s *messageService) GetMessagesBySessionBeforeTime(ctx context.Context,
sessionID string, beforeTime time.Time, limit int,
) ([]*types.Message, error) {
logger.Info(ctx, "Start getting messages before time")
logger.Infof(ctx, "Getting messages before %v for session ID: %s, limit: %d", beforeTime, sessionID, limit)
- // Verify the session exists before retrieving messages (use SessionTenantID when set, e.g. pipeline with shared agent)
tenantID, ok := sessionTenantIDForLookup(ctx)
if !ok {
logger.Error(ctx, "Tenant ID not found in context for session lookup")
@@ -226,7 +195,6 @@ func (s *messageService) GetMessagesBySessionBeforeTime(ctx context.Context,
return nil, err
}
- // Retrieve messages before the specified time
logger.Info(ctx, "Session exists, getting messages before time")
messages, err := s.messageRepo.GetMessagesBySessionBeforeTime(ctx, sessionID, beforeTime, limit)
if err != nil {
@@ -243,16 +211,10 @@ func (s *messageService) GetMessagesBySessionBeforeTime(ctx context.Context,
}
// UpdateMessage updates an existing message's content or metadata
-// Parameters:
-// - ctx: Context containing tenant information
-// - message: The message with updated fields
-//
-// Returns an error if the update fails
func (s *messageService) UpdateMessage(ctx context.Context, message *types.Message) error {
logger.Info(ctx, "Start updating message")
logger.Infof(ctx, "Updating message, ID: %s, session ID: %s", message.ID, message.SessionID)
- // Verify the session exists before updating the message
tenantID := types.MustTenantIDFromContext(ctx)
logger.Infof(ctx, "Checking if session exists, tenant ID: %d", tenantID)
_, err := s.sessionRepo.Get(ctx, tenantID, message.SessionID)
@@ -261,7 +223,6 @@ func (s *messageService) UpdateMessage(ctx context.Context, message *types.Messa
return err
}
- // Update the message in the repository
logger.Info(ctx, "Session exists, updating message")
err = s.messageRepo.UpdateMessage(ctx, message)
if err != nil {
@@ -276,18 +237,11 @@ func (s *messageService) UpdateMessage(ctx context.Context, message *types.Messa
return nil
}
-// DeleteMessage removes a message from a session
-// Parameters:
-// - ctx: Context containing tenant information
-// - sessionID: The ID of the session containing the message
-// - messageID: The ID of the message to delete
-//
-// Returns an error if deletion fails
+// DeleteMessage removes a message from a session, also cleaning up its Knowledge entry in the chat history KB.
func (s *messageService) DeleteMessage(ctx context.Context, sessionID string, messageID string) error {
logger.Info(ctx, "Start deleting message")
logger.Infof(ctx, "Deleting message, session ID: %s, message ID: %s", sessionID, messageID)
- // Verify the session exists before deleting the message
tenantID := types.MustTenantIDFromContext(ctx)
logger.Infof(ctx, "Checking if session exists, tenant ID: %d", tenantID)
_, err := s.sessionRepo.Get(ctx, tenantID, sessionID)
@@ -296,6 +250,13 @@ func (s *messageService) DeleteMessage(ctx context.Context, sessionID string, me
return err
}
+ // Get the message first to check if it has an associated Knowledge entry
+ msg, err := s.messageRepo.GetMessage(ctx, sessionID, messageID)
+ if err != nil {
+ logger.Errorf(ctx, "Failed to get message for deletion: %v", err)
+ return err
+ }
+
// Delete the message from the repository
logger.Info(ctx, "Session exists, deleting message")
err = s.messageRepo.DeleteMessage(ctx, sessionID, messageID)
@@ -307,6 +268,556 @@ func (s *messageService) DeleteMessage(ctx context.Context, sessionID string, me
return err
}
+ // Async cleanup: delete the associated Knowledge entry from the chat history KB.
+ // Use WithoutCancel so the goroutine survives after the HTTP request context is done.
+ if msg != nil && msg.KnowledgeID != "" {
+ bgCtx := context.WithoutCancel(ctx)
+ go s.DeleteMessageKnowledge(bgCtx, msg.KnowledgeID)
+ }
+
logger.Info(ctx, "Message deleted successfully")
return nil
}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Chat History Knowledge Base — Configuration-driven (via Tenant.ChatHistoryConfig)
+// ─────────────────────────────────────────────────────────────────────────────
+
+// getChatHistoryConfig reads the chat history KB configuration from the tenant's settings.
+// Returns nil if the feature is not configured or disabled.
+func (s *messageService) getChatHistoryConfig(ctx context.Context) *types.ChatHistoryConfig {
+ tenant, ok := types.TenantInfoFromContext(ctx)
+ if !ok {
+ return nil
+ }
+ if tenant.ChatHistoryConfig == nil || !tenant.ChatHistoryConfig.IsConfigured() {
+ return nil
+ }
+ return tenant.ChatHistoryConfig
+}
+
+// getRetrievalConfig reads the global retrieval configuration from the tenant's settings.
+// Returns an empty config (with defaults) if not configured.
+func (s *messageService) getRetrievalConfig(ctx context.Context) *types.RetrievalConfig {
+ tenant, ok := types.TenantInfoFromContext(ctx)
+ if !ok {
+ return &types.RetrievalConfig{}
+ }
+ if tenant.RetrievalConfig == nil {
+ return &types.RetrievalConfig{}
+ }
+ return tenant.RetrievalConfig
+}
+
+// IndexMessageToKB indexes a message (Q&A pair) into the chat history knowledge base asynchronously.
+// It creates a Knowledge entry (passage) containing both the user query and assistant answer,
+// then links the message to the Knowledge entry via the knowledge_id field.
+// The KB ID is read from the tenant's ChatHistoryConfig — if not configured, indexing is skipped.
+func (s *messageService) IndexMessageToKB(ctx context.Context, userQuery string, assistantAnswer string, messageID string, sessionID string) {
+ if strings.TrimSpace(userQuery) == "" && strings.TrimSpace(assistantAnswer) == "" {
+ return
+ }
+
+ cfg := s.getChatHistoryConfig(ctx)
+ if cfg == nil {
+ return
+ }
+
+ logger.Infof(ctx, "Indexing message to chat history KB %s, message ID: %s, session ID: %s", cfg.KnowledgeBaseID, messageID, sessionID)
+
+ // Build passage content: combine Q&A for better semantic search
+ var passages []string
+ passage := fmt.Sprintf("[Session: %s]\nQ: %s\nA: %s", sessionID, userQuery, assistantAnswer)
+ passages = append(passages, passage)
+
+ // Use async (non-sync) passage creation so it doesn't block the response
+ knowledge, err := s.knowService.CreateKnowledgeFromPassage(ctx, cfg.KnowledgeBaseID, passages)
+ if err != nil {
+ logger.Warnf(ctx, "Failed to index message to chat history KB: %v", err)
+ return
+ }
+
+ // Link the message to the knowledge entry
+ if err := s.messageRepo.UpdateMessageKnowledgeID(ctx, messageID, knowledge.ID); err != nil {
+ logger.Warnf(ctx, "Failed to update message knowledge_id: %v", err)
+ return
+ }
+
+ logger.Infof(ctx, "Message indexed to chat history KB: knowledge_id=%s, message_id=%s", knowledge.ID, messageID)
+}
+
+// DeleteMessageKnowledge deletes the Knowledge entry associated with a message from the chat history KB.
+func (s *messageService) DeleteMessageKnowledge(ctx context.Context, knowledgeID string) {
+ if knowledgeID == "" {
+ return
+ }
+ logger.Infof(ctx, "Deleting chat history knowledge entry: %s", knowledgeID)
+ if err := s.knowService.DeleteKnowledge(ctx, knowledgeID); err != nil {
+ logger.Warnf(ctx, "Failed to delete chat history knowledge %s: %v", knowledgeID, err)
+ }
+}
+
+// DeleteSessionKnowledge deletes all Knowledge entries for messages in a session from the chat history KB.
+func (s *messageService) DeleteSessionKnowledge(ctx context.Context, sessionID string) {
+ logger.Infof(ctx, "Deleting all chat history knowledge entries for session: %s", sessionID)
+
+ knowledgeIDs, err := s.messageRepo.GetKnowledgeIDsBySessionID(ctx, sessionID)
+ if err != nil {
+ logger.Warnf(ctx, "Failed to get knowledge IDs for session %s: %v", sessionID, err)
+ return
+ }
+
+ if len(knowledgeIDs) == 0 {
+ return
+ }
+
+ logger.Infof(ctx, "Deleting %d chat history knowledge entries for session %s", len(knowledgeIDs), sessionID)
+ if err := s.knowService.DeleteKnowledgeList(ctx, knowledgeIDs); err != nil {
+ logger.Warnf(ctx, "Failed to batch delete chat history knowledge for session %s: %v", sessionID, err)
+ }
+}
+
+// GetChatHistoryKBStats returns statistics about the chat history knowledge base.
+func (s *messageService) GetChatHistoryKBStats(ctx context.Context) (*types.ChatHistoryKBStats, error) {
+ tenantID := types.MustTenantIDFromContext(ctx)
+ tenant, err := s.tenantService.GetTenantByID(ctx, tenantID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get tenant: %w", err)
+ }
+
+ stats := &types.ChatHistoryKBStats{}
+ cfg := tenant.ChatHistoryConfig
+ if cfg == nil || !cfg.Enabled {
+ return stats, nil
+ }
+
+ stats.Enabled = true
+ stats.EmbeddingModelID = cfg.EmbeddingModelID
+ stats.KnowledgeBaseID = cfg.KnowledgeBaseID
+
+ if cfg.KnowledgeBaseID == "" {
+ return stats, nil
+ }
+
+ // Fetch KB info and fill counts (KnowledgeCount is gorm:"-", needs FillKnowledgeBaseCounts)
+ kb, err := s.kbService.GetKnowledgeBaseByID(ctx, cfg.KnowledgeBaseID)
+ if err != nil {
+ logger.Warnf(ctx, "Failed to get chat history KB %s: %v", cfg.KnowledgeBaseID, err)
+ return stats, nil
+ }
+ if err := s.kbService.FillKnowledgeBaseCounts(ctx, kb); err != nil {
+ logger.Warnf(ctx, "Failed to fill chat history KB counts %s: %v", cfg.KnowledgeBaseID, err)
+ }
+ stats.KnowledgeBaseName = kb.Name
+ stats.IndexedMessageCount = kb.KnowledgeCount
+ stats.HasIndexedMessages = kb.KnowledgeCount > 0
+
+ return stats, nil
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Message Search (Hybrid: Keyword + KB Vector Search)
+// ─────────────────────────────────────────────────────────────────────────────
+
+// SearchMessages searches messages by keyword and/or vector similarity across all sessions of the current tenant.
+// Vector search is delegated to the chat history knowledge base's HybridSearch (configured via ChatHistoryConfig).
+func (s *messageService) SearchMessages(ctx context.Context, params *types.MessageSearchParams) (*types.MessageSearchResult, error) {
+ logger.Infof(ctx, "Start searching messages, query: %s, mode: %s", params.Query, params.Mode)
+
+ tenantID := types.MustTenantIDFromContext(ctx)
+
+ // Set defaults
+ if params.Mode == "" {
+ params.Mode = types.MessageSearchModeHybrid
+ }
+ if params.Limit <= 0 {
+ params.Limit = 20
+ }
+
+ var keywordResults []*types.MessageWithSession
+ var vectorResults []*types.MessageSearchResultItem
+ var err error
+
+ // Step 1: Keyword search (direct PG ILIKE)
+ if params.Mode == types.MessageSearchModeKeyword || params.Mode == types.MessageSearchModeHybrid {
+ keywordResults, err = s.messageRepo.SearchMessagesByKeyword(ctx, tenantID, params.Query, params.SessionIDs, params.Limit*3)
+ if err != nil {
+ logger.Errorf(ctx, "Keyword search failed: %v", err)
+ return nil, err
+ }
+ logger.Infof(ctx, "Keyword search found %d results", len(keywordResults))
+ }
+
+ // Step 2: Vector search via chat history knowledge base (if configured)
+ if params.Mode == types.MessageSearchModeVector || params.Mode == types.MessageSearchModeHybrid {
+ vectorResults, err = s.vectorSearchViaKB(ctx, params)
+ if err != nil {
+ logger.Warnf(ctx, "Vector search via KB failed, falling back to keyword-only: %v", err)
+ if params.Mode == types.MessageSearchModeVector {
+ return nil, err
+ }
+ } else {
+ logger.Infof(ctx, "Vector search found %d results", len(vectorResults))
+ }
+ }
+
+ // Step 3: Merge results based on mode
+ var items []*types.MessageSearchResultItem
+
+ switch params.Mode {
+ case types.MessageSearchModeKeyword:
+ items = convertKeywordResults(keywordResults)
+ case types.MessageSearchModeVector:
+ items = vectorResults
+ case types.MessageSearchModeHybrid:
+ items = rrfMerge(keywordResults, vectorResults)
+ }
+
+ // Step 4: Fetch partner messages (Q&A counterparts) to ensure complete pairs
+ items = s.fetchPartnerMessages(ctx, items)
+
+ // Step 5: Group by request_id to merge Q&A pairs
+ grouped := groupByRequestID(items)
+
+ // Apply limit
+ if len(grouped) > params.Limit {
+ grouped = grouped[:params.Limit]
+ }
+
+ result := &types.MessageSearchResult{
+ Items: grouped,
+ Total: len(grouped),
+ }
+
+ logger.Infof(ctx, "Message search completed, returning %d grouped results", result.Total)
+ return result, nil
+}
+
+// vectorSearchViaKB performs vector search using the chat history knowledge base's HybridSearch.
+// The KB ID is read from ChatHistoryConfig, search params from RetrievalConfig.
+func (s *messageService) vectorSearchViaKB(ctx context.Context, params *types.MessageSearchParams) ([]*types.MessageSearchResultItem, error) {
+ cfg := s.getChatHistoryConfig(ctx)
+ if cfg == nil {
+ return nil, nil // Chat history KB not configured, skip vector search
+ }
+
+ // Read global retrieval config for search parameters
+ rc := s.getRetrievalConfig(ctx)
+
+ // Use KB HybridSearch with vector-only mode (keyword search is done separately on the messages table)
+ searchParams := types.SearchParams{
+ QueryText: params.Query,
+ MatchCount: rc.GetEffectiveEmbeddingTopK(),
+ VectorThreshold: rc.GetEffectiveVectorThreshold(),
+ DisableKeywordsMatch: true, // We handle keyword search separately on the messages table
+ }
+
+ kbResults, err := s.kbService.HybridSearch(ctx, cfg.KnowledgeBaseID, searchParams)
+ if err != nil {
+ return nil, fmt.Errorf("KB hybrid search failed: %w", err)
+ }
+
+ if len(kbResults) == 0 {
+ return nil, nil
+ }
+
+ // Rerank results if a rerank model is configured
+ kbResults = s.rerankResults(ctx, rc, params.Query, kbResults)
+ if len(kbResults) == 0 {
+ return nil, nil
+ }
+
+ // Map KB search results back to messages via knowledge_id
+ knowledgeIDs := make([]string, 0, len(kbResults))
+ scoreByKnowledgeID := make(map[string]float64)
+ for _, r := range kbResults {
+ knowledgeIDs = append(knowledgeIDs, r.KnowledgeID)
+ scoreByKnowledgeID[r.KnowledgeID] = r.Score
+ }
+
+ // Look up messages by their knowledge_id
+ messages, err := s.messageRepo.GetMessagesByKnowledgeIDs(ctx, knowledgeIDs)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get messages by knowledge IDs: %w", err)
+ }
+
+ // Filter by session IDs if specified
+ sessionFilter := make(map[string]bool)
+ for _, sid := range params.SessionIDs {
+ sessionFilter[sid] = true
+ }
+
+ var results []*types.MessageSearchResultItem
+ for _, msg := range messages {
+ if len(sessionFilter) > 0 && !sessionFilter[msg.SessionID] {
+ continue
+ }
+ score := scoreByKnowledgeID[msg.KnowledgeID]
+ results = append(results, &types.MessageSearchResultItem{
+ MessageWithSession: *msg,
+ Score: score,
+ MatchType: "vector",
+ })
+ }
+
+ // Sort by score descending
+ sort.Slice(results, func(i, j int) bool {
+ return results[i].Score > results[j].Score
+ })
+
+ return results, nil
+}
+
+// rerankResults applies rerank model to search results if configured.
+// Returns reranked + filtered results, or original results if rerank is unavailable.
+func (s *messageService) rerankResults(ctx context.Context, rc *types.RetrievalConfig, query string, results []*types.SearchResult) []*types.SearchResult {
+ if rc == nil || rc.RerankModelID == "" || len(results) == 0 {
+ return results
+ }
+
+ reranker, err := s.modelService.GetRerankModel(ctx, rc.RerankModelID)
+ if err != nil {
+ logger.Warnf(ctx, "Failed to get rerank model %s, skipping rerank: %v", rc.RerankModelID, err)
+ return results
+ }
+
+ // Build documents for rerank
+ documents := make([]string, len(results))
+ for i, r := range results {
+ documents[i] = r.Content
+ }
+
+ rankResults, err := reranker.Rerank(ctx, query, documents)
+ if err != nil {
+ logger.Warnf(ctx, "Rerank call failed, skipping: %v", err)
+ return results
+ }
+
+ // Filter by threshold and topK, rebuild results with rerank scores
+ threshold := rc.GetEffectiveRerankThreshold()
+ topK := rc.GetEffectiveRerankTopK()
+
+ var reranked []*types.SearchResult
+ for _, rr := range rankResults {
+ if rr.Index >= len(results) {
+ continue
+ }
+ if rr.RelevanceScore < threshold {
+ continue
+ }
+ item := *results[rr.Index]
+ item.Score = rr.RelevanceScore
+ reranked = append(reranked, &item)
+ if len(reranked) >= topK {
+ break
+ }
+ }
+
+ logger.Infof(ctx, "Rerank: %d -> %d results (threshold=%.2f, topK=%d)", len(results), len(reranked), threshold, topK)
+ return reranked
+}
+
+// convertKeywordResults converts keyword search results to MessageSearchResultItem
+func convertKeywordResults(results []*types.MessageWithSession) []*types.MessageSearchResultItem {
+ items := make([]*types.MessageSearchResultItem, 0, len(results))
+ for i, msg := range results {
+ items = append(items, &types.MessageSearchResultItem{
+ MessageWithSession: *msg,
+ Score: float64(len(results)-i) / float64(len(results)),
+ MatchType: "keyword",
+ })
+ }
+ return items
+}
+
+// rrfMerge merges keyword and vector search results using Reciprocal Rank Fusion (RRF)
+func rrfMerge(keywordResults []*types.MessageWithSession, vectorResults []*types.MessageSearchResultItem) []*types.MessageSearchResultItem {
+ const k = 60.0
+
+ type scoredMsg struct {
+ msg *types.MessageWithSession
+ rrfScore float64
+ matchType string
+ }
+ scoreMap := make(map[string]*scoredMsg)
+
+ for rank, msg := range keywordResults {
+ id := msg.ID
+ rrfScore := 1.0 / (k + float64(rank+1))
+ if existing, ok := scoreMap[id]; ok {
+ existing.rrfScore += rrfScore
+ existing.matchType = "hybrid"
+ } else {
+ scoreMap[id] = &scoredMsg{
+ msg: msg,
+ rrfScore: rrfScore,
+ matchType: "keyword",
+ }
+ }
+ }
+
+ for rank, item := range vectorResults {
+ id := item.ID
+ rrfScore := 1.0 / (k + float64(rank+1))
+ if existing, ok := scoreMap[id]; ok {
+ existing.rrfScore += rrfScore
+ existing.matchType = "hybrid"
+ } else {
+ scoreMap[id] = &scoredMsg{
+ msg: &item.MessageWithSession,
+ rrfScore: rrfScore,
+ matchType: "vector",
+ }
+ }
+ }
+
+ items := make([]*types.MessageSearchResultItem, 0, len(scoreMap))
+ for _, scored := range scoreMap {
+ items = append(items, &types.MessageSearchResultItem{
+ MessageWithSession: *scored.msg,
+ Score: scored.rrfScore,
+ MatchType: scored.matchType,
+ })
+ }
+
+ sort.Slice(items, func(i, j int) bool {
+ return items[i].Score > items[j].Score
+ })
+
+ return items
+}
+
+// fetchPartnerMessages looks at the search results and, for each request_id that
+// has only one role (Q-only or A-only), fetches the partner message from DB so
+// that groupByRequestID can produce complete Q&A pairs.
+func (s *messageService) fetchPartnerMessages(ctx context.Context, items []*types.MessageSearchResultItem) []*types.MessageSearchResultItem {
+ // Collect request_ids and track which roles we already have
+ type roleSet struct {
+ hasUser bool
+ hasAssistant bool
+ }
+ seen := make(map[string]*roleSet)
+ existingIDs := make(map[string]bool)
+ for _, item := range items {
+ existingIDs[item.ID] = true
+ rid := item.RequestID
+ if rid == "" {
+ continue
+ }
+ rs, ok := seen[rid]
+ if !ok {
+ rs = &roleSet{}
+ seen[rid] = rs
+ }
+ if item.Role == "user" {
+ rs.hasUser = true
+ } else if item.Role == "assistant" {
+ rs.hasAssistant = true
+ }
+ }
+
+ // Find request_ids that need partner lookup
+ var needFetch []string
+ for rid, rs := range seen {
+ if !rs.hasUser || !rs.hasAssistant {
+ needFetch = append(needFetch, rid)
+ }
+ }
+ if len(needFetch) == 0 {
+ return items
+ }
+
+ // Fetch partner messages
+ partners, err := s.messageRepo.GetMessagesByRequestIDs(ctx, needFetch)
+ if err != nil {
+ logger.Warnf(ctx, "Failed to fetch partner messages: %v", err)
+ return items
+ }
+
+ // Append only messages not already in results
+ for _, p := range partners {
+ if existingIDs[p.ID] {
+ continue
+ }
+ existingIDs[p.ID] = true
+ items = append(items, &types.MessageSearchResultItem{
+ MessageWithSession: *p,
+ Score: 0, // partner is not directly matched
+ MatchType: "",
+ })
+ }
+
+ return items
+}
+
+// groupByRequestID merges individual message search results into Q&A pairs
+// grouped by request_id. Messages without a request_id become standalone items.
+func groupByRequestID(items []*types.MessageSearchResultItem) []*types.MessageSearchGroupItem {
+ type groupState struct {
+ item *types.MessageSearchGroupItem
+ order int // preserve the order of first appearance
+ }
+ groups := make(map[string]*groupState)
+ nextOrder := 0
+
+ for _, item := range items {
+ key := item.RequestID
+ if key == "" {
+ // No request_id — treat as standalone
+ key = item.ID
+ }
+
+ g, exists := groups[key]
+ if !exists {
+ g = &groupState{
+ item: &types.MessageSearchGroupItem{
+ RequestID: item.RequestID,
+ SessionID: item.SessionID,
+ SessionTitle: item.SessionTitle,
+ CreatedAt: item.CreatedAt,
+ },
+ order: nextOrder,
+ }
+ nextOrder++
+ groups[key] = g
+ }
+
+ // Assign content based on role
+ switch item.Role {
+ case "user":
+ g.item.QueryContent = item.Content
+ case "assistant":
+ g.item.AnswerContent = item.Content
+ }
+
+ // Keep the best score and merge match types
+ if item.Score > g.item.Score {
+ g.item.Score = item.Score
+ }
+ if g.item.MatchType == "" {
+ g.item.MatchType = item.MatchType
+ } else if g.item.MatchType != item.MatchType {
+ g.item.MatchType = "hybrid"
+ }
+
+ // Use earliest created_at
+ if item.CreatedAt.Before(g.item.CreatedAt) {
+ g.item.CreatedAt = item.CreatedAt
+ }
+ }
+
+ // Collect and sort by original order (which reflects score ranking)
+ result := make([]*types.MessageSearchGroupItem, 0, len(groups))
+ ordered := make([]*groupState, 0, len(groups))
+ for _, g := range groups {
+ ordered = append(ordered, g)
+ }
+ sort.Slice(ordered, func(i, j int) bool {
+ return ordered[i].order < ordered[j].order
+ })
+ for _, g := range ordered {
+ result = append(result, g.item)
+ }
+
+ return result
+}
diff --git a/internal/application/service/session.go b/internal/application/service/session.go
index 04d17b01..16f2ed46 100644
--- a/internal/application/service/session.go
+++ b/internal/application/service/session.go
@@ -205,6 +205,22 @@ func (s *sessionService) DeleteSession(ctx context.Context, id string) error {
// Get tenant ID from context
tenantID := types.MustTenantIDFromContext(ctx)
+ // Cleanup chat history knowledge entries for this session (async, best-effort).
+ // Use WithoutCancel so the goroutine survives after the HTTP request context is done.
+ bgCtx := context.WithoutCancel(ctx)
+ go func() {
+ knowledgeIDs, err := s.messageRepo.GetKnowledgeIDsBySessionID(bgCtx, id)
+ if err != nil {
+ logger.Warnf(bgCtx, "Failed to get knowledge IDs for session %s: %v", id, err)
+ return
+ }
+ if len(knowledgeIDs) > 0 {
+ if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {
+ logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", id, err)
+ }
+ }
+ }()
+
// Cleanup temporary KB stored in Redis for this session
if err := s.webSearchStateRepo.DeleteWebSearchTempKBState(ctx, id); err != nil {
logger.Warnf(ctx, "Failed to cleanup temporary KB for session %s: %v", id, err)
@@ -239,7 +255,22 @@ func (s *sessionService) BatchDeleteSessions(ctx context.Context, ids []string)
tenantID := types.MustTenantIDFromContext(ctx)
// Cleanup associated resources for each session
+ bgCtx := context.WithoutCancel(ctx)
for _, id := range ids {
+ // Cleanup chat history knowledge entries (async, best-effort)
+ go func(sessionID string) {
+ knowledgeIDs, err := s.messageRepo.GetKnowledgeIDsBySessionID(bgCtx, sessionID)
+ if err != nil {
+ logger.Warnf(bgCtx, "Failed to get knowledge IDs for session %s: %v", sessionID, err)
+ return
+ }
+ if len(knowledgeIDs) > 0 {
+ if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {
+ logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", sessionID, err)
+ }
+ }
+ }(id)
+
if err := s.webSearchStateRepo.DeleteWebSearchTempKBState(ctx, id); err != nil {
logger.Warnf(ctx, "Failed to cleanup temporary KB for session %s: %v", id, err)
}
@@ -269,7 +300,22 @@ func (s *sessionService) DeleteAllSessions(ctx context.Context) error {
if err != nil {
logger.Warnf(ctx, "Failed to list sessions for cleanup: %v", err)
} else {
+ bgCtx := context.WithoutCancel(ctx)
for _, session := range sessions {
+ // Cleanup chat history knowledge entries (async, best-effort)
+ go func(sessionID string) {
+ knowledgeIDs, err := s.messageRepo.GetKnowledgeIDsBySessionID(bgCtx, sessionID)
+ if err != nil {
+ logger.Warnf(bgCtx, "Failed to get knowledge IDs for session %s: %v", sessionID, err)
+ return
+ }
+ if len(knowledgeIDs) > 0 {
+ if err := s.knowledgeService.DeleteKnowledgeList(bgCtx, knowledgeIDs); err != nil {
+ logger.Warnf(bgCtx, "Failed to delete chat history knowledge for session %s: %v", sessionID, err)
+ }
+ }
+ }(session.ID)
+
if err := s.webSearchStateRepo.DeleteWebSearchTempKBState(ctx, session.ID); err != nil {
logger.Warnf(ctx, "Failed to cleanup temporary KB for session %s: %v", session.ID, err)
}
@@ -1210,8 +1256,15 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
return []*types.SearchResult{}, nil
}
- // Create default retrieval parameters
+ // Create default retrieval parameters — prefer tenant RetrievalConfig, fallback to built-in defaults
userID, _ := types.UserIDFromContext(ctx)
+
+ // Load tenant-level retrieval config (nil is safe — GetEffective* methods handle nil receiver)
+ var rc *types.RetrievalConfig
+ if tenant, err2 := s.tenantService.GetTenantByID(ctx, tenantID); err2 == nil {
+ rc = tenant.RetrievalConfig
+ }
+
chatManage := &types.ChatManage{
Query: query,
RewriteQuery: query,
@@ -1219,12 +1272,12 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
KnowledgeBaseIDs: knowledgeBaseIDs,
KnowledgeIDs: knowledgeIDs,
SearchTargets: searchTargets,
- VectorThreshold: s.cfg.Conversation.VectorThreshold, // Use default configuration
- KeywordThreshold: s.cfg.Conversation.KeywordThreshold, // Use default configuration
- EmbeddingTopK: s.cfg.Conversation.EmbeddingTopK, // Use default configuration
- RerankTopK: s.cfg.Conversation.RerankTopK, // Use default configuration
- RerankThreshold: s.cfg.Conversation.RerankThreshold, // Use default configuration
MaxRounds: s.cfg.Conversation.MaxRounds,
+ EmbeddingTopK: rc.GetEffectiveEmbeddingTopK(),
+ VectorThreshold: rc.GetEffectiveVectorThreshold(),
+ KeywordThreshold: rc.GetEffectiveKeywordThreshold(),
+ RerankTopK: rc.GetEffectiveRerankTopK(),
+ RerankThreshold: rc.GetEffectiveRerankThreshold(),
}
// Get default models
@@ -1234,14 +1287,18 @@ func (s *sessionService) SearchKnowledge(ctx context.Context,
return nil, err
}
- // Find the first available rerank model
- for _, model := range models {
- if model == nil {
- continue
- }
- if model.Type == types.ModelTypeRerank {
- chatManage.RerankModelID = model.ID
- break
+ // Use rerank model from RetrievalConfig if set, otherwise auto-select the first available
+ if rc != nil && rc.RerankModelID != "" {
+ chatManage.RerankModelID = rc.RerankModelID
+ } else {
+ for _, model := range models {
+ if model == nil {
+ continue
+ }
+ if model.Type == types.ModelTypeRerank {
+ chatManage.RerankModelID = model.ID
+ break
+ }
}
}
diff --git a/internal/handler/message.go b/internal/handler/message.go
index 2d26fb0f..11838cc4 100644
--- a/internal/handler/message.go
+++ b/internal/handler/message.go
@@ -9,6 +9,7 @@ import (
"github.com/Tencent/WeKnora/internal/errors"
"github.com/Tencent/WeKnora/internal/logger"
+ "github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
secutils "github.com/Tencent/WeKnora/internal/utils"
)
@@ -156,3 +157,97 @@ func (h *MessageHandler) DeleteMessage(c *gin.Context) {
"message": "Message deleted successfully",
})
}
+
+// SearchMessages godoc
+// @Summary 搜索历史对话
+// @Description 通过关键词和/或向量相似度搜索历史对话记录,支持关键词、向量、混合三种模式
+// @Tags 消息
+// @Accept json
+// @Produce json
+// @Param request body SearchMessagesRequest true "搜索请求"
+// @Success 200 {object} map[string]interface{} "搜索结果"
+// @Failure 400 {object} errors.AppError "请求参数错误"
+// @Security Bearer
+// @Security ApiKeyAuth
+// @Router /messages/search [post]
+func (h *MessageHandler) SearchMessages(c *gin.Context) {
+ ctx := c.Request.Context()
+
+ logger.Info(ctx, "Start searching messages")
+
+ var request SearchMessagesRequest
+ if err := c.ShouldBindJSON(&request); err != nil {
+ logger.Error(ctx, "Failed to parse search request", err)
+ c.Error(errors.NewBadRequestError(err.Error()))
+ return
+ }
+
+ if request.Query == "" {
+ logger.Error(ctx, "Query content is empty")
+ c.Error(errors.NewBadRequestError("Query content cannot be empty"))
+ return
+ }
+
+ params := &types.MessageSearchParams{
+ Query: secutils.SanitizeForLog(request.Query),
+ Mode: types.MessageSearchMode(request.Mode),
+ Limit: request.Limit,
+ SessionIDs: request.SessionIDs,
+ }
+
+ logger.Infof(ctx, "Searching messages with params: query=%s, mode=%s, limit=%d, session_ids=%v",
+ params.Query, params.Mode, params.Limit, params.SessionIDs)
+
+ result, err := h.MessageService.SearchMessages(ctx, params)
+ if err != nil {
+ logger.ErrorWithFields(ctx, err, nil)
+ c.Error(errors.NewInternalServerError(err.Error()))
+ return
+ }
+
+ logger.Infof(ctx, "Message search completed, found %d results", result.Total)
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": result,
+ })
+}
+
+// SearchMessagesRequest defines the request structure for searching messages
+type SearchMessagesRequest struct {
+ // Query text for search
+ Query string `json:"query" binding:"required"`
+ // Search mode: "keyword", "vector", "hybrid" (default: "hybrid")
+ Mode string `json:"mode"`
+ // Maximum number of results to return (default: 20)
+ Limit int `json:"limit"`
+ // Filter by specific session IDs (optional)
+ SessionIDs []string `json:"session_ids"`
+}
+
+// GetChatHistoryKBStats godoc
+// @Summary 获取聊天历史知识库统计
+// @Description 获取聊天历史知识库的统计信息(已索引消息数、知识库大小等)
+// @Tags 消息
+// @Accept json
+// @Produce json
+// @Success 200 {object} map[string]interface{} "统计信息"
+// @Security Bearer
+// @Security ApiKeyAuth
+// @Router /messages/chat-history-stats [get]
+func (h *MessageHandler) GetChatHistoryKBStats(c *gin.Context) {
+ ctx := c.Request.Context()
+
+ logger.Info(ctx, "Getting chat history KB stats")
+
+ stats, err := h.MessageService.GetChatHistoryKBStats(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": stats,
+ })
+}
diff --git a/internal/handler/session/helpers.go b/internal/handler/session/helpers.go
index 03abf522..aaca8461 100644
--- a/internal/handler/session/helpers.go
+++ b/internal/handler/session/helpers.go
@@ -171,7 +171,7 @@ func (h *Handler) setupStopEventHandler(
assistantMessage.Content = "用户停止了本次对话"
// Use session's tenant for message update (ctx may have effectiveTenantID when using shared agent)
updateCtx := context.WithValue(ctx, types.TenantIDContextKey, sessionTenantID)
- h.completeAssistantMessage(updateCtx, assistantMessage)
+ h.completeAssistantMessage(updateCtx, assistantMessage, "") // empty query: stopped conversations are not indexed
return nil
})
}
diff --git a/internal/handler/session/qa.go b/internal/handler/session/qa.go
index fd12983a..fea7aa5b 100644
--- a/internal/handler/session/qa.go
+++ b/internal/handler/session/qa.go
@@ -420,7 +420,7 @@ func (h *Handler) executeNormalModeQA(reqCtx *qaRequestContext, generateTitle bo
// Content already contains
... tags from chat_completion_stream.go
// Use session's tenant for message update (asyncCtx may have effectiveTenantID when using shared agent)
updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID)
- h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage)
+ h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query)
// Emit EventAgentComplete - this will trigger handleComplete which sends the SSE complete event
// Note: Don't cancel context here, let the SSE handler close naturally after receiving the complete event
streamCtx.eventBus.Emit(streamCtx.asyncCtx, event.Event{
@@ -527,7 +527,7 @@ func (h *Handler) executeAgentModeQA(reqCtx *qaRequestContext) {
}
// Use session's tenant for message update (session belongs to session.TenantID; asyncCtx may have effectiveTenantID when using shared agent)
updateCtx := context.WithValue(streamCtx.asyncCtx, types.TenantIDContextKey, reqCtx.session.TenantID)
- h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage)
+ h.completeAssistantMessage(updateCtx, streamCtx.assistantMessage, reqCtx.query)
logger.Infof(streamCtx.asyncCtx, "Agent QA service completed for session: %s", sessionID)
}()
@@ -561,9 +561,15 @@ func (h *Handler) executeAgentModeQA(reqCtx *qaRequestContext) {
reqCtx.requestID, streamCtx.eventBus, reqCtx.session.Title == "")
}
-// completeAssistantMessage marks an assistant message as complete and updates it
-func (h *Handler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message) {
+// completeAssistantMessage marks an assistant message as complete, updates it,
+// and asynchronously indexes the Q&A pair into the chat history knowledge base.
+func (h *Handler) completeAssistantMessage(ctx context.Context, assistantMessage *types.Message, userQuery string) {
assistantMessage.UpdatedAt = time.Now()
assistantMessage.IsCompleted = true
_ = h.messageService.UpdateMessage(ctx, assistantMessage)
+
+ // Asynchronously index the Q&A pair into the chat history knowledge base for vector search.
+ // Use WithoutCancel so the goroutine survives after the HTTP request context is done.
+ bgCtx := context.WithoutCancel(ctx)
+ go h.messageService.IndexMessageToKB(bgCtx, userQuery, assistantMessage.Content, assistantMessage.ID, assistantMessage.SessionID)
}
diff --git a/internal/handler/tenant.go b/internal/handler/tenant.go
index 91fd34d9..29bb7bad 100644
--- a/internal/handler/tenant.go
+++ b/internal/handler/tenant.go
@@ -22,6 +22,7 @@ import (
type TenantHandler struct {
service interfaces.TenantService
userService interfaces.UserService
+ kbService interfaces.KnowledgeBaseService
config *config.Config
}
@@ -57,10 +58,11 @@ func (h *TenantHandler) authorizeTenantAccess(c *gin.Context, targetTenantID uin
// - config: Application configuration
//
// Returns a pointer to the newly created TenantHandler
-func NewTenantHandler(service interfaces.TenantService, userService interfaces.UserService, config *config.Config) *TenantHandler {
+func NewTenantHandler(service interfaces.TenantService, userService interfaces.UserService, kbService interfaces.KnowledgeBaseService, config *config.Config) *TenantHandler {
return &TenantHandler{
service: service,
userService: userService,
+ kbService: kbService,
config: config,
}
}
@@ -632,6 +634,12 @@ func (h *TenantHandler) GetTenantKV(c *gin.Context) {
case "storage-engine-config":
h.GetTenantStorageEngineConfig(c)
return
+ case "chat-history-config":
+ h.GetTenantChatHistoryConfig(c)
+ return
+ case "retrieval-config":
+ h.GetTenantRetrievalConfig(c)
+ return
default:
logger.Info(ctx, "KV key not supported", "key", key)
c.Error(errors.NewBadRequestError("unsupported key"))
@@ -672,6 +680,12 @@ func (h *TenantHandler) UpdateTenantKV(c *gin.Context) {
case "storage-engine-config":
h.updateTenantStorageEngineConfigInternal(c)
return
+ case "chat-history-config":
+ h.updateTenantChatHistoryConfigInternal(c)
+ return
+ case "retrieval-config":
+ h.updateTenantRetrievalConfigInternal(c)
+ return
default:
logger.Info(ctx, "KV key not supported", "key", key)
c.Error(errors.NewBadRequestError("unsupported key"))
@@ -1014,3 +1028,177 @@ func (h *TenantHandler) GetPromptTemplates(c *gin.Context) {
"data": templates,
})
}
+
+// GetTenantChatHistoryConfig returns the tenant's chat history KB configuration.
+func (h *TenantHandler) GetTenantChatHistoryConfig(c *gin.Context) {
+ ctx := c.Request.Context()
+ tenant, _ := types.TenantInfoFromContext(ctx)
+ if tenant == nil {
+ logger.Error(ctx, "Tenant is empty")
+ c.Error(errors.NewBadRequestError("Tenant is empty"))
+ return
+ }
+ data := tenant.ChatHistoryConfig
+ if data == nil {
+ data = &types.ChatHistoryConfig{}
+ }
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": data,
+ })
+}
+
+// updateTenantChatHistoryConfigInternal updates the tenant's chat history KB configuration.
+// When enabled with an embedding model and no KB exists yet, it auto-creates a hidden KB.
+func (h *TenantHandler) updateTenantChatHistoryConfigInternal(c *gin.Context) {
+ ctx := c.Request.Context()
+
+ // The frontend sends: enabled, embedding_model_id
+ // knowledge_base_id is managed internally.
+ var req types.ChatHistoryConfig
+ if err := c.ShouldBindJSON(&req); err != nil {
+ logger.Error(ctx, "Failed to parse request parameters", err)
+ c.Error(errors.NewValidationError("Invalid request data").WithDetails(err.Error()))
+ return
+ }
+
+ tenant, _ := types.TenantInfoFromContext(ctx)
+ if tenant == nil {
+ logger.Error(ctx, "Tenant is empty")
+ c.Error(errors.NewBadRequestError("Tenant is empty"))
+ return
+ }
+
+ existing := tenant.ChatHistoryConfig
+
+ // Build the new config, preserving the internally-managed knowledge_base_id
+ cfg := &types.ChatHistoryConfig{
+ Enabled: req.Enabled,
+ EmbeddingModelID: req.EmbeddingModelID,
+ KnowledgeBaseID: "", // will be set below
+ }
+
+ // Carry over existing KB ID if the embedding model hasn't changed
+ if existing != nil && existing.KnowledgeBaseID != "" {
+ if existing.EmbeddingModelID == req.EmbeddingModelID {
+ cfg.KnowledgeBaseID = existing.KnowledgeBaseID
+ } else {
+ // Embedding model changed — the old KB is incompatible.
+ // We'll create a new one below. The old KB remains but is orphaned (can be cleaned up later).
+ logger.Infof(ctx, "Embedding model changed from %s to %s, will create new chat history KB", existing.EmbeddingModelID, req.EmbeddingModelID)
+ }
+ }
+
+ // Auto-create hidden KB if enabled + model set + no KB yet
+ if cfg.Enabled && cfg.EmbeddingModelID != "" && cfg.KnowledgeBaseID == "" {
+ kb := &types.KnowledgeBase{
+ Name: "__chat_history__",
+ Type: types.KnowledgeBaseTypeDocument,
+ IsTemporary: true,
+ Description: "Auto-managed knowledge base for chat history message indexing",
+ EmbeddingModelID: cfg.EmbeddingModelID,
+ }
+ createdKB, err := h.kbService.CreateKnowledgeBase(ctx, kb)
+ if err != nil {
+ logger.ErrorWithFields(ctx, err, nil)
+ c.Error(errors.NewInternalServerError("Failed to create chat history knowledge base").WithDetails(err.Error()))
+ return
+ }
+ cfg.KnowledgeBaseID = createdKB.ID
+ logger.Infof(ctx, "Auto-created chat history KB: id=%s, embedding_model=%s", createdKB.ID, cfg.EmbeddingModelID)
+ }
+
+ tenant.ChatHistoryConfig = cfg
+ updatedTenant, err := h.service.UpdateTenant(ctx, tenant)
+ if err != nil {
+ if appErr, ok := errors.IsAppError(err); ok {
+ c.Error(appErr)
+ } else {
+ logger.ErrorWithFields(ctx, err, nil)
+ c.Error(errors.NewInternalServerError("Failed to update chat history config").WithDetails(err.Error()))
+ }
+ return
+ }
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": updatedTenant.ChatHistoryConfig,
+ "message": "Chat history configuration updated successfully",
+ })
+}
+
+// GetTenantRetrievalConfig returns the tenant's global retrieval configuration.
+func (h *TenantHandler) GetTenantRetrievalConfig(c *gin.Context) {
+ ctx := c.Request.Context()
+ tenant, _ := types.TenantInfoFromContext(ctx)
+ if tenant == nil {
+ logger.Error(ctx, "Tenant is empty")
+ c.Error(errors.NewBadRequestError("Tenant is empty"))
+ return
+ }
+ data := tenant.RetrievalConfig
+ if data == nil {
+ data = &types.RetrievalConfig{}
+ }
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": data,
+ })
+}
+
+// updateTenantRetrievalConfigInternal updates the tenant's global retrieval configuration.
+func (h *TenantHandler) updateTenantRetrievalConfigInternal(c *gin.Context) {
+ ctx := c.Request.Context()
+
+ var cfg types.RetrievalConfig
+ if err := c.ShouldBindJSON(&cfg); err != nil {
+ logger.Error(ctx, "Failed to parse request parameters", err)
+ c.Error(errors.NewValidationError("Invalid request data").WithDetails(err.Error()))
+ return
+ }
+
+ // Validate thresholds
+ if cfg.VectorThreshold < 0 || cfg.VectorThreshold > 1 {
+ c.Error(errors.NewBadRequestError("vector_threshold must be between 0 and 1"))
+ return
+ }
+ if cfg.KeywordThreshold < 0 || cfg.KeywordThreshold > 1 {
+ c.Error(errors.NewBadRequestError("keyword_threshold must be between 0 and 1"))
+ return
+ }
+ if cfg.RerankThreshold < 0 || cfg.RerankThreshold > 1 {
+ c.Error(errors.NewBadRequestError("rerank_threshold must be between 0 and 1"))
+ return
+ }
+ if cfg.EmbeddingTopK < 0 || cfg.EmbeddingTopK > 200 {
+ c.Error(errors.NewBadRequestError("embedding_top_k must be between 0 and 200"))
+ return
+ }
+ if cfg.RerankTopK < 0 || cfg.RerankTopK > 200 {
+ c.Error(errors.NewBadRequestError("rerank_top_k must be between 0 and 200"))
+ return
+ }
+
+ tenant, _ := types.TenantInfoFromContext(ctx)
+ if tenant == nil {
+ logger.Error(ctx, "Tenant is empty")
+ c.Error(errors.NewBadRequestError("Tenant is empty"))
+ return
+ }
+
+ tenant.RetrievalConfig = &cfg
+ updatedTenant, err := h.service.UpdateTenant(ctx, tenant)
+ if err != nil {
+ if appErr, ok := errors.IsAppError(err); ok {
+ c.Error(appErr)
+ } else {
+ logger.ErrorWithFields(ctx, err, nil)
+ c.Error(errors.NewInternalServerError("Failed to update retrieval config").WithDetails(err.Error()))
+ }
+ return
+ }
+ c.JSON(http.StatusOK, gin.H{
+ "success": true,
+ "data": updatedTenant.RetrievalConfig,
+ "message": "Retrieval configuration updated successfully",
+ })
+}
diff --git a/internal/router/router.go b/internal/router/router.go
index 68dc731b..72973701 100644
--- a/internal/router/router.go
+++ b/internal/router/router.go
@@ -276,6 +276,10 @@ func RegisterMessageRoutes(r *gin.RouterGroup, handler *handler.MessageHandler)
// 消息路由组
messages := r.Group("/messages")
{
+ // 搜索历史对话(关键词 + 向量混合搜索)
+ messages.POST("/search", handler.SearchMessages)
+ // 获取聊天历史知识库的统计信息
+ messages.GET("/chat-history-stats", handler.GetChatHistoryKBStats)
// 加载更早的消息,用于向上滚动加载
messages.GET("/:session_id/load", handler.LoadMessages)
// 删除消息
diff --git a/internal/types/chat_history_config.go b/internal/types/chat_history_config.go
new file mode 100644
index 00000000..98dd17e3
--- /dev/null
+++ b/internal/types/chat_history_config.go
@@ -0,0 +1,47 @@
+package types
+
+import (
+ "database/sql/driver"
+ "encoding/json"
+)
+
+// ChatHistoryConfig represents the chat history knowledge base configuration for a tenant.
+// This config is managed via the settings UI and controls how chat messages are indexed
+// and searched using a knowledge base for vector search.
+//
+// The KnowledgeBaseID is auto-managed: when the user enables the feature and picks an
+// embedding model, the backend automatically creates (or reuses) a hidden KB.
+// Users do NOT pick a KB themselves.
+type ChatHistoryConfig struct {
+ // Enabled controls whether chat history indexing is active
+ Enabled bool `json:"enabled"`
+ // EmbeddingModelID is the ID of the embedding model used for vectorizing chat messages.
+ // Once messages have been indexed, the model cannot be changed (requires re-indexing).
+ EmbeddingModelID string `json:"embedding_model_id"`
+ // KnowledgeBaseID is the auto-managed hidden knowledge base for chat history.
+ // This is set internally when the feature is first enabled; users should not set this directly.
+ KnowledgeBaseID string `json:"knowledge_base_id"`
+}
+
+// Value implements the driver.Valuer interface for database serialization
+func (c ChatHistoryConfig) Value() (driver.Value, error) {
+ return json.Marshal(c)
+}
+
+// Scan implements the sql.Scanner interface for database deserialization
+func (c *ChatHistoryConfig) Scan(value interface{}) error {
+ if value == nil {
+ return nil
+ }
+ b, ok := value.([]byte)
+ if !ok {
+ return nil
+ }
+ return json.Unmarshal(b, c)
+}
+
+// IsConfigured returns true if the chat history KB is properly configured and ready to use.
+// Requires: enabled + embedding model selected + KB auto-created.
+func (c *ChatHistoryConfig) IsConfigured() bool {
+ return c != nil && c.Enabled && c.EmbeddingModelID != "" && c.KnowledgeBaseID != ""
+}
diff --git a/internal/types/interfaces/message.go b/internal/types/interfaces/message.go
index ffb17775..61bc6652 100644
--- a/internal/types/interfaces/message.go
+++ b/internal/types/interfaces/message.go
@@ -31,11 +31,53 @@ type MessageService interface {
// DeleteMessage deletes a message
DeleteMessage(ctx context.Context, sessionID string, id string) error
+
+ // SearchMessages searches messages by keyword and/or vector similarity across all sessions of the current tenant.
+ // Uses the chat history knowledge base for vector search instead of in-memory computation.
+ SearchMessages(ctx context.Context, params *types.MessageSearchParams) (*types.MessageSearchResult, error)
+
+ // IndexMessageToKB indexes a message (Q&A pair) into the chat history knowledge base asynchronously.
+ // Called after assistant message is created to enable future vector search.
+ IndexMessageToKB(ctx context.Context, userQuery string, assistantAnswer string, messageID string, sessionID string)
+
+ // DeleteMessageKnowledge deletes the Knowledge entry associated with a message from the chat history KB.
+ DeleteMessageKnowledge(ctx context.Context, knowledgeID string)
+
+ // DeleteSessionKnowledge deletes all Knowledge entries for messages in a session from the chat history KB.
+ DeleteSessionKnowledge(ctx context.Context, sessionID string)
+
+ // GetChatHistoryKBStats returns statistics about the chat history knowledge base (indexed message count, etc.)
+ GetChatHistoryKBStats(ctx context.Context) (*types.ChatHistoryKBStats, error)
}
// MessageRepository defines the message repository interface
type MessageRepository interface {
- MessageService
+ // CreateMessage creates a message
+ CreateMessage(ctx context.Context, message *types.Message) (*types.Message, error)
+ // GetMessage gets a message
+ GetMessage(ctx context.Context, sessionID string, id string) (*types.Message, error)
+ // GetMessagesBySession gets all messages of a session
+ GetMessagesBySession(ctx context.Context, sessionID string, page int, pageSize int) ([]*types.Message, error)
+ // GetRecentMessagesBySession gets recent messages of a session
+ GetRecentMessagesBySession(ctx context.Context, sessionID string, limit int) ([]*types.Message, error)
+ // GetMessagesBySessionBeforeTime gets messages before a specific time of a session
+ GetMessagesBySessionBeforeTime(
+ ctx context.Context, sessionID string, beforeTime time.Time, limit int,
+ ) ([]*types.Message, error)
+ // UpdateMessage updates a message
+ UpdateMessage(ctx context.Context, message *types.Message) error
+ // DeleteMessage deletes a message
+ DeleteMessage(ctx context.Context, sessionID string, id string) error
// GetFirstMessageOfUser gets the first message of a user
GetFirstMessageOfUser(ctx context.Context, sessionID string) (*types.Message, error)
+ // SearchMessagesByKeyword searches messages by keyword (ILIKE) across sessions for a tenant
+ SearchMessagesByKeyword(ctx context.Context, tenantID uint64, keyword string, sessionIDs []string, limit int) ([]*types.MessageWithSession, error)
+ // GetMessagesByKnowledgeIDs retrieves messages by their associated Knowledge IDs
+ GetMessagesByKnowledgeIDs(ctx context.Context, knowledgeIDs []string) ([]*types.MessageWithSession, error)
+ // GetMessagesByRequestIDs retrieves messages by their request IDs (used to fetch Q&A pair partners)
+ GetMessagesByRequestIDs(ctx context.Context, requestIDs []string) ([]*types.MessageWithSession, error)
+ // GetKnowledgeIDsBySessionID retrieves all knowledge IDs for messages in a session
+ GetKnowledgeIDsBySessionID(ctx context.Context, sessionID string) ([]string, error)
+ // UpdateMessageKnowledgeID updates the knowledge_id field for a message
+ UpdateMessageKnowledgeID(ctx context.Context, messageID string, knowledgeID string) error
}
diff --git a/internal/types/message.go b/internal/types/message.go
index 1db2e4b2..3809b25d 100644
--- a/internal/types/message.go
+++ b/internal/types/message.go
@@ -82,6 +82,9 @@ type Message struct {
IsFallback bool `json:"is_fallback,omitempty"`
// Agent total execution duration in milliseconds (from query start to answer start)
AgentDurationMs int64 `json:"agent_duration_ms,omitempty" gorm:"column:agent_duration_ms;default:0"`
+ // KnowledgeID links this message to a Knowledge entry in the chat history knowledge base
+ // Used for vector search indexing: when set, the message content has been indexed as a Knowledge passage
+ KnowledgeID string `json:"knowledge_id,omitempty" gorm:"type:varchar(36);index"`
// Message creation timestamp
CreatedAt time.Time `json:"created_at"`
// Last update timestamp
@@ -136,3 +139,89 @@ func (m *Message) BeforeCreate(tx *gorm.DB) (err error) {
}
return nil
}
+
+// MessageSearchMode represents the search mode for message search
+type MessageSearchMode string
+
+const (
+ // MessageSearchModeKeyword searches by keyword only
+ MessageSearchModeKeyword MessageSearchMode = "keyword"
+ // MessageSearchModeVector searches by vector similarity only
+ MessageSearchModeVector MessageSearchMode = "vector"
+ // MessageSearchModeHybrid combines keyword and vector search with RRF fusion
+ MessageSearchModeHybrid MessageSearchMode = "hybrid"
+)
+
+// MessageSearchParams defines the parameters for searching chat history messages
+type MessageSearchParams struct {
+ // Query text for search
+ Query string `json:"query" binding:"required"`
+ // Search mode: "keyword", "vector", "hybrid" (default: "hybrid")
+ Mode MessageSearchMode `json:"mode"`
+ // Maximum number of results to return (default: 20)
+ Limit int `json:"limit"`
+ // Filter by specific session IDs (optional, empty means all sessions)
+ SessionIDs []string `json:"session_ids"`
+}
+
+// MessageWithSession extends Message with session title for search results
+type MessageWithSession struct {
+ Message
+ // Title of the session this message belongs to
+ SessionTitle string `json:"session_title"`
+}
+
+// MessageSearchResultItem represents a single search result item (internal, pre-merge)
+type MessageSearchResultItem struct {
+ // The matched message with session info
+ MessageWithSession
+ // Search relevance score (higher is better)
+ Score float64 `json:"score"`
+ // How this result was matched: "keyword", "vector", or "hybrid"
+ MatchType string `json:"match_type"`
+}
+
+// MessageSearchGroupItem represents a merged Q&A pair in search results.
+// Messages sharing the same request_id are grouped together so that the user query
+// and assistant answer are displayed side by side.
+type MessageSearchGroupItem struct {
+ // The request_id that groups Q&A together
+ RequestID string `json:"request_id"`
+ // Session info
+ SessionID string `json:"session_id"`
+ SessionTitle string `json:"session_title"`
+ // User query content (role=user)
+ QueryContent string `json:"query_content"`
+ // Assistant answer content (role=assistant), may be empty if only Q matched
+ AnswerContent string `json:"answer_content"`
+ // Best score among the matched messages in this group
+ Score float64 `json:"score"`
+ // How this result was matched: "keyword", "vector", or "hybrid"
+ MatchType string `json:"match_type"`
+ // Timestamp of the earliest message in the group
+ CreatedAt time.Time `json:"created_at"`
+}
+
+// MessageSearchResult represents the search result for message search
+type MessageSearchResult struct {
+ // List of merged Q&A pairs
+ Items []*MessageSearchGroupItem `json:"items"`
+ // Total number of results
+ Total int `json:"total"`
+}
+
+// ChatHistoryKBStats represents statistics about the chat history knowledge base
+type ChatHistoryKBStats struct {
+ // Whether the chat history KB is configured and enabled
+ Enabled bool `json:"enabled"`
+ // ID of the embedding model used
+ EmbeddingModelID string `json:"embedding_model_id,omitempty"`
+ // ID of the knowledge base used for chat history
+ KnowledgeBaseID string `json:"knowledge_base_id,omitempty"`
+ // Name of the knowledge base
+ KnowledgeBaseName string `json:"knowledge_base_name,omitempty"`
+ // Number of indexed message entries (Knowledge count)
+ IndexedMessageCount int64 `json:"indexed_message_count"`
+ // Whether there are any indexed messages (used by frontend to lock embedding model)
+ HasIndexedMessages bool `json:"has_indexed_messages"`
+}
diff --git a/internal/types/retrieval_config.go b/internal/types/retrieval_config.go
new file mode 100644
index 00000000..6a275d8e
--- /dev/null
+++ b/internal/types/retrieval_config.go
@@ -0,0 +1,84 @@
+package types
+
+import (
+ "database/sql/driver"
+ "encoding/json"
+)
+
+// RetrievalConfig holds the global retrieval/search configuration for a tenant.
+// This replaces the retrieval-related fields previously scattered in ConversationConfig
+// and ChatHistoryConfig. Both knowledge search and message search share these parameters.
+//
+// Stored as a JSONB column on the tenants table, managed via the settings UI
+// at /tenants/kv/retrieval-config.
+type RetrievalConfig struct {
+ // EmbeddingTopK is the maximum number of chunks returned by vector search (default: 50)
+ EmbeddingTopK int `json:"embedding_top_k"`
+ // VectorThreshold is the minimum vector similarity score (0-1, default: 0.15)
+ VectorThreshold float64 `json:"vector_threshold"`
+ // KeywordThreshold is the minimum keyword match score (0-1, default: 0.3)
+ KeywordThreshold float64 `json:"keyword_threshold"`
+ // RerankTopK is the maximum number of results after reranking (default: 10)
+ RerankTopK int `json:"rerank_top_k"`
+ // RerankThreshold is the minimum rerank score (0-1, default: 0.2)
+ RerankThreshold float64 `json:"rerank_threshold"`
+ // RerankModelID is the ID of the rerank model to use (required for search)
+ RerankModelID string `json:"rerank_model_id"`
+}
+
+// GetEffectiveEmbeddingTopK returns EmbeddingTopK with a fallback default.
+func (c *RetrievalConfig) GetEffectiveEmbeddingTopK() int {
+ if c == nil || c.EmbeddingTopK <= 0 {
+ return 50
+ }
+ return c.EmbeddingTopK
+}
+
+// GetEffectiveVectorThreshold returns VectorThreshold with a fallback default.
+func (c *RetrievalConfig) GetEffectiveVectorThreshold() float64 {
+ if c == nil || c.VectorThreshold <= 0 {
+ return 0.15
+ }
+ return c.VectorThreshold
+}
+
+// GetEffectiveKeywordThreshold returns KeywordThreshold with a fallback default.
+func (c *RetrievalConfig) GetEffectiveKeywordThreshold() float64 {
+ if c == nil || c.KeywordThreshold <= 0 {
+ return 0.3
+ }
+ return c.KeywordThreshold
+}
+
+// GetEffectiveRerankTopK returns RerankTopK with a fallback default.
+func (c *RetrievalConfig) GetEffectiveRerankTopK() int {
+ if c == nil || c.RerankTopK <= 0 {
+ return 10
+ }
+ return c.RerankTopK
+}
+
+// GetEffectiveRerankThreshold returns RerankThreshold with a fallback default.
+func (c *RetrievalConfig) GetEffectiveRerankThreshold() float64 {
+ if c == nil || c.RerankThreshold <= 0 {
+ return 0.2
+ }
+ return c.RerankThreshold
+}
+
+// Value implements the driver.Valuer interface for database serialization
+func (c RetrievalConfig) Value() (driver.Value, error) {
+ return json.Marshal(c)
+}
+
+// Scan implements the sql.Scanner interface for database deserialization
+func (c *RetrievalConfig) Scan(value interface{}) error {
+ if value == nil {
+ return nil
+ }
+ b, ok := value.([]byte)
+ if !ok {
+ return nil
+ }
+ return json.Unmarshal(b, c)
+}
diff --git a/internal/types/tenant.go b/internal/types/tenant.go
index 5edd49d7..0ee8b105 100644
--- a/internal/types/tenant.go
+++ b/internal/types/tenant.go
@@ -103,6 +103,10 @@ type Tenant struct {
ParserEngineConfig *ParserEngineConfig `yaml:"parser_engine_config" json:"parser_engine_config" gorm:"type:jsonb"`
// Storage engine config: parameters for Local, MinIO, COS. Used for document/file storage and docreader.
StorageEngineConfig *StorageEngineConfig `yaml:"storage_engine_config" json:"storage_engine_config" gorm:"type:jsonb"`
+ // Chat history config: knowledge base configuration for indexing and searching chat messages via vector search
+ ChatHistoryConfig *ChatHistoryConfig `yaml:"chat_history_config" json:"chat_history_config" gorm:"type:jsonb"`
+ // Retrieval config: global search/retrieval parameters shared by knowledge search and message search
+ RetrievalConfig *RetrievalConfig `yaml:"retrieval_config" json:"retrieval_config" gorm:"type:jsonb"`
// Creation time
CreatedAt time.Time `yaml:"created_at" json:"created_at"`
// Last updated time
diff --git a/migrations/versioned/000018_add_message_knowledge_id.down.sql b/migrations/versioned/000018_add_message_knowledge_id.down.sql
new file mode 100644
index 00000000..dbd6a06d
--- /dev/null
+++ b/migrations/versioned/000018_add_message_knowledge_id.down.sql
@@ -0,0 +1,9 @@
+-- Remove retrieval_config column from tenants table
+ALTER TABLE tenants DROP COLUMN IF EXISTS retrieval_config;
+
+-- Remove chat_history_config column from tenants table
+ALTER TABLE tenants DROP COLUMN IF EXISTS chat_history_config;
+
+-- Remove knowledge_id column from messages table
+DROP INDEX IF EXISTS idx_messages_knowledge_id;
+ALTER TABLE messages DROP COLUMN IF EXISTS knowledge_id;
diff --git a/migrations/versioned/000018_add_message_knowledge_id.up.sql b/migrations/versioned/000018_add_message_knowledge_id.up.sql
new file mode 100644
index 00000000..d4c0b999
--- /dev/null
+++ b/migrations/versioned/000018_add_message_knowledge_id.up.sql
@@ -0,0 +1,9 @@
+-- Add knowledge_id column to messages table for linking messages to chat history knowledge base entries
+ALTER TABLE messages ADD COLUMN IF NOT EXISTS knowledge_id VARCHAR(36);
+CREATE INDEX IF NOT EXISTS idx_messages_knowledge_id ON messages(knowledge_id);
+
+-- Add chat_history_config JSONB column to tenants table
+ALTER TABLE tenants ADD COLUMN IF NOT EXISTS chat_history_config JSONB;
+
+-- Add retrieval_config JSONB column to tenants table
+ALTER TABLE tenants ADD COLUMN IF NOT EXISTS retrieval_config JSONB;