feat(memory-api): add end user management and enhance memory API endpoints

- Add end_user_controller with unauthenticated endpoint for creating end users
- Implement get_or_create_end_user logic to handle duplicate end users by other_id
- Register end_user_controller router in main controller initialization
- Add list_memory_configs endpoint to retrieve all workspace memory configurations
- Update MemoryWriteRequest and MemoryReadRequest to make config_id required field
- Refactor memory API endpoints to parse request body directly instead of using Body parameter
- Add CreateEndUserRequest and CreateEndUserResponse schemas for end user creation
- Add ListConfigsResponse schema for configs listing endpoint
- Remove unused config_id and llm_model_id parameters from Neo4j write operation
- Update .gitignore to exclude redbear-mem-metrics and pitch-deck directories

api/app/controllers/__init__.py

@@ -13,6 +13,7 @@ from . import (
     document_controller,
     emotion_config_controller,
     emotion_controller,
+    end_user_controller,
     file_controller,
     file_storage_controller,
     home_page_controller,
@@ -96,5 +97,6 @@ manager_router.include_router(file_storage_controller.router)
 manager_router.include_router(ontology_controller.router)
 manager_router.include_router(skill_controller.router)
 manager_router.include_router(i18n_controller.router)
+manager_router.include_router(end_user_controller.router)
 
 __all__ = ["manager_router"]

api/app/controllers/end_user_controller.py

@@ -0,0 +1,48 @@
+"""End User 管理接口 - 无需认证"""
+
+from app.core.logging_config import get_business_logger
+from app.core.response_utils import success
+from app.db import get_db
+from app.repositories.end_user_repository import EndUserRepository
+from app.schemas.memory_api_schema import (
+    CreateEndUserRequest,
+    CreateEndUserResponse,
+)
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+router = APIRouter(prefix="/end_users", tags=["End Users"])
+logger = get_business_logger()
+
+
+@router.post("")
+async def create_end_user(
+    data: CreateEndUserRequest,
+    db: Session = Depends(get_db),
+):
+    """
+    Create an end user.
+    
+    Creates a new end user for the given workspace.
+    If an end user with the same other_id already exists in the workspace,
+    returns the existing one.
+    """
+    logger.info(f"Create end user request - other_id: {data.other_id}, workspace_id: {data.workspace_id}")
+
+    end_user_repo = EndUserRepository(db)
+    end_user = end_user_repo.get_or_create_end_user(
+        app_id=None,
+        workspace_id=data.workspace_id,
+        other_id=data.other_id,
+    )
+
+    logger.info(f"End user ready: {end_user.id}")
+
+    result = {
+        "id": str(end_user.id),
+        "other_id": end_user.other_id or "",
+        "other_name": end_user.other_name or "",
+        "workspace_id": str(end_user.workspace_id),
+    }
+
+    return success(data=CreateEndUserResponse(**result).model_dump(), msg="End user created successfully")

api/app/controllers/service/memory_api_controller.py

@@ -6,6 +6,7 @@ from app.core.response_utils import success
 from app.db import get_db
 from app.schemas.api_key_schema import ApiKeyAuth
 from app.schemas.memory_api_schema import (
+    ListConfigsResponse,
     MemoryReadRequest,
     MemoryReadResponse,
     MemoryWriteRequest,
@@ -31,14 +32,15 @@ async def write_memory_api_service(
     request: Request,
     api_key_auth: ApiKeyAuth = None,
     db: Session = Depends(get_db),
-    payload: MemoryWriteRequest = Body(..., embed=False),
-
+    message: str = Body(..., description="Message content"),
 ):
     """
     Write memory to storage.
     
     Stores memory content for the specified end user using the Memory API Service.
     """
+    body = await request.json()
+    payload = MemoryWriteRequest(**body)
     logger.info(f"Memory write request - end_user_id: {payload.end_user_id}, workspace_id: {api_key_auth.workspace_id}")
     
     memory_api_service = MemoryAPIService(db)
@@ -62,13 +64,15 @@ async def read_memory_api_service(
     request: Request,
     api_key_auth: ApiKeyAuth = None,
     db: Session = Depends(get_db),
-    payload: MemoryReadRequest = Body(..., embed=False),
+    message: str = Body(..., description="Query message"),
 ):
     """
     Read memory from storage.
     
     Queries and retrieves memories for the specified end user with context-aware responses.
     """
+    body = await request.json()
+    payload = MemoryReadRequest(**body)
     logger.info(f"Memory read request - end_user_id: {payload.end_user_id}")
     
     memory_api_service = MemoryAPIService(db)
@@ -85,3 +89,27 @@ async def read_memory_api_service(
     
     logger.info(f"Memory read successful for end_user: {payload.end_user_id}")
     return success(data=MemoryReadResponse(**result).model_dump(), msg="Memory read successfully")
+
+
+@router.get("/configs")
+@require_api_key(scopes=["memory"])
+async def list_memory_configs(
+    request: Request,
+    api_key_auth: ApiKeyAuth = None,
+    db: Session = Depends(get_db),
+):
+    """
+    List all memory configs for the workspace.
+    
+    Returns all available memory configurations associated with the authorized workspace.
+    """
+    logger.info(f"List configs request - workspace_id: {api_key_auth.workspace_id}")
+
+    memory_api_service = MemoryAPIService(db)
+
+    result = memory_api_service.list_memory_configs(
+        workspace_id=api_key_auth.workspace_id,
+    )
+
+    logger.info(f"Listed {result['total']} configs for workspace: {api_key_auth.workspace_id}")
+    return success(data=ListConfigsResponse(**result).model_dump(), msg="Configs listed successfully")