Files
Enterprise-Knowledge-Base/internal/application/service/agent_service.go
T
wizardchen 9f6b903ef2 feat: Integrate LLM-based reranking in KnowledgeSearchTool
- Added optional chat model to KnowledgeSearchTool for enhanced reranking using LLM prompt scoring.
- Updated rerankResults method to prioritize LLM-based reranking over traditional rerank model.
- Implemented new functions for LLM scoring and parsing scores from responses, improving search result relevance.
- Enhanced migration script to handle database versioning and dirty state checks more robustly.
2025-11-13 01:22:08 +08:00

336 lines
10 KiB
Go

package service
import (
"context"
"fmt"
"github.com/Tencent/WeKnora/internal/agent"
"github.com/Tencent/WeKnora/internal/agent/tools"
"github.com/Tencent/WeKnora/internal/config"
"github.com/Tencent/WeKnora/internal/event"
"github.com/Tencent/WeKnora/internal/logger"
"github.com/Tencent/WeKnora/internal/mcp"
"github.com/Tencent/WeKnora/internal/models/chat"
"github.com/Tencent/WeKnora/internal/models/rerank"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"gorm.io/gorm"
)
const MAX_ITERATIONS = 30 // Max iterations for agent execution
// agentService implements agent-related business logic
type agentService struct {
cfg *config.Config
modelService interfaces.ModelService
knowledgeBaseService interfaces.KnowledgeBaseService
knowledgeService interfaces.KnowledgeService
chunkService interfaces.ChunkService
mcpServiceService interfaces.MCPServiceService
mcpManager *mcp.MCPManager
eventBus *event.EventBus
db *gorm.DB
webSearchService interfaces.WebSearchService
}
// NewAgentService creates a new agent service
func NewAgentService(
cfg *config.Config,
modelService interfaces.ModelService,
knowledgeBaseService interfaces.KnowledgeBaseService,
knowledgeService interfaces.KnowledgeService,
chunkService interfaces.ChunkService,
mcpServiceService interfaces.MCPServiceService,
mcpManager *mcp.MCPManager,
eventBus *event.EventBus,
db *gorm.DB,
webSearchService interfaces.WebSearchService,
) interfaces.AgentService {
return &agentService{
cfg: cfg,
modelService: modelService,
knowledgeBaseService: knowledgeBaseService,
knowledgeService: knowledgeService,
chunkService: chunkService,
mcpServiceService: mcpServiceService,
mcpManager: mcpManager,
eventBus: eventBus,
db: db,
webSearchService: webSearchService,
}
}
// CreateAgentEngineWithEventBus creates an agent engine with the given configuration and EventBus
func (s *agentService) CreateAgentEngine(
ctx context.Context,
config *types.AgentConfig,
eventBus *event.EventBus,
contextManager interfaces.ContextManager,
sessionID string,
sessionService interfaces.SessionService,
) (interfaces.AgentEngine, error) {
logger.Infof(ctx, "Creating agent engine with custom EventBus")
// Validate config
if err := s.ValidateConfig(config); err != nil {
return nil, fmt.Errorf("invalid agent config: %w", err)
}
chatModel, err := s.modelService.GetChatModel(ctx, config.ThinkingModelID)
if err != nil {
return nil, fmt.Errorf("failed to get thinking model: %w", err)
}
if chatModel == nil {
return nil, fmt.Errorf("chat model is nil after initialization")
}
rerankModel, err := s.modelService.GetRerankModel(ctx, config.RerankModelID)
if err != nil {
return nil, fmt.Errorf("failed to get rerank model: %w", err)
}
if rerankModel == nil {
return nil, fmt.Errorf("rerank model is nil after initialization")
}
// Create tool registry
toolRegistry := tools.NewToolRegistry(s.knowledgeBaseService, s.knowledgeService, s.chunkService, s.db)
// Register tools
if err := s.registerTools(ctx, toolRegistry, config, rerankModel, chatModel, sessionID, sessionService); err != nil {
return nil, fmt.Errorf("failed to register tools: %w", err)
}
// Register MCP tools from enabled services for this tenant
tenantID := uint(0)
if tid, ok := ctx.Value(types.TenantIDContextKey).(uint); ok {
tenantID = tid
}
if tenantID > 0 && s.mcpServiceService != nil && s.mcpManager != nil {
// Get enabled MCP services for this tenant
mcpServices, err := s.mcpServiceService.ListMCPServices(ctx, tenantID)
if err != nil {
logger.Warnf(ctx, "Failed to list MCP services: %v", err)
} else {
// Filter enabled services
enabledServices := make([]*types.MCPService, 0)
for _, svc := range mcpServices {
if svc.Enabled {
enabledServices = append(enabledServices, svc)
}
}
// Register MCP tools
if len(enabledServices) > 0 {
if err := tools.RegisterMCPTools(ctx, toolRegistry, enabledServices, s.mcpManager); err != nil {
logger.Warnf(ctx, "Failed to register MCP tools: %v", err)
} else {
logger.Infof(ctx, "Registered MCP tools from %d enabled services", len(enabledServices))
}
}
}
}
// Get knowledge base detailed information for prompt
kbInfos, err := s.getKnowledgeBaseInfos(ctx, config.KnowledgeBases)
if err != nil {
logger.Warnf(ctx, "Failed to get knowledge base details, using IDs only: %v", err)
// Create fallback info with IDs only
kbInfos = make([]*agent.KnowledgeBaseInfo, 0, len(config.KnowledgeBases))
for _, kbID := range config.KnowledgeBases {
kbInfos = append(kbInfos, &agent.KnowledgeBaseInfo{
ID: kbID,
Name: kbID, // Use ID as name when details unavailable
Description: "",
DocCount: 0,
})
}
}
systemPromptTemplate := agent.DefaultSystemPromptTemplate
if config.UseCustomSystemPrompt && config.SystemPrompt != "" {
systemPromptTemplate = config.SystemPrompt
}
// Create engine with provided EventBus and contextManager
engine := agent.NewAgentEngine(
config,
chatModel,
toolRegistry,
s.knowledgeBaseService,
eventBus,
kbInfos,
contextManager,
sessionID,
systemPromptTemplate,
)
return engine, nil
}
// registerTools registers tools based on the agent configuration
func (s *agentService) registerTools(
ctx context.Context,
registry *tools.ToolRegistry,
config *types.AgentConfig,
rerankModel rerank.Reranker,
chatModel chat.Chat,
sessionID string,
sessionService interfaces.SessionService,
) error {
// If no specific tools allowed, register default tools
allowedTools := config.AllowedTools
if len(allowedTools) == 0 {
// Register default tools from config
if s.cfg.Agent != nil && len(s.cfg.Agent.DefaultTools) > 0 {
allowedTools = s.cfg.Agent.DefaultTools
}
}
// If web search is enabled, add web_search to allowedTools
if config.WebSearchEnabled {
allowedTools = append(allowedTools, "web_search")
allowedTools = append(allowedTools, "web_fetch")
}
// Get tenant ID from context
tenantID := uint(0)
if tid, ok := ctx.Value(types.TenantIDContextKey).(uint); ok {
tenantID = tid
}
logger.Infof(ctx, "Registering tools: %v, tenant ID: %d, webSearchEnabled: %v", allowedTools, tenantID, config.WebSearchEnabled)
// Register each allowed tool
for _, toolName := range allowedTools {
switch toolName {
case "thinking":
registry.RegisterTool(tools.NewSequentialThinkingTool())
case "todo_write":
registry.RegisterTool(tools.NewTodoWriteTool())
case "knowledge_search":
registry.RegisterTool(tools.NewKnowledgeSearchTool(s.knowledgeBaseService, tenantID, config.KnowledgeBases, rerankModel, chatModel))
case "get_related_chunks":
registry.RegisterTool(tools.NewGetRelatedChunksTool(s.chunkService, s.knowledgeBaseService))
case "query_knowledge_graph":
registry.RegisterTool(tools.NewQueryKnowledgeGraphTool(s.knowledgeBaseService))
case "get_document_info":
registry.RegisterTool(tools.NewGetDocumentInfoTool(s.knowledgeService, s.chunkService))
case "database_query":
registry.RegisterTool(tools.NewDatabaseQueryTool(s.db, tenantID))
case "web_search":
registry.RegisterTool(tools.NewWebSearchTool(
s.webSearchService,
s.knowledgeBaseService,
s.knowledgeService,
sessionService,
sessionID,
config.WebSearchMaxResults,
))
logger.Infof(ctx, "Registered web_search tool for session: %s, maxResults: %d", sessionID, config.WebSearchMaxResults)
case "web_fetch":
registry.RegisterTool(tools.NewWebFetchTool(chatModel))
logger.Infof(ctx, "Registered web_fetch tool for session: %s", sessionID)
default:
logger.Warnf(ctx, "Unknown tool: %s", toolName)
}
}
logger.Infof(ctx, "Registered %d tools", len(registry.ListTools()))
return nil
}
// ValidateConfig validates the agent configuration
func (s *agentService) ValidateConfig(config *types.AgentConfig) error {
if config == nil {
return fmt.Errorf("config cannot be nil")
}
if !config.Enabled {
return fmt.Errorf("agent is not enabled")
}
if config.MaxIterations <= 0 {
config.MaxIterations = 5 // Default
}
if config.MaxIterations > MAX_ITERATIONS {
return fmt.Errorf("max iterations too high: %d (max %d)", config.MaxIterations, MAX_ITERATIONS)
}
if config.ThinkingModelID == "" {
return fmt.Errorf("ThinkingModelID is required but not set")
}
return nil
}
// getKnowledgeBaseInfos retrieves detailed information for knowledge bases
func (s *agentService) getKnowledgeBaseInfos(ctx context.Context, kbIDs []string) ([]*agent.KnowledgeBaseInfo, error) {
if len(kbIDs) == 0 {
return []*agent.KnowledgeBaseInfo{}, nil
}
kbInfos := make([]*agent.KnowledgeBaseInfo, 0, len(kbIDs))
for _, kbID := range kbIDs {
// Get knowledge base details
kb, err := s.knowledgeBaseService.GetKnowledgeBaseByID(ctx, kbID)
if err != nil {
logger.Warnf(ctx, "Failed to get knowledge base %s: %v", kbID, err)
// Add fallback info
kbInfos = append(kbInfos, &agent.KnowledgeBaseInfo{
ID: kbID,
Name: kbID,
Description: "",
DocCount: 0,
RecentDocs: []agent.RecentDocInfo{},
})
continue
}
// Get document count and recent documents
docCount := 0
recentDocs := []agent.RecentDocInfo{}
// Get recent documents using paged query (first 10, assumed to be sorted by created_at desc)
pageResult, err := s.knowledgeService.ListPagedKnowledgeByKnowledgeBaseID(ctx, kbID, &types.Pagination{
Page: 1,
PageSize: 10,
})
if err == nil && pageResult != nil {
docCount = int(pageResult.Total)
// Convert to Knowledge slice
if knowledges, ok := pageResult.Data.([]*types.Knowledge); ok {
for _, k := range knowledges {
if len(recentDocs) >= 10 {
break
}
recentDocs = append(recentDocs, agent.RecentDocInfo{
KnowledgeID: k.ID,
Title: k.Title,
Description: k.Description,
FileName: k.FileName,
Type: k.FileType,
CreatedAt: k.CreatedAt.Format("2006-01-02"),
FileSize: k.FileSize,
})
}
}
}
kbInfos = append(kbInfos, &agent.KnowledgeBaseInfo{
ID: kb.ID,
Name: kb.Name,
Description: kb.Description,
DocCount: docCount,
RecentDocs: recentDocs,
})
}
return kbInfos, nil
}