remove conversation management

src/apis/routes/chat_route.py

@@ -1,8 +1,6 @@
 from fastapi import (
     APIRouter,
     status,
-    Depends,
-    BackgroundTasks,
     HTTPException,
     File,
     UploadFile,
@@ -12,12 +10,9 @@ from fastapi.responses import JSONResponse
 from src.utils.logger import logger
 from src.agents.role_play.flow import role_play_agent
 from pydantic import BaseModel, Field
-from typing import List, Dict, Any, Optional
-from src.agents.role_play.scenarios import get_scenarios, get_scenario_by_id
+from typing import Dict, Any, Optional
+from src.agents.role_play.scenarios import get_scenarios
 import json
-import os
-import uuid
-from datetime import datetime
 import base64
 
 router = APIRouter(prefix="/ai", tags=["AI"])
@@ -31,91 +26,6 @@ class RoleplayRequest(BaseModel):
     scenario: Dict[str, Any] = Field(..., description="The scenario for the roleplay")
 
 
-class SessionRequest(BaseModel):
-    session_id: str = Field(..., description="Session ID to perform operations on")
-
-
-class CreateSessionRequest(BaseModel):
-    name: str = Field(..., description="Name for the new session")
-
-
-class UpdateSessionRequest(BaseModel):
-    session_id: str = Field(..., description="Session ID to update")
-    name: str = Field(..., description="New name for the session")
-
-
-# Session management helper functions
-SESSIONS_FILE = "sessions.json"
-
-
-def load_sessions() -> List[Dict[str, Any]]:
-    """Load sessions from JSON file"""
-    try:
-        if os.path.exists(SESSIONS_FILE):
-            with open(SESSIONS_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-        return []
-    except Exception as e:
-        logger.error(f"Error loading sessions: {str(e)}")
-        return []
-
-
-def save_sessions(sessions: List[Dict[str, Any]]):
-    """Save sessions to JSON file"""
-    try:
-        with open(SESSIONS_FILE, "w", encoding="utf-8") as f:
-            json.dump(sessions, f, ensure_ascii=False, indent=2, default=str)
-    except Exception as e:
-        logger.error(f"Error saving sessions: {str(e)}")
-
-
-def create_session(name: str) -> Dict[str, Any]:
-    """Create a new session"""
-    session_id = str(uuid.uuid4())
-    session = {
-        "id": session_id,
-        "name": name,
-        "created_at": datetime.now().isoformat(),
-        "last_message": None,
-        "message_count": 0,
-    }
-
-    sessions = load_sessions()
-    sessions.append(session)
-    save_sessions(sessions)
-
-    return session
-
-
-def get_session_by_id(session_id: str) -> Optional[Dict[str, Any]]:
-    """Get session by ID"""
-    sessions = load_sessions()
-    return next((s for s in sessions if s["id"] == session_id), None)
-
-
-def update_session_last_message(session_id: str, message: str):
-    """Update session's last message"""
-    sessions = load_sessions()
-    for session in sessions:
-        if session["id"] == session_id:
-            session["last_message"] = message
-            session["message_count"] = session.get("message_count", 0) + 1
-            break
-    save_sessions(sessions)
-
-
-def delete_session_by_id(session_id: str) -> bool:
-    """Delete session by ID"""
-    sessions = load_sessions()
-    original_count = len(sessions)
-    sessions = [s for s in sessions if s["id"] != session_id]
-
-    if len(sessions) < original_count:
-        save_sessions(sessions)
-        return True
-    return False
-
-
 @router.get("/scenarios", status_code=status.HTTP_200_OK)
 async def list_scenarios():
     """Get all available scenarios"""
@@ -134,7 +44,7 @@ async def roleplay(
     audio_file: Optional[UploadFile] = File(None, description="Audio file from user"),
 ):
     """Send a message (text or audio) to the roleplay agent"""
-
+    logger.info(f"Received roleplay request: {session_id}")
     # Validate that at least one input is provided
     if not text_message and not audio_file:
         raise HTTPException(
@@ -211,8 +121,6 @@ async def roleplay(
             },
             {"configurable": {"thread_id": session_id}},
         )
-        last_message = text_message if text_message else "[Audio message]"
-        update_session_last_message(session_id, last_message)
 
         # Extract AI response content
         ai_response = response["messages"][-1].content
@@ -223,160 +131,3 @@ async def roleplay(
     except Exception as e:
         logger.error(f"Error in roleplay: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
-
-
-@router.post("/get-messages", status_code=status.HTTP_200_OK)
-async def get_messages(request: SessionRequest):
-    """Get all messages from a conversation session"""
-    try:
-
-        # Create agent instance
-        agent = role_play_agent()
-
-        # Get current state
-        current_state = agent.get_state(
-            {"configurable": {"thread_id": request.session_id}}
-        )
-
-        if not current_state or not current_state.values:
-            return JSONResponse(
-                content={
-                    "session_id": request.session_id,
-                    "messages": [],
-                    "total_messages": 0,
-                }
-            )
-
-        # Extract messages from state
-        messages = []
-        if "messages" in current_state.values:
-            raw_messages = current_state.values["messages"]
-
-            for msg in raw_messages:
-                # Convert message object to dict format
-                if hasattr(msg, "content") and hasattr(msg, "type"):
-                    messages.append(
-                        {
-                            "role": getattr(msg, "type", "unknown"),
-                            "content": getattr(msg, "content", ""),
-                            "timestamp": getattr(msg, "timestamp", None),
-                        }
-                    )
-                elif hasattr(msg, "content"):
-                    # Handle different message formats
-                    role = (
-                        "human"
-                        if hasattr(msg, "__class__")
-                        and "Human" in msg.__class__.__name__
-                        else "ai"
-                    )
-                    messages.append(
-                        {
-                            "role": role,
-                            "content": msg.content,
-                            "timestamp": getattr(msg, "timestamp", None),
-                        }
-                    )
-                else:
-                    # Fallback for unexpected message format
-                    messages.append(
-                        {"role": "unknown", "content": str(msg), "timestamp": None}
-                    )
-
-        return JSONResponse(
-            content={
-                "session_id": request.session_id,
-                "messages": messages,
-                "total_messages": len(messages),
-            }
-        )
-
-    except Exception as e:
-        logger.error(
-            f"Error getting messages for session {request.session_id}: {str(e)}"
-        )
-        raise HTTPException(status_code=500, detail=f"Failed to get messages: {str(e)}")
-
-
-@router.get("/sessions", status_code=status.HTTP_200_OK)
-async def get_sessions():
-    """Get all sessions"""
-    try:
-        sessions = load_sessions()
-        return JSONResponse(content={"sessions": sessions})
-    except Exception as e:
-        logger.error(f"Error getting sessions: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Failed to get sessions: {str(e)}")
-
-
-@router.post("/sessions", status_code=status.HTTP_201_CREATED)
-async def create_new_session(request: CreateSessionRequest):
-    """Create a new session"""
-    try:
-        session = create_session(request.name)
-        return JSONResponse(content={"session": session})
-    except Exception as e:
-        logger.error(f"Error creating session: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Failed to create session: {str(e)}"
-        )
-
-
-@router.get("/sessions/{session_id}", status_code=status.HTTP_200_OK)
-async def get_session(session_id: str):
-    """Get a specific session by ID"""
-    try:
-        session = get_session_by_id(session_id)
-        if not session:
-            raise HTTPException(status_code=404, detail="Session not found")
-        return JSONResponse(content={"session": session})
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error getting session {session_id}: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Failed to get session: {str(e)}")
-
-
-@router.put("/sessions/{session_id}", status_code=status.HTTP_200_OK)
-async def update_session(session_id: str, request: UpdateSessionRequest):
-    """Update a session"""
-    try:
-        sessions = load_sessions()
-        session_found = False
-
-        for session in sessions:
-            if session["id"] == session_id:
-                session["name"] = request.name
-                session_found = True
-                break
-
-        if not session_found:
-            raise HTTPException(status_code=404, detail="Session not found")
-
-        save_sessions(sessions)
-        updated_session = get_session_by_id(session_id)
-        return JSONResponse(content={"session": updated_session})
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error updating session {session_id}: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Failed to update session: {str(e)}"
-        )
-
-
-@router.delete("/sessions/{session_id}", status_code=status.HTTP_200_OK)
-async def delete_session(session_id: str):
-    """Delete a session"""
-    try:
-        success = delete_session_by_id(session_id)
-        if not success:
-            raise HTTPException(status_code=404, detail="Session not found")
-        return JSONResponse(content={"message": "Session deleted successfully"})
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Error deleting session {session_id}: {str(e)}")
-        raise HTTPException(
-            status_code=500, detail=f"Failed to delete session: {str(e)}"
-        )

src/apis/routes/lesson_route.py

@@ -39,15 +39,17 @@ class LessonPracticeRequest(BaseModel):
 def load_lessons_from_file() -> List[Lesson]:
     """Load lessons from the JSON file"""
     try:
-        lessons_file_path = os.path.join(os.path.dirname(__file__), "..", "..", "data", "lessons.json")
-        
+        lessons_file_path = os.path.join(
+            os.path.dirname(__file__), "..", "..", "data", "lessons.json"
+        )
+
         if not os.path.exists(lessons_file_path):
             logger.warning(f"Lessons file not found at {lessons_file_path}")
             return []
-            
-        with open(lessons_file_path, 'r', encoding='utf-8') as file:
+
+        with open(lessons_file_path, "r", encoding="utf-8") as file:
             lessons_data = json.load(file)
-            
+
         # Convert to Lesson objects
         lessons = []
         for lesson_data in lessons_data:
@@ -55,9 +57,11 @@ def load_lessons_from_file() -> List[Lesson]:
                 lesson = Lesson(**lesson_data)
                 lessons.append(lesson)
             except Exception as e:
-                logger.error(f"Error parsing lesson {lesson_data.get('id', 'unknown')}: {str(e)}")
+                logger.error(
+                    f"Error parsing lesson {lesson_data.get('id', 'unknown')}: {str(e)}"
+                )
                 continue
-                
+
         return lessons
     except Exception as e:
         logger.error(f"Error loading lessons: {str(e)}")
@@ -68,22 +72,19 @@ def load_lessons_from_file() -> List[Lesson]:
 async def get_all_lessons():
     """
     Get all available lessons
-    
+
     Returns:
         LessonResponse: Contains list of all lessons and total count
     """
     try:
         lessons = load_lessons_from_file()
-        
-        return LessonResponse(
-            lessons=lessons,
-            total=len(lessons)
-        )
+
+        return LessonResponse(lessons=lessons, total=len(lessons))
     except Exception as e:
         logger.error(f"Error retrieving lessons: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to retrieve lessons"
+            detail="Failed to retrieve lessons",
         )
 
 
@@ -91,25 +92,25 @@ async def get_all_lessons():
 async def get_lesson_by_id(lesson_id: str):
     """
     Get a specific lesson by ID
-    
+
     Args:
         lesson_id (str): The unique identifier of the lesson
-        
+
     Returns:
         LessonDetailResponse: Contains the lesson details
     """
     try:
         lessons = load_lessons_from_file()
-        
+
         # Find the lesson with the specified ID
         lesson = next((l for l in lessons if l.id == lesson_id), None)
-        
+
         if not lesson:
             raise HTTPException(
                 status_code=status.HTTP_404_NOT_FOUND,
-                detail=f"Lesson with ID '{lesson_id}' not found"
+                detail=f"Lesson with ID '{lesson_id}' not found",
             )
-            
+
         return LessonDetailResponse(lesson=lesson)
     except HTTPException:
         raise
@@ -117,7 +118,7 @@ async def get_lesson_by_id(lesson_id: str):
         logger.error(f"Error retrieving lesson {lesson_id}: {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to retrieve lesson"
+            detail="Failed to retrieve lesson",
         )
 
 
@@ -125,31 +126,27 @@ async def get_lesson_by_id(lesson_id: str):
 async def search_lessons_by_unit(unit_name: str):
     """
     Search lessons by unit name (case-insensitive partial match)
-    
+
     Args:
         unit_name (str): Part of the unit name to search for
-        
+
     Returns:
         LessonResponse: Contains list of matching lessons
     """
     try:
         lessons = load_lessons_from_file()
-        
+
         # Filter lessons by unit name (case-insensitive partial match)
         matching_lessons = [
-            lesson for lesson in lessons 
-            if unit_name.lower() in lesson.unit.lower()
+            lesson for lesson in lessons if unit_name.lower() in lesson.unit.lower()
         ]
-        
-        return LessonResponse(
-            lessons=matching_lessons,
-            total=len(matching_lessons)
-        )
+
+        return LessonResponse(lessons=matching_lessons, total=len(matching_lessons))
     except Exception as e:
         logger.error(f"Error searching lessons by unit '{unit_name}': {str(e)}")
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail="Failed to search lessons"
+            detail="Failed to search lessons",
         )
 
 
@@ -158,9 +155,7 @@ async def chat(
     session_id: str = Form(
         ..., description="Session ID for tracking user interactions"
     ),
-    lesson_data: str = Form(
-        ..., description="The lesson data as JSON string"
-    ),
+    lesson_data: str = Form(..., description="The lesson data as JSON string"),
     text_message: Optional[str] = Form(None, description="Text message from user"),
     audio_file: Optional[UploadFile] = File(None, description="Audio file from user"),
 ):
@@ -242,7 +237,7 @@ async def chat(
             },
             {"configurable": {"thread_id": session_id}},
         )
-        
+
         # Extract AI response content
         ai_response = response["messages"][-1].content
         logger.info(f"AI response: {ai_response}")

src/apis/routes/user_route.py

@@ -1,7 +1,6 @@
 from fastapi import APIRouter, status, Depends, BackgroundTasks
 from fastapi.responses import JSONResponse
 from src.utils.logger import logger
-from src.utils.redis import set_key_redis, delete_key_redis
 
 
 router = APIRouter(prefix="/user", tags=["User"])

src/utils/redis.py

@@ -1,18 +0,0 @@
-import redis.asyncio as redis
-
-# redis_client = redis.from_url(
-#     RedisCfg.REDIS_URL, encoding="utf-8", decode_responses=True
-# )
-
-
-async def set_key_redis(key, value, time=300):
-    return None #redis_client.set(key, value, time)
-
-
-async def get_key_redis(key):
-    
-    return None #await redis_client.get(key)
-
-
-async def delete_key_redis(key):
-    return None#redis_client.delete(key)