Add brain memory services and APIs

Introduce the backend pieces for brain memory ingestion, routing, and
system telemetry so the new knowledge workflows can project data into a
brain view. The supporting tests lock in the new behavior and keep the
expanded backend surface stable.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

backend/app/routers/__init__.py

@@ -10,3 +10,5 @@ from app.routers.settings import router as settings_router
 from app.routers.folder import router as folder_router
 from app.routers.skill import router as skill_router
 from app.routers.log import router as log_router
+from app.routers.system import router as system_router
+from app.routers.brain import router as brain_router

backend/app/routers/brain.py

@@ -0,0 +1,61 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models.user import User
+from app.routers.auth import get_current_user
+from app.schemas.brain import (
+    BrainEventOut,
+    BrainLearnRunOut,
+    BrainMemoryOut,
+    BrainOverviewOut,
+    BrainTagGroupsOut,
+)
+from app.services.brain_service import BrainService
+
+router = APIRouter(prefix="/api/brain", tags=["知识大脑"])
+
+
+@router.get("/overview", response_model=BrainOverviewOut)
+async def get_brain_overview(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    service = BrainService(db)
+    return await service.get_overview(current_user.id)
+
+
+@router.get("/memories", response_model=list[BrainMemoryOut])
+async def list_brain_memories(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    service = BrainService(db)
+    return await service.list_memories(current_user.id)
+
+
+@router.get("/tags", response_model=BrainTagGroupsOut)
+async def list_brain_tags(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    service = BrainService(db)
+    return await service.list_tags(current_user.id)
+
+
+@router.get("/events", response_model=list[BrainEventOut])
+async def list_brain_events(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    service = BrainService(db)
+    return await service.list_events(current_user.id)
+
+
+@router.post("/learn/run", response_model=BrainLearnRunOut)
+async def run_brain_learning(
+    current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
+):
+    service = BrainService(db)
+    return await service.run_learning(current_user.id)

backend/app/routers/conversation.py

@@ -92,11 +92,12 @@ async def chat(
 ):
     """简单版对话（非流式）"""
     agent_svc = AgentService(db)
-    conv_id, msg_id, content = await agent_svc.chat_simple(
+    conv_id, msg_id, content, model_name = await agent_svc.chat_simple(
         user_id=current_user.id,
         message=data.message,
         conversation_id=data.conversation_id,
         file_ids=data.file_ids,
+        model_name=data.model_name,
     )
 
     # 更新对话消息计数
@@ -111,6 +112,7 @@ async def chat(
         message_id=msg_id,
         content=content,
         agent_name="jarvis",
+        model_name=model_name,
     )
 
 
@@ -128,24 +130,24 @@ async def chat_stream(
             user_id=current_user.id,
             message=data.message,
             conversation_id=data.conversation_id,
+            file_ids=data.file_ids,
+            model_name=data.model_name,
         )
 
-        # 先发送元数据
         yield f"event: metadata\ndata: {json.dumps({'conversation_id': conv_id, 'message_id': msg_id})}\n\n"
 
-        # 流式发送内容
-        collected = ""
         try:
-            async for chunk in stream:
-                if chunk:
-                    collected += chunk
-                    yield f"event: chunk\ndata: {json.dumps({'content': chunk})}\n\n"
-
-            # 更新数据库中的消息
-            await agent_svc.save_response(msg_id, collected)
-
+            async for event in stream:
+                event_type = event.get('type', 'progress')
+                if event_type == 'chunk':
+                    yield f"event: chunk\ndata: {json.dumps({'content': event.get('content', '')}, ensure_ascii=False)}\n\n"
+                elif event_type == 'error':
+                    yield f"event: error\ndata: {json.dumps({'error': event.get('error', '未知错误')}, ensure_ascii=False)}\n\n"
+                else:
+                    payload = {k: v for k, v in event.items() if k != 'type'}
+                    yield f"event: progress\ndata: {json.dumps(payload, ensure_ascii=False)}\n\n"
         except Exception as e:
-            yield f"event: error\ndata: {json.dumps({'error': str(e)})}\n\n"
+            yield f"event: error\ndata: {json.dumps({'error': str(e)}, ensure_ascii=False)}\n\n"
         finally:
             yield f"event: done\ndata: {json.dumps({'message_id': msg_id})}\n\n"
 

backend/app/routers/folder.py

@@ -6,7 +6,7 @@ from app.database import get_db
 from app.models.folder import Folder
 from app.models.user import User
 from app.schemas.folder import FolderCreate, FolderUpdate, FolderOut, FolderTreeOut
-from app.services.auth_service import get_current_user
+from app.routers.auth import get_current_user
 
 router = APIRouter(prefix="/api/folders", tags=["文件夹"])
 

backend/app/routers/settings.py

@@ -1,4 +1,6 @@
-from fastapi import APIRouter, Depends, HTTPException
+import logging
+import time
+from fastapi import APIRouter, Depends, HTTPException, Request
 from sqlalchemy.ext.asyncio import AsyncSession
 from app.database import get_db
 from app.models.user import User
@@ -6,22 +8,40 @@ from app.routers.auth import get_current_user
 from app.schemas.settings import (
     SettingsOut, ProfileUpdateIn, LLMConfigIn, SchedulerConfigIn, LLMTestIn
 )
+from app.services.log_service import LogService
 from app.services.settings_service import (
     get_user_settings, update_user_profile, update_llm_config,
     update_scheduler_config, test_llm_connection
 )
+from app.logging_utils import summarize_llm_config
+
+logger = logging.getLogger(__name__)
 
 router = APIRouter(prefix="/api/settings", tags=["设置"])
 
 
 @router.get("", response_model=SettingsOut)
 async def get_settings(
+    request: Request,
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
+    request.state.user_id = current_user.id
     settings = await get_user_settings(current_user.id, db)
     if not settings:
         raise HTTPException(status_code=404, detail="用户不存在")
+
+    await LogService(db).system_log(
+        message="加载用户设置",
+        source="settings",
+        user_id=current_user.id,
+        request_id=request.state.request_id,
+        route=request.url.path,
+        method=request.method,
+        status_code=200,
+        operation="settings.get",
+        details={"llm_config": summarize_llm_config(settings.get("llm_config"))},
+    )
     return settings
 
 
@@ -46,42 +66,128 @@ async def update_profile(
 @router.put("/llm")
 async def update_llm(
     data: LLMConfigIn,
+    request: Request,
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
+    request.state.user_id = current_user.id
+    log_service = LogService(db)
+    start = time.perf_counter()
+    payload = data.model_dump(exclude_none=True)
     try:
-        config = await update_llm_config(current_user.id, data.model_dump(exclude_none=True), db)
+        config = await update_llm_config(current_user.id, payload, db)
+        await log_service.system_log(
+            message="更新 LLM 配置成功",
+            source="settings",
+            user_id=current_user.id,
+            request_id=request.state.request_id,
+            route=request.url.path,
+            method=request.method,
+            status_code=200,
+            operation="settings.update_llm",
+            duration_ms=int((time.perf_counter() - start) * 1000),
+            details={
+                "request": summarize_llm_config(payload),
+                "stored": summarize_llm_config(config),
+            },
+        )
         return {"llm_config": config}
     except ValueError as e:
+        await log_service.system_log(
+            message="更新 LLM 配置失败",
+            level="warning",
+            source="settings",
+            user_id=current_user.id,
+            request_id=request.state.request_id,
+            route=request.url.path,
+            method=request.method,
+            status_code=400,
+            error_type=e.__class__.__name__,
+            operation="settings.update_llm",
+            duration_ms=int((time.perf_counter() - start) * 1000),
+            details={"request": summarize_llm_config(payload), "detail": str(e)},
+        )
         raise HTTPException(status_code=400, detail=str(e))
 
 
 @router.post("/llm/test")
 async def test_llm(
     data: LLMTestIn,
+    request: Request,
     current_user: User = Depends(get_current_user),
+    db: AsyncSession = Depends(get_db),
 ):
+    request.state.user_id = current_user.id
+    start = time.perf_counter()
     result = await test_llm_connection(
         provider=data.provider,
         model=data.model,
         base_url=data.base_url,
         api_key=data.api_key
     )
+    await LogService(db).system_log(
+        message="测试 LLM 连接",
+        level="info" if result.get("success") else "warning",
+        source="settings",
+        user_id=current_user.id,
+        request_id=request.state.request_id,
+        route=request.url.path,
+        method=request.method,
+        status_code=200,
+        error_type=None if result.get("success") else "llm_test_failed",
+        operation="settings.test_llm",
+        duration_ms=int((time.perf_counter() - start) * 1000),
+        details={
+            "provider": data.provider,
+            "model": data.model,
+            "has_base_url": bool(data.base_url),
+            "has_api_key": bool(data.api_key),
+            "success": result.get("success"),
+            "error": result.get("error"),
+        },
+    )
     return result
 
 
 @router.put("/scheduler")
 async def update_scheduler(
     data: SchedulerConfigIn,
+    request: Request,
     current_user: User = Depends(get_current_user),
     db: AsyncSession = Depends(get_db),
 ):
+    request.state.user_id = current_user.id
+    payload = data.model_dump(exclude_none=True)
     try:
         config = await update_scheduler_config(
             current_user.id,
-            data.model_dump(exclude_none=True),
+            payload,
             db
         )
+        await LogService(db).system_log(
+            message="更新调度配置成功",
+            source="settings",
+            user_id=current_user.id,
+            request_id=request.state.request_id,
+            route=request.url.path,
+            method=request.method,
+            status_code=200,
+            operation="settings.update_scheduler",
+            details={"request": payload, "stored": config},
+        )
         return {"scheduler_config": config}
     except ValueError as e:
+        await LogService(db).system_log(
+            message="更新调度配置失败",
+            level="warning",
+            source="settings",
+            user_id=current_user.id,
+            request_id=request.state.request_id,
+            route=request.url.path,
+            method=request.method,
+            status_code=400,
+            error_type=e.__class__.__name__,
+            operation="settings.update_scheduler",
+            details={"request": payload, "detail": str(e)},
+        )
         raise HTTPException(status_code=400, detail=str(e))

backend/app/routers/system.py

@@ -0,0 +1,9 @@
+from fastapi import APIRouter
+from app.services.system_service import SystemService
+
+router = APIRouter(prefix='/api/system', tags=['system'])
+
+
+@router.get('/status')
+async def get_system_status():
+    return SystemService().get_status()