feat(memory): integrate mem0 long-term memory for Chat Shell

backend/app/api/api.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from app.api.endpoints import admin, auth, oidc, quota, repository, users
+from app.api.endpoints import admin, auth, memory, oidc, quota, repository, users
 from app.api.endpoints.adapter import (
     agents,
     attachments,
@@ -34,4 +34,5 @@
 api_router.include_router(executors.router, prefix="/executors", tags=["executors"])
 api_router.include_router(quota.router, prefix="/quota", tags=["quota"])
 api_router.include_router(dify.router, prefix="/dify", tags=["dify"])
+api_router.include_router(memory.router, prefix="/memories", tags=["memories"])
 api_router.include_router(k_router)

backend/app/api/endpoints/adapter/chat.py

@@ -558,6 +558,7 @@ async def generate_with_ids():
             message=final_message,
             model_config=model_config,
             system_prompt=system_prompt,
+            user_id=current_user.id,
         )
 
         # Forward the stream

backend/app/api/endpoints/memory.py

@@ -0,0 +1,256 @@
+# SPDX-FileCopyrightText: 2025 WeCode-AI, Inc.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Memory management API endpoints.
+
+Provides endpoints for managing user long-term memories stored in mem0.
+"""
+
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+
+from app.core import security
+from app.models.user import User
+from app.services.chat.memory_service import memory_service
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class MemoryResponse(BaseModel):
+    """Response model for a single memory."""
+
+    id: str
+    content: str
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+
+class MemoryListResponse(BaseModel):
+    """Response model for memory list."""
+
+    memories: list[MemoryResponse]
+    total: int
+
+
+class UpdateMemoryRequest(BaseModel):
+    """Request model for updating a memory."""
+
+    content: str
+
+
+@router.get("")
+async def get_memories(
+    keyword: Optional[str] = None,
+    current_user: User = Depends(security.get_current_user),
+) -> MemoryListResponse:
+    """
+    Get all memories for the current user.
+
+    Args:
+        keyword: Optional keyword to search/filter memories
+
+    Returns:
+        List of user's memories
+    """
+    if not memory_service.is_configured:
+        return MemoryListResponse(memories=[], total=0)
+
+    try:
+        if keyword:
+            # Search memories by keyword
+            raw_memories = await memory_service.search_memories(
+                user_id=current_user.id,
+                query=keyword,
+                limit=100,
+            )
+        else:
+            # Get all memories
+            raw_memories = await memory_service.get_all_memories(
+                user_id=current_user.id,
+            )
+
+        # Transform to response format
+        memories = []
+        for mem in raw_memories:
+            memory_id = mem.get("id", mem.get("memory_id", ""))
+            content = mem.get("memory", mem.get("text", mem.get("content", "")))
+            created_at = mem.get("created_at", mem.get("createdAt"))
+            updated_at = mem.get("updated_at", mem.get("updatedAt"))
+
+            if memory_id and content:
+                memories.append(MemoryResponse(
+                    id=str(memory_id),
+                    content=content,
+                    created_at=str(created_at) if created_at else None,
+                    updated_at=str(updated_at) if updated_at else None,
+                ))
+
+        return MemoryListResponse(memories=memories, total=len(memories))
+
+    except Exception as e:
+        logger.error(f"Error fetching memories for user {current_user.id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch memories")
+
+
+@router.get("/{memory_id}")
+async def get_memory(
+    memory_id: str,
+    current_user: User = Depends(security.get_current_user),
+) -> MemoryResponse:
+    """
+    Get a single memory by ID.
+
+    Args:
+        memory_id: Memory ID
+
+    Returns:
+        Memory details
+    """
+    if not memory_service.is_configured:
+        raise HTTPException(status_code=404, detail="Memory service not configured")
+
+    try:
+        mem = await memory_service.get_memory(memory_id)
+
+        if not mem:
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        # Verify ownership by checking user_id
+        mem_user_id = mem.get("user_id", "")
+        if str(mem_user_id) != str(current_user.id):
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        content = mem.get("memory", mem.get("text", mem.get("content", "")))
+        created_at = mem.get("created_at", mem.get("createdAt"))
+        updated_at = mem.get("updated_at", mem.get("updatedAt"))
+
+        return MemoryResponse(
+            id=memory_id,
+            content=content,
+            created_at=str(created_at) if created_at else None,
+            updated_at=str(updated_at) if updated_at else None,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error fetching memory {memory_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to fetch memory")
+
+
+@router.put("/{memory_id}")
+async def update_memory(
+    memory_id: str,
+    request: UpdateMemoryRequest,
+    current_user: User = Depends(security.get_current_user),
+) -> MemoryResponse:
+    """
+    Update a memory's content.
+
+    Args:
+        memory_id: Memory ID
+        request: Update request with new content
+
+    Returns:
+        Updated memory
+    """
+    if not memory_service.is_configured:
+        raise HTTPException(status_code=404, detail="Memory service not configured")
+
+    try:
+        # First verify the memory exists and belongs to this user
+        existing = await memory_service.get_memory(memory_id)
+        if not existing:
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        mem_user_id = existing.get("user_id", "")
+        if str(mem_user_id) != str(current_user.id):
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        # Update the memory
+        result = await memory_service.update_memory(memory_id, request.content)
+
+        if not result:
+            raise HTTPException(status_code=500, detail="Failed to update memory")
+
+        # Return updated memory
+        created_at = result.get("created_at", existing.get("created_at"))
+        updated_at = result.get("updated_at", result.get("updatedAt"))
+
+        return MemoryResponse(
+            id=memory_id,
+            content=request.content,
+            created_at=str(created_at) if created_at else None,
+            updated_at=str(updated_at) if updated_at else None,
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating memory {memory_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to update memory")
+
+
+@router.delete("/{memory_id}")
+async def delete_memory(
+    memory_id: str,
+    current_user: User = Depends(security.get_current_user),
+):
+    """
+    Delete a memory.
+
+    Args:
+        memory_id: Memory ID
+
+    Returns:
+        Success message
+    """
+    if not memory_service.is_configured:
+        raise HTTPException(status_code=404, detail="Memory service not configured")
+
+    try:
+        # First verify the memory exists and belongs to this user
+        existing = await memory_service.get_memory(memory_id)
+        if not existing:
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        mem_user_id = existing.get("user_id", "")
+        if str(mem_user_id) != str(current_user.id):
+            raise HTTPException(status_code=404, detail="Memory not found")
+
+        # Delete the memory
+        success = await memory_service.delete_memory(memory_id)
+
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to delete memory")
+
+        return {"success": True, "message": "Memory deleted successfully"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting memory {memory_id}: {e}")
+        raise HTTPException(status_code=500, detail="Failed to delete memory")
+
+
+@router.get("/health/check")
+async def check_memory_service():
+    """
+    Check if memory service is healthy and configured.
+
+    Returns:
+        Service status
+    """
+    is_healthy = await memory_service.health_check()
+
+    return {
+        "configured": memory_service.is_configured,
+        "healthy": is_healthy,
+    }

backend/app/core/config.py

@@ -113,6 +113,11 @@ class Settings(BaseSettings):
     MAX_UPLOAD_FILE_SIZE_MB: int = 50  # Maximum file size in MB
     MAX_EXTRACTED_TEXT_LENGTH: int = 1000000  # Maximum extracted text length
 
+    # mem0 long-term memory configuration
+    MEM0_BASE_URL: str = ""  # mem0 service URL (e.g., http://localhost:8080)
+    MEM0_API_KEY: str = ""  # mem0 API key (if required)
+    MEM0_ENABLED: bool = True  # Enable/disable mem0 integration
+
 
     class Config:
         env_file = ".env"

backend/app/services/chat/__init__.py

@@ -7,14 +7,17 @@
 
 This module provides direct LLM API calling capabilities for Chat Shell type,
 bypassing the Docker Executor container for lightweight chat scenarios.
+Also includes long-term memory integration via mem0.
 """
 
 from app.services.chat.chat_service import chat_service
 from app.services.chat.session_manager import session_manager
 from app.services.chat.model_resolver import get_model_config_for_bot
+from app.services.chat.memory_service import memory_service
 
 __all__ = [
     "chat_service",
     "session_manager",
     "get_model_config_for_bot",
+    "memory_service",
 ]