diff --git a/app/api/extract-document/route.ts b/app/api/extract-document/route.ts
new file mode 100644
index 0000000000..582eeca7f6
--- /dev/null
+++ b/app/api/extract-document/route.ts
@@ -0,0 +1,184 @@
+import { NextRequest } from 'next/server';
+import {
+  isServerConfiguredProvider,
+  resolvePDFApiKey,
+  resolvePDFBaseUrl,
+} from '@/lib/server/provider-config';
+import { PDF_PROVIDERS } from '@/lib/pdf/constants';
+import type { PDFProviderId } from '@/lib/pdf/types';
+import type { ParsedPdfContent } from '@/lib/types/pdf';
+import {
+  documentArtifactToParsedPdfContent,
+  getDocumentExtractorProvider,
+  selectDocumentExtractorProvider,
+} from '@/lib/document';
+import { normalizeDocumentMimeType } from '@/lib/document/mime';
+import { createLogger } from '@/lib/logger';
+import { apiError, apiSuccess } from '@/lib/server/api-response';
+import { validateUrlForSSRF } from '@/lib/server/ssrf-guard';
+
+const log = createLogger('Extract Document');
+
+function isPdfProviderId(providerId: string): providerId is PDFProviderId {
+  return providerId in PDF_PROVIDERS;
+}
+
+function supportsMimeType(provider: { supportedMimeTypes: string[] }, mimeType: string): boolean {
+  return provider.supportedMimeTypes.map((type) => type.toLowerCase()).includes(mimeType);
+}
+
+function isSelfHostedMinerUProvider(
+  providerId: string,
+): providerId is Extract<PDFProviderId, 'mineru'> {
+  return providerId === 'mineru';
+}
+
+function requestedTypeLabel(mimeType: string): string {
+  if (mimeType === 'application/vnd.openxmlformats-officedocument.wordprocessingml.document') {
+    return 'DOCX';
+  }
+  if (mimeType === 'application/vnd.openxmlformats-officedocument.presentationml.presentation') {
+    return 'PPTX';
+  }
+  return mimeType;
+}
+
+export async function POST(req: NextRequest) {
+  let fileName: string | undefined;
+  let resolvedProviderId: string | undefined;
+  try {
+    const contentType = req.headers.get('content-type') || '';
+    if (!contentType.includes('multipart/form-data')) {
+      log.error('Invalid Content-Type for document upload:', contentType);
+      return apiError(
+        'INVALID_REQUEST',
+        400,
+        `Invalid Content-Type: expected multipart/form-data, got "${contentType}"`,
+      );
+    }
+
+    const formData = await req.formData();
+    const documentFile = (formData.get('file') || formData.get('pdf')) as File | null;
+    const preferredProviderId = formData.get('providerId') as string | null;
+    const apiKey = formData.get('apiKey') as string | null;
+    const baseUrl = formData.get('baseUrl') as string | null;
+
+    if (!documentFile) {
+      return apiError('MISSING_REQUIRED_FIELD', 400, 'No course material file provided');
+    }
+
+    fileName = documentFile.name;
+    const mimeType = normalizeDocumentMimeType({
+      mimeType: documentFile.type,
+      fileName: documentFile.name,
+    });
+    if (!mimeType) {
+      return apiError(
+        'INVALID_REQUEST',
+        400,
+        `Unsupported course material type for "${documentFile.name}"`,
+      );
+    }
+
+    let provider = preferredProviderId
+      ? getDocumentExtractorProvider(preferredProviderId)
+      : undefined;
+    if (preferredProviderId && !provider) {
+      return apiError(
+        'INVALID_REQUEST',
+        400,
+        `Unknown document extractor provider: ${preferredProviderId}`,
+      );
+    }
+
+    if (provider && !supportsMimeType(provider, mimeType)) provider = undefined;
+
+    try {
+      provider =
+        provider ||
+        selectDocumentExtractorProvider({
+          mimeType,
+          requiredCapabilities: { text: true },
+        });
+    } catch (error) {
+      return apiError(
+        'INVALID_REQUEST',
+        400,
+        error instanceof Error ? error.message : `Unsupported course material type "${mimeType}"`,
+      );
+    }
+    resolvedProviderId = provider.id;
+
+    let managed = isPdfProviderId(provider.id) && isServerConfiguredProvider('pdf', provider.id);
+    let clientBaseUrl = managed ? undefined : baseUrl || undefined;
+    if (isSelfHostedMinerUProvider(provider.id) && !managed && !clientBaseUrl) {
+      const cloudProvider = getDocumentExtractorProvider('mineru-cloud');
+      const cloudManaged = isServerConfiguredProvider('pdf', 'mineru-cloud');
+      const cloudApiKey = resolvePDFApiKey(
+        'mineru-cloud',
+        cloudManaged ? undefined : apiKey || undefined,
+      );
+      if (cloudProvider && supportsMimeType(cloudProvider, mimeType) && cloudApiKey) {
+        provider = cloudProvider;
+        managed = cloudManaged;
+        clientBaseUrl = managed ? undefined : baseUrl || undefined;
+        resolvedProviderId = provider.id;
+      }
+    }
+    if (isSelfHostedMinerUProvider(provider.id) && !managed && !clientBaseUrl) {
+      return apiError(
+        'INVALID_REQUEST',
+        422,
+        `${requestedTypeLabel(mimeType)} extraction requires a configured MinerU document extractor. Configure a self-hosted MinerU base URL or a MinerU Cloud API key in PDF provider settings.`,
+      );
+    }
+    if (clientBaseUrl && process.env.NODE_ENV === 'production') {
+      const ssrfError = await validateUrlForSSRF(clientBaseUrl);
+      if (ssrfError) {
+        return apiError('INVALID_URL', 403, ssrfError);
+      }
+    }
+
+    const config = {
+      providerId: provider.id,
+      apiKey: isPdfProviderId(provider.id)
+        ? resolvePDFApiKey(provider.id, managed ? undefined : apiKey || undefined)
+        : apiKey || undefined,
+      baseUrl: isPdfProviderId(provider.id)
+        ? resolvePDFBaseUrl(provider.id, clientBaseUrl)
+        : clientBaseUrl,
+    };
+
+    const arrayBuffer = await documentFile.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    const artifact = await provider.extract({
+      buffer,
+      fileName: documentFile.name,
+      fileSize: documentFile.size,
+      mimeType,
+      config,
+    });
+    const result = documentArtifactToParsedPdfContent(artifact);
+
+    const resultWithMetadata: ParsedPdfContent = {
+      ...result,
+      metadata: {
+        ...result.metadata,
+        pageCount: result.metadata?.pageCount ?? 0,
+        fileName: documentFile.name,
+        fileSize: documentFile.size,
+        mimeType,
+        parser: result.metadata?.parser ?? provider.id,
+      },
+    };
+
+    return apiSuccess({ data: resultWithMetadata });
+  } catch (error) {
+    log.error(
+      `Document extraction failed [provider=${resolvedProviderId ?? 'unknown'}, file="${fileName ?? 'unknown'}"]:`,
+      error,
+    );
+    return apiError('PARSE_FAILED', 500, error instanceof Error ? error.message : 'Unknown error');
+  }
+}
diff --git a/app/generation-preview/page.tsx b/app/generation-preview/page.tsx
index b489a67875..6dccc88c7b 100644
--- a/app/generation-preview/page.tsx
+++ b/app/generation-preview/page.tsx
@@ -37,7 +37,12 @@ import type { Stage } from '@/lib/types/stage';
 import type { SceneOutline, PdfImage, ImageMapping } from '@/lib/types/generation';
 import { AgentRevealModal } from '@/components/agent/agent-reveal-modal';
 import { createLogger } from '@/lib/logger';
-import { type GenerationSessionState, ALL_STEPS, getActiveSteps } from './types';
+import {
+  type GenerationSessionState,
+  ALL_STEPS,
+  getActiveSteps,
+  getGenerationStepText,
+} from './types';
 import { StepVisualizer } from './components/visualizers';
 import { resolveTaskEngineModeFromOutlineDoneEvent } from './vocational-mode';
 
@@ -231,7 +236,7 @@ function GenerationPreviewContent() {
     abortControllerRef.current = controller;
     const signal = controller.signal;
 
-    // Use a local mutable copy so we can update it after PDF parsing
+    // Use a local mutable copy so we can update it after document extraction
     let currentSession = generationSession;
 
     setError(null);
@@ -241,38 +246,38 @@ function GenerationPreviewContent() {
       // Compute active steps for this session (recomputed after session mutations)
       let activeSteps = getActiveSteps(currentSession);
 
-      // Determine if we need the PDF analysis step
+      // Determine if we need the document analysis step
       const hasPdfToAnalyze = !!currentSession.pdfStorageKey && !currentSession.pdfText;
-      // If no PDF to analyze, skip to the next available step
+      // If no document to analyze, skip to the next available step
       if (!hasPdfToAnalyze) {
         const firstNonPdfIdx = activeSteps.findIndex((s) => s.id !== 'pdf-analysis');
         setCurrentStepIndex(Math.max(0, firstNonPdfIdx));
       }
 
-      // Step 0: Parse PDF if needed
+      // Step 0: Extract uploaded course material if needed
       if (hasPdfToAnalyze) {
-        log.debug('=== Generation Preview: Parsing PDF ===');
+        log.debug('=== Generation Preview: Extracting course material ===');
         const pdfBlob = await loadPdfBlob(currentSession.pdfStorageKey!);
         if (!pdfBlob) {
-          throw new Error(t('generation.pdfLoadFailed'));
+          throw new Error(t('generation.courseMaterialLoadFailed'));
         }
 
         // Ensure pdfBlob is a valid Blob with content
         if (!(pdfBlob instanceof Blob) || pdfBlob.size === 0) {
-          log.error('Invalid PDF blob:', {
+          log.error('Invalid course material blob:', {
             type: typeof pdfBlob,
             size: pdfBlob instanceof Blob ? pdfBlob.size : 'N/A',
           });
-          throw new Error(t('generation.pdfLoadFailed'));
+          throw new Error(t('generation.courseMaterialLoadFailed'));
         }
 
         // Wrap as a File to guarantee multipart/form-data with correct content-type
         const pdfFile = new File([pdfBlob], currentSession.pdfFileName || 'document.pdf', {
-          type: 'application/pdf',
+          type: currentSession.documentMimeType || pdfBlob.type || 'application/pdf',
         });
 
         const parseFormData = new FormData();
-        parseFormData.append('pdf', pdfFile);
+        parseFormData.append('file', pdfFile);
 
         if (currentSession.pdfProviderId) {
           parseFormData.append('providerId', currentSession.pdfProviderId);
@@ -284,7 +289,7 @@ function GenerationPreviewContent() {
           parseFormData.append('baseUrl', currentSession.pdfProviderConfig.baseUrl);
         }
 
-        const parseResponse = await fetch('/api/parse-pdf', {
+        const parseResponse = await fetch('/api/extract-document', {
           method: 'POST',
           body: parseFormData,
           signal,
@@ -292,12 +297,12 @@ function GenerationPreviewContent() {
 
         if (!parseResponse.ok) {
           const errorData = await parseResponse.json();
-          throw new Error(errorData.error || t('generation.pdfParseFailed'));
+          throw new Error(errorData.error || t('generation.courseMaterialParseFailed'));
         }
 
         const parseResult = await parseResponse.json();
         if (!parseResult.success || !parseResult.data) {
-          throw new Error(t('generation.pdfParseFailed'));
+          throw new Error(t('generation.courseMaterialParseFailed'));
         }
 
         let pdfText = parseResult.data.text as string;
@@ -358,7 +363,7 @@ function GenerationPreviewContent() {
           }),
         );
 
-        // Update session with parsed PDF data
+        // Update session with extracted document data
         const updatedSession = {
           ...currentSession,
           pdfText,
@@ -1137,6 +1142,7 @@ function GenerationPreviewContent() {
     activeSteps.length > 0
       ? activeSteps[Math.min(currentStepIndex, activeSteps.length - 1)]
       : ALL_STEPS[0];
+  const activeStepText = getGenerationStepText(activeStep, session);
 
   if (isReviewingOutlines) {
     const outlineStepIndex = Math.max(
@@ -1327,14 +1333,14 @@ function GenerationPreviewContent() {
                         ? t('generation.generationFailed')
                         : isComplete
                           ? t('generation.generationComplete')
-                          : t(activeStep.title)}
+                          : t(activeStepText.title, activeStepText.titleValues)}
                     </h2>
                     <p className="text-muted-foreground text-base">
                       {error
                         ? error
                         : isComplete
                           ? t('generation.classroomReady')
-                          : statusMessage || t(activeStep.description)}
+                          : statusMessage || t(activeStepText.description)}
                     </p>
                   </motion.div>
                 </AnimatePresence>
diff --git a/app/generation-preview/types.ts b/app/generation-preview/types.ts
index f5b1637b89..9d3b943cd4 100644
--- a/app/generation-preview/types.ts
+++ b/app/generation-preview/types.ts
@@ -21,6 +21,7 @@ export interface GenerationSessionState {
   // PDF deferred parsing fields
   pdfStorageKey?: string;
   pdfFileName?: string;
+  documentMimeType?: string;
   pdfProviderId?: string;
   pdfProviderConfig?: { apiKey?: string; baseUrl?: string };
   // Web search context
@@ -42,11 +43,48 @@ export type GenerationStep = {
   type: 'analysis' | 'writing' | 'visual';
 };
 
+function getDocumentTypeLabel(session: GenerationSessionState | null): string {
+  const mimeType = session?.documentMimeType;
+  if (mimeType) {
+    if (mimeType === 'application/pdf') return 'PDF';
+    if (mimeType.includes('wordprocessingml')) return 'DOCX';
+    if (mimeType.includes('presentationml')) return 'PPTX';
+    if (mimeType === 'text/plain') return 'TXT';
+    if (mimeType.includes('markdown')) return 'Markdown';
+  }
+  const extension = session?.pdfFileName?.split('.').pop()?.trim().toLowerCase();
+  if (extension === 'pdf') return 'PDF';
+  if (extension === 'docx') return 'DOCX';
+  if (extension === 'pptx') return 'PPTX';
+  if (extension === 'txt') return 'TXT';
+  if (extension === 'md' || extension === 'markdown') return 'Markdown';
+  return 'document';
+}
+
+export function getGenerationStepText(
+  step: GenerationStep,
+  session: GenerationSessionState | null,
+) {
+  if (step.id === 'pdf-analysis') {
+    const documentType = getDocumentTypeLabel(session);
+    return {
+      title: 'generation.analyzingCourseMaterial',
+      titleValues: { type: documentType },
+      description: 'generation.analyzingCourseMaterialDesc',
+    };
+  }
+  return {
+    title: step.title,
+    titleValues: undefined,
+    description: step.description,
+  };
+}
+
 export const ALL_STEPS: GenerationStep[] = [
   {
     id: 'pdf-analysis',
-    title: 'generation.analyzingPdf',
-    description: 'generation.analyzingPdfDesc',
+    title: 'generation.analyzingCourseMaterial',
+    description: 'generation.analyzingCourseMaterialDesc',
     icon: ScanLine,
     type: 'analysis',
   },
diff --git a/app/page.tsx b/app/page.tsx
index b4d32e8cbb..c27bda6b23 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -37,6 +37,7 @@ import { AgentBar } from '@/components/agent/agent-bar';
 import { useTheme } from '@/lib/hooks/use-theme';
 import { nanoid } from 'nanoid';
 import { storePdfBlob } from '@/lib/utils/image-storage';
+import { normalizeDocumentMimeType } from '@/lib/document/mime';
 import type { UserRequirements } from '@/lib/types/generation';
 import { useSettingsStore } from '@/lib/store/settings';
 import { hasUsableLLMProvider } from '@/lib/store/settings-validation';
@@ -307,12 +308,17 @@ function HomePage() {
 
       let pdfStorageKey: string | undefined;
       let pdfFileName: string | undefined;
+      let documentMimeType: string | undefined;
       let pdfProviderId: string | undefined;
       let pdfProviderConfig: { apiKey?: string; baseUrl?: string } | undefined;
 
       if (form.pdfFile) {
         pdfStorageKey = await storePdfBlob(form.pdfFile);
         pdfFileName = form.pdfFile.name;
+        documentMimeType = normalizeDocumentMimeType({
+          mimeType: form.pdfFile.type,
+          fileName: form.pdfFile.name,
+        });
 
         const settings = useSettingsStore.getState();
         pdfProviderId = settings.pdfProviderId;
@@ -333,6 +339,7 @@ function HomePage() {
         imageStorageIds: [],
         pdfStorageKey,
         pdfFileName,
+        documentMimeType,
         pdfProviderId,
         pdfProviderConfig,
         sceneOutlines: null,
diff --git a/components/generation/generation-toolbar.tsx b/components/generation/generation-toolbar.tsx
index ca651b23d2..dc7e019009 100644
--- a/components/generation/generation-toolbar.tsx
+++ b/components/generation/generation-toolbar.tsx
@@ -36,10 +36,11 @@ import {
 } from '@/lib/ai/thinking-config';
 import type { SettingsSection } from '@/lib/types/settings';
 import { MediaPopover } from '@/components/generation/media-popover';
+import { COURSE_MATERIAL_ACCEPT, isSupportedCourseMaterial } from '@/lib/document/mime';
 
 // ─── Constants ───────────────────────────────────────────────
-const MAX_PDF_SIZE_MB = 50;
-const MAX_PDF_SIZE_BYTES = MAX_PDF_SIZE_MB * 1024 * 1024;
+const MAX_COURSE_MATERIAL_SIZE_MB = 50;
+const MAX_COURSE_MATERIAL_SIZE_BYTES = MAX_COURSE_MATERIAL_SIZE_MB * 1024 * 1024;
 
 // ─── Types ───────────────────────────────────────────────────
 export interface GenerationToolbarProps {
@@ -112,10 +113,13 @@ export function GenerationToolbar({
   const currentThinkingConfig =
     thinkingConfigs[getThinkingConfigKey(currentProviderId, currentModelId)];
 
-  // PDF handler
+  // Course material handler
   const handleFileSelect = (file: File) => {
-    if (file.type !== 'application/pdf') return;
-    if (file.size > MAX_PDF_SIZE_BYTES) {
+    if (!isSupportedCourseMaterial({ mimeType: file.type, fileName: file.name })) {
+      onPdfError(t('upload.unsupportedCourseMaterial'));
+      return;
+    }
+    if (file.size > MAX_COURSE_MATERIAL_SIZE_BYTES) {
       onPdfError(t('upload.fileTooLarge'));
       return;
     }
@@ -169,7 +173,7 @@ export function GenerationToolbar({
         {/* ── Separator ── */}
         <div className="w-px h-4 bg-border/60 mx-1" />
 
-        {/* ── PDF (parser + upload) combined Popover ── */}
+        {/* ── Course material (extractor + upload) combined Popover ── */}
         <Popover>
           <PopoverTrigger asChild>
             {pdfFile ? (
@@ -194,10 +198,10 @@ export function GenerationToolbar({
             )}
           </PopoverTrigger>
           <PopoverContent align="start" className="w-72 p-0">
-            {/* Parser selector */}
+            {/* Extractor selector */}
             <div className="flex items-center gap-2 px-3 pt-3 pb-2">
               <span className="text-xs font-medium text-muted-foreground shrink-0">
-                {t('toolbar.pdfParser')}
+                {t('toolbar.documentExtractor')}
               </span>
               <Select
                 value={pdfProviderId}
@@ -239,7 +243,7 @@ export function GenerationToolbar({
                 type="file"
                 ref={fileInputRef}
                 className="hidden"
-                accept=".pdf"
+                accept={COURSE_MATERIAL_ACCEPT}
                 onChange={(e) => {
                   const f = e.target.files?.[0];
                   if (f) handleFileSelect(f);
@@ -263,7 +267,7 @@ export function GenerationToolbar({
                     onClick={() => onPdfFileChange(null)}
                     className="w-full text-xs text-destructive hover:underline text-left"
                   >
-                    {t('toolbar.removePdf')}
+                    {t('toolbar.removeCourseMaterial')}
                   </button>
                 </div>
               ) : (
@@ -288,9 +292,9 @@ export function GenerationToolbar({
                   }}
                 >
                   <Paperclip className="size-5 text-muted-foreground/50 mb-1.5" />
-                  <p className="text-xs font-medium">{t('toolbar.pdfUpload')}</p>
+                  <p className="text-xs font-medium">{t('toolbar.courseMaterialUpload')}</p>
                   <p className="text-[10px] text-muted-foreground/60 mt-0.5">
-                    {t('upload.pdfSizeLimit')}
+                    {t('upload.courseMaterialSizeLimit')}
                   </p>
                 </div>
               )}
diff --git a/lib/document/extractors/pdf.ts b/lib/document/extractors/pdf.ts
index 2e17247a5a..893e159313 100644
--- a/lib/document/extractors/pdf.ts
+++ b/lib/document/extractors/pdf.ts
@@ -1,6 +1,8 @@
-import { parsePDF } from '@/lib/pdf/pdf-providers';
+import { parseWithMinerUCloud } from '@/lib/pdf/mineru-cloud';
+import { parsePDF, parseWithMinerUDocument } from '@/lib/pdf/pdf-providers';
 import { PDF_PROVIDERS } from '@/lib/pdf/constants';
 import type { PDFProviderConfig, PDFProviderId } from '@/lib/pdf/types';
+import { DOCUMENT_MIME_TYPES } from '../mime';
 import { parsedPdfToDocumentArtifact } from '../pdf-compat';
 import type {
   DocumentExtractorCapabilities,
@@ -8,7 +10,12 @@ import type {
   DocumentExtractorProvider,
 } from '../types';
 
-const PDF_MIME_TYPES = ['application/pdf'];
+const PDF_MIME_TYPES = [DOCUMENT_MIME_TYPES.pdf];
+const MINERU_DOCUMENT_MIME_TYPES = [
+  DOCUMENT_MIME_TYPES.pdf,
+  DOCUMENT_MIME_TYPES.docx,
+  DOCUMENT_MIME_TYPES.pptx,
+];
 
 function capabilitiesFromPdfProvider(
   provider: PDFProviderConfig,
@@ -32,17 +39,24 @@ function createPdfBackedDocumentExtractor(id: PDFProviderId): DocumentExtractorP
   return {
     id,
     displayName: pdfProvider.name,
-    supportedMimeTypes: PDF_MIME_TYPES,
+    supportedMimeTypes:
+      id === 'mineru' || id === 'mineru-cloud' ? MINERU_DOCUMENT_MIME_TYPES : PDF_MIME_TYPES,
     capabilities: capabilitiesFromPdfProvider(pdfProvider, id),
     async extract(input: DocumentExtractorInput) {
-      const parsed = await parsePDF(
-        {
-          providerId: id,
-          apiKey: input.config.apiKey,
-          baseUrl: input.config.baseUrl,
-        },
-        input.buffer,
-      );
+      const config = {
+        providerId: id,
+        apiKey: input.config.apiKey,
+        baseUrl: input.config.baseUrl,
+      };
+      const parsed =
+        id === 'mineru-cloud'
+          ? await parseWithMinerUCloud(config, input.buffer, input.fileName)
+          : input.mimeType === DOCUMENT_MIME_TYPES.pdf
+            ? await parsePDF(config, input.buffer)
+            : await parseWithMinerUDocument(config, input.buffer, {
+                fileName: input.fileName || 'document',
+                mimeType: input.mimeType,
+              });
 
       return parsedPdfToDocumentArtifact(parsed, input);
     },
diff --git a/lib/document/extractors/registry.ts b/lib/document/extractors/registry.ts
index 5a3d9ccb59..50092877ee 100644
--- a/lib/document/extractors/registry.ts
+++ b/lib/document/extractors/registry.ts
@@ -1,8 +1,14 @@
 import { pdfDocumentExtractorProviders } from './pdf';
+import { textDocumentExtractorProvider } from './text';
 import type { DocumentExtractorProvider, DocumentExtractorProviderId } from '../types';
 
+const documentExtractorProviders = [
+  textDocumentExtractorProvider,
+  ...pdfDocumentExtractorProviders,
+];
+
 const DOCUMENT_EXTRACTOR_PROVIDERS: Record<DocumentExtractorProviderId, DocumentExtractorProvider> =
-  Object.fromEntries(pdfDocumentExtractorProviders.map((provider) => [provider.id, provider]));
+  Object.fromEntries(documentExtractorProviders.map((provider) => [provider.id, provider]));
 
 export function getDocumentExtractorProviders(): DocumentExtractorProvider[] {
   return Object.values(DOCUMENT_EXTRACTOR_PROVIDERS);
diff --git a/lib/document/extractors/text.ts b/lib/document/extractors/text.ts
new file mode 100644
index 0000000000..b8d4ce850f
--- /dev/null
+++ b/lib/document/extractors/text.ts
@@ -0,0 +1,53 @@
+import { DOCUMENT_MIME_TYPES } from '../mime';
+import type { DocumentExtractorProvider } from '../types';
+
+const TEXT_MIME_TYPES = [DOCUMENT_MIME_TYPES.txt, DOCUMENT_MIME_TYPES.markdown, 'text/x-markdown'];
+
+function textDecoderForBuffer(buffer: Buffer): TextDecoder {
+  if (buffer.length >= 2) {
+    if (buffer[0] === 0xff && buffer[1] === 0xfe) return new TextDecoder('utf-16le');
+    if (buffer[0] === 0xfe && buffer[1] === 0xff) return new TextDecoder('utf-16be');
+  }
+  if (buffer.length >= 3 && buffer[0] === 0xef && buffer[1] === 0xbb && buffer[2] === 0xbf) {
+    return new TextDecoder('utf-8');
+  }
+
+  return new TextDecoder('utf-8');
+}
+
+export const textDocumentExtractorProvider: DocumentExtractorProvider = {
+  id: 'plain-text',
+  displayName: 'Plain Text',
+  supportedMimeTypes: TEXT_MIME_TYPES,
+  capabilities: {
+    text: true,
+    images: false,
+    tables: false,
+    formulas: false,
+    layout: false,
+    ocr: false,
+    async: false,
+  },
+  async extract(input) {
+    const text = textDecoderForBuffer(input.buffer).decode(input.buffer);
+    const isMarkdown =
+      input.mimeType === DOCUMENT_MIME_TYPES.markdown || input.mimeType === 'text/x-markdown';
+    return {
+      metadata: {
+        fileName: input.fileName,
+        fileSize: input.fileSize,
+        mimeType: input.mimeType,
+        providerId: 'plain-text',
+      },
+      blocks: [
+        {
+          id: 'text_1',
+          type: isMarkdown ? 'markdown' : 'text',
+          text,
+        },
+      ],
+      assets: [],
+      diagnostics: [],
+    };
+  },
+};
diff --git a/lib/document/index.ts b/lib/document/index.ts
index 714b365325..59d86a9f05 100644
--- a/lib/document/index.ts
+++ b/lib/document/index.ts
@@ -4,6 +4,13 @@ export {
   getDocumentExtractorProviders,
   selectDocumentExtractorProvider,
 } from './extractors/registry';
+export {
+  COURSE_MATERIAL_ACCEPT,
+  DOCUMENT_MIME_TYPES,
+  SUPPORTED_COURSE_MATERIAL_MIME_TYPES,
+  isSupportedCourseMaterial,
+  normalizeDocumentMimeType,
+} from './mime';
 export { documentArtifactToParsedPdfContent, parsedPdfToDocumentArtifact } from './pdf-compat';
 export type {
   DocumentArtifact,
diff --git a/lib/document/mime.ts b/lib/document/mime.ts
new file mode 100644
index 0000000000..a2c5837116
--- /dev/null
+++ b/lib/document/mime.ts
@@ -0,0 +1,72 @@
+export const DOCUMENT_MIME_TYPES = {
+  pdf: 'application/pdf',
+  docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  txt: 'text/plain',
+  markdown: 'text/markdown',
+} as const;
+
+export const SUPPORTED_COURSE_MATERIAL_MIME_TYPES = [
+  DOCUMENT_MIME_TYPES.pdf,
+  DOCUMENT_MIME_TYPES.docx,
+  DOCUMENT_MIME_TYPES.pptx,
+  DOCUMENT_MIME_TYPES.txt,
+  DOCUMENT_MIME_TYPES.markdown,
+  'text/x-markdown',
+] as const;
+
+export const COURSE_MATERIAL_ACCEPT = [
+  '.pdf',
+  '.docx',
+  '.pptx',
+  '.txt',
+  '.md',
+  '.markdown',
+  ...SUPPORTED_COURSE_MATERIAL_MIME_TYPES,
+].join(',');
+
+const MIME_BY_EXTENSION: Record<string, string> = {
+  pdf: DOCUMENT_MIME_TYPES.pdf,
+  docx: DOCUMENT_MIME_TYPES.docx,
+  pptx: DOCUMENT_MIME_TYPES.pptx,
+  txt: DOCUMENT_MIME_TYPES.txt,
+  md: DOCUMENT_MIME_TYPES.markdown,
+  markdown: DOCUMENT_MIME_TYPES.markdown,
+};
+
+const GENERIC_DOCUMENT_MIME_TYPES = new Set([
+  'application/octet-stream',
+  'application/zip',
+  'application/x-zip',
+  'application/x-zip-compressed',
+]);
+
+export function normalizeDocumentMimeType(input: {
+  mimeType?: string | null;
+  fileName?: string | null;
+}): string {
+  const mimeType = input.mimeType?.split(';')[0]?.trim().toLowerCase();
+  const extension = input.fileName?.split('.').pop()?.toLowerCase();
+  const mimeTypeFromExtension = extension ? MIME_BY_EXTENSION[extension] : undefined;
+
+  if (mimeTypeFromExtension && (!mimeType || GENERIC_DOCUMENT_MIME_TYPES.has(mimeType))) {
+    return mimeTypeFromExtension;
+  }
+
+  if (mimeType) {
+    if (mimeType === 'text/x-markdown') return DOCUMENT_MIME_TYPES.markdown;
+    return mimeType;
+  }
+
+  return mimeTypeFromExtension || '';
+}
+
+export function isSupportedCourseMaterial(input: {
+  mimeType?: string | null;
+  fileName?: string | null;
+}): boolean {
+  const normalized = normalizeDocumentMimeType(input);
+  return SUPPORTED_COURSE_MATERIAL_MIME_TYPES.includes(
+    normalized as (typeof SUPPORTED_COURSE_MATERIAL_MIME_TYPES)[number],
+  );
+}
diff --git a/lib/document/pdf-compat.ts b/lib/document/pdf-compat.ts
index 64b17abd70..d8b112fe4f 100644
--- a/lib/document/pdf-compat.ts
+++ b/lib/document/pdf-compat.ts
@@ -51,6 +51,10 @@ function pdfLayoutType(value: unknown): NonNullable<ParsedPdfContent['layout']>[
     : 'text';
 }
 
+function isMinerUMarkdownParser(parser: unknown): boolean {
+  return parser === 'mineru' || parser === 'mineru-cloud';
+}
+
 export function parsedPdfToDocumentArtifact(
   parsed: ParsedPdfContent,
   input: DocumentExtractorInput,
@@ -60,7 +64,7 @@ export function parsedPdfToDocumentArtifact(
   if (parsed.text) {
     blocks.push({
       id: 'document-text',
-      type: parsed.metadata?.parser === 'mineru' ? 'markdown' : 'text',
+      type: isMinerUMarkdownParser(parsed.metadata?.parser) ? 'markdown' : 'text',
       text: parsed.text,
     });
   }
diff --git a/lib/i18n/locales/ar-SA.json b/lib/i18n/locales/ar-SA.json
index 7aef8b20af..79f52e9a2e 100644
--- a/lib/i18n/locales/ar-SA.json
+++ b/lib/i18n/locales/ar-SA.json
@@ -13,6 +13,9 @@
     "pdfParser": "محلل PDF",
     "pdfUpload": "رفع PDF",
     "removePdf": "إزالة الملف",
+    "documentExtractor": "مستخرج المستندات",
+    "courseMaterialUpload": "رفع مادة المقرر",
+    "removeCourseMaterial": "إزالة الملف",
     "webSearchOn": "مُفعّل",
     "webSearchOff": "انقر للتفعيل",
     "webSearchDesc": "البحث في الإنترنت عن معلومات محدّثة قبل التوليد",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "يدعم ملفات PDF حتى 50 ميغابايت",
+    "courseMaterialSizeLimit": "يدعم ملفات PDF وDOCX وPPTX وTXT وMarkdown حتى 50 ميغابايت",
     "generateFailed": "فشل توليد الفصل، يرجى المحاولة مرة أخرى",
     "requirementPlaceholder": "أخبرني بأي شيء تريد تعلمه، مثلاً:\n\"علمني بايثون من الصفر في 30 دقيقة\"\n\"اشرح تحويل فورييه على السبورة\"\n\"كيف تلعب لعبة أفالون\"",
     "requirementRequired": "يرجى إدخال متطلبات المقرر",
-    "fileTooLarge": "الملف كبير جدًا. يرجى اختيار ملف PDF أصغر من 50 ميغابايت"
+    "fileTooLarge": "الملف كبير جدًا. يرجى اختيار ملف أصغر من 50 ميغابايت",
+    "unsupportedCourseMaterial": "نوع مادة المقرر غير مدعوم. يرجى رفع PDF أو DOCX أو PPTX أو TXT أو Markdown."
   },
   "generation": {
-    "analyzingPdf": "تحليل مستند PDF",
-    "analyzingPdfDesc": "جارٍ استخراج هيكل المستند ومحتواه...",
     "pdfLoadFailed": "فشل تحميل ملف PDF، يرجى المحاولة مرة أخرى",
     "pdfParseFailed": "فشل تحليل PDF",
+    "analyzingCourseMaterial": "تحليل ملف {{type}}",
+    "analyzingCourseMaterialDesc": "جارٍ استخراج هيكل المستند ومحتواه...",
+    "courseMaterialLoadFailed": "فشل تحميل مادة المقرر، يرجى المحاولة مرة أخرى",
+    "courseMaterialParseFailed": "فشل تحليل مادة المقرر",
     "streamNotReadable": "تعذرت قراءة تدفق التوليد",
     "generatingOutlines": "صياغة مخطط المقرر",
     "generatingOutlinesDesc": "جارٍ هيكلة مسار التعلم...",
diff --git a/lib/i18n/locales/en-US.json b/lib/i18n/locales/en-US.json
index ea062ed378..8d82dc301f 100644
--- a/lib/i18n/locales/en-US.json
+++ b/lib/i18n/locales/en-US.json
@@ -13,6 +13,9 @@
     "pdfParser": "Parser",
     "pdfUpload": "Upload PDF",
     "removePdf": "Remove file",
+    "documentExtractor": "Extractor",
+    "courseMaterialUpload": "Upload course material",
+    "removeCourseMaterial": "Remove file",
     "webSearchOn": "Enabled",
     "webSearchOff": "Click to enable",
     "webSearchDesc": "Search the web for up-to-date information before generation",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "Supports PDF files up to 50MB",
+    "courseMaterialSizeLimit": "Supports PDF, DOCX, PPTX, TXT, and Markdown files up to 50MB",
     "generateFailed": "Failed to generate classroom, please try again",
     "requirementPlaceholder": "Tell me anything you want to learn, e.g.\n\"Teach me Python from scratch in 30 minutes\"\n\"Explain Fourier Transform on the whiteboard\"\n\"How to play the board game Avalon\"",
     "requirementRequired": "Please enter course requirements",
-    "fileTooLarge": "File too large. Please select a PDF file smaller than 50MB"
+    "fileTooLarge": "File too large. Please select a file smaller than 50MB",
+    "unsupportedCourseMaterial": "Unsupported course material type. Please upload PDF, DOCX, PPTX, TXT, or Markdown."
   },
   "generation": {
-    "analyzingPdf": "Analyzing PDF Document",
-    "analyzingPdfDesc": "Extracting document structure and content...",
     "pdfLoadFailed": "Failed to load PDF file, please try again",
     "pdfParseFailed": "PDF parsing failed",
+    "analyzingCourseMaterial": "Analyzing {{type}} file",
+    "analyzingCourseMaterialDesc": "Extracting document structure and content...",
+    "courseMaterialLoadFailed": "Failed to load course material, please try again",
+    "courseMaterialParseFailed": "Course material parsing failed",
     "streamNotReadable": "Unable to read generation stream",
     "generatingOutlines": "Drafting Course Outline",
     "generatingOutlinesDesc": "Structuring the learning path...",
diff --git a/lib/i18n/locales/ja-JP.json b/lib/i18n/locales/ja-JP.json
index 2c113f9294..1e91d86ce7 100644
--- a/lib/i18n/locales/ja-JP.json
+++ b/lib/i18n/locales/ja-JP.json
@@ -13,6 +13,9 @@
     "pdfParser": "パーサー",
     "pdfUpload": "PDFをアップロード",
     "removePdf": "ファイルを削除",
+    "documentExtractor": "抽出器",
+    "courseMaterialUpload": "教材をアップロード",
+    "removeCourseMaterial": "ファイルを削除",
     "webSearchOn": "有効",
     "webSearchOff": "クリックして有効化",
     "webSearchDesc": "生成前にウェブ検索で最新情報を取得します",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "50MBまでのPDFファイルに対応しています",
+    "courseMaterialSizeLimit": "50MBまでのPDF、DOCX、PPTX、TXT、Markdownファイルに対応しています",
     "generateFailed": "教室の生成に失敗しました。もう一度お試しください",
     "requirementPlaceholder": "学びたいことを自由に入力してください。例えば：\n「Pythonをゼロから30分で教えて」\n「フーリエ変換をホワイトボードで解説して」\n「ボードゲーム『アバロン』の遊び方」",
     "requirementRequired": "コースの要件を入力してください",
-    "fileTooLarge": "ファイルが大きすぎます。50MB以下のPDFファイルを選択してください"
+    "fileTooLarge": "ファイルが大きすぎます。50MB以下のファイルを選択してください",
+    "unsupportedCourseMaterial": "対応していない教材形式です。PDF、DOCX、PPTX、TXT、Markdownをアップロードしてください。"
   },
   "generation": {
-    "analyzingPdf": "PDFドキュメントを分析中",
-    "analyzingPdfDesc": "ドキュメントの構造と内容を抽出しています...",
     "pdfLoadFailed": "PDFファイルの読み込みに失敗しました。もう一度お試しください",
     "pdfParseFailed": "PDFの解析に失敗しました",
+    "analyzingCourseMaterial": "{{type}}ファイルを分析中",
+    "analyzingCourseMaterialDesc": "ドキュメントの構造と内容を抽出しています...",
+    "courseMaterialLoadFailed": "教材の読み込みに失敗しました。もう一度お試しください",
+    "courseMaterialParseFailed": "教材の解析に失敗しました",
     "streamNotReadable": "生成ストリームを読み取れません",
     "generatingOutlines": "コースアウトラインを作成中",
     "generatingOutlinesDesc": "学習パスを構成しています...",
diff --git a/lib/i18n/locales/ko-KR.json b/lib/i18n/locales/ko-KR.json
index 1af5b8dd0e..e6fce68c96 100644
--- a/lib/i18n/locales/ko-KR.json
+++ b/lib/i18n/locales/ko-KR.json
@@ -13,6 +13,9 @@
     "pdfParser": "파서",
     "pdfUpload": "PDF 업로드",
     "removePdf": "파일 제거",
+    "documentExtractor": "추출기",
+    "courseMaterialUpload": "강의 자료 업로드",
+    "removeCourseMaterial": "파일 제거",
     "webSearchOn": "사용 중",
     "webSearchOff": "클릭하여 사용",
     "webSearchDesc": "생성 전 최신 정보를 웹에서 검색합니다",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "최대 50MB PDF 파일을 지원합니다",
+    "courseMaterialSizeLimit": "최대 50MB PDF, DOCX, PPTX, TXT, Markdown 파일을 지원합니다",
     "generateFailed": "교실 생성에 실패했습니다. 다시 시도해주세요",
     "requirementPlaceholder": "학습하고 싶은 내용을 자유롭게 입력하세요, 예:\n\"파이썬을 30분 만에 처음부터 가르쳐주세요\"\n\"칠판에 푸리에 변환을 설명해주세요\"\n\"보드게임 Avalon 하는 방법\"",
     "requirementRequired": "강좌 요구사항을 입력해주세요",
-    "fileTooLarge": "파일이 너무 큽니다. 50MB 미만의 PDF 파일을 선택해주세요"
+    "fileTooLarge": "파일이 너무 큽니다. 50MB 미만의 파일을 선택해주세요",
+    "unsupportedCourseMaterial": "지원하지 않는 강의 자료 형식입니다. PDF, DOCX, PPTX, TXT 또는 Markdown을 업로드해주세요."
   },
   "generation": {
-    "analyzingPdf": "PDF 문서 분석 중",
-    "analyzingPdfDesc": "문서 구조와 내용을 추출하고 있어요...",
     "pdfLoadFailed": "PDF 파일 불러오기에 실패했습니다. 다시 시도해주세요",
     "pdfParseFailed": "PDF 파싱에 실패했습니다",
+    "analyzingCourseMaterial": "{{type}} 파일 분석 중",
+    "analyzingCourseMaterialDesc": "문서 구조와 내용을 추출하고 있어요...",
+    "courseMaterialLoadFailed": "강의 자료를 불러오지 못했습니다. 다시 시도해주세요",
+    "courseMaterialParseFailed": "강의 자료 파싱에 실패했습니다",
     "streamNotReadable": "생성 스트림을 읽을 수 없습니다",
     "generatingOutlines": "강좌 개요 작성 중",
     "generatingOutlinesDesc": "학습 경로를 구성하고 있어요...",
diff --git a/lib/i18n/locales/pt-BR.json b/lib/i18n/locales/pt-BR.json
index 6ce6ad1e71..39ca7b6f7f 100644
--- a/lib/i18n/locales/pt-BR.json
+++ b/lib/i18n/locales/pt-BR.json
@@ -13,6 +13,9 @@
     "pdfParser": "Analisador",
     "pdfUpload": "Enviar PDF",
     "removePdf": "Remover arquivo",
+    "documentExtractor": "Extrator",
+    "courseMaterialUpload": "Enviar material do curso",
+    "removeCourseMaterial": "Remover arquivo",
     "webSearchOn": "Ativada",
     "webSearchOff": "Clique para ativar",
     "webSearchDesc": "Pesquise na web por informações atualizadas antes da geração",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "Suporta arquivos PDF de até 50 MB",
+    "courseMaterialSizeLimit": "Suporta PDF, DOCX, PPTX, TXT e Markdown de até 50 MB",
     "generateFailed": "Falha ao gerar a sala, tente novamente",
     "requirementPlaceholder": "Conte-me o que você quer aprender, por exemplo:\n\"Me ensine Python do zero em 30 minutos\"\n\"Explique a Transformada de Fourier no quadro\"\n\"Como jogar o jogo de tabuleiro Avalon\"",
     "requirementRequired": "Por favor, descreva os objetivos do curso",
-    "fileTooLarge": "Arquivo muito grande. Selecione um PDF com menos de 50 MB"
+    "fileTooLarge": "Arquivo muito grande. Selecione um arquivo com menos de 50 MB",
+    "unsupportedCourseMaterial": "Tipo de material não suportado. Envie PDF, DOCX, PPTX, TXT ou Markdown."
   },
   "generation": {
-    "analyzingPdf": "Analisando o Documento PDF",
-    "analyzingPdfDesc": "Extraindo estrutura e conteúdo do documento...",
     "pdfLoadFailed": "Falha ao carregar o PDF, tente novamente",
     "pdfParseFailed": "Falha ao analisar o PDF",
+    "analyzingCourseMaterial": "Analisando arquivo {{type}}",
+    "analyzingCourseMaterialDesc": "Extraindo estrutura e conteúdo do documento...",
+    "courseMaterialLoadFailed": "Falha ao carregar o material do curso, tente novamente",
+    "courseMaterialParseFailed": "Falha ao analisar o material do curso",
     "streamNotReadable": "Não foi possível ler o fluxo de geração",
     "generatingOutlines": "Esboçando o Roteiro do Curso",
     "generatingOutlinesDesc": "Estruturando o caminho de aprendizagem...",
diff --git a/lib/i18n/locales/ru-RU.json b/lib/i18n/locales/ru-RU.json
index 515fe1291a..0aaf8bec6a 100644
--- a/lib/i18n/locales/ru-RU.json
+++ b/lib/i18n/locales/ru-RU.json
@@ -13,6 +13,9 @@
     "pdfParser": "Парсер",
     "pdfUpload": "Загрузить PDF",
     "removePdf": "Удалить файл",
+    "documentExtractor": "Экстрактор",
+    "courseMaterialUpload": "Загрузить материал курса",
+    "removeCourseMaterial": "Удалить файл",
     "webSearchOn": "Включено",
     "webSearchOff": "Нажмите для включения",
     "webSearchDesc": "Поиск актуальной информации в интернете перед генерацией",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "Поддержка PDF до 50 МБ",
+    "courseMaterialSizeLimit": "Поддержка PDF, DOCX, PPTX, TXT и Markdown до 50 МБ",
     "generateFailed": "Ошибка генерации, попробуйте снова",
     "requirementPlaceholder": "Расскажите, что вы хотите изучить, например:\n\"Научи меня Python с нуля за 30 минут\"\n\"Объясни преобразование Фурье на доске\"\n\"Как играть в настольную игру Авалон\"",
     "requirementRequired": "Пожалуйста, укажите требования к курсу",
-    "fileTooLarge": "Файл слишком большой. Выберите PDF до 50 МБ"
+    "fileTooLarge": "Файл слишком большой. Выберите файл до 50 МБ",
+    "unsupportedCourseMaterial": "Неподдерживаемый тип материала. Загрузите PDF, DOCX, PPTX, TXT или Markdown."
   },
   "generation": {
-    "analyzingPdf": "Анализ PDF-документа",
-    "analyzingPdfDesc": "Извлечение структуры и содержимого документа...",
     "pdfLoadFailed": "Не удалось загрузить PDF, попробуйте снова",
     "pdfParseFailed": "Ошибка обработки PDF",
+    "analyzingCourseMaterial": "Анализ файла {{type}}",
+    "analyzingCourseMaterialDesc": "Извлечение структуры и содержимого документа...",
+    "courseMaterialLoadFailed": "Не удалось загрузить материал курса, попробуйте снова",
+    "courseMaterialParseFailed": "Ошибка обработки материала курса",
     "streamNotReadable": "Не удалось прочитать поток генерации",
     "generatingOutlines": "Создание структуры курса",
     "generatingOutlinesDesc": "Формирование учебной программы...",
diff --git a/lib/i18n/locales/zh-CN.json b/lib/i18n/locales/zh-CN.json
index 568aa7a0c4..fcb725cb20 100644
--- a/lib/i18n/locales/zh-CN.json
+++ b/lib/i18n/locales/zh-CN.json
@@ -13,6 +13,9 @@
     "pdfParser": "解析器",
     "pdfUpload": "上传 PDF",
     "removePdf": "移除文件",
+    "documentExtractor": "文档解析器",
+    "courseMaterialUpload": "上传课程材料",
+    "removeCourseMaterial": "移除文件",
     "webSearchOn": "已开启",
     "webSearchOff": "点击开启",
     "webSearchDesc": "生成前搜索网络获取最新资料，让内容更丰富准确",
@@ -806,16 +809,20 @@
   },
   "upload": {
     "pdfSizeLimit": "支持最大50MB的PDF文件",
+    "courseMaterialSizeLimit": "支持最大 50MB 的 PDF、DOCX、PPTX、TXT 和 Markdown 文件",
     "generateFailed": "生成课堂失败，请重试",
     "requirementPlaceholder": "输入你想学的任何内容，例如：\n「从零学 Python，30 分钟写出第一个程序」\n「用白板给我讲解傅里叶变换」\n「阿瓦隆桌游怎么玩」",
     "requirementRequired": "请输入课程需求",
-    "fileTooLarge": "文件过大，请选择小于50MB的PDF文件"
+    "fileTooLarge": "文件过大，请选择小于 50MB 的文件",
+    "unsupportedCourseMaterial": "不支持的课程材料类型，请上传 PDF、DOCX、PPTX、TXT 或 Markdown 文件"
   },
   "generation": {
-    "analyzingPdf": "解析 PDF 文档",
-    "analyzingPdfDesc": "正在提取文档结构和内容...",
     "pdfLoadFailed": "无法加载 PDF 文件，请重试",
     "pdfParseFailed": "PDF 解析失败",
+    "analyzingCourseMaterial": "解析 {{type}} 文件",
+    "analyzingCourseMaterialDesc": "正在提取文档结构和内容...",
+    "courseMaterialLoadFailed": "无法加载课程材料，请重试",
+    "courseMaterialParseFailed": "课程材料解析失败",
     "streamNotReadable": "无法读取生成数据流",
     "generatingOutlines": "生成课程大纲",
     "generatingOutlinesDesc": "正在构建学习路径...",
diff --git a/lib/i18n/locales/zh-TW.json b/lib/i18n/locales/zh-TW.json
index d09132f87a..d62acfca66 100644
--- a/lib/i18n/locales/zh-TW.json
+++ b/lib/i18n/locales/zh-TW.json
@@ -13,6 +13,9 @@
     "pdfParser": "解析器",
     "pdfUpload": "上傳 PDF",
     "removePdf": "移除檔案",
+    "documentExtractor": "文件解析器",
+    "courseMaterialUpload": "上傳課程材料",
+    "removeCourseMaterial": "移除檔案",
     "webSearchOn": "已開啟",
     "webSearchOff": "點擊開啟",
     "webSearchDesc": "生成前搜尋網路取得最新資料，讓內容更豐富準確",
@@ -791,16 +794,20 @@
   },
   "upload": {
     "pdfSizeLimit": "支援最大50MB的PDF檔案",
+    "courseMaterialSizeLimit": "支援最大 50MB 的 PDF、DOCX、PPTX、TXT 和 Markdown 檔案",
     "generateFailed": "生成課堂失敗，請重試",
     "requirementPlaceholder": "輸入你想學的任何內容，例如：\n「從零學 Python，30 分鐘寫出第一個程式」\n「用白板為我講解傅立葉轉換」\n「阿瓦隆桌遊怎麼玩」",
     "requirementRequired": "請輸入課程需求",
-    "fileTooLarge": "檔案過大，請選擇小於50MB的PDF檔案"
+    "fileTooLarge": "檔案過大，請選擇小於 50MB 的檔案",
+    "unsupportedCourseMaterial": "不支援的課程材料類型，請上傳 PDF、DOCX、PPTX、TXT 或 Markdown 檔案"
   },
   "generation": {
-    "analyzingPdf": "解析 PDF 文件",
-    "analyzingPdfDesc": "正在擷取文件結構和內容...",
     "pdfLoadFailed": "無法載入 PDF 檔案，請重試",
     "pdfParseFailed": "PDF 解析失敗",
+    "analyzingCourseMaterial": "解析 {{type}} 檔案",
+    "analyzingCourseMaterialDesc": "正在擷取文件結構和內容...",
+    "courseMaterialLoadFailed": "無法載入課程材料，請重試",
+    "courseMaterialParseFailed": "課程材料解析失敗",
     "streamNotReadable": "無法讀取生成資料流",
     "generatingOutlines": "生成課程大綱",
     "generatingOutlinesDesc": "正在建構學習路徑...",
diff --git a/lib/pdf/mineru-cloud.ts b/lib/pdf/mineru-cloud.ts
index c22274eacb..865319ff24 100644
--- a/lib/pdf/mineru-cloud.ts
+++ b/lib/pdf/mineru-cloud.ts
@@ -93,12 +93,15 @@ async function readMinerUJson<T>(res: Response, context: string): Promise<T> {
 
 // ── Filename sanitization ─────────────────────────────────────────────────────
 
+const MINERU_CLOUD_SUPPORTED_EXTENSIONS = new Set(['pdf', 'docx', 'pptx']);
+
 function sanitizeFileName(name: string | undefined): string {
   const fallback = 'document.pdf';
   const raw = (name ?? fallback).split(/[/\\]/).pop()?.trim() ?? fallback;
   const trimmed = raw.slice(0, 240);
-  if (!trimmed.toLowerCase().endsWith('.pdf')) return fallback;
   if (trimmed.includes('..')) return fallback;
+  const extension = trimmed.split('.').pop()?.toLowerCase();
+  if (!extension || !MINERU_CLOUD_SUPPORTED_EXTENSIONS.has(extension)) return fallback;
   return trimmed || fallback;
 }
 
@@ -198,25 +201,32 @@ async function parseMinerUZip(zipUrl: string): Promise<ParsedPdfContent> {
   }
 
   // Build a synthetic fileResult compatible with extractMinerUResult
-  return extractMinerUResult({
+  const parsed = extractMinerUResult({
     md_content: mdContent,
     images: imageData,
     content_list: contentList,
   });
+  return {
+    ...parsed,
+    metadata: {
+      ...(parsed.metadata ?? { pageCount: 0 }),
+      parser: 'mineru-cloud',
+    },
+  };
 }
 
 // ── Main entry point ──────────────────────────────────────────────────────────
 
 /**
- * Parse a PDF using the MinerU Cloud v4 API.
+ * Parse a document using the MinerU Cloud v4 API.
  *
  * @param config - Must have `apiKey` (required) and optionally `baseUrl` (defaults to mineru.net/api/v4)
- * @param pdfBuffer - Raw PDF bytes
+ * @param documentBuffer - Raw document bytes
  * @param sourceFileName - Original filename for the upload
  */
 export async function parseWithMinerUCloud(
   config: PDFParserConfig,
-  pdfBuffer: Buffer,
+  documentBuffer: Buffer,
   sourceFileName?: string,
 ): Promise<ParsedPdfContent> {
   const token = config.apiKey;
@@ -227,7 +237,7 @@ export async function parseWithMinerUCloud(
   const apiRoot = (config.baseUrl || MINERU_CLOUD_DEFAULT_BASE).replace(/\/+$/, '');
   const uploadFileName = sanitizeFileName(sourceFileName);
 
-  log.info(`[MinerU Cloud] Starting parse: ${uploadFileName} (${pdfBuffer.byteLength} bytes)`);
+  log.info(`[MinerU Cloud] Starting parse: ${uploadFileName} (${documentBuffer.byteLength} bytes)`);
 
   // Step 1: Create batch — request presigned upload URL
   const batchData = await fetchWithRetry(async () => {
@@ -257,17 +267,17 @@ export async function parseWithMinerUCloud(
     throw new Error('MinerU Cloud batch response missing batch_id or upload URLs');
   }
 
-  log.info(`[MinerU Cloud] Batch ${batchData.batch_id} created, uploading PDF...`);
+  log.info(`[MinerU Cloud] Batch ${batchData.batch_id} created, uploading document...`);
 
-  // Step 2: Upload PDF to presigned URL
+  // Step 2: Upload document to presigned URL
   const putRes = await fetchWithRetry(
     () =>
       fetch(uploadUrls[0], {
         method: 'PUT',
         body: new Blob([
-          pdfBuffer.buffer.slice(
-            pdfBuffer.byteOffset,
-            pdfBuffer.byteOffset + pdfBuffer.byteLength,
+          documentBuffer.buffer.slice(
+            documentBuffer.byteOffset,
+            documentBuffer.byteOffset + documentBuffer.byteLength,
           ) as ArrayBuffer,
         ]),
         signal: AbortSignal.timeout(TIMEOUTS.upload),
diff --git a/lib/pdf/pdf-providers.ts b/lib/pdf/pdf-providers.ts
index b3444535f8..894e274fd5 100644
--- a/lib/pdf/pdf-providers.ts
+++ b/lib/pdf/pdf-providers.ts
@@ -282,6 +282,17 @@ async function parseWithUnpdf(pdfBuffer: Buffer): Promise<ParsedPdfContent> {
 async function parseWithMinerU(
   config: PDFParserConfig,
   pdfBuffer: Buffer,
+): Promise<ParsedPdfContent> {
+  return parseWithMinerUDocument(config, pdfBuffer, {
+    fileName: 'document.pdf',
+    mimeType: 'application/pdf',
+  });
+}
+
+export async function parseWithMinerUDocument(
+  config: PDFParserConfig,
+  documentBuffer: Buffer,
+  options: { fileName: string; mimeType: string },
 ): Promise<ParsedPdfContent> {
   if (!config.baseUrl) {
     throw new Error(
@@ -291,22 +302,20 @@ async function parseWithMinerU(
     );
   }
 
-  log.info('[MinerU] Parsing PDF with MinerU server:', config.baseUrl);
-
-  const fileName = 'document.pdf';
+  log.info(`[MinerU] Parsing document with MinerU server: ${config.baseUrl}`);
 
   // Create FormData for file upload
   const formData = new FormData();
 
   // Convert Buffer to Blob
-  const arrayBuffer = pdfBuffer.buffer.slice(
-    pdfBuffer.byteOffset,
-    pdfBuffer.byteOffset + pdfBuffer.byteLength,
+  const arrayBuffer = documentBuffer.buffer.slice(
+    documentBuffer.byteOffset,
+    documentBuffer.byteOffset + documentBuffer.byteLength,
   );
   const blob = new Blob([arrayBuffer as ArrayBuffer], {
-    type: 'application/pdf',
+    type: options.mimeType,
   });
-  formData.append('files', blob, fileName);
+  formData.append('files', blob, options.fileName);
 
   // MinerU API form fields
   // Defaults already: return_md=true, formula_enable=true, table_enable=true
@@ -338,7 +347,7 @@ async function parseWithMinerU(
   const json = await response.json();
 
   // Response: { results: { "<fileName>": { md_content, images, content_list, ... } } }
-  const fileResult = json.results?.[fileName];
+  const fileResult = json.results?.[options.fileName];
   if (!fileResult) {
     const keys = json.results ? Object.keys(json.results) : [];
     // Try first available key in case filename doesn't match exactly
@@ -346,7 +355,7 @@ async function parseWithMinerU(
     if (!fallback) {
       throw new Error(`MinerU returned no results. Response keys: ${JSON.stringify(keys)}`);
     }
-    log.warn(`[MinerU] Filename mismatch, using key "${keys[0]}" instead of "${fileName}"`);
+    log.warn(`[MinerU] Filename mismatch, using key "${keys[0]}" instead of "${options.fileName}"`);
     return extractMinerUResult(fallback);
   }
 
diff --git a/lib/server/provider-config.ts b/lib/server/provider-config.ts
index ad9350699f..9f5e385052 100644
--- a/lib/server/provider-config.ts
+++ b/lib/server/provider-config.ts
@@ -167,15 +167,22 @@ function loadEnvSection(
   {
     requiresBaseUrl = false,
     keylessProviders = new Set<string>(),
-  }: { requiresBaseUrl?: boolean; keylessProviders?: Set<string> } = {},
+    baseUrlOptionalProviders = new Set<string>(),
+  }: {
+    requiresBaseUrl?: boolean;
+    keylessProviders?: Set<string>;
+    baseUrlOptionalProviders?: Set<string>;
+  } = {},
 ): Record<string, ServerProviderEntry> {
   const result: Record<string, ServerProviderEntry> = {};
+  const requiresBaseUrlForProvider = (providerId: string) =>
+    requiresBaseUrl && !baseUrlOptionalProviders.has(providerId);
 
   // First, add everything from YAML as defaults
   if (yamlSection) {
     for (const [id, entry] of Object.entries(yamlSection)) {
       if (
-        requiresBaseUrl
+        requiresBaseUrlForProvider(id)
           ? !!entry?.baseUrl
           : entry?.apiKey || (entry?.baseUrl && keylessProviders.has(id))
       ) {
@@ -211,7 +218,7 @@ function loadEnvSection(
 
     // Activate on API key, or base URL alone for keyless providers (e.g. Ollama)
     if (
-      requiresBaseUrl
+      requiresBaseUrlForProvider(providerId)
         ? !envBaseUrl
         : !(envApiKey || (envBaseUrl && keylessProviders.has(providerId)))
     )
@@ -305,7 +312,10 @@ function buildConfig(yamlData: YamlData): ServerConfig {
     asr: loadEnvSection(ASR_ENV_MAP, yamlData.asr, {
       keylessProviders: new Set(['lemonade-asr']),
     }),
-    pdf: loadEnvSection(PDF_ENV_MAP, yamlData.pdf, { requiresBaseUrl: true }),
+    pdf: loadEnvSection(PDF_ENV_MAP, yamlData.pdf, {
+      requiresBaseUrl: true,
+      baseUrlOptionalProviders: new Set(['mineru-cloud']),
+    }),
     image,
     video: loadEnvSection(VIDEO_ENV_MAP, yamlData.video),
     webSearch: loadEnvSection(WEB_SEARCH_ENV_MAP, yamlData['web-search']),
diff --git a/tests/document/extract-document-route.test.ts b/tests/document/extract-document-route.test.ts
new file mode 100644
index 0000000000..add39dabab
--- /dev/null
+++ b/tests/document/extract-document-route.test.ts
@@ -0,0 +1,198 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { NextRequest } from 'next/server';
+
+const mocks = vi.hoisted(() => ({
+  isServerConfiguredProvider: vi.fn(() => false),
+  resolvePDFApiKey: vi.fn((_providerId: string, clientKey?: string) => clientKey || ''),
+  resolvePDFBaseUrl: vi.fn((_providerId: string, clientBaseUrl?: string) => clientBaseUrl),
+  parseWithMinerUCloud: vi.fn(),
+}));
+
+vi.mock('@/lib/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+vi.mock('@/lib/server/provider-config', () => ({
+  isServerConfiguredProvider: mocks.isServerConfiguredProvider,
+  resolvePDFApiKey: mocks.resolvePDFApiKey,
+  resolvePDFBaseUrl: mocks.resolvePDFBaseUrl,
+}));
+
+vi.mock('@/lib/pdf/mineru-cloud', () => ({
+  parseWithMinerUCloud: mocks.parseWithMinerUCloud,
+}));
+
+async function postExtractDocument(input: {
+  file: File;
+  providerId?: string;
+  apiKey?: string;
+  baseUrl?: string;
+}) {
+  const { POST } = await import('@/app/api/extract-document/route');
+  const formData = new FormData();
+  formData.append('file', input.file);
+  if (input.providerId) formData.append('providerId', input.providerId);
+  if (input.apiKey) formData.append('apiKey', input.apiKey);
+  if (input.baseUrl) formData.append('baseUrl', input.baseUrl);
+
+  const request = new Request('http://localhost/api/extract-document', {
+    method: 'POST',
+    body: formData,
+  });
+  return POST(request as unknown as NextRequest);
+}
+
+describe('POST /api/extract-document', () => {
+  beforeEach(() => {
+    vi.resetModules();
+    vi.unstubAllEnvs();
+    mocks.isServerConfiguredProvider.mockReturnValue(false);
+    mocks.resolvePDFApiKey.mockImplementation(
+      (_providerId: string, clientKey?: string) => clientKey || '',
+    );
+    mocks.resolvePDFBaseUrl.mockImplementation(
+      (_providerId: string, clientBaseUrl?: string) => clientBaseUrl,
+    );
+    mocks.parseWithMinerUCloud.mockReset();
+    mocks.parseWithMinerUCloud.mockResolvedValue({
+      text: 'cloud parsed text',
+      images: [],
+      metadata: {
+        pageCount: 1,
+        parser: 'mineru-cloud',
+      },
+    });
+    delete process.env.PDF_MINERU_BASE_URL;
+    delete process.env.PDF_MINERU_API_KEY;
+  });
+
+  it('returns 400 for unsupported course material MIME types', async () => {
+    const res = await postExtractDocument({
+      file: new File(['x,y'], 'sheet.csv', { type: 'text/csv' }),
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(400);
+    expect(json).toMatchObject({
+      success: false,
+      errorCode: 'INVALID_REQUEST',
+    });
+  });
+
+  it('returns 400 for an unknown requested provider', async () => {
+    const res = await postExtractDocument({
+      file: new File(['hello'], 'notes.txt', { type: 'text/plain' }),
+      providerId: 'missing-provider',
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(400);
+    expect(json).toMatchObject({
+      success: false,
+      errorCode: 'INVALID_REQUEST',
+      error: 'Unknown document extractor provider: missing-provider',
+    });
+  });
+
+  it('treats an incompatible preferred provider as a hint and falls back by MIME type', async () => {
+    const res = await postExtractDocument({
+      file: new File(['hello'], 'notes.txt', { type: 'text/plain' }),
+      providerId: 'unpdf',
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(json).toMatchObject({
+      success: true,
+      data: {
+        text: 'hello',
+        metadata: {
+          mimeType: 'text/plain',
+          parser: 'plain-text',
+        },
+      },
+    });
+  });
+
+  it('returns actionable 422 diagnostics when DOCX requires unconfigured MinerU', async () => {
+    const res = await postExtractDocument({
+      file: new File(['not really docx'], 'lesson.docx', {
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      }),
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(422);
+    expect(json).toMatchObject({
+      success: false,
+      errorCode: 'INVALID_REQUEST',
+    });
+    expect(json.error).toContain('DOCX extraction requires a configured MinerU document extractor');
+    expect(json.error).toContain('self-hosted MinerU base URL or a MinerU Cloud API key');
+  });
+
+  it('allows MinerU Cloud PDF extraction with an API key and no base URL', async () => {
+    const res = await postExtractDocument({
+      file: new File(['%PDF-1.4'], 'lesson.pdf', { type: 'application/pdf' }),
+      providerId: 'mineru-cloud',
+      apiKey: 'cloud-key',
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(json).toMatchObject({
+      success: true,
+      data: {
+        text: 'cloud parsed text',
+        metadata: {
+          parser: 'mineru-cloud',
+        },
+      },
+    });
+    expect(mocks.parseWithMinerUCloud).toHaveBeenCalledWith(
+      expect.objectContaining({
+        providerId: 'mineru-cloud',
+        apiKey: 'cloud-key',
+        baseUrl: undefined,
+      }),
+      expect.any(Buffer),
+      'lesson.pdf',
+    );
+  });
+
+  it('falls back to MinerU Cloud for DOCX when self-hosted MinerU is unavailable and a cloud key is provided', async () => {
+    const res = await postExtractDocument({
+      file: new File(['not really docx'], 'lesson.docx', {
+        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      }),
+      apiKey: 'cloud-key',
+    });
+    const json = await res.json();
+
+    expect(res.status).toBe(200);
+    expect(json).toMatchObject({
+      success: true,
+      data: {
+        text: 'cloud parsed text',
+        metadata: {
+          parser: 'mineru-cloud',
+          mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        },
+      },
+    });
+    expect(mocks.parseWithMinerUCloud).toHaveBeenCalledWith(
+      expect.objectContaining({
+        providerId: 'mineru-cloud',
+        apiKey: 'cloud-key',
+        baseUrl: undefined,
+      }),
+      expect.any(Buffer),
+      'lesson.docx',
+    );
+  });
+});
diff --git a/tests/document/extractor-registry.test.ts b/tests/document/extractor-registry.test.ts
index 80db8b61d8..cd0c04b3cd 100644
--- a/tests/document/extractor-registry.test.ts
+++ b/tests/document/extractor-registry.test.ts
@@ -10,19 +10,51 @@ describe('document extractor registry', () => {
   it('exposes existing PDF providers through the document extractor boundary', () => {
     const providers = getDocumentExtractorProviders();
 
-    expect(providers.map((provider) => provider.id)).toEqual(['unpdf', 'mineru', 'mineru-cloud']);
+    expect(providers.map((provider) => provider.id)).toEqual([
+      'plain-text',
+      'unpdf',
+      'mineru',
+      'mineru-cloud',
+    ]);
     expect(providers.every((provider) => provider.supportedMimeTypes)).toBe(true);
     expect(
-      providers.every((provider) => provider.supportedMimeTypes.includes('application/pdf')),
+      providers
+        .filter((provider) => provider.id !== 'plain-text')
+        .every((provider) => provider.supportedMimeTypes.includes('application/pdf')),
     ).toBe(true);
   });
 
-  it('declares MinerU capabilities without exposing unsupported upload formats yet', () => {
+  it('exposes a local plain-text extractor for TXT and Markdown', () => {
+    const plainText = getDocumentExtractorProvider('plain-text');
+
+    expect(plainText).toBeDefined();
+    expect(plainText?.supportedMimeTypes).toEqual([
+      'text/plain',
+      'text/markdown',
+      'text/x-markdown',
+    ]);
+    expect(plainText?.capabilities).toMatchObject({
+      text: true,
+      images: false,
+      tables: false,
+      formulas: false,
+      layout: false,
+      ocr: false,
+      async: false,
+    });
+  });
+
+  it('declares MinerU capabilities and supported course material formats', () => {
     const mineru = getDocumentExtractorProvider('mineru');
+    const mineruCloud = getDocumentExtractorProvider('mineru-cloud');
 
     expect(mineru).toBeDefined();
     expect(mineru?.displayName).toBe('MinerU');
-    expect(mineru?.supportedMimeTypes).toEqual(['application/pdf']);
+    expect(mineru?.supportedMimeTypes).toEqual([
+      'application/pdf',
+      'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    ]);
     expect(mineru?.capabilities).toMatchObject({
       text: true,
       images: true,
@@ -32,6 +64,17 @@ describe('document extractor registry', () => {
       ocr: true,
       async: false,
     });
+    expect(mineruCloud).toBeDefined();
+    expect(mineruCloud?.supportedMimeTypes).toEqual(mineru?.supportedMimeTypes);
+    expect(mineruCloud?.capabilities).toMatchObject({
+      text: true,
+      images: true,
+      tables: true,
+      formulas: true,
+      layout: true,
+      ocr: true,
+      async: true,
+    });
   });
 
   it('selects a preferred provider only when it supports the requested MIME type', () => {
@@ -42,10 +85,17 @@ describe('document extractor registry', () => {
       }).id,
     ).toBe('mineru-cloud');
 
-    expect(() =>
+    expect(
       selectDocumentExtractorProvider({
         mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
         preferredProviderId: 'mineru',
+      }).id,
+    ).toBe('mineru');
+
+    expect(() =>
+      selectDocumentExtractorProvider({
+        mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        preferredProviderId: 'unpdf',
       }),
     ).toThrow(/does not support MIME type/);
   });
@@ -70,8 +120,34 @@ describe('document extractor registry', () => {
   it('returns a clear error when no provider supports the MIME type', () => {
     expect(() =>
       selectDocumentExtractorProvider({
-        mimeType: 'text/plain',
+        mimeType: 'application/vnd.ms-excel',
       }),
     ).toThrow(/No document extractor supports MIME type/);
   });
+
+  it('can capability-match Office course material to MinerU', () => {
+    expect(
+      selectDocumentExtractorProvider({
+        mimeType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        requiredCapabilities: { text: true },
+      }).id,
+    ).toBe('mineru');
+
+    expect(
+      selectDocumentExtractorProvider({
+        mimeType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+        preferredProviderId: 'mineru-cloud',
+        requiredCapabilities: { text: true },
+      }).id,
+    ).toBe('mineru-cloud');
+  });
+
+  it('can capability-match text course material locally', () => {
+    expect(
+      selectDocumentExtractorProvider({
+        mimeType: 'text/markdown',
+        requiredCapabilities: { text: true },
+      }).id,
+    ).toBe('plain-text');
+  });
 });
diff --git a/tests/document/mime.test.ts b/tests/document/mime.test.ts
new file mode 100644
index 0000000000..b381bb90b1
--- /dev/null
+++ b/tests/document/mime.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest';
+import { DOCUMENT_MIME_TYPES, normalizeDocumentMimeType } from '@/lib/document/mime';
+
+describe('document MIME normalization', () => {
+  it('uses Office filename extensions when browsers report generic ZIP MIME types', () => {
+    expect(
+      normalizeDocumentMimeType({
+        mimeType: 'application/zip',
+        fileName: 'lesson.docx',
+      }),
+    ).toBe(DOCUMENT_MIME_TYPES.docx);
+
+    expect(
+      normalizeDocumentMimeType({
+        mimeType: 'application/x-zip-compressed',
+        fileName: 'slides.pptx',
+      }),
+    ).toBe(DOCUMENT_MIME_TYPES.pptx);
+  });
+
+  it('keeps specific MIME types when they are not generic upload fallbacks', () => {
+    expect(
+      normalizeDocumentMimeType({
+        mimeType: 'text/plain',
+        fileName: 'lesson.docx',
+      }),
+    ).toBe(DOCUMENT_MIME_TYPES.txt);
+  });
+});
diff --git a/tests/document/mineru-cloud.test.ts b/tests/document/mineru-cloud.test.ts
new file mode 100644
index 0000000000..c45281f3a1
--- /dev/null
+++ b/tests/document/mineru-cloud.test.ts
@@ -0,0 +1,161 @@
+import JSZip from 'jszip';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { parseWithMinerUCloud } from '@/lib/pdf/mineru-cloud';
+
+vi.mock('@/lib/logger', () => ({
+  createLogger: () => ({
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  }),
+}));
+
+describe('MinerU Cloud document upload', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('preserves supported Office filename extensions for Cloud type inference', async () => {
+    const zip = new JSZip();
+    zip.file('full.md', '# Parsed lesson');
+    const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' });
+    const batchBodies: unknown[] = [];
+    const fetchMock = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+      const url = String(input);
+      if (url.endsWith('/file-urls/batch')) {
+        batchBodies.push(JSON.parse(String(init?.body)));
+        return new Response(
+          JSON.stringify({
+            code: 0,
+            msg: 'ok',
+            data: {
+              batch_id: 'batch-1',
+              file_urls: ['https://upload.example/lesson.docx'],
+            },
+          }),
+          { status: 200 },
+        );
+      }
+      if (url === 'https://upload.example/lesson.docx') {
+        return new Response('', { status: 200 });
+      }
+      if (url.endsWith('/extract-results/batch/batch-1')) {
+        return new Response(
+          JSON.stringify({
+            code: 0,
+            msg: 'ok',
+            data: {
+              extract_result: {
+                file_name: 'lesson.docx',
+                state: 'done',
+                full_zip_url: 'https://download.example/result.zip',
+              },
+            },
+          }),
+          { status: 200 },
+        );
+      }
+      if (url === 'https://download.example/result.zip') {
+        return new Response(
+          zipBuffer.buffer.slice(
+            zipBuffer.byteOffset,
+            zipBuffer.byteOffset + zipBuffer.byteLength,
+          ) as ArrayBuffer,
+          { status: 200 },
+        );
+      }
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await parseWithMinerUCloud(
+      {
+        providerId: 'mineru-cloud',
+        apiKey: 'cloud-key',
+        baseUrl: 'https://mineru.example/api/v4',
+      },
+      Buffer.from('docx bytes'),
+      'lesson.docx',
+    );
+
+    expect(result.text).toContain('Parsed lesson');
+    expect(result.metadata?.parser).toBe('mineru-cloud');
+    expect(batchBodies).toEqual([
+      expect.objectContaining({
+        files: [{ name: 'lesson.docx' }],
+      }),
+    ]);
+  });
+
+  it('falls back to a supported filename for legacy Office extensions outside route scope', async () => {
+    const zip = new JSZip();
+    zip.file('full.md', '# Parsed legacy lesson');
+    const zipBuffer = await zip.generateAsync({ type: 'nodebuffer' });
+    const batchBodies: unknown[] = [];
+    const fetchMock = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
+      const url = String(input);
+      if (url.endsWith('/file-urls/batch')) {
+        batchBodies.push(JSON.parse(String(init?.body)));
+        return new Response(
+          JSON.stringify({
+            code: 0,
+            msg: 'ok',
+            data: {
+              batch_id: 'batch-legacy',
+              file_urls: ['https://upload.example/document.pdf'],
+            },
+          }),
+          { status: 200 },
+        );
+      }
+      if (url === 'https://upload.example/document.pdf') {
+        return new Response('', { status: 200 });
+      }
+      if (url.endsWith('/extract-results/batch/batch-legacy')) {
+        return new Response(
+          JSON.stringify({
+            code: 0,
+            msg: 'ok',
+            data: {
+              extract_result: {
+                file_name: 'document.pdf',
+                state: 'done',
+                full_zip_url: 'https://download.example/legacy.zip',
+              },
+            },
+          }),
+          { status: 200 },
+        );
+      }
+      if (url === 'https://download.example/legacy.zip') {
+        return new Response(
+          zipBuffer.buffer.slice(
+            zipBuffer.byteOffset,
+            zipBuffer.byteOffset + zipBuffer.byteLength,
+          ) as ArrayBuffer,
+          { status: 200 },
+        );
+      }
+      throw new Error(`Unexpected fetch: ${url}`);
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    const result = await parseWithMinerUCloud(
+      {
+        providerId: 'mineru-cloud',
+        apiKey: 'cloud-key',
+        baseUrl: 'https://mineru.example/api/v4',
+      },
+      Buffer.from('doc bytes'),
+      'legacy.doc',
+    );
+
+    expect(result.text).toContain('Parsed legacy lesson');
+    expect(batchBodies).toEqual([
+      expect.objectContaining({
+        files: [{ name: 'document.pdf' }],
+      }),
+    ]);
+  });
+});
diff --git a/tests/document/pdf-compat.test.ts b/tests/document/pdf-compat.test.ts
index cb86dc1058..6f8f7a35b5 100644
--- a/tests/document/pdf-compat.test.ts
+++ b/tests/document/pdf-compat.test.ts
@@ -106,6 +106,31 @@ describe('PDF compatibility adapter', () => {
     ]);
   });
 
+  it('normalizes MinerU Cloud markdown output into a markdown document block', () => {
+    const parsed: ParsedPdfContent = {
+      text: '# Cloud Parsed Lesson',
+      images: [],
+      metadata: {
+        pageCount: 1,
+        parser: 'mineru-cloud',
+      },
+    };
+
+    const artifact = parsedPdfToDocumentArtifact(parsed, {
+      buffer: Buffer.from('docx'),
+      fileName: 'lesson.docx',
+      fileSize: 456,
+      mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      config: { providerId: 'mineru-cloud' },
+    });
+
+    expect(artifact.blocks[0]).toMatchObject({
+      id: 'document-text',
+      type: 'markdown',
+      text: '# Cloud Parsed Lesson',
+    });
+  });
+
   it('round-trips back to the existing ParsedPdfContent shape used by generation', () => {
     const parsed: ParsedPdfContent = {
       text: 'Plain text',
diff --git a/tests/document/text-extractor.test.ts b/tests/document/text-extractor.test.ts
new file mode 100644
index 0000000000..e5d4b643f2
--- /dev/null
+++ b/tests/document/text-extractor.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+
+import { extractDocument } from '@/lib/document';
+
+describe('plain text document extractor', () => {
+  it('extracts TXT content locally', async () => {
+    const artifact = await extractDocument({
+      buffer: Buffer.from('Hello OpenMAIC\nLine 2', 'utf-8'),
+      fileName: 'test.txt',
+      fileSize: 20,
+      mimeType: 'text/plain',
+      config: { providerId: 'plain-text' },
+    });
+
+    expect(artifact.metadata).toMatchObject({
+      fileName: 'test.txt',
+      mimeType: 'text/plain',
+      providerId: 'plain-text',
+    });
+    expect(artifact.blocks).toEqual([
+      {
+        id: 'text_1',
+        type: 'text',
+        text: 'Hello OpenMAIC\nLine 2',
+      },
+    ]);
+  });
+
+  it('extracts Markdown content locally as markdown blocks', async () => {
+    const artifact = await extractDocument({
+      buffer: Buffer.from('# Title', 'utf-8'),
+      fileName: 'test.md',
+      fileSize: 7,
+      mimeType: 'text/markdown',
+      config: { providerId: 'plain-text' },
+    });
+
+    expect(artifact.blocks[0]).toMatchObject({
+      type: 'markdown',
+      text: '# Title',
+    });
+  });
+
+  it('detects UTF-16LE text from a BOM when MIME charset has been normalized away', async () => {
+    const artifact = await extractDocument({
+      buffer: Buffer.from([0xff, 0xfe, 0x60, 0x4f, 0x7d, 0x59]),
+      fileName: 'test.txt',
+      fileSize: 6,
+      mimeType: 'text/plain',
+      config: { providerId: 'plain-text' },
+    });
+
+    expect(artifact.blocks[0]).toMatchObject({
+      type: 'text',
+      text: '你好',
+    });
+  });
+});
diff --git a/tests/server/provider-config.test.ts b/tests/server/provider-config.test.ts
index 0bfb6b030a..55ce7e37f5 100644
--- a/tests/server/provider-config.test.ts
+++ b/tests/server/provider-config.test.ts
@@ -383,6 +383,32 @@ pdf:
 
       expect(providers.mineru).toBeUndefined();
     });
+
+    it('includes MinerU Cloud from env when only API key is configured', async () => {
+      vi.stubEnv('PDF_MINERU_CLOUD_API_KEY', 'mineru-cloud-key');
+      const { getServerPDFProviders, resolvePDFApiKey, resolvePDFBaseUrl } =
+        await import('@/lib/server/provider-config');
+      const providers = getServerPDFProviders();
+
+      expect(providers['mineru-cloud']).toBeDefined();
+      expect(resolvePDFApiKey('mineru-cloud')).toBe('mineru-cloud-key');
+      expect(resolvePDFBaseUrl('mineru-cloud')).toBeUndefined();
+    });
+
+    it('includes MinerU Cloud from YAML when only API key is configured', async () => {
+      yamlOverride = `
+pdf:
+  mineru-cloud:
+    apiKey: mineru-cloud-yaml-key
+`;
+      const { getServerPDFProviders, resolvePDFApiKey, resolvePDFBaseUrl } =
+        await import('@/lib/server/provider-config');
+      const providers = getServerPDFProviders();
+
+      expect(providers['mineru-cloud']).toBeDefined();
+      expect(resolvePDFApiKey('mineru-cloud')).toBe('mineru-cloud-yaml-key');
+      expect(resolvePDFBaseUrl('mineru-cloud')).toBeUndefined();
+    });
   });
 
   describe('image and video provider metadata', () => {