Iris: Course Memory ingestion

src/main/java/de/tum/cit/aet/artemis/communication/repository/AnswerPostRepository.java

@@ -212,4 +212,43 @@ default void userHasAccessToAllAnswerPostsElseThrow(Collection<Long> answerPostI
             throw new AccessForbiddenException("AnswerPost", answerPostIds);
         }
     }
+
+    /**
+     * Whether the answer post carries a human verifier, i.e. whether a tutor approved it in the verification dashboard.
+     * <p>
+     * An Iris answer published automatically on a high confidence score is also stored as {@code verified}, but with no
+     * {@code verifiedBy} — see {@code AutonomousTutorService#createAndSaveAnswerPost}, which sets only {@code verifiedAt}
+     * because there is no human reviewer. {@code verifiedBy} is therefore what tells the two apart.
+     * <p>
+     * Queried as a projection rather than read off the entity on purpose: {@code AnswerPost#verifiedBy} is a lazy
+     * {@code @ManyToOne} that the thread-loading query does not fetch, and adding it there would put an extra user join
+     * on a hot read path.
+     *
+     * @param answerPostId the ID of the {@link AnswerPost} to check
+     * @return {@code true} if a user is recorded as the verifier, {@code false} if none is or the answer post does not exist
+     */
+    @Query("""
+            SELECT CASE WHEN COUNT(answerPost) > 0 THEN TRUE ELSE FALSE END
+            FROM AnswerPost answerPost
+            WHERE answerPost.id = :answerPostId
+                AND answerPost.verifiedBy IS NOT NULL
+            """)
+    boolean hasHumanVerifier(@Param("answerPostId") long answerPostId);
+
+    /**
+     * Returns the login of the user recorded as the verifier of the given {@link AnswerPost}.
+     * <p>
+     * Queried rather than navigated from the entity because {@code verifiedBy} is lazy and is not part of
+     * the eager thread fetch, so reading it off a detached answer would fail outside a transaction.
+     *
+     * @param answerPostId the ID of the {@link AnswerPost} to look up
+     * @return the verifier's login, or empty if none is recorded or the answer post does not exist
+     */
+    @Query("""
+            SELECT answerPost.verifiedBy.login
+            FROM AnswerPost answerPost
+            WHERE answerPost.id = :answerPostId
+                AND answerPost.verifiedBy IS NOT NULL
+            """)
+    Optional<String> findVerifierLoginById(@Param("answerPostId") long answerPostId);
 }

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,9 +257,35 @@ public AnswerPost updateAnswerMessage(Long courseId, Long answerMessageId, Updat
         syncAnswerPostWithWeaviate(updatedAnswerMessage, conversation);
 
         this.preparePostAndBroadcast(updatedAnswerMessage, course);
+
+        // Trigger B: the thread's resolution state changed, or the text an existing entry was built from
+        // did. Resolution changes fire in both directions so un-marking the last resolving answer retracts
+        // the entry instead of leaving it served as verified. Content edits re-ingest because the entry
+        // would otherwise keep serving the wording the author just corrected — the upsert is keyed on the
+        // thread, so re-sending it replaces the entry rather than adding a second one.
+        if (resolutionChanged || contributesToCourseMemory(updatedAnswerMessage)) {
+            try {
+                courseMemoryIngestionApi.ifPresent(api -> api.onThreadResolutionChanged(updatedAnswerMessage.getPost(), updatedAnswerMessage, user, course));
+            }
+            catch (Exception e) {
+                log.error("Failed to update course memory after update of answer post {}", updatedAnswerMessage.getId(), e);
+            }
+        }
         return updatedAnswerMessage;
     }
 
+    /**
+     * Whether this answer is what a thread's Course Memory entry would have been built from, i.e. whether
+     * changing or removing it has to be reflected there. True for an answer that resolves the thread and
+     * for a verified Iris answer, which the verification trigger stores in its own right.
+     *
+     * @param answerMessage the answer to check
+     * @return {@code true} if the thread's entry depends on this answer
+     */
+    private boolean contributesToCourseMemory(AnswerPost answerMessage) {
+        return Boolean.TRUE.equals(answerMessage.doesResolvePost()) || (answerMessage.getAuthor() != null && answerMessage.getAuthor().isBot() && answerMessage.isVerified());
+    }
+
     private Conversation mayUpdateOrDeleteAnswerMessageElseThrow(AnswerPost existingAnswerPost, User user) {
         boolean userIsAuthor = existingAnswerPost.getAuthor().getId().equals(user.getId());
         Conversation conversation = existingAnswerPost.getPost().getConversation();
@@ -296,6 +328,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. Evaluated
+        // before the delete, while the answer is still loaded.
+        boolean contributedToCourseMemory = contributesToCourseMemory(answerMessage);
+
         // 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 +351,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 +432,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;
     }
 
@@ -376,6 +380,19 @@ public Post updateMessage(Long courseId, Long postId, UpdatePostingDTO messagePo
         preparePostForBroadcast(updatedPost);
         broadcastForPost(updatedPost, MetisCrudAction.UPDATE, course.getId(), null);
 
+        // The stored Course Memory question is derived from this post, so an edited question has to be
+        // re-extracted; otherwise Iris keeps matching future students against the wording that was just
+        // corrected. Only resolved threads have an entry to update, and the upsert is keyed on the thread,
+        // so this replaces the entry rather than adding a second one.
+        if (updatedPost.isResolved()) {
+            try {
+                courseMemoryIngestionApi.ifPresent(api -> api.onThreadResolutionChanged(updatedPost, null, user, course));
+            }
+            catch (Exception e) {
+                log.error("Failed to update course memory after edit of thread {}", updatedPost.getId(), e);
+            }
+        }
+
         return updatedPost;
     }
 
@@ -412,6 +429,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/communication/service/conversation/ChannelService.java

@@ -13,6 +13,8 @@
 
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Lazy;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
@@ -36,13 +38,16 @@
 import de.tum.cit.aet.artemis.globalsearch.config.schema.entityschemas.SearchableEntitySchema;
 import de.tum.cit.aet.artemis.globalsearch.dto.searchableentity.ChannelSearchableEntityDTO;
 import de.tum.cit.aet.artemis.globalsearch.service.SearchableEntityWeaviateService;
+import de.tum.cit.aet.artemis.iris.api.CourseMemoryIngestionApi;
 import de.tum.cit.aet.artemis.lecture.domain.Lecture;
 
 @Profile(PROFILE_CORE)
 @Lazy
 @Service
 public class ChannelService {
 
+    private static final Logger log = LoggerFactory.getLogger(ChannelService.class);
+
     public static final String CHANNEL_ENTITY_NAME = "messages.channel";
 
     private static final String CHANNEL_NAME_REGEX = "^[a-z0-9$][a-z0-9:\\-]{0,30}$";
@@ -59,15 +64,18 @@ public class ChannelService {
 
     private final Optional<SearchableEntityWeaviateService> searchableEntityWeaviateService;
 
+    private final Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi;
+
     public ChannelService(ConversationParticipantRepository conversationParticipantRepository, ChannelRepository channelRepository, ConversationService conversationService,
             UserRepository userRepository, StudentParticipationRepository studentParticipationRepository,
-            Optional<SearchableEntityWeaviateService> searchableEntityWeaviateServiceOptional) {
+            Optional<SearchableEntityWeaviateService> searchableEntityWeaviateServiceOptional, Optional<CourseMemoryIngestionApi> courseMemoryIngestionApi) {
         this.conversationParticipantRepository = conversationParticipantRepository;
         this.channelRepository = channelRepository;
         this.conversationService = conversationService;
         this.userRepository = userRepository;
         this.studentParticipationRepository = studentParticipationRepository;
         this.searchableEntityWeaviateService = searchableEntityWeaviateServiceOptional;
+        this.courseMemoryIngestionApi = courseMemoryIngestionApi;
     }
 
     private void syncChannelWithWeaviate(Channel channel) {
@@ -223,10 +231,33 @@ public void deleteChannel(@Nullable Channel channel) {
                 service.deleteEntityAsync(SearchableEntitySchema.TypeValues.CHANNEL, channel.getId());
                 service.deleteAllPostsForChannelAsync(channel.getId());
             });
+            // Course Memory entries outlive the posts they were mined from, so the channel going away has
+            // to retract them explicitly — otherwise Iris keeps serving answers whose source is gone.
+            removeChannelFromCourseMemory(channel);
             conversationService.deleteConversation(channel.getId());
         }
     }
 
+    /**
+     * Retracts every Course Memory entry mined from the given channel, because the channel was deleted or
+     * is no longer a public place Iris may draw from. Best-effort: a failure here must not abort the
+     * channel operation that triggered it.
+     *
+     * @param channel the channel whose entries should be removed
+     */
+    public void removeChannelFromCourseMemory(Channel channel) {
+        if (channel == null || channel.getId() == null || channel.getCourse() == null) {
+            return;
+        }
+        try {
+            User user = userRepository.getUser();
+            courseMemoryIngestionApi.ifPresent(api -> api.onChannelNoLongerEligible(channel, user, channel.getCourse()));
+        }
+        catch (Exception e) {
+            log.error("Failed to remove course memory entries of channel {}", channel.getId(), e);
+        }
+    }
+
     /**
      * Checks if the given channel is valid for the given course or throws an
      * exception