Version: 0.9.74.dev.260505

后端：
1.阶段 6 memory 服务化 CP1-CP3 落地
- 新增 cmd/memory 独立进程入口，落地 services/memory dao/rpc/sv 与 memory zrpc pb
- 将 memory.extract.requested outbox 消费与 memory worker 迁入 cmd/memory，单体 worker 不再消费 memory outbox
- 新增 gateway/client/memory、shared/contracts/memory 和 shared/ports memory port
- 将 /api/v1/memory/items* HTTP 管理面切到 memory zrpc，gateway 只保留鉴权、限流、幂等、参数绑定和响应透传
- 新增 memory Retrieve RPC，并将 agent 主链路 memory reader 切到 memory zrpc 读取
- 补充 agent memory RPC reader 适配器，保留注入侧 observer / metrics 观测能力
- 保留旧 backend/memory 核心实现作为迁移期复用与回退面，cmd/memory 内部继续复用既有 Module / ReadService 逻辑
- 补充 memory.rpc 示例配置，更新单体 outbox 发布边界与 memory handler 注释口径

backend/cmd/memory/main.go

@@ -0,0 +1,138 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"syscall"
+
+	"github.com/LoveLosita/smartflow/backend/bootstrap"
+	kafkabus "github.com/LoveLosita/smartflow/backend/infra/kafka"
+	outboxinfra "github.com/LoveLosita/smartflow/backend/infra/outbox"
+	"github.com/LoveLosita/smartflow/backend/inits"
+	memorymodule "github.com/LoveLosita/smartflow/backend/memory"
+	memoryobserve "github.com/LoveLosita/smartflow/backend/memory/observe"
+	llmservice "github.com/LoveLosita/smartflow/backend/services/llm"
+	memorydao "github.com/LoveLosita/smartflow/backend/services/memory/dao"
+	memoryrpc "github.com/LoveLosita/smartflow/backend/services/memory/rpc"
+	memorysv "github.com/LoveLosita/smartflow/backend/services/memory/sv"
+	ragservice "github.com/LoveLosita/smartflow/backend/services/rag"
+	ragconfig "github.com/LoveLosita/smartflow/backend/services/rag/config"
+	"github.com/spf13/viper"
+)
+
+func main() {
+	if err := bootstrap.LoadConfig(); err != nil {
+		log.Fatalf("failed to load config: %v", err)
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	db, err := memorydao.OpenDBFromConfig()
+	if err != nil {
+		log.Fatalf("failed to connect memory database: %v", err)
+	}
+
+	llmClient, err := buildMemoryLLMClient()
+	if err != nil {
+		log.Fatalf("failed to initialize memory LLM client: %v", err)
+	}
+
+	ragRuntime, err := buildMemoryRAGRuntime(ctx)
+	if err != nil {
+		log.Fatalf("failed to initialize memory RAG runtime: %v", err)
+	}
+
+	memoryCfg := memorymodule.LoadConfigFromViper()
+	memoryObserver := memoryobserve.NewLoggerObserver(log.Default())
+	memoryMetrics := memoryobserve.NewMetricsRegistry()
+	module := memorymodule.NewModuleWithObserve(
+		db,
+		llmClient,
+		ragRuntime,
+		memoryCfg,
+		memorymodule.ObserveDeps{
+			Observer: memoryObserver,
+			Metrics:  memoryMetrics,
+		},
+	)
+
+	outboxRepo := outboxinfra.NewRepository(db)
+	svc, err := memorysv.NewService(memorysv.Options{
+		Module:      module,
+		OutboxRepo:  outboxRepo,
+		KafkaConfig: kafkabus.LoadConfig(),
+	})
+	if err != nil {
+		log.Fatalf("failed to initialize memory service: %v", err)
+	}
+	defer svc.Close()
+
+	svc.StartWorkers(ctx)
+
+	server, listenOn, err := memoryrpc.NewServer(memoryrpc.ServerOptions{
+		ListenOn: viper.GetString("memory.rpc.listenOn"),
+		Timeout:  viper.GetDuration("memory.rpc.timeout"),
+		Service:  svc,
+	})
+	if err != nil {
+		log.Fatalf("failed to build memory zrpc server: %v", err)
+	}
+	defer server.Stop()
+
+	go func() {
+		log.Printf("memory zrpc service starting on %s", listenOn)
+		server.Start()
+	}()
+
+	<-ctx.Done()
+	log.Println("memory service stopping")
+}
+
+// buildMemoryLLMClient 初始化 memory 抽取链路使用的模型客户端。
+//
+// 说明：
+// 1. CP1 先复用既有 llm-service canonical 入口，不在 memory 服务里重建模型调用封装；
+// 2. 当前启动入口与 cmd/start.go / cmd/active-scheduler 都需要 Eino 初始化，后续若出现第三处重复装配，应抽公共 bootstrap；
+// 3. 返回 ProClient 是因为现有 memory.Module 只需要 llmservice.Client，不需要完整 Service。
+func buildMemoryLLMClient() (*llmservice.Client, error) {
+	aiHub, err := inits.InitEino()
+	if err != nil {
+		return nil, err
+	}
+	llmService := llmservice.New(llmservice.Options{
+		AIHub:             aiHub,
+		APIKey:            os.Getenv("ARK_API_KEY"),
+		BaseURL:           viper.GetString("agent.baseURL"),
+		CourseVisionModel: viper.GetString("courseImport.visionModel"),
+	})
+	return llmService.ProClient(), nil
+}
+
+// buildMemoryRAGRuntime 初始化 memory 检索与向量同步使用的 RAG Runtime。
+//
+// 暂不抽公共层原因：
+// 1. 本轮只迁 memory 一个能力域，避免同时调整 cmd/start.go 的既有装配路径；
+// 2. RAG 的 canonical 入口已在 services/rag 内，当前函数只做启动层配置读取与日志包装；
+// 3. 等 agent 服务也迁出后，再统一评估 llm/rag 启动装配的公共 bootstrap。
+func buildMemoryRAGRuntime(ctx context.Context) (ragservice.Runtime, error) {
+	ragCfg := ragconfig.LoadFromViper()
+	if !ragCfg.Enabled {
+		log.Println("RAG service is disabled for memory")
+		return nil, nil
+	}
+
+	ragLogger := log.Default()
+	ragService, err := ragservice.NewFromConfig(ctx, ragCfg, ragservice.FactoryDeps{
+		Logger:   ragLogger,
+		Observer: ragservice.NewLoggerObserver(ragLogger),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("build memory RAG service failed: %w", err)
+	}
+	log.Printf("Memory RAG runtime initialized: store=%s embed=%s reranker=%s", ragCfg.Store, ragCfg.EmbedProvider, ragCfg.RerankerProvider)
+	return ragService.Runtime(), nil
+}

backend/cmd/start.go

@@ -16,6 +16,7 @@ import (
 	"github.com/LoveLosita/smartflow/backend/gateway/api"
 	gatewayactivescheduler "github.com/LoveLosita/smartflow/backend/gateway/client/activescheduler"
 	gatewaycourse "github.com/LoveLosita/smartflow/backend/gateway/client/course"
+	gatewaymemory "github.com/LoveLosita/smartflow/backend/gateway/client/memory"
 	gatewaynotification "github.com/LoveLosita/smartflow/backend/gateway/client/notification"
 	gatewayschedule "github.com/LoveLosita/smartflow/backend/gateway/client/schedule"
 	gatewaytask "github.com/LoveLosita/smartflow/backend/gateway/client/task"
@@ -114,7 +115,7 @@ func StartAPI() {
 }
 
 // StartWorker 只启动后台异步能力，不注册 Gin 路由。
-// 当前包含单体残留域 outbox relay / Kafka consumer / memory worker；主动调度扫描已迁到 cmd/active-scheduler。
+// 当前只包含单体残留域 agent outbox relay / Kafka consumer；memory worker 已迁到 cmd/memory。
 func StartWorker() {
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer stop()
@@ -202,10 +203,11 @@ func buildRuntime(ctx context.Context) (*appRuntime, error) {
 	agentRepo := dao.NewAgentDAO(db)
 	outboxRepo := outboxinfra.NewRepository(db)
 
-	eventBus, err := buildEventBus(outboxRepo)
+	eventBus, err := buildAgentEventBus(outboxRepo)
 	if err != nil {
 		return nil, err
 	}
+	eventPublisher := buildCoreOutboxPublisher(outboxRepo)
 
 	// Service 层初始化。
 	userAuthClient, err := gatewayuserauth.NewClient(gatewayuserauth.ClientConfig{
@@ -257,6 +259,14 @@ func buildRuntime(ctx context.Context) (*appRuntime, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to initialize course zrpc client: %w", err)
 	}
+	memoryClient, err := gatewaymemory.NewClient(gatewaymemory.ClientConfig{
+		Endpoints: viper.GetStringSlice("memory.rpc.endpoints"),
+		Target:    viper.GetString("memory.rpc.target"),
+		Timeout:   viper.GetDuration("memory.rpc.timeout"),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize memory zrpc client: %w", err)
+	}
 	activeSchedulerClient, err := gatewayactivescheduler.NewClient(gatewayactivescheduler.ClientConfig{
 		Endpoints: viper.GetStringSlice("activeScheduler.rpc.endpoints"),
 		Target:    viper.GetString("activeScheduler.rpc.target"),
@@ -280,7 +290,7 @@ func buildRuntime(ctx context.Context) (*appRuntime, error) {
 		agentCacheRepo,
 		manager.ActiveSchedule,
 		manager.ActiveScheduleSession,
-		eventBus,
+		eventPublisher,
 		scheduleService,
 		taskSv,
 	)
@@ -293,8 +303,10 @@ func buildRuntime(ctx context.Context) (*appRuntime, error) {
 		taskRepo,
 		taskClassRepo,
 		scheduleRepo,
-		memoryModule,
+		memoryClient,
 		memoryCfg,
+		memoryObserver,
+		memoryMetrics,
 	)
 
 	// 1. task_pool facts 已统一走 task RPC，避免聊天 rerun 继续直连 tasks 表；
@@ -333,7 +345,7 @@ func buildRuntime(ctx context.Context) (*appRuntime, error) {
 		return nil, err
 	}
 	agentService.SetActiveScheduleSessionRerunFunc(buildActiveScheduleSessionRerunFunc(manager.ActiveSchedule, activeScheduleGraphRunner, activeSchedulePreviewConfirm, activeScheduleFeedbackLocator))
-	handlers := buildAPIHandlers(taskClient, taskClassClient, courseClient, scheduleClient, agentService, memoryModule, activeSchedulerClient, notificationClient)
+	handlers := buildAPIHandlers(taskClient, taskClassClient, courseClient, scheduleClient, agentService, memoryClient, activeSchedulerClient, notificationClient)
 
 	runtime := &appRuntime{
 		db:          db,
@@ -380,21 +392,19 @@ func buildRAGService(ctx context.Context) (*ragservice.Service, error) {
 	return ragService, nil
 }
 
-func buildEventBus(outboxRepo *outboxinfra.Repository) (eventsvc.OutboxBus, error) {
-	// outbox 多 service 门面装配：
-	// 1. 按 service 维度创建独立 engine，topic / group 由 service 名称推导；
-	// 2. 对外仍然只暴露一个 Publish / Start / Close 门面；
-	// 3. kafka.enabled=false 时返回 nil，业务按既有降级策略执行。
+func buildAgentEventBus(outboxRepo *outboxinfra.Repository) (eventsvc.OutboxBus, error) {
+	// agent outbox 消费边界装配：
+	// 1. 单体残留在 CP1 后只消费 agent 自己的 outbox；
+	// 2. memory.extract.requested 仍可被发布到 memory_outbox_messages，但消费与 worker 已迁往 cmd/memory；
+	// 3. kafka.enabled=false 时返回 nil，业务按既有同步降级策略执行。
 	kafkaCfg := kafkabus.LoadConfig()
-	serviceBuses := make(map[string]eventsvc.OutboxBus, len(eventsvc.OutboxServiceNames()))
-	for _, serviceName := range eventsvc.OutboxServiceNames() {
-		bus, err := eventsvc.NewServiceOutboxBus(outboxRepo, kafkaCfg, serviceName)
-		if err != nil {
-			return nil, fmt.Errorf("failed to initialize outbox event bus for service %s: %w", serviceName, err)
-		}
-		if bus != nil {
-			serviceBuses[serviceName] = bus
-		}
+	bus, err := eventsvc.NewServiceOutboxBus(outboxRepo, kafkaCfg, outboxinfra.ServiceAgent)
+	if err != nil {
+		return nil, fmt.Errorf("failed to initialize outbox event bus for service %s: %w", outboxinfra.ServiceAgent, err)
+	}
+	serviceBuses := make(map[string]eventsvc.OutboxBus, 1)
+	if bus != nil {
+		serviceBuses[outboxinfra.ServiceAgent] = bus
 	}
 
 	eventBus := eventsvc.NewRoutedOutboxBus(serviceBuses)
@@ -404,6 +414,23 @@ func buildEventBus(outboxRepo *outboxinfra.Repository) (eventsvc.OutboxBus, erro
 	return eventBus, nil
 }
 
+// buildCoreOutboxPublisher 构造单体残留发布器。
+//
+// 职责边界：
+// 1. 只负责把 agent 主链路产生的跨服务事件写入对应服务 outbox 表；
+// 2. 不创建 memory consumer / relay，memory 消费边界已迁往 cmd/memory；
+// 3. kafka.enabled=false 时返回 nil，让聊天历史继续走同步 DB fallback。
+func buildCoreOutboxPublisher(outboxRepo *outboxinfra.Repository) outboxinfra.EventPublisher {
+	kafkaCfg := kafkabus.LoadConfig()
+	if !kafkaCfg.Enabled || outboxRepo == nil {
+		return nil
+	}
+	return &repositoryOutboxPublisher{
+		repo:     outboxRepo,
+		maxRetry: kafkaCfg.MaxRetry,
+	}
+}
+
 type repositoryOutboxPublisher struct {
 	repo     *outboxinfra.Repository
 	maxRetry int
@@ -429,12 +456,12 @@ func buildTaskOutboxPublisher(outboxRepo *outboxinfra.Repository) outboxinfra.Ev
 // Publish 以 publish-only 方式写入服务级 outbox。
 //
 // 说明：
-// 1. 这里不复用 outbox EventBus，是因为 EventBus 会创建并启动对应 service engine；
-// 2. 单体残留只允许发布 task 事件，不允许启动 task consumer，否则会和 cmd/task 抢同一 consumer group；
-// 3. payload 仍包装成统一 OutboxEventPayload，确保 cmd/task relay / consumer 能按标准协议解析。
+// 1. 这里不复用 outbox EventBus，是因为 EventBus 会创建并可能启动对应 service engine；
+// 2. 单体残留在 task / memory 等迁移期只允许发布跨服务事件，不允许抢对应 consumer group；
+// 3. payload 仍包装成统一 OutboxEventPayload，确保独立服务 relay / consumer 能按标准协议解析。
 func (p *repositoryOutboxPublisher) Publish(ctx context.Context, req outboxinfra.PublishRequest) error {
 	if p == nil || p.repo == nil {
-		return fmt.Errorf("task outbox publisher is not initialized")
+		return fmt.Errorf("outbox publisher is not initialized")
 	}
 
 	eventType := strings.TrimSpace(req.EventType)
@@ -746,8 +773,10 @@ func configureAgentService(
 	taskRepo *dao.TaskDAO,
 	taskClassRepo *dao.TaskClassDAO,
 	scheduleRepo *dao.ScheduleDAO,
-	memoryModule *memory.Module,
+	memoryReaderClient ports.MemoryReaderClient,
 	memoryCfg memorymodel.Config,
+	memoryObserver memoryobserve.Observer,
+	memoryMetrics memoryobserve.MetricsRecorder,
 ) {
 	if agentService == nil {
 		return
@@ -790,7 +819,11 @@ func configureAgentService(
 		CreateTask: buildQuickTaskCreateFunc(taskRepo),
 		QueryTasks: buildQuickTaskQueryFunc(agentService),
 	})
-	agentService.SetMemoryReader(memoryModule, memoryCfg)
+	// 1. agent 主链路读取记忆统一走 memory zrpc，避免 CP3 后继续直连本进程 memory.Module；
+	// 2. observer / metrics 继续复用启动期装配，保证注入侧观测在 RPC 切流后不丢；
+	// 3. 旧 memoryModule 仍保留在启动图中，作为迁移期依赖和后续回退面；
+	// 4. memory 服务暂不可用时，预取链路只记录警告并软降级，不阻断聊天主流程。
+	agentService.SetMemoryReader(agentsvcsvc.NewMemoryRPCReader(memoryReaderClient, memoryObserver, memoryMetrics), memoryCfg)
 }
 
 func buildTaskClassUpsertFunc(taskClassRepo *dao.TaskClassDAO) func(userID int, input newagenttools.TaskClassUpsertInput) (newagenttools.TaskClassUpsertPersistResult, error) {
@@ -926,7 +959,7 @@ func buildAPIHandlers(
 	courseClient ports.CourseCommandClient,
 	scheduleClient ports.ScheduleCommandClient,
 	agentService *service.AgentService,
-	memoryModule *memory.Module,
+	memoryClient ports.MemoryCommandClient,
 	activeSchedulerClient ports.ActiveSchedulerCommandClient,
 	notificationClient ports.NotificationCommandClient,
 ) *api.ApiHandlers {
@@ -936,7 +969,7 @@ func buildAPIHandlers(
 		CourseHandler:    api.NewCourseHandler(courseClient),
 		ScheduleHandler:  api.NewScheduleAPI(scheduleClient),
 		AgentHandler:     api.NewAgentHandler(agentService),
-		MemoryHandler:    api.NewMemoryHandler(memoryModule),
+		MemoryHandler:    api.NewMemoryHandler(memoryClient),
 		ActiveSchedule:   api.NewActiveScheduleAPI(activeSchedulerClient),
 		Notification:     api.NewNotificationAPI(notificationClient),
 	}
@@ -953,10 +986,7 @@ func (r *appRuntime) startWorkers(ctx context.Context) {
 	} else {
 		log.Println("Outbox event bus is disabled")
 	}
-
-	if r.memoryModule != nil {
-		r.memoryModule.StartWorker(ctx)
-	}
+	log.Println("Memory worker is managed by cmd/memory in phase 6 CP1")
 }
 
 func (r *appRuntime) registerEventHandlers() error {