Iris: Course Memory ingestion

src/main/java/de/tum/cit/aet/artemis/communication/service/AnswerMessageService.java

@@ -48,6 +48,7 @@
 import de.tum.cit.aet.artemis.globalsearch.dto.searchableentity.PostSearchableEntityDTO;
 import de.tum.cit.aet.artemis.globalsearch.service.SearchableEntityWeaviateService;
 import de.tum.cit.aet.artemis.iris.api.AutonomousTutorApi;
+import de.tum.cit.aet.artemis.iris.api.CourseMemoryIngestionApi;
 import de.tum.cit.aet.artemis.notification.domain.course_notifications.NewAnswerNotification;
 import de.tum.cit.aet.artemis.notification.domain.course_notifications.NewMentionNotification;
 import de.tum.cit.aet.artemis.notification.service.CourseNotificationService;
@@ -78,6 +79,8 @@ public class AnswerMessageService extends PostingService {
 
     private final Optional<AutonomousTutorApi> autonomousTutorApi;
 
+    private final Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi;
+
     private final TransactionTemplate transactionTemplate;
 
     private final Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService;
@@ -88,7 +91,7 @@ public AnswerMessageService(SingleUserNotificationService singleUserNotification
             ConversationService conversationService, ExerciseRepository exerciseRepository, SavedPostRepository savedPostRepository,
             WebsocketMessagingService websocketMessagingService, ConversationParticipantRepository conversationParticipantRepository,
             ChannelAuthorizationService channelAuthorizationService, PostRepository postRepository, CourseNotificationService courseNotificationService,
-            Optional<AutonomousTutorApi> autonomousTutorApi, PlatformTransactionManager transactionManager,
+            Optional<AutonomousTutorApi> autonomousTutorApi, Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi, PlatformTransactionManager transactionManager,
             Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService) {
         super(courseRepository, userRepository, exerciseRepository, authorizationCheckService, websocketMessagingService, conversationParticipantRepository, savedPostRepository);
         this.answerPostRepository = answerPostRepository;
@@ -98,6 +101,7 @@ public AnswerMessageService(SingleUserNotificationService singleUserNotification
         this.singleUserNotificationService = singleUserNotificationService;
         this.postRepository = postRepository;
         this.courseNotificationService = courseNotificationService;
+        this.courseMemoryIngestionApi = courseMemoryIngestionApi;
         this.autonomousTutorApi = autonomousTutorApi;
         this.transactionTemplate = new TransactionTemplate(transactionManager);
         this.searchableEntityWeaviateService = searchableEntityWeaviateService;
@@ -229,14 +233,16 @@ public AnswerPost updateAnswerMessage(Long courseId, Long answerMessageId, Updat
         // only the content of the message can be updated
         existingAnswerMessage.setContent(answerMessage.content());
 
-        // determine if the update operation is to mark the answer message as resolving the original post
+        // determine if the update operation changes whether the answer message resolves the original post
+        boolean resolutionChanged = false;
         if (existingAnswerMessage.doesResolvePost() != answerMessage.resolvesPost()) {
             // check if requesting user is allowed to mark this answer message as resolving, i.e. if user is author or original message or at least tutor
             mayMarkAnswerMessageAsResolvingElseThrow(existingAnswerMessage, user, course);
             existingAnswerMessage.setResolvesPost(answerMessage.resolvesPost());
             // sets the message as resolved if there exists any resolving answer
             existingAnswerMessage.getPost().setResolved(existingAnswerMessage.getPost().getAnswers().stream().anyMatch(AnswerPost::doesResolvePost));
             postRepository.save(existingAnswerMessage.getPost());
+            resolutionChanged = true;
         }
         else {
             // check if requesting user is allowed to update the content, i.e. if user is author of answer message or at least tutor
@@ -251,6 +257,17 @@ public AnswerPost updateAnswerMessage(Long courseId, Long answerMessageId, Updat
         syncAnswerPostWithWeaviate(updatedAnswerMessage, conversation);
 
         this.preparePostAndBroadcast(updatedAnswerMessage, course);
+
+        // Trigger B: the thread's resolution state changed. Fires in both directions so un-marking the
+        // last resolving answer retracts the Course Memory entry instead of leaving it served as verified.
+        if (resolutionChanged) {
+            try {
+                courseMemoryIngestionApi.ifPresent(api -> api.onThreadResolutionChanged(updatedAnswerMessage.getPost(), updatedAnswerMessage, user, course));
+            }
+            catch (Exception e) {
+                log.error("Failed to update course memory after resolution change on answer post {}", updatedAnswerMessage.getId(), e);
+            }
+        }
         return updatedAnswerMessage;
     }
 
@@ -296,6 +313,11 @@ public void deleteAnswerMessageById(Long courseId, Long answerMessageId) {
         }
         ensureConversationBelongsToCourseElseThrow(conversation, courseId);
 
+        // An answer that resolved the thread or that was a verified Iris answer is what the thread's
+        // Course Memory entry was built from, so its removal has to be reflected there too.
+        boolean contributedToCourseMemory = Boolean.TRUE.equals(answerMessage.doesResolvePost())
+                || (answerMessage.getAuthor() != null && answerMessage.getAuthor().isBot() && answerMessage.isVerified());
+
         // we need to explicitly remove the answer post from the answers of the broadcast post to share up-to-date information
         Post updatedMessage = answerMessage.getPost();
         updatedMessage.removeAnswerPost(answerMessage);
@@ -314,6 +336,17 @@ public void deleteAnswerMessageById(Long courseId, Long answerMessageId) {
         savedPostRepository.deleteAll(savedPosts);
 
         broadcastForPost(updatedMessage, MetisCrudAction.UPDATE, course.getId(), null);
+
+        // Re-ingest from whatever verified answer survives, or delete the entry if none does. Runs after
+        // the delete is committed so the re-fetched thread no longer contains the removed answer.
+        if (contributedToCourseMemory) {
+            try {
+                courseMemoryIngestionApi.ifPresent(api -> api.onThreadResolutionChanged(updatedMessage, null, user, course));
+            }
+            catch (Exception e) {
+                log.error("Failed to update course memory after deletion of answer post {}", answerMessageId, e);
+            }
+        }
     }
 
     /**
@@ -384,6 +417,15 @@ public AnswerPost verifyAnswerMessage(Long courseId, Long answerMessageId, Verif
 
         sendMentionNotificationForAnswerMessage(course, verificationResult.conversation(), verificationResult.answerMessage(), verificationResult.mentionedUsers());
         this.preparePostAndBroadcast(verificationResult.answerMessage(), course);
+
+        // Trigger A: a tutor approved (IRIS_AUTO) or edited (IRIS_CORRECTED) an Iris draft -> ingest into Course Memory
+        boolean edited = verifyDto != null && verifyDto.content() != null && !verifyDto.content().isBlank();
+        try {
+            courseMemoryIngestionApi.ifPresent(api -> api.onAnswerVerified(verificationResult.answerMessage(), edited, user, course));
+        }
+        catch (Exception e) {
+            log.error("Failed to ingest verified answer post {} into course memory", verificationResult.answerMessage().getId(), e);
+        }
         return verificationResult.answerMessage();
     }
 

src/main/java/de/tum/cit/aet/artemis/communication/service/ConversationMessagingService.java

@@ -56,6 +56,7 @@
 import de.tum.cit.aet.artemis.globalsearch.dto.searchableentity.PostSearchableEntityDTO;
 import de.tum.cit.aet.artemis.globalsearch.service.SearchableEntityWeaviateService;
 import de.tum.cit.aet.artemis.iris.api.AutonomousTutorApi;
+import de.tum.cit.aet.artemis.iris.api.CourseMemoryIngestionApi;
 import de.tum.cit.aet.artemis.notification.domain.course_notifications.NewAnnouncementNotification;
 import de.tum.cit.aet.artemis.notification.domain.course_notifications.NewMentionNotification;
 import de.tum.cit.aet.artemis.notification.domain.course_notifications.NewPostNotification;
@@ -83,14 +84,16 @@ public class ConversationMessagingService extends PostingService {
 
     private final Optional<AutonomousTutorApi> autonomousTutorApi;
 
+    private final Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi;
+
     private final Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService;
 
     protected ConversationMessagingService(CourseRepository courseRepository, ExerciseRepository exerciseRepository, ConversationMessageRepository conversationMessageRepository,
             AuthorizationCheckService authorizationCheckService, WebsocketMessagingService websocketMessagingService, UserRepository userRepository,
             ConversationService conversationService, ConversationParticipantRepository conversationParticipantRepository, ChannelAuthorizationService channelAuthorizationService,
             SavedPostRepository savedPostRepository, CourseNotificationService courseNotificationService, PostRepository postRepository,
             SingleUserNotificationService singleUserNotificationService, Optional<AutonomousTutorApi> autonomousTutorApi,
-            Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService) {
+            Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi, Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService) {
         super(courseRepository, userRepository, exerciseRepository, authorizationCheckService, websocketMessagingService, conversationParticipantRepository, savedPostRepository);
         this.conversationService = conversationService;
         this.conversationMessageRepository = conversationMessageRepository;
@@ -99,6 +102,7 @@ protected ConversationMessagingService(CourseRepository courseRepository, Exerci
         this.postRepository = postRepository;
         this.singleUserNotificationService = singleUserNotificationService;
         this.autonomousTutorApi = autonomousTutorApi;
+        this.courseMemoryIngestionApi = courseMemoryIngestionApi;
         this.searchableEntityWeaviateService = searchableEntityWeaviateService;
     }
 
@@ -412,6 +416,15 @@ public void deleteMessageById(Long courseId, Long postId) {
         conversationService.notifyAllConversationMembersAboutUpdate(conversation);
         preparePostForBroadcast(post);
         broadcastForPost(post, MetisCrudAction.DELETE, course.getId(), null);
+
+        // The thread is gone, so its Course Memory entry must go too — otherwise Iris keeps serving an
+        // answer whose source no longer exists and whose backlink is dead.
+        try {
+            courseMemoryIngestionApi.ifPresent(api -> api.onThreadDeleted(post, user, course));
+        }
+        catch (Exception e) {
+            log.error("Failed to delete course memory for deleted thread {}", postId, e);
+        }
     }
 
     /**

src/main/java/de/tum/cit/aet/artemis/iris/api/CourseMemoryIngestionApi.java

@@ -0,0 +1,66 @@
+package de.tum.cit.aet.artemis.iris.api;
+
+import org.jspecify.annotations.Nullable;
+import org.springframework.context.annotation.Conditional;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.stereotype.Controller;
+
+import de.tum.cit.aet.artemis.account.domain.User;
+import de.tum.cit.aet.artemis.communication.domain.AnswerPost;
+import de.tum.cit.aet.artemis.communication.domain.Post;
+import de.tum.cit.aet.artemis.course.domain.Course;
+import de.tum.cit.aet.artemis.iris.config.IrisEnabled;
+import de.tum.cit.aet.artemis.iris.service.CourseMemoryIngestionService;
+
+/**
+ * Public facade for Course Memory ingestion, consumed by the communication module via an
+ * {@code Optional<CourseMemoryIngestionApi>} so it stays a no-op when Iris is disabled.
+ */
+@Conditional(IrisEnabled.class)
+@Controller
+@Lazy
+public class CourseMemoryIngestionApi extends AbstractIrisApi {
+
+    private final CourseMemoryIngestionService courseMemoryIngestionService;
+
+    public CourseMemoryIngestionApi(CourseMemoryIngestionService courseMemoryIngestionService) {
+        this.courseMemoryIngestionService = courseMemoryIngestionService;
+    }
+
+    /**
+     * Trigger A: a tutor approved (optionally edited) an Iris-generated answer in the verification dashboard.
+     *
+     * @param verifiedAnswer the now-verified Iris answer post
+     * @param edited         whether the tutor edited the draft before approving
+     * @param verifier       the tutor who verified the answer
+     * @param course         the course the answer belongs to
+     */
+    public void onAnswerVerified(AnswerPost verifiedAnswer, boolean edited, User verifier, Course course) {
+        courseMemoryIngestionService.ingestVerifiedAnswer(verifiedAnswer, edited, verifier, course);
+    }
+
+    /**
+     * Trigger B: a thread's resolution state changed — an answer was marked resolving, un-marked, or
+     * deleted. Ingests the thread while it still holds an answer someone stands behind, and deletes
+     * its entry once none remains.
+     *
+     * @param post             the thread's root post
+     * @param triggeringAnswer the answer whose flag changed, or {@code null} when it was deleted
+     * @param marker           the user who changed the resolution state, if known
+     * @param course           the course the thread belongs to
+     */
+    public void onThreadResolutionChanged(Post post, @Nullable AnswerPost triggeringAnswer, @Nullable User marker, Course course) {
+        courseMemoryIngestionService.handleResolutionChange(post, triggeringAnswer, marker, course);
+    }
+
+    /**
+     * The whole thread was deleted, so its Course Memory entry is removed with it.
+     *
+     * @param post   the thread's root post, before deletion
+     * @param actor  the user who deleted the thread, notified about the removal
+     * @param course the course the thread belongs to
+     */
+    public void onThreadDeleted(Post post, @Nullable User actor, Course course) {
+        courseMemoryIngestionService.handleThreadDeleted(post, actor, course);
+    }
+}

src/main/java/de/tum/cit/aet/artemis/iris/domain/CourseMemoryOperation.java

@@ -0,0 +1,16 @@
+package de.tum.cit.aet.artemis.iris.domain;
+
+/**
+ * Which Course Memory operation a Pyris webhook run performs. Both share the same job type and
+ * status callback, so the job has to carry this to interpret a completion.
+ */
+public enum CourseMemoryOperation {
+    /**
+     * A thread's Q/A entry is being written or refreshed.
+     */
+    INGEST,
+    /**
+     * A thread's entry is being removed because it stopped being resolved.
+     */
+    DELETE
+}

src/main/java/de/tum/cit/aet/artemis/iris/domain/CourseMemoryStage.java

@@ -0,0 +1,20 @@
+package de.tum.cit.aet.artemis.iris.domain;
+
+/**
+ * How far a Course Memory run has got. Sent to the acting user so the UI can report that ingestion
+ * actually started (as opposed to being skipped) and later that it finished.
+ */
+public enum CourseMemoryStage {
+    /**
+     * Artemis has dispatched the webhook to Pyris.
+     */
+    TRIGGERED,
+    /**
+     * Pyris reported the run finished.
+     */
+    COMPLETED,
+    /**
+     * Pyris reported the run failed.
+     */
+    FAILED
+}

src/main/java/de/tum/cit/aet/artemis/iris/dto/IrisCourseMemoryStatusDTO.java

@@ -0,0 +1,40 @@
+package de.tum.cit.aet.artemis.iris.dto;
+
+import org.jspecify.annotations.Nullable;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.iris.domain.CourseMemoryOperation;
+import de.tum.cit.aet.artemis.iris.domain.CourseMemoryStage;
+
+/**
+ * Progress of a Course Memory run, pushed over the websocket to the user who triggered it on
+ * {@code /topic/iris/course-memory/{courseId}}.
+ * <p>
+ * {@code TRIGGERED} is sent by Artemis at the moment it dispatches the webhook — not when the user
+ * clicks — because ingestion is conditional: non-public channels, Iris-disabled courses and
+ * bot-authored answers are skipped, and a retraction dispatches a deletion instead. A client-side
+ * toast fired on the HTTP response would claim ingestion started in all of those cases.
+ * {@code COMPLETED} / {@code FAILED} arrive later, from Pyris' status callback.
+ *
+ * @param operation    whether the run writes or removes the entry
+ * @param stage        how far the run has got
+ * @param courseId     the course the entry is scoped to
+ * @param postId       stringified id of the thread's root post, the entry's key
+ * @param errorMessage failure detail reported by Pyris, only set for {@link CourseMemoryStage#FAILED}
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record IrisCourseMemoryStatusDTO(CourseMemoryOperation operation, CourseMemoryStage stage, long courseId, String postId, @Nullable String errorMessage) {
+
+    public static IrisCourseMemoryStatusDTO triggered(CourseMemoryOperation operation, long courseId, String postId) {
+        return new IrisCourseMemoryStatusDTO(operation, CourseMemoryStage.TRIGGERED, courseId, postId, null);
+    }
+
+    public static IrisCourseMemoryStatusDTO completed(CourseMemoryOperation operation, long courseId, String postId) {
+        return new IrisCourseMemoryStatusDTO(operation, CourseMemoryStage.COMPLETED, courseId, postId, null);
+    }
+
+    public static IrisCourseMemoryStatusDTO failed(CourseMemoryOperation operation, long courseId, String postId, @Nullable String errorMessage) {
+        return new IrisCourseMemoryStatusDTO(operation, CourseMemoryStage.FAILED, courseId, postId, errorMessage);
+    }
+}