Merge pull request #42 from AET-DevOps25/feature/make-server-work-with-genai-improvements

yassinsws · web-flow · commit 918aeb1abce3 · 2025-07-20T21:19:39.000+01:00
Feature/make server work with genai improvements
diff --git a/.env.dev b/.env.dev
@@ -17,12 +17,12 @@ DOCUMENT_SERVICE_URL=http://document-service:8084
 # GenAI container
 WEAVIATE_HOST=weaviate
 WEAVIATE_PORT=8090
-OPEN_WEBUI_API_KEY_CHAT=dummy-key-chat
-OPEN_WEBUI_API_KEY_GEN=dummy-key-gen
+OPEN_WEBUI_API_KEY_CHAT=sk-5760c1bddad74624a09046ef2bc6c8dc
+OPEN_WEBUI_API_KEY_GEN=sk-8cc49d1e38ee436b93b9fbd31795b320
 LANGSMITH_TRACING=true
-LANGSMITH_ENDPOINT=https://api.smith.langchain.com
-LANGSMITH_API_KEY=dummy-langsmith-key
-LANGSMITH_PROJECT=studymate
+LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
+LANGSMITH_API_KEY="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"
+LANGSMITH_PROJECT="studymate"
 
 # Grafana
 GF_SECURITY_ADMIN_USER=admin
diff --git a/.github/workflows/deploy-genai-service.yml b/.github/workflows/deploy-genai-service.yml
@@ -140,12 +140,12 @@ jobs:
           echo "🔍 Verifying GenAI service deployment..."
           
           # Wait for pod to be ready
-            kubectl wait --for=condition=ready pod -l app.kubernetes.io/component=genai-service -n study-mate --timeout=300s || {
-    echo "❌ GenAI service pod failed to become ready"
-    echo "🔍 Pod status:"
-    kubectl get pods -n study-mate -l app.kubernetes.io/component=genai-service -o wide
-    echo "🔍 Pod logs:"
-    kubectl logs -l app.kubernetes.io/component=genai-service -n study-mate --tail=50 || echo "⚠️  Could not get logs"
+          kubectl wait --for=condition=ready pod -l app.kubernetes.io/component=genai-service -n study-mate --timeout=300s || {
+            echo "❌ GenAI service pod failed to become ready"
+            echo "🔍 Pod status:"
+            kubectl get pods -n study-mate -l app.kubernetes.io/component=genai-service -o wide
+            echo "🔍 Pod logs:"
+            kubectl logs -l app.kubernetes.io/component=genai-service -n study-mate --tail=50 || echo "⚠️  Could not get logs"
             exit 1
           }
           
diff --git a/database_setup_microservices.sql b/database_setup_microservices.sql
@@ -1,10 +1,12 @@
 -- Create separate databases for each microservice
 CREATE DATABASE auth_db;
 CREATE DATABASE document_db;
+CREATE DATABASE genai_db;
 
 -- Grant permissions
 GRANT ALL PRIVILEGES ON DATABASE auth_db TO postgres;
 GRANT ALL PRIVILEGES ON DATABASE document_db TO postgres;
+GRANT ALL PRIVILEGES ON DATABASE genai_db TO postgres;
 
 -- Connect to auth_db and create users table
 \c auth_db;
diff --git a/server/genai-service/build.gradle.kts b/server/genai-service/build.gradle.kts
@@ -1,6 +1,7 @@
 plugins {
     kotlin("jvm") version "1.9.25"
     kotlin("plugin.spring") version "1.9.25"
+    kotlin("plugin.jpa") version "1.9.25"  // Added for JPA entities
     id("org.springframework.boot") version "3.2.12"
     id("io.spring.dependency-management") version "1.1.7"
 }
@@ -23,6 +24,7 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-webflux")  // Added for WebClient support
     implementation("org.springframework.boot:spring-boot-starter-validation")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
+    implementation("org.springframework.boot:spring-boot-starter-data-jpa")  // Added for JPA/Hibernate
     implementation("org.postgresql:postgresql")
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin")
     implementation("org.jetbrains.kotlin:kotlin-reflect")
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/GenAiServiceApplication.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/GenAiServiceApplication.kt
@@ -3,9 +3,11 @@ package de.tum.cit.aet.genai
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
 import org.springframework.scheduling.annotation.EnableAsync
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories
 
 @SpringBootApplication
 @EnableAsync
+@EnableJpaRepositories
 class GenAiServiceApplication
 
 fun main(args: Array<String>) {
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/controller/GenAiController.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/controller/GenAiController.kt
@@ -2,6 +2,7 @@ package de.tum.cit.aet.genai.controller
 
 import de.tum.cit.aet.genai.dto.*
 import de.tum.cit.aet.genai.service.GenAiService
+import de.tum.cit.aet.genai.service.ChatMessageService
 import jakarta.validation.Valid
 import org.slf4j.LoggerFactory
 import org.springframework.http.HttpStatus
@@ -16,7 +17,8 @@ import org.springframework.web.context.request.async.DeferredResult
 @RequestMapping("/api/genai")
 @CrossOrigin(origins = ["*"])
 class GenAiController(
-    private val genAiService: GenAiService
+    private val genAiService: GenAiService,
+    private val chatMessageService: ChatMessageService
 ) {
     
     private val logger = LoggerFactory.getLogger(GenAiController::class.java)
@@ -145,7 +147,7 @@ class GenAiController(
         
         val result = DeferredResult<ResponseEntity<Any>>(600000L) // 10 minutes timeout
         
-        genAiService.getSessionAsync(sessionId, userId) { response, error ->
+        genAiService.getSessionAsync(userId) { response, error ->
             if (error != null) {
                 logger.error("Error getting session: {}", error.message, error)
                 result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
@@ -376,7 +378,7 @@ class GenAiController(
         return result
     }
     
-    // New chat endpoints that match frontend expectations
+    // Chat session endpoints (simplified to match Python service pattern)
     @PostMapping("/chat/sessions")
     fun createChatSession(
         @Valid @RequestBody request: ChatSessionRequest,
@@ -386,19 +388,41 @@ class GenAiController(
         
         val result = DeferredResult<ResponseEntity<Any>>(600000L) // 10 minutes timeout
         
-        genAiService.createChatSessionAsync(request, userId) { response, error ->
-            if (error != null) {
-                logger.error("Error creating chat session: {}", error.message, error)
-                result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
-                    ErrorResponse(
-                        error = "Chat session creation failed",
-                        message = "Failed to create chat session: ${error.message}",
-                        timestamp = LocalDateTime.now().format(dateFormatter)
+        // Python service doesn't have sessions - it just loads documents per user
+        // If documents are provided, load the first one for this user (for chat only, no content generation)
+        if (request.documentIds.isNotEmpty()) {
+            val primaryDocumentId = request.documentIds.first()
+            
+            genAiService.loadDocumentForChatAsync(primaryDocumentId, userId) { success, error ->
+                if (error != null || !success) {
+                    logger.error("Error loading document for chat: {}", error?.message ?: "Unknown error")
+                    result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
+                        ErrorResponse(
+                            error = "Failed to initialize chat",
+                            message = "Could not load document for chat: ${error?.message ?: "Unknown error"}",
+                            timestamp = LocalDateTime.now().format(dateFormatter)
+                        )
+                    ))
+                } else {
+                    // Return session response with actual message history
+                    val messages = chatMessageService.getSessionMessages(userId) // sessionId = userId
+                    val response = mapOf(
+                        "sessionId" to userId,
+                        "messages" to messages,
+                        "documentsInContext" to request.documentIds
                     )
-                ))
-            } else {
-                result.setResult(ResponseEntity.ok(response))
+                    result.setResult(ResponseEntity.ok(response))
+                }
             }
+        } else {
+            // No documents provided, return session with existing message history
+            val messages = chatMessageService.getSessionMessages(userId) // sessionId = userId
+            val response = mapOf(
+                "sessionId" to userId,
+                "messages" to messages,
+                "documentsInContext" to emptyList<String>()
+            )
+            result.setResult(ResponseEntity.ok(response))
         }
         
         return result
@@ -413,19 +437,26 @@ class GenAiController(
         
         val result = DeferredResult<ResponseEntity<Any>>(600000L) // 10 minutes timeout
         
-        genAiService.getChatSessionAsync(sessionId, userId) { response, error ->
-            if (error != null) {
-                logger.error("Error getting chat session: {}", error.message, error)
-                result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
-                    ErrorResponse(
-                        error = "Chat session retrieval failed",
-                        message = "Failed to get chat session: ${error.message}",
-                        timestamp = LocalDateTime.now().format(dateFormatter)
-                    )
-                ))
-            } else {
-                result.setResult(ResponseEntity.ok(response))
-            }
+        try {
+            // Get actual message history from database
+            val messages = chatMessageService.getSessionMessages(sessionId)
+            
+            val response = mapOf(
+                "sessionId" to sessionId,
+                "messages" to messages,
+                "documentsInContext" to emptyList<String>() // Would need to extract from message context if needed
+            )
+            
+            result.setResult(ResponseEntity.ok(response))
+        } catch (e: Exception) {
+            logger.error("Error getting chat session: {}", e.message, e)
+            result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
+                ErrorResponse(
+                    error = "Failed to get chat session",
+                    message = "Could not retrieve chat history: ${e.message}",
+                    timestamp = LocalDateTime.now().format(dateFormatter)
+                )
+            ))
         }
         
         return result
@@ -441,24 +472,103 @@ class GenAiController(
         
         val result = DeferredResult<ResponseEntity<Any>>(600000L) // 10 minutes timeout
         
-        genAiService.sendChatMessageAsync(sessionId, request, userId) { response, error ->
-            if (error != null) {
-                logger.error("Error sending chat message: {}", error.message, error)
-                result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
-                    ErrorResponse(
-                        error = "Message sending failed",
-                        message = "Failed to send message: ${error.message}",
-                        timestamp = LocalDateTime.now().format(dateFormatter)
-                    )
-                ))
-            } else {
-                result.setResult(ResponseEntity.ok(response))
+        try {
+            // Save user message to database first
+            chatMessageService.saveUserMessage(
+                sessionId = sessionId,
+                userId = userId,
+                content = request.message,
+                documentIds = request.documentIds
+            )
+            
+            // Use the simple chat functionality - Python service uses user_id for context
+            val chatRequest = ChatRequest(message = request.message, userId = userId)
+            
+            genAiService.chatAsync(chatRequest) { chatResponse, error ->
+                if (error != null) {
+                    logger.error("Error sending chat message: {}", error.message, error)
+                    result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
+                        ErrorResponse(
+                            error = "Message sending failed",
+                            message = "Failed to send message: ${error.message}",
+                            timestamp = LocalDateTime.now().format(dateFormatter)
+                        )
+                    ))
+                } else {
+                    try {
+                        // Save bot response to database
+                        val botMessage = chatMessageService.saveBotMessage(
+                            sessionId = sessionId,
+                            userId = userId,
+                            content = chatResponse!!.response
+                        )
+                        
+                        // Transform to expected response format
+                        val messageResponse = mapOf(
+                            "id" to (botMessage.id ?: java.util.UUID.randomUUID().toString()),
+                            "content" to chatResponse.response,
+                            "sender" to "bot",
+                            "timestamp" to chatResponse.timestamp,
+                            "sources" to null,
+                            "documentReferences" to null
+                        )
+                        result.setResult(ResponseEntity.ok(messageResponse))
+                    } catch (e: Exception) {
+                        logger.error("Error saving bot message: {}", e.message, e)
+                        // Still return the response even if saving failed
+                        val messageResponse = mapOf(
+                            "id" to java.util.UUID.randomUUID().toString(),
+                            "content" to chatResponse!!.response,
+                            "sender" to "bot",
+                            "timestamp" to chatResponse.timestamp,
+                            "sources" to null,
+                            "documentReferences" to null
+                        )
+                        result.setResult(ResponseEntity.ok(messageResponse))
+                    }
+                }
             }
+        } catch (e: Exception) {
+            logger.error("Error saving user message: {}", e.message, e)
+            result.setResult(ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(
+                ErrorResponse(
+                    error = "Message saving failed",
+                    message = "Failed to save user message: ${e.message}",
+                    timestamp = LocalDateTime.now().format(dateFormatter)
+                )
+            ))
         }
         
         return result
     }
 
+    @DeleteMapping("/chat/sessions/{sessionId}/messages")
+    fun clearChatHistory(
+        @PathVariable sessionId: String,
+        @RequestHeader("X-User-ID") userId: String
+    ): ResponseEntity<Map<String, Any>> {
+        logger.info("DELETE /genai/chat/sessions/{}/messages for user: {}", sessionId, userId)
+        
+        return try {
+            val deletedCount = chatMessageService.clearSessionMessages(sessionId)
+            
+            ResponseEntity.ok(mapOf<String, Any>(
+                "message" to "Chat history cleared successfully",
+                "deletedMessages" to deletedCount,
+                "sessionId" to sessionId,
+                "timestamp" to LocalDateTime.now().format(dateFormatter)
+            ))
+        } catch (e: Exception) {
+            logger.error("Error clearing chat history: {}", e.message, e)
+            ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(mapOf<String, Any>(
+                "error" to "Failed to clear chat history",
+                "message" to (e.message ?: "Unknown error"),
+                "timestamp" to LocalDateTime.now().format(dateFormatter)
+            ))
+        }
+    }
+
+
     @GetMapping("/health")
     fun healthCheck(): ResponseEntity<Map<String, String>> {
         return ResponseEntity.ok(mapOf(
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/entity/ChatMessage.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/entity/ChatMessage.kt
@@ -0,0 +1,35 @@
+package de.tum.cit.aet.genai.entity
+
+import jakarta.persistence.*
+import java.time.LocalDateTime
+
+@Entity
+@Table(name = "chat_messages")
+data class ChatMessage(
+    @Id
+    @GeneratedValue(strategy = GenerationType.UUID)
+    val id: String? = null,
+    
+    @Column(name = "session_id", nullable = false)
+    val sessionId: String,
+    
+    @Column(name = "user_id", nullable = false)
+    val userId: String,
+    
+    @Column(name = "content", nullable = false, columnDefinition = "TEXT")
+    val content: String,
+    
+    @Enumerated(EnumType.STRING)
+    @Column(name = "sender", nullable = false)
+    val sender: MessageSender,
+    
+    @Column(name = "timestamp", nullable = false)
+    val timestamp: LocalDateTime = LocalDateTime.now(),
+    
+    @Column(name = "document_ids")
+    val documentIds: String? = null  // JSON string of document IDs
+)
+
+enum class MessageSender {
+    USER, BOT
+} 
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/repository/ChatMessageRepository.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/repository/ChatMessageRepository.kt
@@ -0,0 +1,30 @@
+package de.tum.cit.aet.genai.repository
+
+import de.tum.cit.aet.genai.entity.ChatMessage
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.data.jpa.repository.Query
+import org.springframework.data.repository.query.Param
+import org.springframework.stereotype.Repository
+
+@Repository
+interface ChatMessageRepository : JpaRepository<ChatMessage, String> {
+    
+    // Get messages for a specific session, ordered by timestamp
+    fun findBySessionIdOrderByTimestampAsc(sessionId: String): List<ChatMessage>
+    
+    // Get messages for a user across all sessions
+    fun findByUserIdOrderByTimestampDesc(userId: String): List<ChatMessage>
+    
+    // Get recent messages for a session (limit)
+    @Query("SELECT m FROM ChatMessage m WHERE m.sessionId = :sessionId ORDER BY m.timestamp DESC LIMIT :limit")
+    fun findRecentMessagesBySessionId(@Param("sessionId") sessionId: String, @Param("limit") limit: Int): List<ChatMessage>
+    
+    // Count messages in a session
+    fun countBySessionId(sessionId: String): Long
+    
+    // Delete all messages for a session
+    fun deleteBySessionId(sessionId: String): Long
+    
+    // Check if session exists (has any messages)
+    fun existsBySessionId(sessionId: String): Boolean
+} 
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/service/ChatMessageService.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/service/ChatMessageService.kt
diff --git a/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/service/GenAiService.kt b/server/genai-service/src/main/kotlin/de/tum/cit/aet/genai/service/GenAiService.kt
diff --git a/server/genai-service/src/main/resources/application.properties b/server/genai-service/src/main/resources/application.properties
