diff --git a/packages/common/index.ts b/packages/common/index.ts
index 319b935a5..2cd088932 100644
--- a/packages/common/index.ts
+++ b/packages/common/index.ts
@@ -1753,6 +1753,7 @@ export class LMSCourseIntegrationPartial {
   lmsSynchronize!: boolean
   isExpired!: boolean
   selectedResourceTypes?: LMSResourceType[]
+  moduleLinkedPagesOnly?: boolean
 }
 
 export type LMSCourseAPIResponse = {
@@ -1790,6 +1791,7 @@ export type LMSPage = {
   syncEnabled?: boolean
   modified?: Date
   uploaded?: Date
+  isModuleLinked?: boolean
 }
 
 export type LMSFile = {
@@ -1803,6 +1805,23 @@ export type LMSFile = {
   uploaded?: Date
 }
 
+export type LMSModule = {
+  id: number
+  name: string
+  items_url?: string
+  items?: LMSModuleItem[]
+}
+
+export type LMSModuleItem = {
+  id: number
+  title: string
+  type: string
+  content_id?: number
+  html_url?: string
+  url?: string
+  page_url?: string
+}
+
 export enum LMSQuizAccessLevel {
   LOGISTICS_ONLY = 'logistics_only',
   LOGISTICS_AND_QUESTIONS = 'logistics_and_questions',
diff --git a/packages/frontend/app/(dashboard)/course/[cid]/(settings)/settings/lms_integrations/page.tsx b/packages/frontend/app/(dashboard)/course/[cid]/(settings)/settings/lms_integrations/page.tsx
index e05bb8361..b0f116636 100644
--- a/packages/frontend/app/(dashboard)/course/[cid]/(settings)/settings/lms_integrations/page.tsx
+++ b/packages/frontend/app/(dashboard)/course/[cid]/(settings)/settings/lms_integrations/page.tsx
@@ -127,12 +127,17 @@ export default function CourseLMSIntegrationPage(props: {
   const [delModalOpen, setDelModalOpen] = useState<boolean>(false)
   const [isTesting, setIsTesting] = useState<boolean>(false)
   const [selectedResources, setSelectedResources] = useState<string[]>([])
+  const [moduleLinkedPagesOnly, setModuleLinkedPagesOnly] =
+    useState<boolean>(false)
 
   useEffect(() => {
     if (integration?.selectedResourceTypes) {
       setSelectedResources(integration.selectedResourceTypes)
     }
-  }, [integration?.selectedResourceTypes])
+    if (integration?.moduleLinkedPagesOnly !== undefined) {
+      setModuleLinkedPagesOnly(integration.moduleLinkedPagesOnly)
+    }
+  }, [integration?.selectedResourceTypes, integration?.moduleLinkedPagesOnly])
 
   const onSelectedResourcesChange: GetProp<
     typeof Checkbox.Group,
@@ -145,9 +150,18 @@ export default function CourseLMSIntegrationPage(props: {
     if (!integration?.selectedResourceTypes) return false
     const currentSorted = [...selectedResources].sort()
     const dbSorted = [...integration.selectedResourceTypes].sort()
-    if (currentSorted.length !== dbSorted.length) return true
-    return currentSorted.some((item, index) => item !== dbSorted[index])
-  }, [selectedResources, integration?.selectedResourceTypes])
+    const resourcesChanged =
+      currentSorted.length !== dbSorted.length ||
+      currentSorted.some((item, index) => item !== dbSorted[index])
+    const moduleLinkedChanged =
+      moduleLinkedPagesOnly !== integration.moduleLinkedPagesOnly
+    return resourcesChanged || moduleLinkedChanged
+  }, [
+    selectedResources,
+    integration?.selectedResourceTypes,
+    moduleLinkedPagesOnly,
+    integration?.moduleLinkedPagesOnly,
+  ])
 
   const fetchOrgIntegrationsAsync = useCallback(async () => {
     await API.lmsIntegration
@@ -286,16 +300,42 @@ export default function CourseLMSIntegrationPage(props: {
   }
 
   const handleSaveAndResync = async () => {
-    try {
-      await API.lmsIntegration.updateSelectedResourceTypes(
-        courseId,
-        selectedResources as string[],
-      )
-      message.success('Resource types updated!')
-      await forceSync()
-      setUpdateFlag(!updateFlag)
-    } catch (err) {
-      message.error(getErrorMessage(err))
+    const wasModuleLinkedDisabled = !integration?.moduleLinkedPagesOnly
+    const isEnablingModuleLinked =
+      wasModuleLinkedDisabled && moduleLinkedPagesOnly
+
+    const performUpdate = async () => {
+      try {
+        await API.lmsIntegration.updateSelectedResourceTypes(
+          courseId,
+          selectedResources as string[],
+        )
+
+        await API.lmsIntegration.updateModuleLinkedPagesOnly(
+          courseId,
+          moduleLinkedPagesOnly,
+        )
+
+        message.success('Settings updated!')
+        await forceSync()
+        setUpdateFlag(!updateFlag)
+      } catch (err) {
+        message.error(getErrorMessage(err))
+      }
+    }
+
+    if (isEnablingModuleLinked) {
+      Modal.confirm({
+        title: 'Enable Module-linked Pages Only?',
+        content:
+          'Enabling "Module-linked pages only" will remove any standalone pages (not linked in course modules) from the chatbot. ' +
+          'Only pages that are specifically linked within course modules will remain available to the chatbot.',
+        okText: 'Continue',
+        cancelText: 'Cancel',
+        onOk: performUpdate,
+      })
+    } else {
+      await performUpdate()
     }
   }
 
@@ -810,43 +850,78 @@ export default function CourseLMSIntegrationPage(props: {
                         label: 'Resource Selector',
                         key: '2',
                         children: (
-                          <div className={'flex flex-col items-center gap-2'}>
+                          <div
+                            className={
+                              'flex flex-col items-center gap-4 px-4 py-2'
+                            }
+                          >
                             <Checkbox.Group
                               style={{ width: '100%' }}
                               onChange={onSelectedResourcesChange}
                               value={selectedResources}
                             >
-                              <Row gutter={[16, 16]}>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="assignments">
-                                    Assignments
-                                  </Checkbox>
+                              <Row gutter={[24, 16]}>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="assignments">
+                                      Assignments
+                                    </Checkbox>
+                                  </div>
                                 </Col>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="announcements">
-                                    Announcements
-                                  </Checkbox>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="announcements">
+                                      Announcements
+                                    </Checkbox>
+                                  </div>
                                 </Col>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="files">Files</Checkbox>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="files">Files</Checkbox>
+                                  </div>
                                 </Col>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="pages">Pages</Checkbox>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="pages">Pages</Checkbox>
+                                  </div>
                                 </Col>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="quizzes">Quizzes</Checkbox>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="quizzes">Quizzes</Checkbox>
+                                  </div>
                                 </Col>
-                                <Col xs={24} sm={12} md={8}>
-                                  <Checkbox value="Syllabus" disabled={true}>
-                                    <Tooltip title="Coming Soon!">
-                                      <span className="text-gray-400 line-through">
-                                        Syllabus
-                                      </span>
-                                    </Tooltip>
-                                  </Checkbox>
+                                <Col xs={24} sm={12} lg={8}>
+                                  <div className="flex min-h-[50px] items-center p-3">
+                                    <Checkbox value="Syllabus" disabled={true}>
+                                      <Tooltip title="Coming Soon!">
+                                        <span className="text-gray-400 line-through">
+                                          Syllabus
+                                        </span>
+                                      </Tooltip>
+                                    </Checkbox>
+                                  </div>
                                 </Col>
                               </Row>
                             </Checkbox.Group>
+
+                            {/* Module-linked pages toggle */}
+                            {selectedResources.includes('pages') && (
+                              <div className="mt-4 w-full rounded-lg bg-gray-50 p-3">
+                                <Checkbox
+                                  checked={moduleLinkedPagesOnly}
+                                  onChange={(e) => {
+                                    setModuleLinkedPagesOnly(e.target.checked)
+                                  }}
+                                >
+                                  <Tooltip title="Only sync pages that are linked within course modules. When enabled, standalone pages will be excluded from the chatbot. WARNING: This will remove any previously synced standalone pages from the chatbot when you save changes.">
+                                    <span className="text-sm font-medium">
+                                      Module-linked pages only
+                                    </span>
+                                  </Tooltip>
+                                </Checkbox>
+                              </div>
+                            )}
+
                             <Button
                               size={'large'}
                               shape={'round'}
@@ -866,7 +941,7 @@ export default function CourseLMSIntegrationPage(props: {
                               style={{ marginTop: '30px' }}
                               onClick={handleSaveAndResync}
                               loading={syncing && integration.lmsSynchronize}
-                              className="w-full sm:w-auto"
+                              className="w-full sm:w-auto md:max-w-xs lg:max-w-sm"
                             >
                               <span className="hidden sm:inline">
                                 Save and Re-Sync Documents
diff --git a/packages/frontend/app/api/index.ts b/packages/frontend/app/api/index.ts
index 28031576f..eb115c8cf 100644
--- a/packages/frontend/app/api/index.ts
+++ b/packages/frontend/app/api/index.ts
@@ -1440,6 +1440,16 @@ class APIClient {
       this.req('POST', `/api/v1/lms/course/${courseId}/resources`, undefined, {
         selectedResourceTypes,
       }),
+    updateModuleLinkedPagesOnly: async (
+      courseId: number,
+      moduleLinkedPagesOnly: boolean,
+    ): Promise<string> =>
+      this.req(
+        'PUT',
+        `/api/v1/lms/course/${courseId}/module-pages-only`,
+        undefined,
+        { moduleLinkedPagesOnly },
+      ),
     testIntegration: async (
       courseId: number,
       props: TestLMSIntegrationParams,
diff --git a/packages/server/src/lmsIntegration/lmsCourseIntegration.entity.ts b/packages/server/src/lmsIntegration/lmsCourseIntegration.entity.ts
index 76c33d916..bd05898f8 100644
--- a/packages/server/src/lmsIntegration/lmsCourseIntegration.entity.ts
+++ b/packages/server/src/lmsIntegration/lmsCourseIntegration.entity.ts
@@ -69,6 +69,9 @@ export class LMSCourseIntegrationModel extends BaseEntity {
   @OneToMany((type) => LMSPageModel, (page) => page.course)
   pages: LMSPageModel[];
 
+  @Column({ type: 'boolean', default: false })
+  moduleLinkedPagesOnly: boolean;
+
   @OneToMany((type) => LMSFileModel, (file) => file.course)
   files: LMSFileModel[];
 
diff --git a/packages/server/src/lmsIntegration/lmsIntegration.adapter.ts b/packages/server/src/lmsIntegration/lmsIntegration.adapter.ts
index 3896652f7..a53e4b4d8 100644
--- a/packages/server/src/lmsIntegration/lmsIntegration.adapter.ts
+++ b/packages/server/src/lmsIntegration/lmsIntegration.adapter.ts
@@ -7,6 +7,8 @@ import {
   LMSCourseAPIResponse,
   LMSFile,
   LMSIntegrationPlatform,
+  LMSModule,
+  LMSModuleItem,
   LMSPage,
   LMSQuiz,
 } from '@koh/common';
@@ -83,6 +85,13 @@ export abstract class AbstractLMSAdapter {
     return null;
   }
 
+  async getModules(): Promise<{
+    status: LMSApiResponseStatus;
+    modules: LMSModule[];
+  }> {
+    return null;
+  }
+
   async getFiles(): Promise<{
     status: LMSApiResponseStatus;
     files: LMSFile[];
@@ -103,6 +112,13 @@ export abstract class AbstractLMSAdapter {
         return '';
     }
   }
+
+  async clearPageCache(): Promise<void> {
+    if (this.cacheManager) {
+      const pagesKey = `pages_basic_${this.integration.apiCourseId}`;
+      await this.cacheManager.del(pagesKey);
+    }
+  }
 }
 
 abstract class ImplementedLMSAdapter extends AbstractLMSAdapter {
@@ -173,7 +189,7 @@ class CanvasLMSAdapter extends ImplementedLMSAdapter {
         }
       })
       .catch((error) => {
-        console.log(
+        console.error(
           `Error contacting ${this.integration.orgIntegration.rootUrl}: ${error}`,
         );
         return { status: LMSApiResponseStatus.Error };
@@ -370,34 +386,41 @@ class CanvasLMSAdapter extends ImplementedLMSAdapter {
     status: LMSApiResponseStatus;
     pages: LMSPage[];
   }> {
-    const pagesKey = `pages_complete_${this.integration.apiCourseId}`;
+    const pagesKey = `pages_basic_${this.integration.apiCourseId}`;
 
+    let basicPages: any[] | null = null;
     if (this.cacheManager) {
-      const cachedPages = await this.cacheManager.get(pagesKey);
-      if (cachedPages) {
-        return cachedPages as {
-          status: LMSApiResponseStatus;
-          pages: LMSPage[];
-        };
-      }
+      basicPages = await this.cacheManager.get(pagesKey);
     }
 
-    // If not cached, fetch as normal
-    const { status, data } = await this.GetPaginated(
-      `courses/${this.integration.apiCourseId}/pages`,
-    );
+    if (!basicPages) {
+      const { status, data } = await this.GetPaginated(
+        `courses/${this.integration.apiCourseId}/pages`,
+      );
+
+      if (status != LMSApiResponseStatus.Success) return { status, pages: [] };
 
-    if (status != LMSApiResponseStatus.Success) return { status, pages: [] };
+      basicPages = data.filter((datum: any) => datum.published == true);
+
+      if (this.cacheManager) {
+        await this.cacheManager.set(pagesKey, basicPages, 600000);
+      }
+    }
+
+    // Always fetch module-linked status fresh (not cached)
+    const moduleLinkedPageUrls = await this.getModuleLinkedPageUrls();
 
     const pages: LMSPage[] = [];
 
     // Individual page calls will now be cached by the Get() method
-    for (const page of data.filter((datum: any) => datum.published == true)) {
+    for (const page of basicPages) {
       const pageResult = await this.Get(
         `courses/${this.integration.apiCourseId}/pages/${page.url}`,
       );
 
       if (pageResult.status === LMSApiResponseStatus.Success) {
+        const isModuleLinked = moduleLinkedPageUrls.includes(page.url);
+
         pages.push({
           id: pageResult.data.page_id,
           title: pageResult.data.title,
@@ -405,21 +428,92 @@ class CanvasLMSAdapter extends ImplementedLMSAdapter {
           url: page.url,
           frontPage: page.front_page,
           modified: new Date(pageResult.data.updated_at),
+          isModuleLinked,
         });
       }
     }
 
-    const result = {
+    return {
       status: LMSApiResponseStatus.Success,
       pages,
     };
+  }
 
-    // Cache complete result for 10 minutes
-    if (this.cacheManager) {
-      await this.cacheManager.set(pagesKey, result, 600000);
+  private async getModuleLinkedPageUrls(): Promise<string[]> {
+    const modulesResult = await this.getModules();
+    if (modulesResult.status !== LMSApiResponseStatus.Success) {
+      return [];
     }
 
-    return result;
+    const pageUrls: string[] = [];
+
+    for (const module of modulesResult.modules) {
+      const itemsResult = await this.getModuleItems(module.id);
+      if (itemsResult.status === LMSApiResponseStatus.Success) {
+        const pageItems = itemsResult.items.filter(
+          (item) => item.type === 'Page',
+        );
+
+        for (const item of pageItems) {
+          let pageUrl = item.page_url;
+
+          if (!pageUrl && item.url) {
+            const match = item.url.match(/\/pages\/([^\/\?]+)/);
+            if (match) {
+              pageUrl = match[1];
+            }
+          }
+
+          if (pageUrl) {
+            pageUrls.push(pageUrl);
+          }
+        }
+      }
+    }
+
+    const uniqueUrls = [...new Set(pageUrls)];
+    return uniqueUrls;
+  }
+
+  async getModules(): Promise<{
+    status: LMSApiResponseStatus;
+    modules: LMSModule[];
+  }> {
+    const { status, data } = await this.GetPaginated(
+      `courses/${this.integration.apiCourseId}/modules`,
+    );
+
+    if (status != LMSApiResponseStatus.Success) return { status, modules: [] };
+
+    const modules: LMSModule[] = data
+      .filter((module: any) => module.published == true)
+      .map((module: any) => {
+        return {
+          id: module.id,
+          name: module.name,
+          items_url: module.items_url,
+        } as LMSModule;
+      });
+
+    return {
+      status: LMSApiResponseStatus.Success,
+      modules,
+    };
+  }
+
+  async getModuleItems(moduleId: number): Promise<{
+    status: LMSApiResponseStatus;
+    items: LMSModuleItem[];
+  }> {
+    const { status, data } = await this.GetPaginated(
+      `courses/${this.integration.apiCourseId}/modules/${moduleId}/items`,
+    );
+
+    if (status != LMSApiResponseStatus.Success) return { status, items: [] };
+    return {
+      status: LMSApiResponseStatus.Success,
+      items: data,
+    };
   }
 
   async getFiles(): Promise<{
@@ -482,9 +576,7 @@ class CanvasLMSAdapter extends ImplementedLMSAdapter {
 
       // Placeholder questions if no questions fetched from the API
       if (questionsData.length === 0 && quizData?.question_count > 0) {
-        console.log(
-          `Quiz ${quiz.id}: No question details available (likely permissions), using question_count: ${quizData.question_count}`,
-        );
+        // No question details available (likely permissions), using question_count
         for (let i = 1; i <= quizData.question_count; i++) {
           questionsData.push({
             id: `placeholder_${quiz.id}_${i}`,
diff --git a/packages/server/src/lmsIntegration/lmsIntegration.controller.ts b/packages/server/src/lmsIntegration/lmsIntegration.controller.ts
index a93b3eb2d..ee36320d0 100644
--- a/packages/server/src/lmsIntegration/lmsIntegration.controller.ts
+++ b/packages/server/src/lmsIntegration/lmsIntegration.controller.ts
@@ -10,7 +10,7 @@ import {
   Post,
   UseGuards,
 } from '@nestjs/common';
-import { Get } from '@nestjs/common/decorators';
+import { Get, Put } from '@nestjs/common/decorators';
 import {
   ERROR_MESSAGES,
   LMSApiResponseStatus,
@@ -510,14 +510,6 @@ export class LMSIntegrationController {
       );
     }
 
-    const selectedResources: LMSResourceType[] =
-      integration.selectedResourceTypes;
-    if (!selectedResources.includes(LMSResourceType.QUIZZES)) {
-      throw new BadRequestException(
-        ERROR_MESSAGES.lmsController.resourceDisabled,
-      );
-    }
-
     return await this.integrationService.getItems(courseId, LMSGet.Quizzes);
   }
 
@@ -775,6 +767,20 @@ export class LMSIntegrationController {
       );
     }
 
+    if (
+      newState &&
+      uploadType === LMSUpload.Pages &&
+      integration.moduleLinkedPagesOnly
+    ) {
+      const page = item as LMSPage;
+      if (!page.isModuleLinked) {
+        throw new HttpException(
+          'Cannot sync unlinked page when "Module-linked pages only" setting is enabled',
+          HttpStatus.BAD_REQUEST,
+        );
+      }
+    }
+
     try {
       const result = await this.integrationService.singleDocOperation(
         courseId,
@@ -886,4 +892,25 @@ export class LMSIntegrationController {
 
     return `Successfully updated selected resource types for course ${courseId}.`;
   }
+
+  @Put('course/:courseId/module-pages-only')
+  @UseGuards(JwtAuthGuard, CourseRolesGuard)
+  @Roles(Role.PROFESSOR)
+  async updateModuleLinkedPagesOnly(
+    @Param('courseId', ParseIntPipe) courseId: number,
+    @Body() body: { moduleLinkedPagesOnly: boolean },
+  ): Promise<string> {
+    const integration = await LMSCourseIntegrationModel.findOne({
+      where: { courseId },
+    });
+
+    if (!integration) {
+      throw new HttpException('Integration not found', HttpStatus.NOT_FOUND);
+    }
+
+    integration.moduleLinkedPagesOnly = body.moduleLinkedPagesOnly;
+    await LMSCourseIntegrationModel.save(integration);
+
+    return `Successfully updated module pages setting for course ${courseId}.`;
+  }
 }
diff --git a/packages/server/src/lmsIntegration/lmsIntegration.service.ts b/packages/server/src/lmsIntegration/lmsIntegration.service.ts
index d25fd1cdc..f408f097e 100644
--- a/packages/server/src/lmsIntegration/lmsIntegration.service.ts
+++ b/packages/server/src/lmsIntegration/lmsIntegration.service.ts
@@ -330,6 +330,7 @@ export class LMSIntegrationService {
               modified: pages[idx].modified ?? found.modified,
               uploaded: found.uploaded,
               syncEnabled: found.syncEnabled,
+              isModuleLinked: found.isModuleLinked,
             };
           }
         }
@@ -469,6 +470,11 @@ export class LMSIntegrationService {
       errors: 0,
     };
 
+    const adapterForCache = await this.getAdapter(courseId);
+    if (adapterForCache) {
+      await adapterForCache.clearPageCache();
+    }
+
     // maybe add this later to fallback to all resources if db fetch does not work
 
     //   const selectedResources: LMSResourceType[] =
@@ -579,6 +585,22 @@ export class LMSIntegrationService {
           break;
         case LMSUpload.Pages:
           items = result.pages;
+          if (courseIntegration.moduleLinkedPagesOnly) {
+            const allPages = items as LMSPage[];
+            const moduleLinkedPages = allPages.filter(
+              (page) => page.isModuleLinked === true,
+            );
+            if (moduleLinkedPages.length === 0 && allPages.length > 0) {
+              console.warn(
+                `Module-linked pages only setting is enabled for course ${courseId}, ` +
+                  `but no pages were detected as module-linked out of ${allPages.length} total pages. ` +
+                  `This might indicate that no pages are linked in course modules, or there's a ` +
+                  `configuration issue. Proceeding with filter - this will remove all page content from chatbot.`,
+              );
+            }
+
+            items = moduleLinkedPages;
+          }
           break;
         case LMSUpload.Files:
           items = result.files;
@@ -596,13 +618,29 @@ export class LMSIntegrationService {
         | LMSQuizModel
       )[] = modelAndPersisted.items;
 
-      const toRemove: (
+      let toRemove: (
         | LMSAnnouncementModel
         | LMSAssignmentModel
         | LMSPageModel
         | LMSFileModel
         | LMSQuizModel
-      )[] = persistedItems.filter((i0) => !items.find((i1) => i1.id == i0.id));
+      )[] = [];
+
+      if (type === LMSUpload.Pages && courseIntegration.moduleLinkedPagesOnly) {
+        const allPagesFromLMS = result.pages as LMSPage[];
+        const persistedPages = persistedItems as LMSPageModel[];
+
+        toRemove = persistedPages.filter((persistedPage) => {
+          const currentLMSPage = allPagesFromLMS.find(
+            (p) => p.id === persistedPage.id,
+          );
+          return !currentLMSPage || !currentLMSPage.isModuleLinked;
+        });
+      } else {
+        toRemove = persistedItems.filter(
+          (i0) => !items.find((i1) => i1.id == i0.id),
+        );
+      }
 
       if (toRemove.length > 0) {
         // the code below led to inconsistent behaviour of syncDocuments when items
@@ -1315,6 +1353,7 @@ export class LMSIntegrationService {
         lmsIntegration.apiKeyExpiry != undefined &&
         new Date(lmsIntegration.apiKeyExpiry).getTime() < new Date().getTime(),
       selectedResourceTypes: lmsIntegration.selectedResourceTypes,
+      moduleLinkedPagesOnly: lmsIntegration.moduleLinkedPagesOnly,
     } satisfies LMSCourseIntegrationPartial;
   }
 
@@ -1386,10 +1425,6 @@ export class LMSIntegrationService {
       await quiz.save();
 
       if (quiz.syncEnabled && quiz.chatbotDocumentId) {
-        console.log(
-          `Updating chatbot document for quiz ${quizId} with new access level: ${accessLevel}`,
-        );
-
         await this.singleDocOperation(
           courseId,
           quiz,
@@ -1403,8 +1438,6 @@ export class LMSIntegrationService {
           LMSUpload.Quizzes,
           'Sync',
         );
-
-        console.log(`Successfully updated chatbot document for quiz ${quizId}`);
       }
 
       return true;
diff --git a/packages/server/src/lmsIntegration/lmsPage.entity.ts b/packages/server/src/lmsIntegration/lmsPage.entity.ts
index 375de7ad2..178a7c14c 100644
--- a/packages/server/src/lmsIntegration/lmsPage.entity.ts
+++ b/packages/server/src/lmsIntegration/lmsPage.entity.ts
@@ -47,6 +47,9 @@ export class LMSPageModel extends BaseEntity {
   @Column({ type: 'boolean', default: true })
   syncEnabled: boolean;
 
+  @Column({ type: 'boolean', default: false })
+  isModuleLinked: boolean;
+
   @ManyToOne(
     (type) => LMSCourseIntegrationModel,
     (integration) => integration.pages,
diff --git a/packages/server/test/lmsIntegration.integration.ts b/packages/server/test/lmsIntegration.integration.ts
index 30b0a57e0..3e3e8e6ca 100644
--- a/packages/server/test/lmsIntegration.integration.ts
+++ b/packages/server/test/lmsIntegration.integration.ts
@@ -275,16 +275,6 @@ describe('Lms Integration Integrations', () => {
       });
     });
 
-    describe('GET /lms/:courseId/quizzes', () => {
-      it('should return 400 when quiz resource is disabled', async () => {
-        const res = await supertest({ userId: prof.id }).get(
-          `/lms/${course.id}/quizzes`,
-        );
-        expect(res.status).toBe(400);
-        expect(res.body.message).toContain('resource type');
-      });
-    });
-
     describe('GET /lms/:courseId/quiz/:quizId/preview/:accessLevel', () => {
       it('should return 400 when quiz resource is disabled', async () => {
         const res = await supertest({ userId: prof.id }).get(