添加项目详细文档

添加完整的 README.md 文件，包含以下内容：
- 项目介绍（中英文对照）
- 技术栈说明（后端、前端、数据库、缓存等）
- 项目架构图
- 目录结构说明
- 主要功能特性
- API 接口列表
- 环境配置指南
- 启动项目说明
- 配置说明
- 许可证信息

删除根目录下无用的 package.json 文件

.gitignore

@@ -0,0 +1,48 @@
+/.git/
+/.gitignore
+/.idea/
+/.vscode/
+/backend/venv/
+/backend/command/
+/backend/.env
+/backend/.env.local
+/backend/.env.*.local
+/backend/app/__pycache__/*
+/backend/data/uploads
+/backend/data/charts
+/backend/data/logs
+
+/frontend/node_modules/
+/frontend/dist/
+/frontend/build/
+/frontend/.vscode/
+/frontend/.idea/
+/frontend/.env
+/frontend/*.log
+
+/frontend/src/api/
+/frontend/src/api/index.js
+/frontend/src/api/index.ts
+/frontend/src/api/index.tsx
+/frontend/src/api/index.py
+/frontend/src/api/index.go
+/frontend/src/api/index.java
+
+/frontend - 副本/
+
+/docs/
+/frontendTest/
+/supabase.txt
+
+# 取消跟踪的文件 / Untracked files
+比赛备赛规划.md
+Q&A.xlsx
+package.json
+技术路线.md
+开发路径.md
+开发日志_2026-03-16.md
+/logs/
+
+# Python cache
+**/__pycache__/**
+**.pyc

README.md

@@ -0,0 +1,238 @@
+# FilesReadSystem
+
+## 项目介绍 / Project Introduction
+
+基于大语言模型的文档理解与多源数据融合系统，专为第十七届中国大学生服务外包创新创业大赛（A23赛题）开发。本系统利用大语言模型（LLM）解析、分析各类文档格式并提取结构化数据，支持通过自然语言指令自动填写模板表格。
+
+A document understanding and multi-source data fusion system based on Large Language Models (LLM), developed for the 17th China University Student Service Outsourcing Innovation and Entrepreneurship Competition (Topic A23). This system uses LLMs to parse, analyze, and extract structured data from various document formats, supporting automatic template table filling through natural language instructions.
+
+---
+
+## 技术栈 / Technology Stack
+
+| 层次 / Layer | 组件 / Component | 说明 / Description |
+|:---|:---|:---|
+| 后端 / Backend | FastAPI + Uvicorn | RESTful API，异步任务调度 / API & async task scheduling |
+| 前端 / Frontend | React + TypeScript + Vite | 文件上传、表格配置、聊天界面 / Upload, table config, chat UI |
+| 异步任务 / Async Tasks | Celery + Redis | 处理耗时的解析与AI提取 / Heavy parsing & AI extraction |
+| 文档数据库 / Document DB | MongoDB (Motor) | 元数据、提取结果、文档块存储 / Metadata, results, chunk storage |
+| 关系数据库 / Relational DB | MySQL (SQLAlchemy) | 结构化数据存储 / Structured data storage |
+| 缓存 / Cache | Redis | 缓存与任务队列 / Caching & task queue |
+| 向量检索 / Vector Search | FAISS | 高效相似性搜索 / Efficient similarity search |
+| AI集成 / AI Integration | LangChain-style + MiniMax API | RAG流水线、提示词管理 / RAG pipeline, prompt management |
+| 文档解析 / Document Parsing | python-docx, pandas, openpyxl, markdown-it | 多格式支持 / Multi-format support |
+
+---
+
+## 项目架构 / Project Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         User Interface                           │
+│              (React + TypeScript + shadcn/ui)                    │
+└─────────────────────────────────────────────────────────────────┘
+                                │
+                                ▼
+┌─────────────────────────────────────────────────────────────────┐
+│                      FastAPI Backend                             │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────────┐ │
+│  │ Upload API  │  │ RAG Search   │  │ Natural Language       │ │
+│  │ /documents  │  │ /rag/search  │  │ /instruction/execute   │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────────┘ │
+│  ┌─────────────┐  ┌──────────────┐  ┌─────────────────────────┐ │
+│  │ AI Analyze  │  │ Template Fill│  │ Visualization          │ │
+│  │ /ai/analyze │  │ /templates   │  │ /visualization         │ │
+│  └─────────────┘  └──────────────┘  └─────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────┘
+                                │
+          ┌─────────────────────┼─────────────────────┐
+          ▼                     ▼                     ▼
+┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐
+│    MongoDB      │   │      MySQL      │   │      Redis      │
+│  (Documents)    │   │  (Structured)   │   │   (Cache/Queue) │
+└─────────────────┘   └─────────────────┘   └─────────────────┘
+          │
+          ▼
+┌─────────────────┐
+│     FAISS       │
+│ (Vector Index)  │
+└─────────────────┘
+```
+
+---
+
+## 目录结构 / Directory Structure
+
+```
+FilesReadSystem/
+├── backend/                      # 后端服务（Python + FastAPI）
+│   ├── app/
+│   │   ├── api/endpoints/       # API路由层 / API endpoints
+│   │   │   ├── ai_analyze.py    # AI分析接口 / AI analysis
+│   │   │   ├── documents.py     # 文档管理 / Document management
+│   │   │   ├── instruction.py   # 自然语言指令 / Natural language instruction
+│   │   │   ├── rag.py           # RAG检索 / RAG retrieval
+│   │   │   ├── tasks.py         # 任务管理 / Task management
+│   │   │   ├── templates.py     # 模板管理 / Template management
+│   │   │   ├── upload.py        # 文件上传 / File upload
+│   │   │   └── visualization.py # 可视化 / Visualization
+│   │   ├── core/
+│   │   │   ├── database/        # 数据库连接 / Database connections
+│   │   │   └── document_parser/ # 文档解析器 / Document parsers
+│   │   ├── services/            # 业务逻辑服务 / Business logic services
+│   │   │   ├── llm_service.py         # LLM调用 / LLM service
+│   │   │   ├── rag_service.py         # RAG流水线 / RAG pipeline
+│   │   │   ├── template_fill_service.py # 模板填充 / Template filling
+│   │   │   ├── excel_ai_service.py    # Excel AI分析 / Excel AI analysis
+│   │   │   ├── word_ai_service.py     # Word AI分析 / Word AI analysis
+│   │   │   └── table_rag_service.py   # 表格RAG / Table RAG
+│   │   └── instruction/         # 指令解析与执行 / Instruction parsing & execution
+│   ├── requirements.txt         # Python依赖 / Python dependencies
+│   └── README.md
+│
+├── frontend/                    # 前端项目（React + TypeScript）
+│   ├── src/
+│   │   ├── pages/              # 页面组件 / Page components
+│   │   │   ├── Dashboard.tsx   # 仪表板 / Dashboard
+│   │   │   ├── Documents.tsx    # 文档管理 / Document management
+│   │   │   ├── TemplateFill.tsx # 模板填充 / Template fill
+│   │   │   └── InstructionChat.tsx # 指令聊天 / Instruction chat
+│   │   ├── components/ui/      # shadcn/ui组件库 / shadcn/ui components
+│   │   ├── contexts/          # React上下文 / React contexts
+│   │   ├── db/                # API调用封装 / API call wrappers
+│   │   └── supabase/functions/ # Edge函数 / Edge functions
+│   ├── package.json
+│   └── README.md
+│
+├── docs/                       # 文档与测试数据 / Documentation & test data
+├── logs/                       # 应用日志 / Application logs
+└── README.md                   # 本文件 / This file
+```
+
+---
+
+## 主要功能 / Key Features
+
+- **多格式文档解析** / Multi-format Document Parsing
+  - Excel (.xlsx)
+  - Word (.docx)
+  - Markdown (.md)
+  - Plain Text (.txt)
+
+- **AI智能分析** / AI-Powered Analysis
+  - 文档内容理解与摘要
+  - 表格数据自动提取
+  - 多文档联合推理
+
+- **RAG检索增强** / RAG (Retrieval Augmented Generation)
+  - 语义向量相似度搜索
+  - 上下文感知的答案生成
+
+- **模板自动填充** / Template Auto-fill
+  - 智能表格模板识别
+  - 自然语言指令驱动填写
+  - 批量数据导入导出
+
+- **自然语言指令** / Natural Language Instructions
+  - 意图识别与解析
+  - 多步骤任务自动执行
+
+---
+
+## API接口 / API Endpoints
+
+| 方法 / Method | 路径 / Path | 说明 / Description |
+|:---|:---|:---|
+| GET | `/health` | 健康检查 / Health check |
+| POST | `/upload/document` | 单文件上传 / Single file upload |
+| POST | `/upload/documents` | 批量上传 / Batch upload |
+| GET | `/documents` | 文档库 / Document library |
+| GET | `/tasks/{task_id}` | 任务状态 / Task status |
+| POST | `/rag/search` | RAG语义搜索 / RAG search |
+| POST | `/templates/upload` | 模板上传 / Template upload |
+| POST | `/templates/fill` | 执行模板填充 / Execute template fill |
+| POST | `/ai/analyze/excel` | Excel AI分析 / Excel AI analysis |
+| POST | `/ai/analyze/word` | Word AI分析 / Word AI analysis |
+| POST | `/instruction/recognize` | 意图识别 / Intent recognition |
+| POST | `/instruction/execute` | 执行指令 / Execute instruction |
+| GET | `/visualization/statistics` | 统计图表 / Statistics charts |
+
+---
+
+## 环境配置 / Environment Setup
+
+### 后端 / Backend
+
+```bash
+cd backend
+
+# 创建虚拟环境 / Create virtual environment
+python -m venv venv
+
+# 激活虚拟环境 / Activate virtual environment
+# Windows PowerShell:
+.\venv\Scripts\Activate.ps1
+# Windows CMD:
+.\venv\Scripts\Activate.bat
+
+# 安装依赖 / Install dependencies
+pip install -r requirements.txt
+
+# 复制环境变量模板 / Copy environment template
+copy .env.example .env
+# 编辑 .env 填入API密钥 / Edit .env with your API keys
+```
+
+### 前端 / Frontend
+
+```bash
+cd frontend
+
+# 安装依赖 / Install dependencies
+npm install
+
+# 或使用 pnpm / Or using pnpm
+pnpm install
+```
+
+---
+
+## 启动项目 / Starting the Project
+
+### 后端启动 / Backend Startup
+
+```bash
+cd backend
+./venv/Scripts/python.exe -m uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
+```
+
+### 前端启动 / Frontend Startup
+
+```bash
+cd frontend
+npm run dev
+# 或 / or
+pnpm dev
+```
+
+前端地址 / Frontend URL: http://localhost:5173
+
+---
+
+## 配置说明 / Configuration
+
+### 环境变量 / Environment Variables
+
+| 变量 / Variable | 说明 / Description |
+|:---|:---|
+| `MONGODB_URL` | MongoDB连接地址 / MongoDB connection URL |
+| `MYSQL_HOST` | MySQL主机 / MySQL host |
+| `REDIS_URL` | Redis连接地址 / Redis connection URL |
+| `MINIMAX_API_KEY` | MiniMax API密钥 / MiniMax API key |
+| `MINIMAX_API_URL` | MiniMax API地址 / MiniMax API URL |
+
+---
+
+## 许可证 / License
+
+ISC

backend/.env.example

@@ -1,16 +1,61 @@
-# 基础配置
+# ============================================================
+# 基于大语言模型的文档理解与多源数据融合系统
+# 环境变量配置文件
+# ============================================================
+# 复制此文件为 .env 并填入实际值
+
+# ==================== 应用基础配置 ====================
 APP_NAME="FilesReadSystem"
 DEBUG=true
+API_V1_STR="/api/v1"
 
-# 数据库
+# ==================== MongoDB 配置 ====================
-MONGODB_URL="mongodb://username:password@host:port"
+# 非结构化数据存储 (原始文档、解析结果)
-MONGODB_DB_NAME=""
+MONGODB_URL="mongodb://localhost:27017"
+MONGODB_DB_NAME="document_system"
+
+# ==================== MySQL 配置 ====================
+# 结构化数据存储 (Excel表格、查询结果)
+MYSQL_HOST="localhost"
+MYSQL_PORT=3306
+MYSQL_USER="root"
+MYSQL_PASSWORD="your_password_here"
+MYSQL_DATABASE="document_system"
+MYSQL_CHARSET="utf8mb4"
+
+# ==================== Redis 配置 ====================
+# 缓存/任务队列
 REDIS_URL="redis://localhost:6379/0"
 
-# 大模型 API
+# ==================== LLM AI 配置 ====================
-LLM_API_KEY=""
+# 大语言模型 API 配置
-LLM_BASE_URL=""
+# 支持 OpenAI 兼容格式 (DeepSeek, 智谱 GLM, 阿里等)
+# 智谱 AI (Zhipu AI) GLM 系列:
+#   - 模型: glm-4-flash (快速文本模型), glm-4 (标准), glm-4-plus (高性能)
+#   - API: https://open.bigmodel.cn
+#   - API Key: https://open.bigmodel.cn/usercenter/apikeys
+LLM_API_KEY="ca79ad9f96524cd5afc3e43ca97f347d.cpiLLx2oyitGvTeU"
+LLM_BASE_URL="https://open.bigmodel.cn/api/paas/v4"
+LLM_MODEL_NAME="glm-4v-plus"
 
-# 文件存储配置
+# ==================== Supabase 配置 ====================
+# Supabase 项目配置
+SUPABASE_URL="your_supabase_url_here"
+SUPABASE_ANON_KEY="your_supabase_anon_key_here"
+SUPABASE_SERVICE_KEY="your_supabase_service_key_here"
+
+# ==================== 文件路径配置 ====================
+# 上传文件存储目录 (相对于项目根目录)
 UPLOAD_DIR="./data/uploads"
-MAX_UPLOAD_SIZE=104857600  # 100MB
+
+# Faiss 向量数据库持久化目录 (LangChain + Faiss 实现)
+FAISS_INDEX_DIR="./data/faiss"
+
+# ==================== RAG 配置 ====================
+# Embedding 模型名称
+EMBEDDING_MODEL="all-MiniLM-L6-v2"
+
+# ==================== Celery 配置 ====================
+# 异步任务队列 Broker
+CELERY_BROKER_URL="redis://localhost:6379/1"
+CELERY_RESULT_BACKEND="redis://localhost:6379/2"

backend/=3.0.0

@@ -0,0 +1,38 @@
+Requirement already satisfied: sentence-transformers in c:\python312\lib\site-packages (2.2.2)
+Requirement already satisfied: transformers<5.0.0,>=4.6.0 in c:\python312\lib\site-packages (from sentence-transformers) (4.57.6)
+Requirement already satisfied: tqdm in c:\python312\lib\site-packages (from sentence-transformers) (4.66.1)
+Requirement already satisfied: torch>=1.6.0 in c:\python312\lib\site-packages (from sentence-transformers) (2.10.0)
+Requirement already satisfied: torchvision in c:\python312\lib\site-packages (from sentence-transformers) (0.25.0)
+Requirement already satisfied: numpy in c:\python312\lib\site-packages (from sentence-transformers) (1.26.2)
+Requirement already satisfied: scikit-learn in c:\python312\lib\site-packages (from sentence-transformers) (1.8.0)
+Requirement already satisfied: scipy in c:\python312\lib\site-packages (from sentence-transformers) (1.16.3)
+Requirement already satisfied: nltk in c:\python312\lib\site-packages (from sentence-transformers) (3.9.3)
+Requirement already satisfied: sentencepiece in c:\python312\lib\site-packages (from sentence-transformers) (0.2.1)
+Requirement already satisfied: huggingface-hub>=0.4.0 in c:\python312\lib\site-packages (from sentence-transformers) (0.36.2)
+Requirement already satisfied: filelock in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (3.25.2)
+Requirement already satisfied: fsspec>=2023.5.0 in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (2026.2.0)
+Requirement already satisfied: packaging>=20.9 in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (23.2)
+Requirement already satisfied: pyyaml>=5.1 in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (6.0.1)
+Requirement already satisfied: requests in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (2.31.0)
+Requirement already satisfied: typing-extensions>=3.7.4.3 in c:\python312\lib\site-packages (from huggingface-hub>=0.4.0->sentence-transformers) (4.15.0)
+Requirement already satisfied: sympy>=1.13.3 in c:\python312\lib\site-packages (from torch>=1.6.0->sentence-transformers) (1.14.0)
+Requirement already satisfied: networkx>=2.5.1 in c:\python312\lib\site-packages (from torch>=1.6.0->sentence-transformers) (3.6.1)
+Requirement already satisfied: jinja2 in c:\python312\lib\site-packages (from torch>=1.6.0->sentence-transformers) (3.1.6)
+Requirement already satisfied: setuptools in c:\python312\lib\site-packages (from torch>=1.6.0->sentence-transformers) (82.0.1)
+Requirement already satisfied: colorama in c:\python312\lib\site-packages (from tqdm->sentence-transformers) (0.4.6)
+Requirement already satisfied: regex!=2019.12.17 in c:\python312\lib\site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers) (2026.2.28)
+Requirement already satisfied: tokenizers<=0.23.0,>=0.22.0 in c:\python312\lib\site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers) (0.22.2)
+Requirement already satisfied: safetensors>=0.4.3 in c:\python312\lib\site-packages (from transformers<5.0.0,>=4.6.0->sentence-transformers) (0.7.0)
+Requirement already satisfied: click in c:\python312\lib\site-packages (from nltk->sentence-transformers) (8.3.1)
+Requirement already satisfied: joblib in c:\python312\lib\site-packages (from nltk->sentence-transformers) (1.5.3)
+Requirement already satisfied: threadpoolctl>=3.2.0 in c:\python312\lib\site-packages (from scikit-learn->sentence-transformers) (3.6.0)
+Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in c:\python312\lib\site-packages (from torchvision->sentence-transformers) (12.1.1)
+Requirement already satisfied: mpmath<1.4,>=1.1.0 in c:\python312\lib\site-packages (from sympy>=1.13.3->torch>=1.6.0->sentence-transformers) (1.3.0)
+Requirement already satisfied: MarkupSafe>=2.0 in c:\python312\lib\site-packages (from jinja2->torch>=1.6.0->sentence-transformers) (3.0.3)
+Requirement already satisfied: charset-normalizer<4,>=2 in c:\python312\lib\site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers) (3.4.6)
+Requirement already satisfied: idna<4,>=2.5 in c:\python312\lib\site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers) (3.11)
+Requirement already satisfied: urllib3<3,>=1.21.1 in c:\python312\lib\site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers) (2.6.3)
+Requirement already satisfied: certifi>=2017.4.17 in c:\python312\lib\site-packages (from requests->huggingface-hub>=0.4.0->sentence-transformers) (2026.2.25)
+
+[notice] A new release of pip is available: 24.2 -> 26.0.1
+[notice] To update, run: python.exe -m pip install --upgrade pip

backend/app/api/__init__.py

@@ -2,13 +2,32 @@
 API 路由注册模块
 """
 from fastapi import APIRouter
-from app.api.endpoints import upload, ai_analyze, visualization, analysis_charts
+from app.api.endpoints import (
+    upload,
+    documents,      # 多格式文档上传
+    tasks,          # 任务管理
+    library,        # 文档库
+    rag,            # RAG检索
+    templates,      # 表格模板
+    ai_analyze,
+    visualization,
+    analysis_charts,
+    health,
+    instruction,    # 智能指令
+)
 
 # 创建主路由
 api_router = APIRouter()
 
 # 注册各模块路由
-api_router.include_router(upload.router)
+api_router.include_router(health.router)           # 健康检查
-api_router.include_router(ai_analyze.router)
+api_router.include_router(upload.router)            # 原有Excel上传
-api_router.include_router(visualization.router)
+api_router.include_router(documents.router)        # 多格式文档上传
-api_router.include_router(analysis_charts.router)
+api_router.include_router(tasks.router)            # 任务状态查询
+api_router.include_router(library.router)          # 文档库管理
+api_router.include_router(rag.router)              # RAG检索
+api_router.include_router(templates.router)        # 表格模板
+api_router.include_router(ai_analyze.router)       # AI分析
+api_router.include_router(visualization.router)    # 可视化
+api_router.include_router(analysis_charts.router)  # 分析图表
+api_router.include_router(instruction.router)      # 智能指令

backend/app/api/endpoints/ai_analyze.py

@@ -2,10 +2,16 @@
 AI 分析 API 接口
 """
 from fastapi import APIRouter, UploadFile, File, HTTPException, Query, Body
+from fastapi.responses import StreamingResponse
 from typing import Optional
 import logging
+import tempfile
+import os
 
 from app.services.excel_ai_service import excel_ai_service
+from app.services.markdown_ai_service import markdown_ai_service
+from app.services.template_fill_service import template_fill_service
+from app.services.word_ai_service import word_ai_service
 
 logger = logging.getLogger(__name__)
 
@@ -93,10 +99,11 @@ async def get_analysis_types():
     获取支持的分析类型列表
 
     Returns:
-        list: 支持的分析类型
+        dict: 支持的分析类型（包含 Excel 和 Markdown）
     """
     return {
-        "types": excel_ai_service.get_supported_analysis_types()
+        "excel_types": excel_ai_service.get_supported_analysis_types(),
+        "markdown_types": markdown_ai_service.get_supported_analysis_types()
     }
 
 
@@ -142,3 +149,337 @@ async def analyze_text(
     except Exception as e:
         logger.error(f"文本分析失败: {str(e)}")
         raise HTTPException(status_code=500, detail=f"分析失败: {str(e)}")
+
+
+@router.post("/analyze/md")
+async def analyze_markdown(
+    file: UploadFile = File(...),
+    analysis_type: str = Query("summary", description="分析类型: summary, outline, key_points, questions, tags, qa, statistics, section"),
+    user_prompt: str = Query("", description="用户自定义提示词"),
+    section_number: Optional[str] = Query(None, description="指定章节编号，如 '一' 或 '（一）'")
+):
+    """
+    上传并使用 AI 分析 Markdown 文件
+
+    Args:
+        file: 上传的 Markdown 文件
+        analysis_type: 分析类型
+        user_prompt: 用户自定义提示词
+        section_number: 指定分析的章节编号
+
+    Returns:
+        dict: 分析结果
+    """
+    # 检查文件类型
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['md', 'markdown']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 .md 和 .markdown"
+        )
+
+    # 验证分析类型
+    supported_types = markdown_ai_service.get_supported_analysis_types()
+    if analysis_type not in supported_types:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的分析类型: {analysis_type}，支持的类型: {', '.join(supported_types)}"
+        )
+
+    try:
+        # 读取文件内容
+        content = await file.read()
+
+        # 保存到临时文件
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.md', delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            logger.info(f"开始分析 Markdown 文件: {file.filename}, 分析类型: {analysis_type}, 章节: {section_number}")
+
+            # 调用 AI 分析服务
+            result = await markdown_ai_service.analyze_markdown(
+                file_path=tmp_path,
+                analysis_type=analysis_type,
+                user_prompt=user_prompt,
+                section_number=section_number
+            )
+
+            logger.info(f"Markdown 分析完成: {file.filename}, 成功: {result['success']}")
+
+            if not result['success']:
+                raise HTTPException(status_code=500, detail=result.get('error', '分析失败'))
+
+            return result
+
+        finally:
+            # 清理临时文件，确保在所有情况下都能清理
+            try:
+                if tmp_path and os.path.exists(tmp_path):
+                    os.unlink(tmp_path)
+            except Exception as cleanup_error:
+                logger.warning(f"临时文件清理失败: {tmp_path}, error: {cleanup_error}")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Markdown AI 分析过程中出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"分析失败: {str(e)}")
+
+
+@router.post("/analyze/md/stream")
+async def analyze_markdown_stream(
+    file: UploadFile = File(...),
+    analysis_type: str = Query("summary", description="分析类型"),
+    user_prompt: str = Query("", description="用户自定义提示词"),
+    section_number: Optional[str] = Query(None, description="指定章节编号")
+):
+    """
+    流式分析 Markdown 文件 (SSE)
+
+    Returns:
+        StreamingResponse: SSE 流式响应
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['md', 'markdown']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 .md 和 .markdown"
+        )
+
+    try:
+        content = await file.read()
+
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.md', delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            logger.info(f"开始流式分析 Markdown 文件: {file.filename}, 分析类型: {analysis_type}")
+
+            async def stream_generator():
+                async for chunk in markdown_ai_service.analyze_markdown_stream(
+                    file_path=tmp_path,
+                    analysis_type=analysis_type,
+                    user_prompt=user_prompt,
+                    section_number=section_number
+                ):
+                    yield chunk
+
+            return StreamingResponse(
+                stream_generator(),
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no"
+                }
+            )
+
+        finally:
+            # 清理临时文件，确保在所有情况下都能清理
+            try:
+                if tmp_path and os.path.exists(tmp_path):
+                    os.unlink(tmp_path)
+            except Exception as cleanup_error:
+                logger.warning(f"临时文件清理失败: {tmp_path}, error: {cleanup_error}")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Markdown AI 流式分析出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"流式分析失败: {str(e)}")
+
+
+@router.post("/analyze/md/outline")
+async def get_markdown_outline(
+    file: UploadFile = File(...)
+):
+    """
+    获取 Markdown 文档的大纲结构（分章节信息）
+
+    Args:
+        file: 上传的 Markdown 文件
+
+    Returns:
+        dict: 文档大纲结构
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['md', 'markdown']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 .md 和 .markdown"
+        )
+
+    try:
+        content = await file.read()
+
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.md', delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            result = await markdown_ai_service.extract_outline(tmp_path)
+            return result
+        finally:
+            # 清理临时文件，确保在所有情况下都能清理
+            try:
+                if tmp_path and os.path.exists(tmp_path):
+                    os.unlink(tmp_path)
+            except Exception as cleanup_error:
+                logger.warning(f"临时文件清理失败: {tmp_path}, error: {cleanup_error}")
+
+    except Exception as e:
+        logger.error(f"获取 Markdown 大纲失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"获取大纲失败: {str(e)}")
+
+
+@router.post("/analyze/txt")
+async def analyze_txt(
+    file: UploadFile = File(...),
+):
+    """
+    上传并使用 AI 分析 TXT 文本文件，提取结构化数据
+
+    将非结构化文本转换为结构化表格数据，便于后续填表使用
+
+    Args:
+        file: 上传的 TXT 文件
+
+    Returns:
+        dict: 分析结果，包含结构化表格数据
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['txt', 'text']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 .txt"
+        )
+
+    try:
+        # 读取文件内容
+        content = await file.read()
+
+        # 保存到临时文件
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.txt', delete=False) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            logger.info(f"开始 AI 分析 TXT 文件: {file.filename}")
+
+            # 使用 template_fill_service 的 AI 分析方法
+            result = await template_fill_service.analyze_txt_with_ai(
+                content=content.decode('utf-8', errors='replace'),
+                filename=file.filename
+            )
+
+            if result:
+                logger.info(f"TXT AI 分析成功: {file.filename}")
+                return {
+                    "success": True,
+                    "filename": file.filename,
+                    "structured_data": result
+                }
+            else:
+                logger.warning(f"TXT AI 分析返回空结果: {file.filename}")
+                return {
+                    "success": False,
+                    "filename": file.filename,
+                    "error": "AI 分析未能提取到结构化数据",
+                    "structured_data": None
+                }
+
+        finally:
+            # 清理临时文件
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"TXT AI 分析过程中出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"分析失败: {str(e)}")
+
+
+# ==================== Word 文档 AI 解析 ====================
+
+@router.post("/analyze/word")
+async def analyze_word(
+    file: UploadFile = File(...),
+    user_hint: str = Query("", description="用户提示词，如'请提取表格数据'")
+):
+    """
+    使用 AI 解析 Word 文档，提取结构化数据
+
+    适用于从非结构化的 Word 文档中提取表格数据、键值对等信息
+
+    Args:
+        file: 上传的 Word 文件
+        user_hint: 用户提示词
+
+    Returns:
+        dict: 包含结构化数据的解析结果
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['docx']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 .docx"
+        )
+
+    try:
+        # 保存上传的文件
+        content = await file.read()
+        suffix = f".{file_ext}"
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
+            tmp.write(content)
+            tmp_path = tmp.name
+
+        try:
+            # 使用 AI 解析 Word 文档
+            result = await word_ai_service.parse_word_with_ai(
+                file_path=tmp_path,
+                user_hint=user_hint or "请提取文档中的所有结构化数据，包括表格、键值对等"
+            )
+
+            if result.get("success"):
+                return {
+                    "success": True,
+                    "filename": file.filename,
+                    "result": result
+                }
+            else:
+                return {
+                    "success": False,
+                    "filename": file.filename,
+                    "error": result.get("error", "AI 解析失败"),
+                    "result": None
+                }
+
+        finally:
+            # 清理临时文件
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Word AI 分析过程中出错: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"分析失败: {str(e)}")

backend/app/api/endpoints/documents.py

@@ -0,0 +1,447 @@
+"""
+文档管理 API 接口
+
+支持多格式文档(docx/xlsx/md/txt)上传、解析、存储和RAG索引
+集成 Excel 存储和 AI 生成字段描述
+"""
+import logging
+import uuid
+from typing import List, Optional
+
+from fastapi import APIRouter, UploadFile, File, HTTPException, Query, BackgroundTasks
+from pydantic import BaseModel
+
+from app.services.file_service import file_service
+from app.core.database import mongodb, redis_db
+from app.services.rag_service import rag_service
+from app.services.table_rag_service import table_rag_service
+from app.services.excel_storage_service import excel_storage_service
+from app.core.document_parser import ParserFactory, ParseResult
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/upload", tags=["文档上传"])
+
+
+# ==================== 辅助函数 ====================
+
+async def update_task_status(
+    task_id: str,
+    status: str,
+    progress: int = 0,
+    message: str = "",
+    result: dict = None,
+    error: str = None
+):
+    """
+    更新任务状态，同时写入 Redis 和 MongoDB
+
+    Args:
+        task_id: 任务ID
+        status: 状态
+        progress: 进度
+        message: 消息
+        result: 结果
+        error: 错误信息
+    """
+    meta = {"progress": progress, "message": message}
+    if result:
+        meta["result"] = result
+    if error:
+        meta["error"] = error
+
+    # 尝试写入 Redis
+    try:
+        await redis_db.set_task_status(task_id, status, meta)
+    except Exception as e:
+        logger.warning(f"Redis 任务状态更新失败: {e}")
+
+    # 尝试写入 MongoDB（作为备用）
+    try:
+        await mongodb.update_task(
+            task_id=task_id,
+            status=status,
+            message=message,
+            result=result,
+            error=error
+        )
+    except Exception as e:
+        logger.warning(f"MongoDB 任务状态更新失败: {e}")
+
+
+# ==================== 请求/响应模型 ====================
+
+class UploadResponse(BaseModel):
+    task_id: str
+    file_count: int
+    message: str
+    status_url: str
+
+
+class TaskStatusResponse(BaseModel):
+    task_id: str
+    status: str
+    progress: int = 0
+    message: Optional[str] = None
+    result: Optional[dict] = None
+    error: Optional[str] = None
+
+
+# ==================== 文档上传接口 ====================
+
+@router.post("/document", response_model=UploadResponse)
+async def upload_document(
+    background_tasks: BackgroundTasks,
+    file: UploadFile = File(...),
+    parse_all_sheets: bool = Query(False, description="是否解析所有工作表(仅Excel)"),
+    sheet_name: Optional[str] = Query(None, description="指定工作表(仅Excel)"),
+    header_row: int = Query(0, description="表头行号(仅Excel)")
+):
+    """
+    上传单个文档并异步处理
+
+    文档会：
+    1. 保存到本地存储
+    2. 解析内容
+    3. 存入 MongoDB (原始内容)
+    4. 如果是 Excel：
+       - 存入 MySQL (结构化数据)
+       - AI 生成字段描述
+       - 建立 RAG 索引
+    5. 建立 RAG 索引 (非结构化文档)
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['docx', 'xlsx', 'xls', 'md', 'txt']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的文件类型: {file_ext}，仅支持 docx/xlsx/xls/md/txt"
+        )
+
+    task_id = str(uuid.uuid4())
+
+    try:
+        # 保存任务记录到 MongoDB（如果 Redis 不可用时仍能查询）
+        try:
+            await mongodb.insert_task(
+                task_id=task_id,
+                task_type="document_parse",
+                status="pending",
+                message=f"文档 {file.filename} 已提交处理"
+            )
+        except Exception as mongo_err:
+            logger.warning(f"MongoDB 保存任务记录失败: {mongo_err}")
+
+        content = await file.read()
+        saved_path = file_service.save_uploaded_file(
+            content,
+            file.filename,
+            subfolder=file_ext
+        )
+
+        background_tasks.add_task(
+            process_document,
+            task_id=task_id,
+            file_path=saved_path,
+            original_filename=file.filename,
+            doc_type=file_ext,
+            parse_options={
+                "parse_all_sheets": parse_all_sheets,
+                "sheet_name": sheet_name,
+                "header_row": header_row
+            }
+        )
+
+        return UploadResponse(
+            task_id=task_id,
+            file_count=1,
+            message=f"文档 {file.filename} 已提交处理",
+            status_url=f"/api/v1/tasks/{task_id}"
+        )
+
+    except Exception as e:
+        logger.error(f"上传文档失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}")
+
+
+@router.post("/documents", response_model=UploadResponse)
+async def upload_documents(
+    background_tasks: BackgroundTasks,
+    files: List[UploadFile] = File(...),
+):
+    """批量上传文档"""
+    if not files:
+        raise HTTPException(status_code=400, detail="没有上传文件")
+
+    task_id = str(uuid.uuid4())
+    saved_paths = []
+
+    try:
+        # 保存任务记录到 MongoDB
+        try:
+            await mongodb.insert_task(
+                task_id=task_id,
+                task_type="batch_parse",
+                status="pending",
+                message=f"已提交 {len(files)} 个文档处理"
+            )
+        except Exception as mongo_err:
+            logger.warning(f"MongoDB 保存批量任务记录失败: {mongo_err}")
+
+        for file in files:
+            if not file.filename:
+                continue
+            content = await file.read()
+            saved_path = file_service.save_uploaded_file(content, file.filename, subfolder="batch")
+            saved_paths.append({
+                "path": saved_path,
+                "filename": file.filename,
+                "ext": file.filename.split('.')[-1].lower()
+            })
+
+        background_tasks.add_task(process_documents_batch, task_id=task_id, files=saved_paths)
+
+        return UploadResponse(
+            task_id=task_id,
+            file_count=len(saved_paths),
+            message=f"已提交 {len(saved_paths)} 个文档处理",
+            status_url=f"/api/v1/tasks/{task_id}"
+        )
+
+    except Exception as e:
+        logger.error(f"批量上传失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"批量上传失败: {str(e)}")
+
+
+# ==================== 任务处理函数 ====================
+
+async def process_document(
+    task_id: str,
+    file_path: str,
+    original_filename: str,
+    doc_type: str,
+    parse_options: dict
+):
+    """处理单个文档"""
+    try:
+        # 状态: 解析中
+        await update_task_status(
+            task_id, status="processing",
+            progress=10, message="正在解析文档"
+        )
+
+        # 解析文档
+        parser = ParserFactory.get_parser(file_path)
+        result = parser.parse(file_path)
+
+        if not result.success:
+            raise Exception(result.error or "解析失败")
+
+        # 状态: 存储中
+        await update_task_status(
+            task_id, status="processing",
+            progress=30, message="正在存储数据"
+        )
+
+        # 存储到 MongoDB
+        doc_id = await mongodb.insert_document(
+            doc_type=doc_type,
+            content=result.data.get("content", ""),
+            metadata={
+                **result.metadata,
+                "original_filename": original_filename,
+                "file_path": file_path
+            },
+            structured_data=result.data.get("structured_data")
+        )
+
+        # 如果是 Excel，存储到 MySQL + AI生成描述 + RAG索引
+        if doc_type in ["xlsx", "xls"]:
+            await update_task_status(
+                task_id, status="processing",
+                progress=50, message="正在存储到MySQL并生成字段描述"
+            )
+
+            try:
+                # 使用 TableRAG 服务完成建表和RAG索引
+                logger.info(f"开始存储Excel到MySQL: {original_filename}, file_path: {file_path}")
+                rag_result = await table_rag_service.build_table_rag_index(
+                    file_path=file_path,
+                    filename=original_filename,
+                    sheet_name=parse_options.get("sheet_name"),
+                    header_row=parse_options.get("header_row", 0)
+                )
+
+                if rag_result.get("success"):
+                    logger.info(f"Excel存储到MySQL成功: {original_filename}, table: {rag_result.get('table_name')}")
+                else:
+                    logger.error(f"RAG索引构建失败: {rag_result.get('error')}")
+            except Exception as e:
+                logger.error(f"Excel存储到MySQL异常: {str(e)}", exc_info=True)
+
+        else:
+            # 非结构化文档
+            await update_task_status(
+                task_id, status="processing",
+                progress=60, message="正在建立索引"
+            )
+
+            # 如果文档中有表格数据，提取并存储到 MySQL + RAG
+            structured_data = result.data.get("structured_data", {})
+            tables = structured_data.get("tables", [])
+
+            if tables:
+                # 对每个表格建立 MySQL 表和 RAG 索引
+                for table_info in tables:
+                    await table_rag_service.index_document_table(
+                        doc_id=doc_id,
+                        filename=original_filename,
+                        table_data=table_info,
+                        source_doc_type=doc_type
+                    )
+
+            # 同时对文档内容建立 RAG 索引
+            await index_document_to_rag(doc_id, original_filename, result, doc_type)
+
+        # 完成
+        await update_task_status(
+            task_id, status="success",
+            progress=100, message="处理完成",
+            result={
+                "doc_id": doc_id,
+                "doc_type": doc_type,
+                "filename": original_filename
+            }
+        )
+
+        logger.info(f"文档处理完成: {original_filename}, doc_id: {doc_id}")
+
+    except Exception as e:
+        logger.error(f"文档处理失败: {str(e)}")
+        await update_task_status(
+            task_id, status="failure",
+            progress=0, message="处理失败",
+            error=str(e)
+        )
+
+
+async def process_documents_batch(task_id: str, files: List[dict]):
+    """批量处理文档"""
+    try:
+        await update_task_status(
+            task_id, status="processing",
+            progress=0, message="开始批量处理"
+        )
+
+        results = []
+        for i, file_info in enumerate(files):
+            try:
+                parser = ParserFactory.get_parser(file_info["path"])
+                result = parser.parse(file_info["path"])
+
+                if result.success:
+                    doc_id = await mongodb.insert_document(
+                        doc_type=file_info["ext"],
+                        content=result.data.get("content", ""),
+                        metadata={
+                            **result.metadata,
+                            "original_filename": file_info["filename"],
+                            "file_path": file_info["path"]
+                        },
+                        structured_data=result.data.get("structured_data")
+                    )
+
+                    # Excel 处理
+                    if file_info["ext"] in ["xlsx", "xls"]:
+                        await table_rag_service.build_table_rag_index(
+                            file_path=file_info["path"],
+                            filename=file_info["filename"]
+                        )
+                    else:
+                        # 非结构化文档：处理其中的表格 + 内容索引
+                        structured_data = result.data.get("structured_data", {})
+                        tables = structured_data.get("tables", [])
+
+                        if tables:
+                            for table_info in tables:
+                                await table_rag_service.index_document_table(
+                                    doc_id=doc_id,
+                                    filename=file_info["filename"],
+                                    table_data=table_info,
+                                    source_doc_type=file_info["ext"]
+                                )
+
+                        await index_document_to_rag(doc_id, file_info["filename"], result, file_info["ext"])
+
+                    results.append({"filename": file_info["filename"], "doc_id": doc_id, "success": True})
+                else:
+                    results.append({"filename": file_info["filename"], "success": False, "error": result.error})
+
+            except Exception as e:
+                results.append({"filename": file_info["filename"], "success": False, "error": str(e)})
+
+            progress = int((i + 1) / len(files) * 100)
+            await update_task_status(
+                task_id, status="processing",
+                progress=progress, message=f"已处理 {i+1}/{len(files)}"
+            )
+
+        await update_task_status(
+            task_id, status="success",
+            progress=100, message="批量处理完成",
+            result={"results": results}
+        )
+
+    except Exception as e:
+        logger.error(f"批量处理失败: {str(e)}")
+        await update_task_status(
+            task_id, status="failure",
+            progress=0, message="批量处理失败",
+            error=str(e)
+        )
+
+
+async def index_document_to_rag(doc_id: str, filename: str, result: ParseResult, doc_type: str):
+    """将非结构化文档索引到 RAG（使用分块索引）"""
+    try:
+        content = result.data.get("content", "")
+        if content:
+            # 将完整内容传递给 RAG 服务自动分块索引
+            rag_service.index_document_content(
+                doc_id=doc_id,
+                content=content,  # 传递完整内容，由 RAG 服务自动分块
+                metadata={
+                    "filename": filename,
+                    "doc_type": doc_type
+                },
+                chunk_size=500,  # 每块 500 字符
+                chunk_overlap=50  # 块之间 50 字符重叠
+            )
+            logger.info(f"RAG 索引完成: {filename}, doc_id={doc_id}")
+    except Exception as e:
+        logger.warning(f"RAG 索引失败: {str(e)}")
+
+
+# ==================== 文档解析接口 ====================
+
+@router.post("/document/parse")
+async def parse_uploaded_document(
+    file_path: str = Query(..., description="文件路径")
+):
+    """解析已上传的文档"""
+    try:
+        parser = ParserFactory.get_parser(file_path)
+        result = parser.parse(file_path)
+
+        if result.success:
+            return result.to_dict()
+        else:
+            raise HTTPException(status_code=400, detail=result.error)
+
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"解析文档失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"解析失败: {str(e)}")

backend/app/api/endpoints/health.py

@@ -0,0 +1,93 @@
+"""
+健康检查接口
+"""
+from datetime import datetime
+from typing import Any, Dict
+
+from fastapi import APIRouter
+
+from app.core.database import mysql_db, mongodb, redis_db
+
+router = APIRouter(tags=["健康检查"])
+
+
+@router.get("/health")
+async def health_check() -> Dict[str, Any]:
+    """
+    健康检查接口
+
+    返回各数据库连接状态和应用信息
+    """
+    # 检查各数据库连接状态
+    mysql_status = "unknown"
+    mongodb_status = "unknown"
+    redis_status = "unknown"
+
+    try:
+        if mysql_db.async_engine is None:
+            mysql_status = "disconnected"
+        else:
+            # 实际执行一次查询验证连接
+            from sqlalchemy import text
+            async with mysql_db.async_engine.connect() as conn:
+                await conn.execute(text("SELECT 1"))
+            mysql_status = "connected"
+    except Exception as e:
+        logger.warning(f"MySQL 健康检查失败: {e}")
+        mysql_status = "error"
+
+    try:
+        if mongodb.client is None:
+            mongodb_status = "disconnected"
+        else:
+            # 实际 ping 验证
+            await mongodb.client.admin.command('ping')
+            mongodb_status = "connected"
+    except Exception as e:
+        logger.warning(f"MongoDB 健康检查失败: {e}")
+        mongodb_status = "error"
+
+    try:
+        if not redis_db.is_connected or redis_db.client is None:
+            redis_status = "disconnected"
+        else:
+            # 实际执行 ping 验证
+            await redis_db.client.ping()
+            redis_status = "connected"
+    except Exception as e:
+        logger.warning(f"Redis 健康检查失败: {e}")
+        redis_status = "error"
+
+    return {
+        "status": "healthy" if all([
+            mysql_status == "connected",
+            mongodb_status == "connected",
+            redis_status == "connected"
+        ]) else "degraded",
+        "timestamp": datetime.utcnow().isoformat(),
+        "services": {
+            "mysql": mysql_status,
+            "mongodb": mongodb_status,
+            "redis": redis_status,
+        }
+    }
+
+
+@router.get("/health/ready")
+async def readiness_check() -> Dict[str, str]:
+    """
+    就绪检查接口
+
+    用于 Kubernetes/负载均衡器检查服务是否就绪
+    """
+    return {"status": "ready"}
+
+
+@router.get("/health/live")
+async def liveness_check() -> Dict[str, str]:
+    """
+    存活检查接口
+
+    用于 Kubernetes/负载均衡器检查服务是否存活
+    """
+    return {"status": "alive"}

backend/app/api/endpoints/instruction.py

@@ -0,0 +1,439 @@
+"""
+智能指令 API 接口
+
+支持自然语言指令解析和执行
+"""
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, HTTPException, Query, BackgroundTasks
+from pydantic import BaseModel
+
+from app.instruction.intent_parser import intent_parser
+from app.instruction.executor import instruction_executor
+from app.core.database import mongodb
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/instruction", tags=["智能指令"])
+
+
+# ==================== 请求/响应模型 ====================
+
+class InstructionRequest(BaseModel):
+    instruction: str
+    doc_ids: Optional[List[str]] = None  # 关联的文档 ID 列表
+    context: Optional[Dict[str, Any]] = None  # 额外上下文
+
+
+class IntentRecognitionResponse(BaseModel):
+    success: bool
+    intent: str
+    params: Dict[str, Any]
+    message: str
+
+
+class InstructionExecutionResponse(BaseModel):
+    success: bool
+    intent: str
+    result: Dict[str, Any]
+    message: str
+
+
+# ==================== 接口 ====================
+
+@router.post("/recognize", response_model=IntentRecognitionResponse)
+async def recognize_intent(request: InstructionRequest):
+    """
+    意图识别接口
+
+    将自然语言指令解析为结构化的意图和参数
+
+    示例指令:
+    - "提取文档中的医院数量和床位数"
+    - "根据这些数据填表"
+    - "总结一下这份文档"
+    - "对比这两个文档的差异"
+    """
+    try:
+        intent, params = await intent_parser.parse(request.instruction)
+
+        # 添加文档关联信息
+        if request.doc_ids:
+            params["document_refs"] = [f"doc_{doc_id}" for doc_id in request.doc_ids]
+
+        intent_names = {
+            "extract": "信息提取",
+            "fill_table": "表格填写",
+            "summarize": "摘要总结",
+            "question": "智能问答",
+            "search": "文档搜索",
+            "compare": "对比分析",
+            "transform": "格式转换",
+            "edit": "文档编辑",
+            "unknown": "未知"
+        }
+
+        return IntentRecognitionResponse(
+            success=True,
+            intent=intent,
+            params=params,
+            message=f"识别到意图: {intent_names.get(intent, intent)}"
+        )
+
+    except Exception as e:
+        logger.error(f"意图识别失败: {e}")
+        return IntentRecognitionResponse(
+            success=False,
+            intent="error",
+            params={},
+            message=f"意图识别失败: {str(e)}"
+        )
+
+
+@router.post("/execute")
+async def execute_instruction(
+    background_tasks: BackgroundTasks,
+    request: InstructionRequest,
+    async_execute: bool = Query(False, description="是否异步执行（仅返回任务ID）")
+):
+    """
+    指令执行接口
+
+    解析并执行自然语言指令
+
+    示例:
+    - 指令: "提取文档1中的医院数量"
+      返回: {"extracted_data": {"医院数量": ["38710个"]}}
+
+    - 指令: "填表"
+      返回: {"filled_data": {...}}
+
+    设置 async_execute=true 可异步执行，返回任务ID用于查询进度
+    """
+    task_id = str(uuid.uuid4())
+
+    if async_execute:
+        # 异步模式：立即返回任务ID，后台执行
+        background_tasks.add_task(
+            _execute_instruction_task,
+            task_id=task_id,
+            instruction=request.instruction,
+            doc_ids=request.doc_ids,
+            context=request.context
+        )
+
+        return {
+            "success": True,
+            "task_id": task_id,
+            "message": "指令已提交执行",
+            "status_url": f"/api/v1/tasks/{task_id}"
+        }
+
+    # 同步模式：等待执行完成
+    return await _execute_instruction_task(task_id, request.instruction, request.doc_ids, request.context)
+
+
+async def _execute_instruction_task(
+    task_id: str,
+    instruction: str,
+    doc_ids: Optional[List[str]],
+    context: Optional[Dict[str, Any]]
+) -> InstructionExecutionResponse:
+    """执行指令的后台任务"""
+    from app.core.database import redis_db, mongodb as mongo_client
+
+    try:
+        # 记录任务
+        try:
+            await mongo_client.insert_task(
+                task_id=task_id,
+                task_type="instruction_execute",
+                status="processing",
+                message="正在执行指令"
+            )
+        except Exception:
+            pass
+
+        # 构建执行上下文
+        ctx: Dict[str, Any] = context or {}
+
+        # 如果提供了文档 ID，获取文档内容
+        if doc_ids:
+            docs = []
+            for doc_id in doc_ids:
+                doc = await mongo_client.get_document(doc_id)
+                if doc:
+                    docs.append(doc)
+
+            if docs:
+                ctx["source_docs"] = docs
+                logger.info(f"指令执行上下文: 关联了 {len(docs)} 个文档")
+
+        # 执行指令
+        result = await instruction_executor.execute(instruction, ctx)
+
+        # 更新任务状态
+        try:
+            await mongo_client.update_task(
+                task_id=task_id,
+                status="success",
+                message="执行完成",
+                result=result
+            )
+        except Exception:
+            pass
+
+        return InstructionExecutionResponse(
+            success=result.get("success", False),
+            intent=result.get("intent", "unknown"),
+            result=result,
+            message=result.get("message", "执行完成")
+        )
+
+    except Exception as e:
+        logger.error(f"指令执行失败: {e}")
+        try:
+            await mongo_client.update_task(
+                task_id=task_id,
+                status="failure",
+                message="执行失败",
+                error=str(e)
+            )
+        except Exception:
+            pass
+
+        return InstructionExecutionResponse(
+            success=False,
+            intent="error",
+            result={"error": str(e)},
+            message=f"指令执行失败: {str(e)}"
+        )
+
+
+@router.post("/chat")
+async def instruction_chat(
+    background_tasks: BackgroundTasks,
+    request: InstructionRequest,
+    async_execute: bool = Query(False, description="是否异步执行（仅返回任务ID）")
+):
+    """
+    指令对话接口
+
+    支持多轮对话的指令执行
+
+    示例对话流程:
+    1. 用户: "上传一些文档"
+    2. 系统: "请上传文档"
+    3. 用户: "提取其中的医院数量"
+    4. 系统: 返回提取结果
+
+    设置 async_execute=true 可异步执行，返回任务ID用于查询进度
+    """
+    task_id = str(uuid.uuid4())
+
+    if async_execute:
+        # 异步模式：立即返回任务ID，后台执行
+        background_tasks.add_task(
+            _execute_chat_task,
+            task_id=task_id,
+            instruction=request.instruction,
+            doc_ids=request.doc_ids,
+            context=request.context
+        )
+
+        return {
+            "success": True,
+            "task_id": task_id,
+            "message": "指令已提交执行",
+            "status_url": f"/api/v1/tasks/{task_id}"
+        }
+
+    # 同步模式：等待执行完成
+    return await _execute_chat_task(task_id, request.instruction, request.doc_ids, request.context)
+
+
+async def _execute_chat_task(
+    task_id: str,
+    instruction: str,
+    doc_ids: Optional[List[str]],
+    context: Optional[Dict[str, Any]]
+):
+    """执行指令对话的后台任务"""
+    from app.core.database import mongodb as mongo_client
+
+    try:
+        # 记录任务
+        try:
+            await mongo_client.insert_task(
+                task_id=task_id,
+                task_type="instruction_chat",
+                status="processing",
+                message="正在处理对话"
+            )
+        except Exception:
+            pass
+
+        # 构建上下文
+        ctx: Dict[str, Any] = context or {}
+
+        # 获取关联文档
+        if doc_ids:
+            docs = []
+            for doc_id in doc_ids:
+                doc = await mongo_client.get_document(doc_id)
+                if doc:
+                    docs.append(doc)
+            if docs:
+                ctx["source_docs"] = docs
+
+        # 执行指令
+        result = await instruction_executor.execute(instruction, ctx)
+
+        # 根据意图类型添加友好的响应消息
+        response_messages = {
+            "extract": f"已提取 {len(result.get('extracted_data', {}))} 个字段的数据",
+            "fill_table": f"填表完成，填写了 {len(result.get('result', {}).get('filled_data', {}))} 个字段",
+            "summarize": "已生成文档摘要",
+            "question": "已找到相关答案",
+            "search": f"找到 {len(result.get('results', []))} 条相关内容",
+            "compare": f"对比了 {len(result.get('comparison', []))} 个文档",
+            "edit": "编辑操作已完成",
+            "transform": "格式转换已完成",
+            "unknown": "无法理解该指令，请尝试更明确的描述"
+        }
+
+        response = {
+            "success": result.get("success", False),
+            "intent": result.get("intent", "unknown"),
+            "result": result,
+            "message": response_messages.get(result.get("intent", ""), result.get("message", "")),
+            "hint": _get_intent_hint(result.get("intent", ""))
+        }
+
+        # 更新任务状态
+        try:
+            await mongo_client.update_task(
+                task_id=task_id,
+                status="success",
+                message="处理完成",
+                result=response
+            )
+        except Exception:
+            pass
+
+        return response
+
+    except Exception as e:
+        logger.error(f"指令对话失败: {e}")
+        try:
+            await mongo_client.update_task(
+                task_id=task_id,
+                status="failure",
+                message="处理失败",
+                error=str(e)
+            )
+        except Exception:
+            pass
+
+        return {
+            "success": False,
+            "error": str(e),
+            "message": f"处理失败: {str(e)}"
+        }
+
+
+def _get_intent_hint(intent: str) -> Optional[str]:
+    """根据意图返回下一步提示"""
+    hints = {
+        "extract": "您可以继续说 '提取更多字段' 或 '将数据填入表格'",
+        "fill_table": "您可以提供表格模板或说 '帮我创建一个表格'",
+        "question": "您可以继续提问或说 '总结一下这些内容'",
+        "search": "您可以查看搜索结果或说 '对比这些内容'",
+        "unknown": "您可以尝试: '提取数据'、'填表'、'总结'、'问答' 等指令"
+    }
+    return hints.get(intent)
+
+
+@router.get("/intents")
+async def list_supported_intents():
+    """
+    获取支持的意图类型列表
+
+    返回所有可用的自然语言指令类型
+    """
+    return {
+        "intents": [
+            {
+                "intent": "extract",
+                "name": "信息提取",
+                "examples": [
+                    "提取文档中的医院数量",
+                    "抽取所有机构的名称",
+                    "找出表格中的数据"
+                ],
+                "params": ["field_refs", "document_refs"]
+            },
+            {
+                "intent": "fill_table",
+                "name": "表格填写",
+                "examples": [
+                    "填表",
+                    "根据这些数据填写表格",
+                    "帮我填到Excel里"
+                ],
+                "params": ["template", "document_refs"]
+            },
+            {
+                "intent": "summarize",
+                "name": "摘要总结",
+                "examples": [
+                    "总结一下这份文档",
+                    "生成摘要",
+                    "概括主要内容"
+                ],
+                "params": ["document_refs"]
+            },
+            {
+                "intent": "question",
+                "name": "智能问答",
+                "examples": [
+                    "这段话说的是什么？",
+                    "有多少家医院？",
+                    "解释一下这个概念"
+                ],
+                "params": ["question", "focus"]
+            },
+            {
+                "intent": "search",
+                "name": "文档搜索",
+                "examples": [
+                    "搜索相关内容",
+                    "找找看有哪些机构",
+                    "查询医院相关的数据"
+                ],
+                "params": ["field_refs", "question"]
+            },
+            {
+                "intent": "compare",
+                "name": "对比分析",
+                "examples": [
+                    "对比这两个文档",
+                    "比较一下差异",
+                    "找出不同点"
+                ],
+                "params": ["document_refs"]
+            },
+            {
+                "intent": "edit",
+                "name": "文档编辑",
+                "examples": [
+                    "润色这段文字",
+                    "修改格式",
+                    "添加注释"
+                ],
+                "params": []
+            }
+        ]
+    }

backend/app/api/endpoints/library.py

@@ -0,0 +1,170 @@
+"""
+文档库管理 API 接口
+
+提供文档列表、详情查询和删除功能
+"""
+import logging
+from typing import Optional, List
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from app.core.database import mongodb
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/documents", tags=["文档库"])
+
+
+class DocumentItem(BaseModel):
+    doc_id: str
+    filename: str
+    original_filename: str
+    doc_type: str
+    file_size: int
+    created_at: str
+    metadata: Optional[dict] = None
+
+
+@router.get("")
+async def get_documents(
+    doc_type: Optional[str] = Query(None, description="文档类型过滤"),
+    limit: int = Query(20, ge=1, le=100, description="返回数量"),
+    skip: int = Query(0, ge=0, description="跳过数量")
+):
+    """
+    获取文档列表
+
+    Returns:
+        文档列表
+    """
+    try:
+        # 构建查询条件
+        query = {}
+        if doc_type:
+            query["doc_type"] = doc_type
+
+        logger.info(f"开始查询文档列表, query: {query}, limit: {limit}")
+
+        # 使用 batch_size 和 max_time_ms 来控制查询
+        cursor = mongodb.documents.find(
+            query,
+            {"content": 0}  # 不返回 content 字段，减少数据传输
+        ).sort("created_at", -1).skip(skip).limit(limit)
+
+        # 设置 10 秒超时
+        cursor.max_time_ms(10000)
+
+        logger.info("Cursor created with 10s timeout, executing...")
+
+        # 使用 batch_size 逐批获取
+        documents_raw = await cursor.to_list(length=limit)
+        logger.info(f"查询到原始文档数: {len(documents_raw)}")
+
+        documents = []
+        for doc in documents_raw:
+            documents.append({
+                "doc_id": str(doc["_id"]),
+                "filename": doc.get("metadata", {}).get("filename", ""),
+                "original_filename": doc.get("metadata", {}).get("original_filename", ""),
+                "doc_type": doc.get("doc_type", ""),
+                "file_size": doc.get("metadata", {}).get("file_size", 0),
+                "created_at": doc.get("created_at", "").isoformat() if doc.get("created_at") else "",
+                "metadata": {
+                    "row_count": doc.get("metadata", {}).get("row_count"),
+                    "column_count": doc.get("metadata", {}).get("column_count"),
+                    "columns": doc.get("metadata", {}).get("columns", [])[:10]
+                }
+            })
+
+        logger.info(f"文档列表处理完成: {len(documents)} 个文档")
+
+        return {
+            "success": True,
+            "documents": documents,
+            "total": len(documents)
+        }
+
+    except Exception as e:
+        err_str = str(e)
+        # 如果是超时错误，返回空列表而不是报错
+        if "timeout" in err_str.lower() or "time" in err_str.lower():
+            logger.warning(f"文档查询超时，返回空列表: {err_str}")
+            return {
+                "success": True,
+                "documents": [],
+                "total": 0,
+                "warning": "查询超时，请稍后重试"
+            }
+        logger.error(f"获取文档列表失败: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"获取文档列表失败: {str(e)}")
+
+
+@router.get("/{doc_id}")
+async def get_document(doc_id: str):
+    """
+    获取文档详情
+
+    Args:
+        doc_id: 文档ID
+
+    Returns:
+        文档详情
+    """
+    try:
+        doc = await mongodb.get_document(doc_id)
+
+        if not doc:
+            raise HTTPException(status_code=404, detail="文档不存在")
+
+        return {
+            "success": True,
+            "document": {
+                "doc_id": str(doc["_id"]),
+                "filename": doc.get("metadata", {}).get("filename", ""),
+                "original_filename": doc.get("metadata", {}).get("original_filename", ""),
+                "doc_type": doc.get("doc_type", ""),
+                "file_size": doc.get("metadata", {}).get("file_size", 0),
+                "created_at": doc.get("created_at", "").isoformat() if doc.get("created_at") else "",
+                "content": doc.get("content", ""),  # 原始文本内容
+                "structured_data": doc.get("structured_data"),  # 结构化数据(如果有)
+                "metadata": doc.get("metadata", {})
+            }
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取文档详情失败: {str(e)}")
+
+
+@router.delete("/{doc_id}")
+async def delete_document(doc_id: str):
+    """
+    删除文档
+
+    Args:
+        doc_id: 文档ID
+
+    Returns:
+        删除结果
+    """
+    try:
+        # 从 MongoDB 删除
+        deleted = await mongodb.delete_document(doc_id)
+
+        if not deleted:
+            raise HTTPException(status_code=404, detail="文档不存在")
+
+        # TODO: 从 MySQL 删除相关数据(如果是Excel)
+        # TODO: 从 RAG 删除相关索引
+
+        return {
+            "success": True,
+            "message": "文档已删除"
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"删除失败: {str(e)}")

backend/app/api/endpoints/rag.py

@@ -0,0 +1,116 @@
+"""
+RAG 检索 API 接口
+
+提供向量检索功能
+"""
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from app.services.rag_service import rag_service
+
+router = APIRouter(prefix="/rag", tags=["RAG检索"])
+
+
+class SearchRequest(BaseModel):
+    query: str
+    top_k: int = 5
+
+
+class SearchResult(BaseModel):
+    content: str
+    metadata: dict
+    score: float
+    doc_id: str
+
+
+@router.post("/search")
+async def search_rag(
+    request: SearchRequest
+):
+    """
+    RAG 语义检索
+
+    根据查询文本检索相关的文档片段或字段
+
+    Args:
+        request.query: 查询文本
+        request.top_k: 返回数量
+
+    Returns:
+        相关文档列表
+    """
+    try:
+        results = rag_service.retrieve(
+            query=request.query,
+            top_k=request.top_k
+        )
+
+        return {
+            "success": True,
+            "results": results
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"检索失败: {str(e)}")
+
+
+@router.get("/status")
+async def get_rag_status():
+    """
+    获取 RAG 索引状态
+
+    Returns:
+        RAG 索引统计信息
+    """
+    try:
+        count = rag_service.get_vector_count()
+
+        return {
+            "success": True,
+            "vector_count": count,
+            "collections": ["document_fields", "document_content"]  # 预留
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"获取状态失败: {str(e)}")
+
+
+@router.post("/rebuild")
+async def rebuild_rag_index():
+    """
+    重建 RAG 索引
+
+    从 MongoDB 中读取所有文档，重新构建向量索引
+    """
+    from app.core.database import mongodb
+
+    try:
+        # 清空现有索引
+        rag_service.clear()
+
+        # 从 MongoDB 读取所有文档
+        cursor = mongodb.documents.find({})
+        count = 0
+
+        async for doc in cursor:
+            content = doc.get("content", "")
+            if content:
+                rag_service.index_document_content(
+                    doc_id=str(doc["_id"]),
+                    content=content[:5000],
+                    metadata={
+                        "filename": doc.get("metadata", {}).get("filename"),
+                        "doc_type": doc.get("doc_type")
+                    }
+                )
+                count += 1
+
+        return {
+            "success": True,
+            "message": f"已重建索引，共处理 {count} 个文档"
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"重建索引失败: {str(e)}")

backend/app/api/endpoints/tasks.py

@@ -0,0 +1,116 @@
+"""
+任务管理 API 接口
+
+提供异步任务状态查询和历史记录
+"""
+from typing import Optional
+
+from fastapi import APIRouter, HTTPException
+
+from app.core.database import redis_db, mongodb
+
+router = APIRouter(prefix="/tasks", tags=["任务管理"])
+
+
+@router.get("/{task_id}")
+async def get_task_status(task_id: str):
+    """
+    查询任务状态
+
+    Args:
+        task_id: 任务ID
+
+    Returns:
+        任务状态信息
+    """
+    # 优先从 Redis 获取
+    status = await redis_db.get_task_status(task_id)
+
+    if status:
+        return {
+            "task_id": task_id,
+            "status": status.get("status", "unknown"),
+            "progress": status.get("meta", {}).get("progress", 0),
+            "message": status.get("meta", {}).get("message"),
+            "result": status.get("meta", {}).get("result"),
+            "error": status.get("meta", {}).get("error")
+        }
+
+    # Redis 不可用时，尝试从 MongoDB 获取
+    mongo_task = await mongodb.get_task(task_id)
+    if mongo_task:
+        return {
+            "task_id": mongo_task.get("task_id"),
+            "status": mongo_task.get("status", "unknown"),
+            "progress": 100 if mongo_task.get("status") == "success" else 0,
+            "message": mongo_task.get("message"),
+            "result": mongo_task.get("result"),
+            "error": mongo_task.get("error")
+        }
+
+    # 任务不存在或状态未知
+    return {
+        "task_id": task_id,
+        "status": "unknown",
+        "progress": 0,
+        "message": "无法获取任务状态（Redis和MongoDB均不可用）",
+        "result": None,
+        "error": None
+    }
+
+
+@router.get("/")
+async def list_tasks(limit: int = 50, skip: int = 0):
+    """
+    获取任务历史列表
+
+    Args:
+        limit: 返回数量限制
+        skip: 跳过数量
+
+    Returns:
+        任务列表
+    """
+    try:
+        tasks = await mongodb.list_tasks(limit=limit, skip=skip)
+        return {
+            "success": True,
+            "tasks": tasks,
+            "count": len(tasks)
+        }
+    except Exception as e:
+        # MongoDB 不可用时返回空列表
+        return {
+            "success": False,
+            "tasks": [],
+            "count": 0,
+            "error": str(e)
+        }
+
+
+@router.delete("/{task_id}")
+async def delete_task(task_id: str):
+    """
+    删除任务
+
+    Args:
+        task_id: 任务ID
+
+    Returns:
+        是否删除成功
+    """
+    try:
+        # 从 Redis 删除
+        if redis_db._connected and redis_db.client:
+            key = f"task:{task_id}"
+            await redis_db.client.delete(key)
+
+        # 从 MongoDB 删除
+        deleted = await mongodb.delete_task(task_id)
+
+        return {
+            "success": True,
+            "deleted": deleted
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"删除任务失败: {str(e)}")

backend/app/api/endpoints/templates.py

@@ -0,0 +1,722 @@
+"""
+表格模板 API 接口
+
+提供模板上传、解析和填写功能
+"""
+import io
+import logging
+import uuid
+from typing import List, Optional
+
+from fastapi import APIRouter, File, HTTPException, Query, UploadFile, BackgroundTasks
+from fastapi.responses import StreamingResponse
+import pandas as pd
+from pydantic import BaseModel
+
+from app.services.template_fill_service import template_fill_service, TemplateField
+from app.services.file_service import file_service
+from app.core.database import mongodb
+from app.core.document_parser import ParserFactory
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/templates", tags=["表格模板"])
+
+
+# ==================== 辅助函数 ====================
+
+async def update_task_status(
+    task_id: str,
+    status: str,
+    progress: int = 0,
+    message: str = "",
+    result: dict = None,
+    error: str = None
+):
+    """
+    更新任务状态，同时写入 Redis 和 MongoDB
+    """
+    from app.core.database import redis_db
+
+    meta = {"progress": progress, "message": message}
+    if result:
+        meta["result"] = result
+    if error:
+        meta["error"] = error
+
+    try:
+        await redis_db.set_task_status(task_id, status, meta)
+    except Exception as e:
+        logger.warning(f"Redis 任务状态更新失败: {e}")
+
+    try:
+        await mongodb.update_task(
+            task_id=task_id,
+            status=status,
+            message=message,
+            result=result,
+            error=error
+        )
+    except Exception as e:
+        logger.warning(f"MongoDB 任务状态更新失败: {e}")
+
+
+# ==================== 请求/响应模型 ====================
+
+class TemplateFieldRequest(BaseModel):
+    """模板字段请求"""
+    cell: str
+    name: str
+    field_type: str = "text"
+    required: bool = True
+    hint: str = ""
+
+
+class FillRequest(BaseModel):
+    """填写请求"""
+    template_id: str
+    template_fields: List[TemplateFieldRequest]
+    source_doc_ids: Optional[List[str]] = None  # MongoDB 文档 ID 列表
+    source_file_paths: Optional[List[str]] = None  # 源文档文件路径列表
+    user_hint: Optional[str] = None
+    task_id: Optional[str] = None  # 可选的任务ID，用于任务历史跟踪
+
+
+class ExportRequest(BaseModel):
+    """导出请求"""
+    template_id: str
+    filled_data: dict
+    format: str = "xlsx"  # xlsx 或 docx
+
+
+# ==================== 接口实现 ====================
+
+@router.post("/upload")
+async def upload_template(
+    file: UploadFile = File(...),
+):
+    """
+    上传表格模板文件
+
+    支持 Excel (.xlsx, .xls) 和 Word (.docx) 格式
+
+    Returns:
+        模板信息，包括提取的字段列表
+    """
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="文件名为空")
+
+    file_ext = file.filename.split('.')[-1].lower()
+    if file_ext not in ['xlsx', 'xls', 'docx']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的模板格式: {file_ext}，仅支持 xlsx/xls/docx"
+        )
+
+    try:
+        # 保存文件
+        content = await file.read()
+        saved_path = file_service.save_uploaded_file(
+            content,
+            file.filename,
+            subfolder="templates"
+        )
+
+        # 提取字段
+        template_fields = await template_fill_service.get_template_fields_from_file(
+            saved_path,
+            file_ext
+        )
+
+        return {
+            "success": True,
+            "template_id": saved_path,
+            "filename": file.filename,
+            "file_type": file_ext,
+            "fields": [
+                {
+                    "cell": f.cell,
+                    "name": f.name,
+                    "field_type": f.field_type,
+                    "required": f.required,
+                    "hint": f.hint
+                }
+                for f in template_fields
+            ],
+            "field_count": len(template_fields)
+        }
+
+    except Exception as e:
+        logger.error(f"上传模板失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"上传失败: {str(e)}")
+
+
+@router.post("/upload-joint")
+async def upload_joint_template(
+    background_tasks: BackgroundTasks,
+    template_file: UploadFile = File(..., description="模板文件"),
+    source_files: List[UploadFile] = File(..., description="源文档文件列表"),
+):
+    """
+    联合上传模板和源文档，一键完成解析和存储
+
+    1. 保存模板文件并提取字段
+    2. 异步处理源文档（解析+存MongoDB）
+    3. 返回模板信息和源文档ID列表
+
+    Args:
+        template_file: 模板文件 (xlsx/xls/docx)
+        source_files: 源文档列表 (docx/xlsx/md/txt)
+
+    Returns:
+        模板ID、字段列表、源文档ID列表
+    """
+    if not template_file.filename:
+        raise HTTPException(status_code=400, detail="模板文件名为空")
+
+    # 验证模板格式
+    template_ext = template_file.filename.split('.')[-1].lower()
+    if template_ext not in ['xlsx', 'xls', 'docx']:
+        raise HTTPException(
+            status_code=400,
+            detail=f"不支持的模板格式: {template_ext}，仅支持 xlsx/xls/docx"
+        )
+
+    # 验证源文档格式
+    valid_exts = ['docx', 'xlsx', 'xls', 'md', 'txt']
+    for sf in source_files:
+        if sf.filename:
+            sf_ext = sf.filename.split('.')[-1].lower()
+            if sf_ext not in valid_exts:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"不支持的源文档格式: {sf_ext}，仅支持 docx/xlsx/xls/md/txt"
+                )
+
+    try:
+        # 1. 保存模板文件
+        template_content = await template_file.read()
+        template_path = file_service.save_uploaded_file(
+            template_content,
+            template_file.filename,
+            subfolder="templates"
+        )
+
+        # 2. 保存并解析源文档 - 提取内容用于生成表头
+        source_file_info = []
+        source_contents = []
+        for sf in source_files:
+            if sf.filename:
+                sf_content = await sf.read()
+                sf_ext = sf.filename.split('.')[-1].lower()
+                sf_path = file_service.save_uploaded_file(
+                    sf_content,
+                    sf.filename,
+                    subfolder=sf_ext
+                )
+                source_file_info.append({
+                    "path": sf_path,
+                    "filename": sf.filename,
+                    "ext": sf_ext
+                })
+                # 解析源文档获取内容（用于 AI 生成表头）
+                try:
+                    from app.core.document_parser import ParserFactory
+                    parser = ParserFactory.get_parser(sf_path)
+                    parse_result = parser.parse(sf_path)
+                    if parse_result.success and parse_result.data:
+                        # 获取原始内容
+                        content = parse_result.data.get("content", "")[:5000] if parse_result.data.get("content") else ""
+
+                        # 获取标题（可能在顶层或structured_data内）
+                        titles = parse_result.data.get("titles", [])
+                        if not titles and parse_result.data.get("structured_data"):
+                            titles = parse_result.data.get("structured_data", {}).get("titles", [])
+                        titles = titles[:10] if titles else []
+
+                        # 获取表格数量（可能在顶层或structured_data内）
+                        tables = parse_result.data.get("tables", [])
+                        if not tables and parse_result.data.get("structured_data"):
+                            tables = parse_result.data.get("structured_data", {}).get("tables", [])
+                        tables_count = len(tables) if tables else 0
+
+                        # 获取表格内容摘要（用于 AI 理解源文档结构）
+                        tables_summary = ""
+                        if tables:
+                            tables_summary = "\n【文档中的表格】:\n"
+                            for idx, table in enumerate(tables[:5]):  # 最多5个表格
+                                if isinstance(table, dict):
+                                    headers = table.get("headers", [])
+                                    rows = table.get("rows", [])
+                                    if headers:
+                                        tables_summary += f"表格{idx+1}表头: {', '.join(str(h) for h in headers)}\n"
+                                    if rows:
+                                        tables_summary += f"表格{idx+1}前3行: "
+                                        for row_idx, row in enumerate(rows[:3]):
+                                            if isinstance(row, list):
+                                                tables_summary += " | ".join(str(c) for c in row) + "; "
+                                            elif isinstance(row, dict):
+                                                tables_summary += " | ".join(str(row.get(h, "")) for h in headers if headers) + "; "
+                                        tables_summary += "\n"
+
+                        source_contents.append({
+                            "filename": sf.filename,
+                            "doc_type": sf_ext,
+                            "content": content,
+                            "titles": titles,
+                            "tables_count": tables_count,
+                            "tables_summary": tables_summary
+                        })
+                        logger.info(f"[DEBUG] source_contents built: filename={sf.filename}, content_len={len(content)}, titles_count={len(titles)}, tables_count={tables_count}")
+                        if tables_summary:
+                            logger.info(f"[DEBUG] tables_summary preview: {tables_summary[:300]}")
+                except Exception as e:
+                    logger.warning(f"解析源文档失败 {sf.filename}: {e}")
+
+        # 3. 根据源文档内容生成表头
+        template_fields = await template_fill_service.get_template_fields_from_file(
+            template_path,
+            template_ext,
+            source_contents=source_contents  # 传递源文档内容
+        )
+
+        # 3. 异步处理源文档到MongoDB
+        task_id = str(uuid.uuid4())
+        if source_file_info:
+            # 保存任务记录到 MongoDB
+            try:
+                await mongodb.insert_task(
+                    task_id=task_id,
+                    task_type="source_process",
+                    status="pending",
+                    message=f"开始处理 {len(source_file_info)} 个源文档"
+                )
+            except Exception as mongo_err:
+                logger.warning(f"MongoDB 保存任务记录失败: {mongo_err}")
+
+            background_tasks.add_task(
+                process_source_documents,
+                task_id=task_id,
+                files=source_file_info
+            )
+
+        logger.info(f"联合上传完成: 模板={template_file.filename}, 源文档={len(source_file_info)}个")
+
+        return {
+            "success": True,
+            "template_id": template_path,
+            "filename": template_file.filename,
+            "file_type": template_ext,
+            "fields": [
+                {
+                    "cell": f.cell,
+                    "name": f.name,
+                    "field_type": f.field_type,
+                    "required": f.required,
+                    "hint": f.hint
+                }
+                for f in template_fields
+            ],
+            "field_count": len(template_fields),
+            "source_file_paths": [f["path"] for f in source_file_info],
+            "source_filenames": [f["filename"] for f in source_file_info],
+            "task_id": task_id
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"联合上传失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"联合上传失败: {str(e)}")
+
+
+async def process_source_documents(task_id: str, files: List[dict]):
+    """异步处理源文档，存入MongoDB"""
+    try:
+        await update_task_status(
+            task_id, status="processing",
+            progress=0, message="开始处理源文档"
+        )
+
+        doc_ids = []
+        for i, file_info in enumerate(files):
+            try:
+                parser = ParserFactory.get_parser(file_info["path"])
+                result = parser.parse(file_info["path"])
+
+                if result.success:
+                    doc_id = await mongodb.insert_document(
+                        doc_type=file_info["ext"],
+                        content=result.data.get("content", ""),
+                        metadata={
+                            **result.metadata,
+                            "original_filename": file_info["filename"],
+                            "file_path": file_info["path"]
+                        },
+                        structured_data=result.data.get("structured_data")
+                    )
+                    doc_ids.append(doc_id)
+                    logger.info(f"源文档处理成功: {file_info['filename']}, doc_id: {doc_id}")
+                else:
+                    logger.error(f"源文档解析失败: {file_info['filename']}, error: {result.error}")
+
+            except Exception as e:
+                logger.error(f"源文档处理异常: {file_info['filename']}, error: {str(e)}")
+
+            progress = int((i + 1) / len(files) * 100)
+            await update_task_status(
+                task_id, status="processing",
+                progress=progress, message=f"已处理 {i+1}/{len(files)}"
+            )
+
+        await update_task_status(
+            task_id, status="success",
+            progress=100, message="源文档处理完成",
+            result={"doc_ids": doc_ids}
+        )
+        logger.info(f"所有源文档处理完成: {len(doc_ids)}个")
+
+    except Exception as e:
+        logger.error(f"源文档批量处理失败: {str(e)}")
+        await update_task_status(
+            task_id, status="failure",
+            progress=0, message="源文档处理失败",
+            error=str(e)
+        )
+
+
+@router.post("/fields")
+async def extract_template_fields(
+    template_id: str = Query(..., description="模板ID/文件路径"),
+    file_type: str = Query("xlsx", description="文件类型")
+):
+    """
+    从已上传的模板提取字段定义
+
+    Args:
+        template_id: 模板ID
+        file_type: 文件类型
+
+    Returns:
+        字段列表
+    """
+    try:
+        fields = await template_fill_service.get_template_fields_from_file(
+            template_id,
+            file_type
+        )
+
+        return {
+            "success": True,
+            "fields": [
+                {
+                    "cell": f.cell,
+                    "name": f.name,
+                    "field_type": f.field_type,
+                    "required": f.required,
+                    "hint": f.hint
+                }
+                for f in fields
+            ]
+        }
+
+    except Exception as e:
+        logger.error(f"提取字段失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"提取失败: {str(e)}")
+
+
+@router.post("/fill")
+async def fill_template(
+    request: FillRequest,
+):
+    """
+    执行表格填写
+
+    根据提供的字段定义，从源文档中检索信息并填写
+
+    Args:
+        request: 填写请求
+
+    Returns:
+        填写结果
+    """
+    # 生成或使用传入的 task_id
+    task_id = request.task_id or str(uuid.uuid4())
+
+    try:
+        # 创建任务记录到 MongoDB
+        try:
+            await mongodb.insert_task(
+                task_id=task_id,
+                task_type="template_fill",
+                status="processing",
+                message=f"开始填表任务: {len(request.template_fields)} 个字段"
+            )
+        except Exception as mongo_err:
+            logger.warning(f"MongoDB 创建任务记录失败: {mongo_err}")
+
+        # 更新进度 - 开始
+        await update_task_status(
+            task_id, "processing",
+            progress=0, message="开始处理..."
+        )
+
+        # 转换字段
+        fields = [
+            TemplateField(
+                cell=f.cell,
+                name=f.name,
+                field_type=f.field_type,
+                required=f.required,
+                hint=f.hint
+            )
+            for f in request.template_fields
+        ]
+
+        # 从 template_id 提取文件类型
+        template_file_type = "xlsx"  # 默认类型
+        if request.template_id:
+            ext = request.template_id.split('.')[-1].lower()
+            if ext in ["xlsx", "xls"]:
+                template_file_type = "xlsx"
+            elif ext == "docx":
+                template_file_type = "docx"
+
+        # 更新进度 - 准备开始填写
+        await update_task_status(
+            task_id, "processing",
+            progress=10, message=f"准备填写 {len(fields)} 个字段..."
+        )
+
+        # 执行填写
+        result = await template_fill_service.fill_template(
+            template_fields=fields,
+            source_doc_ids=request.source_doc_ids,
+            source_file_paths=request.source_file_paths,
+            user_hint=request.user_hint,
+            template_id=request.template_id,
+            template_file_type=template_file_type,
+            task_id=task_id
+        )
+
+        # 更新为成功
+        await update_task_status(
+            task_id, "success",
+            progress=100, message="填表完成",
+            result={
+                "field_count": len(fields),
+                "max_rows": result.get("max_rows", 0)
+            }
+        )
+
+        return {**result, "task_id": task_id}
+
+    except Exception as e:
+        # 更新为失败
+        await update_task_status(
+            task_id, "failure",
+            progress=0, message="填表失败",
+            error=str(e)
+        )
+        logger.error(f"填写表格失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"填写失败: {str(e)}")
+
+
+@router.post("/export")
+async def export_filled_template(
+    request: ExportRequest,
+):
+    """
+    导出填写后的表格
+
+    支持 Excel (.xlsx) 和 Word (.docx) 格式
+
+    Args:
+        request: 导出请求
+
+    Returns:
+        文件流
+    """
+    try:
+        if request.format == "xlsx":
+            return await _export_to_excel(request.filled_data, request.template_id)
+        elif request.format == "docx":
+            return await _export_to_word(request.filled_data, request.template_id)
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=f"不支持的导出格式: {request.format}，仅支持 xlsx/docx"
+            )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"导出失败: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"导出失败: {str(e)}")
+
+
+async def _export_to_excel(filled_data: dict, template_id: str) -> StreamingResponse:
+    """导出为 Excel 格式（支持多行）"""
+    import logging
+    logger = logging.getLogger(__name__)
+
+    logger.info(f"导出填表数据: {len(filled_data)} 个字段")
+
+    # 计算最大行数
+    max_rows = 1
+    for k, v in filled_data.items():
+        if isinstance(v, list) and len(v) > max_rows:
+            max_rows = len(v)
+        logger.info(f"  {k}: {type(v).__name__} = {str(v)[:80]}")
+
+    logger.info(f"最大行数: {max_rows}")
+
+    # 构建多行数据
+    rows_data = []
+    for row_idx in range(max_rows):
+        row = {}
+        for col_name, values in filled_data.items():
+            if isinstance(values, list):
+                # 取对应行的值，不足则填空
+                row[col_name] = values[row_idx] if row_idx < len(values) else ""
+            else:
+                # 非列表，整个值填入第一行
+                row[col_name] = values if row_idx == 0 else ""
+        rows_data.append(row)
+
+    df = pd.DataFrame(rows_data)
+
+    # 确保列顺序
+    if not df.empty:
+        df = df[list(filled_data.keys())]
+
+    logger.info(f"DataFrame 形状: {df.shape}")
+    logger.info(f"DataFrame 列: {list(df.columns)}")
+
+    output = io.BytesIO()
+    with pd.ExcelWriter(output, engine='openpyxl') as writer:
+        df.to_excel(writer, index=False, sheet_name='填写结果')
+
+    output.seek(0)
+
+    filename = f"filled_template.xlsx"
+
+    return StreamingResponse(
+        io.BytesIO(output.getvalue()),
+        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+        headers={"Content-Disposition": f"attachment; filename={filename}"}
+    )
+
+
+async def _export_to_word(filled_data: dict, template_id: str) -> StreamingResponse:
+    """导出为 Word 格式"""
+    import re
+    import tempfile
+    import os
+    from docx import Document
+    from docx.shared import Pt, RGBColor
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+
+    def clean_text(text: str) -> str:
+        """清理文本，移除可能导致Word问题的非法字符"""
+        if not text:
+            return ""
+        # 移除控制字符
+        text = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', text)
+        return text.strip()
+
+    try:
+        # 先保存到临时文件，再读取到内存，确保文档完整性
+        with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
+            tmp_path = tmp_file.name
+
+        doc = Document()
+        doc.add_heading('填写结果', level=1)
+
+        from datetime import datetime
+        info_para = doc.add_paragraph()
+        template_filename = template_id.split('/')[-1].split('\\')[-1] if template_id else '未知'
+        info_para.add_run(f"模板文件: {clean_text(template_filename)}\n").bold = True
+        info_para.add_run(f"导出时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        doc.add_paragraph()
+
+        table = doc.add_table(rows=1, cols=3)
+        table.style = 'Table Grid'
+
+        header_cells = table.rows[0].cells
+        header_cells[0].text = '字段名'
+        header_cells[1].text = '填写值'
+        header_cells[2].text = '状态'
+
+        for field_name, field_value in filled_data.items():
+            row_cells = table.add_row().cells
+            row_cells[0].text = clean_text(str(field_name))
+
+            if isinstance(field_value, list):
+                clean_values = [clean_text(str(v)) for v in field_value if v]
+                display_value = ', '.join(clean_values) if clean_values else ''
+            else:
+                display_value = clean_text(str(field_value)) if field_value else ''
+
+            row_cells[1].text = display_value
+            row_cells[2].text = '已填写' if display_value else '为空'
+
+        # 保存到临时文件
+        doc.save(tmp_path)
+
+        # 读取文件内容
+        with open(tmp_path, 'rb') as f:
+            file_content = f.read()
+
+    finally:
+        # 清理临时文件
+        if os.path.exists(tmp_path):
+            try:
+                os.unlink(tmp_path)
+            except:
+                pass
+
+    output = io.BytesIO(file_content)
+    filename = "filled_template.docx"
+
+    return StreamingResponse(
+        output,
+        media_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        headers={"Content-Disposition": f"attachment; filename*=UTF-8''{filename}"}
+    )
+
+
+@router.post("/export/excel")
+async def export_to_excel(
+    filled_data: dict,
+    template_id: str = Query(..., description="模板ID")
+):
+    """
+    专门导出为 Excel 格式
+
+    Args:
+        filled_data: 填写数据
+        template_id: 模板ID
+
+    Returns:
+        Excel 文件流
+    """
+    return await _export_to_excel(filled_data, template_id)
+
+
+@router.post("/export/word")
+async def export_to_word(
+    filled_data: dict,
+    template_id: str = Query(..., description="模板ID")
+):
+    """
+    专门导出为 Word 格式
+
+    Args:
+        filled_data: 填写数据
+        template_id: 模板ID
+
+    Returns:
+        Word 文件流
+    """
+    return await _export_to_word(filled_data, template_id)

backend/app/api/endpoints/upload.py

@@ -5,11 +5,14 @@ from fastapi import APIRouter, UploadFile, File, HTTPException, Query
 from fastapi.responses import StreamingResponse
 from typing import Optional
 import logging
+import os
 import pandas as pd
 import io
 
 from app.services.file_service import file_service
 from app.core.document_parser import XlsxParser
+from app.services.table_rag_service import table_rag_service
+from app.core.database import mongodb
 
 logger = logging.getLogger(__name__)
 
@@ -27,7 +30,7 @@ async def upload_excel(
     header_row: int = Query(0, description="表头所在的行索引")
 ):
     """
-    上传并解析 Excel 文件
+    上传并解析 Excel 文件，同时存储到 MySQL 数据库
 
     Args:
         file: 上传的 Excel 文件
@@ -77,6 +80,73 @@ async def upload_excel(
             result.metadata['saved_path'] = saved_path
             result.metadata['original_filename'] = file.filename
 
+        # 存储到 MySQL 数据库
+        try:
+            store_result = await table_rag_service.build_table_rag_index(
+                file_path=saved_path,
+                filename=file.filename,
+                sheet_name=sheet_name if sheet_name else None,
+                header_row=header_row
+            )
+            if store_result.get("success"):
+                result.metadata['mysql_table'] = store_result.get('table_name')
+                result.metadata['row_count'] = store_result.get('row_count')
+                logger.info(f"Excel已存储到MySQL: {file.filename}, 表: {store_result.get('table_name')}")
+            else:
+                logger.warning(f"Excel存储到MySQL失败: {store_result.get('error')}")
+        except Exception as e:
+            logger.error(f"Excel存储到MySQL异常: {str(e)}", exc_info=True)
+
+        # 存储到 MongoDB（用于文档列表展示）
+        try:
+            content = ""
+            # 构建文本内容用于展示
+            if result.data:
+                if isinstance(result.data, dict):
+                    # 单 sheet 格式: {columns, rows, ...}
+                    if 'columns' in result.data and 'rows' in result.data:
+                        content += f"Sheet: {result.metadata.get('current_sheet', 'Sheet1') if result.metadata else 'Sheet1'}\n"
+                        content += ", ".join(str(h) for h in result.data['columns']) + "\n"
+                        for row in result.data['rows'][:100]:
+                            if isinstance(row, dict):
+                                content += ", ".join(str(row.get(col, "")) for col in result.data['columns']) + "\n"
+                            elif isinstance(row, list):
+                                content += ", ".join(str(cell) for cell in row) + "\n"
+                        content += f"... (共 {len(result.data['rows'])} 行)\n\n"
+                    # 多 sheet 格式: {sheets: {sheet_name: {columns, rows}}}
+                    elif 'sheets' in result.data:
+                        for sheet_name_key, sheet_data in result.data['sheets'].items():
+                            if isinstance(sheet_data, dict) and 'columns' in sheet_data and 'rows' in sheet_data:
+                                content += f"Sheet: {sheet_name_key}\n"
+                                content += ", ".join(str(h) for h in sheet_data['columns']) + "\n"
+                                for row in sheet_data['rows'][:100]:
+                                    if isinstance(row, dict):
+                                        content += ", ".join(str(row.get(col, "")) for col in sheet_data['columns']) + "\n"
+                                    elif isinstance(row, list):
+                                        content += ", ".join(str(cell) for cell in row) + "\n"
+                                content += f"... (共 {len(sheet_data['rows'])} 行)\n\n"
+
+            doc_metadata = {
+                "filename": os.path.basename(saved_path),
+                "original_filename": file.filename,
+                "saved_path": saved_path,
+                "file_size": len(content),
+                "row_count": result.metadata.get('row_count', 0) if result.metadata else 0,
+                "column_count": result.metadata.get('column_count', 0) if result.metadata else 0,
+                "columns": result.metadata.get('columns', []) if result.metadata else [],
+                "mysql_table": result.metadata.get('mysql_table') if result.metadata else None,
+                "sheet_count": result.metadata.get('sheet_count', 1) if result.metadata else 1,
+            }
+            await mongodb.insert_document(
+                doc_type="xlsx",
+                content=content,
+                metadata=doc_metadata,
+                structured_data=result.data if result.data else None
+            )
+            logger.info(f"Excel文档已存储到MongoDB: {file.filename}, content长度: {len(content)}")
+        except Exception as e:
+            logger.error(f"Excel存储到MongoDB异常: {str(e)}", exc_info=True)
+
         return result.to_dict()
 
     except HTTPException:
@@ -184,7 +254,7 @@ async def export_excel(
         output.seek(0)
 
         # 生成文件名
-        original_name = file_path.split('/')[-1] if '/' in file_path else file_path
+        original_name = os.path.basename(file_path)
         if columns:
             export_name = f"export_{sheet_name or 'data'}_{len(column_list) if columns else 'all'}_cols.xlsx"
         else:

backend/app/config.py

@@ -6,26 +6,67 @@ class Settings(BaseSettings):
     APP_NAME: str = "FilesReadSystem"
     DEBUG: bool = True
     API_V1_STR: str = "/api/v1"
-    
+
-    # 数据库
+    # ==================== 数据库配置 ====================
-    MONGODB_URL: str
+
-    MONGODB_DB_NAME: str
+    # MongoDB 配置 (非结构化数据存储)
-    REDIS_URL: str
+    MONGODB_URL: str = "mongodb://localhost:27017"
-    
+    MONGODB_DB_NAME: str = "document_system"
-    # AI 相关
+
-    LLM_API_KEY: str
+    # MySQL 配置 (结构化数据存储)
-    LLM_BASE_URL: str
+    MYSQL_HOST: str = "localhost"
-    LLM_MODEL_NAME: str
+    MYSQL_PORT: int = 3306
-    
+    MYSQL_USER: str = "root"
-    # 文件路径
+    MYSQL_PASSWORD: str = ""
+    MYSQL_DATABASE: str = "document_system"
+    MYSQL_CHARSET: str = "utf8mb4"
+
+    # Redis 配置 (缓存/任务队列)
+    REDIS_URL: str = "redis://localhost:6379/0"
+
+    # ==================== AI 相关配置 ====================
+    LLM_API_KEY: str = ""
+    LLM_BASE_URL: str = "https://api.minimax.chat"
+    LLM_MODEL_NAME: str = "MiniMax-Text-01"
+
+    # ==================== RAG/Embedding 配置 ====================
+    EMBEDDING_MODEL: str = "all-MiniLM-L6-v2"
+
+    # ==================== Supabase 配置 ====================
+    SUPABASE_URL: str = ""
+    SUPABASE_ANON_KEY: str = ""
+    SUPABASE_SERVICE_KEY: str = ""
+
+    # ==================== 文件路径配置 ====================
     BASE_DIR: Path = Path(__file__).resolve().parent.parent.parent
     UPLOAD_DIR: str = "data/uploads"
-    
+
+    # ==================== RAG/向量数据库配置 ====================
+    FAISS_INDEX_DIR: str = "data/faiss"
+
     # 允许 Pydantic 从 .env 文件读取
     model_config = SettingsConfigDict(
-        env_file=Path(__file__).parent.parent / ".env", 
+        env_file=Path(__file__).parent.parent / ".env",
         env_file_encoding='utf-8',
         extra='ignore'
     )
 
+    @property
+    def mysql_url(self) -> str:
+        """生成MySQL连接URL (同步)"""
+        return (
+            f"mysql+pymysql://{self.MYSQL_USER}:{self.MYSQL_PASSWORD}"
+            f"@{self.MYSQL_HOST}:{self.MYSQL_PORT}/{self.MYSQL_DATABASE}"
+            f"?charset={self.MYSQL_CHARSET}"
+        )
+
+    @property
+    def async_mysql_url(self) -> str:
+        """生成MySQL连接URL (异步)"""
+        return (
+            f"mysql+aiomysql://{self.MYSQL_USER}:{self.MYSQL_PASSWORD}"
+            f"@{self.MYSQL_HOST}:{self.MYSQL_PORT}/{self.MYSQL_DATABASE}"
+            f"?charset={self.MYSQL_CHARSET}"
+        )
+
 settings = Settings()

backend/app/core/database/__init__.py

@@ -0,0 +1,18 @@
+"""
+数据库连接管理模块
+
+提供 MySQL、MongoDB、Redis 的连接管理
+"""
+from app.core.database.mysql import MySQLDB, mysql_db, Base
+from app.core.database.mongodb import MongoDB, mongodb
+from app.core.database.redis_db import RedisDB, redis_db
+
+__all__ = [
+    "MySQLDB",
+    "mysql_db",
+    "MongoDB",
+    "mongodb",
+    "RedisDB",
+    "redis_db",
+    "Base",
+]

backend/app/core/database/mongodb.py

@@ -0,0 +1,375 @@
+"""
+MongoDB 数据库连接管理模块
+
+提供非结构化数据的存储和查询功能
+"""
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from motor.motor_asyncio import AsyncIOMotorClient, AsyncIOMotorDatabase
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class MongoDB:
+    """MongoDB 数据库管理类"""
+
+    def __init__(self):
+        self.client: Optional[AsyncIOMotorClient] = None
+        self.db: Optional[AsyncIOMotorDatabase] = None
+
+    async def connect(self):
+        """建立 MongoDB 连接"""
+        try:
+            self.client = AsyncIOMotorClient(
+                settings.MONGODB_URL,
+                serverSelectionTimeoutMS=30000,  # 30秒超时，适应远程服务器
+                connectTimeoutMS=30000,  # 连接超时
+                socketTimeoutMS=60000,  # Socket 超时
+            )
+            self.db = self.client[settings.MONGODB_DB_NAME]
+            # 验证连接
+            await self.client.admin.command('ping')
+            logger.info(f"MongoDB 连接成功: {settings.MONGODB_DB_NAME}")
+        except Exception as e:
+            logger.error(f"MongoDB 连接失败: {e}")
+            raise
+
+    async def close(self):
+        """关闭 MongoDB 连接"""
+        if self.client:
+            self.client.close()
+            logger.info("MongoDB 连接已关闭")
+
+    @property
+    def documents(self):
+        """文档集合 - 存储原始文档和解析结果"""
+        return self.db["documents"]
+
+    @property
+    def embeddings(self):
+        """向量嵌入集合 - 存储文本嵌入向量"""
+        return self.db["embeddings"]
+
+    @property
+    def rag_index(self):
+        """RAG索引集合 - 存储字段语义索引"""
+        return self.db["rag_index"]
+
+    @property
+    def tasks(self):
+        """任务集合 - 存储任务历史记录"""
+        return self.db["tasks"]
+
+    # ==================== 文档操作 ====================
+
+    async def insert_document(
+        self,
+        doc_type: str,
+        content: str,
+        metadata: Dict[str, Any],
+        structured_data: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        插入文档
+
+        Args:
+            doc_type: 文档类型 (docx/xlsx/md/txt)
+            content: 原始文本内容
+            metadata: 元数据
+            structured_data: 结构化数据 (表格等)
+
+        Returns:
+            插入文档的ID
+        """
+        document = {
+            "doc_type": doc_type,
+            "content": content,
+            "metadata": metadata,
+            "structured_data": structured_data,
+            "created_at": datetime.utcnow(),
+            "updated_at": datetime.utcnow(),
+        }
+        result = await self.documents.insert_one(document)
+        doc_id = str(result.inserted_id)
+        filename = metadata.get("original_filename", "unknown")
+        logger.info(f"✓ 文档已存入MongoDB: [{doc_type}] {filename} | ID: {doc_id}")
+        return doc_id
+
+    async def get_document(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        """根据ID获取文档"""
+        from bson import ObjectId
+        doc = await self.documents.find_one({"_id": ObjectId(doc_id)})
+        if doc:
+            doc["_id"] = str(doc["_id"])
+        return doc
+
+    async def search_documents(
+        self,
+        query: str,
+        doc_type: Optional[str] = None,
+        limit: int = 10,
+    ) -> List[Dict[str, Any]]:
+        """
+        搜索文档
+
+        Args:
+            query: 搜索关键词
+            doc_type: 文档类型过滤
+            limit: 返回数量
+
+        Returns:
+            文档列表
+        """
+        filter_query = {"content": {"$regex": query}}
+        if doc_type:
+            filter_query["doc_type"] = doc_type
+
+        cursor = self.documents.find(filter_query).limit(limit)
+        documents = []
+        async for doc in cursor:
+            doc["_id"] = str(doc["_id"])
+            documents.append(doc)
+        return documents
+
+    async def delete_document(self, doc_id: str) -> bool:
+        """删除文档"""
+        from bson import ObjectId
+        result = await self.documents.delete_one({"_id": ObjectId(doc_id)})
+        return result.deleted_count > 0
+
+    # ==================== RAG 索引操作 ====================
+
+    async def insert_rag_entry(
+        self,
+        table_name: str,
+        field_name: str,
+        field_description: str,
+        embedding: List[float],
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """
+        插入RAG索引条目
+
+        Args:
+            table_name: 表名
+            field_name: 字段名
+            field_description: 字段描述
+            embedding: 向量嵌入
+            metadata: 其他元数据
+
+        Returns:
+            插入条目的ID
+        """
+        entry = {
+            "table_name": table_name,
+            "field_name": field_name,
+            "field_description": field_description,
+            "embedding": embedding,
+            "metadata": metadata or {},
+            "created_at": datetime.utcnow(),
+        }
+        result = await self.rag_index.insert_one(entry)
+        return str(result.inserted_id)
+
+    async def search_rag(
+        self,
+        query_embedding: List[float],
+        top_k: int = 5,
+        table_name: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        搜索RAG索引 (使用向量相似度)
+
+        Args:
+            query_embedding: 查询向量
+            top_k: 返回数量
+            table_name: 可选的表名过滤
+
+        Returns:
+            相关的索引条目
+        """
+        # MongoDB 5.0+ 支持向量搜索
+        # 较低版本使用欧氏距离替代
+        pipeline = [
+            {
+                "$addFields": {
+                    "distance": {
+                        "$reduce": {
+                            "input": {"$range": [0, {"$size": "$embedding"}]},
+                            "initialValue": 0,
+                            "in": {
+                                "$add": [
+                                    "$$value",
+                                    {
+                                        "$pow": [
+                                            {
+                                                "$subtract": [
+                                                    {"$arrayElemAt": ["$embedding", "$$this"]},
+                                                    {"$arrayElemAt": [query_embedding, "$$this"]},
+                                                ]
+                                            },
+                                            2,
+                                        ]
+                                    },
+                                ]
+                            },
+                        }
+                    }
+                }
+            },
+            {"$sort": {"distance": 1}},
+            {"$limit": top_k},
+        ]
+
+        if table_name:
+            pipeline.insert(0, {"$match": {"table_name": table_name}})
+
+        results = []
+        async for doc in self.rag_index.aggregate(pipeline):
+            doc["_id"] = str(doc["_id"])
+            results.append(doc)
+        return results
+
+    # ==================== 集合管理 ====================
+
+    async def create_indexes(self):
+        """创建索引以优化查询"""
+        # 文档集合索引
+        await self.documents.create_index("doc_type")
+        await self.documents.create_index("created_at")
+        await self.documents.create_index([("content", "text")])
+
+        # RAG索引集合索引
+        await self.rag_index.create_index("table_name")
+        await self.rag_index.create_index("field_name")
+
+        # 任务集合索引
+        await self.tasks.create_index("task_id", unique=True)
+        await self.tasks.create_index("created_at")
+
+        logger.info("MongoDB 索引创建完成")
+
+    # ==================== 任务历史操作 ====================
+
+    async def insert_task(
+        self,
+        task_id: str,
+        task_type: str,
+        status: str = "pending",
+        message: str = "",
+        result: Optional[Dict[str, Any]] = None,
+        error: Optional[str] = None,
+    ) -> str:
+        """
+        插入任务记录
+
+        Args:
+            task_id: 任务ID
+            task_type: 任务类型
+            status: 任务状态
+            message: 任务消息
+            result: 任务结果
+            error: 错误信息
+
+        Returns:
+            插入文档的ID
+        """
+        task = {
+            "task_id": task_id,
+            "task_type": task_type,
+            "status": status,
+            "message": message,
+            "result": result,
+            "error": error,
+            "created_at": datetime.utcnow(),
+            "updated_at": datetime.utcnow(),
+        }
+        result_obj = await self.tasks.insert_one(task)
+        return str(result_obj.inserted_id)
+
+    async def update_task(
+        self,
+        task_id: str,
+        status: Optional[str] = None,
+        message: Optional[str] = None,
+        result: Optional[Dict[str, Any]] = None,
+        error: Optional[str] = None,
+    ) -> bool:
+        """
+        更新任务状态
+
+        Args:
+            task_id: 任务ID
+            status: 任务状态
+            message: 任务消息
+            result: 任务结果
+            error: 错误信息
+
+        Returns:
+            是否更新成功
+        """
+        from bson import ObjectId
+
+        update_data = {"updated_at": datetime.utcnow()}
+        if status is not None:
+            update_data["status"] = status
+        if message is not None:
+            update_data["message"] = message
+        if result is not None:
+            update_data["result"] = result
+        if error is not None:
+            update_data["error"] = error
+
+        update_result = await self.tasks.update_one(
+            {"task_id": task_id},
+            {"$set": update_data}
+        )
+        return update_result.modified_count > 0
+
+    async def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """根据task_id获取任务"""
+        task = await self.tasks.find_one({"task_id": task_id})
+        if task:
+            task["_id"] = str(task["_id"])
+        return task
+
+    async def list_tasks(
+        self,
+        limit: int = 50,
+        skip: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        获取任务列表
+
+        Args:
+            limit: 返回数量
+            skip: 跳过数量
+
+        Returns:
+            任务列表
+        """
+        cursor = self.tasks.find().sort("created_at", -1).skip(skip).limit(limit)
+        tasks = []
+        async for task in cursor:
+            task["_id"] = str(task["_id"])
+            # 转换 datetime 为字符串
+            if task.get("created_at"):
+                task["created_at"] = task["created_at"].isoformat()
+            if task.get("updated_at"):
+                task["updated_at"] = task["updated_at"].isoformat()
+            tasks.append(task)
+        return tasks
+
+    async def delete_task(self, task_id: str) -> bool:
+        """删除任务"""
+        result = await self.tasks.delete_one({"task_id": task_id})
+        return result.deleted_count > 0
+
+
+# ==================== 全局单例 ====================
+
+mongodb = MongoDB()

backend/app/core/database/mysql.py

@@ -0,0 +1,214 @@
+"""
+MySQL 数据库连接管理模块
+
+提供结构化数据的存储和查询功能
+"""
+import logging
+from contextlib import asynccontextmanager
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Enum as SQLEnum,
+    Float,
+    Integer,
+    String,
+    Text,
+    create_engine,
+    text,
+)
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+from sqlalchemy.sql import select
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class Base(DeclarativeBase):
+    """SQLAlchemy 声明基类"""
+    pass
+
+
+class MySQLDB:
+    """MySQL 数据库管理类"""
+
+    def __init__(self):
+        # 异步引擎 (用于 FastAPI 异步操作)
+        self.async_engine = create_async_engine(
+            settings.async_mysql_url,
+            echo=settings.DEBUG,  # SQL 日志
+            pool_pre_ping=True,   # 连接前检测
+            pool_size=10,
+            max_overflow=20,
+        )
+
+        # 异步会话工厂
+        self.async_session_factory = async_sessionmaker(
+            bind=self.async_engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+            autocommit=False,
+            autoflush=False,
+        )
+
+        # 同步引擎 (用于 Celery 同步任务)
+        self.sync_engine = create_engine(
+            settings.mysql_url,
+            echo=settings.DEBUG,
+            pool_pre_ping=True,
+            pool_size=5,
+            max_overflow=10,
+        )
+
+        # 同步会话工厂
+        self.sync_session_factory = sessionmaker(
+            bind=self.sync_engine,
+            autocommit=False,
+            autoflush=False,
+        )
+
+    async def init_db(self):
+        """初始化数据库，创建所有表"""
+        try:
+            # 先创建数据库（如果不存在）
+            from sqlalchemy import text
+            db_name = settings.MYSQL_DATABASE
+            # 连接时不指定数据库来创建数据库
+            temp_url = (
+                f"mysql+aiomysql://{settings.MYSQL_USER}:{settings.MYSQL_PASSWORD}"
+                f"@{settings.MYSQL_HOST}:{settings.MYSQL_PORT}/"
+                f"?charset={settings.MYSQL_CHARSET}"
+            )
+            from sqlalchemy.ext.asyncio import create_async_engine
+            temp_engine = create_async_engine(temp_url, echo=False)
+            try:
+                async with temp_engine.connect() as conn:
+                    await conn.execute(text(f"CREATE DATABASE IF NOT EXISTS `{db_name}` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci"))
+                    await conn.commit()
+                logger.info(f"MySQL 数据库 {db_name} 创建或已存在")
+            finally:
+                await temp_engine.dispose()
+
+            # 然后创建表
+            async with self.async_engine.begin() as conn:
+                await conn.run_sync(Base.metadata.create_all)
+            logger.info("MySQL 数据库表初始化完成")
+        except Exception as e:
+            logger.error(f"MySQL 数据库初始化失败: {e}")
+            raise
+
+    async def close(self):
+        """关闭数据库连接"""
+        await self.async_engine.dispose()
+        self.sync_engine.dispose()
+        logger.info("MySQL 数据库连接已关闭")
+
+    @asynccontextmanager
+    async def get_session(self) -> AsyncGenerator[AsyncSession, None]:
+        """获取异步数据库会话"""
+        session = self.async_session_factory()
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+
+    async def execute_query(
+        self,
+        query: str,
+        params: Optional[Dict[str, Any]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        执行原始 SQL 查询
+
+        Args:
+            query: SQL 查询语句
+            params: 查询参数
+
+        Returns:
+            查询结果列表
+        """
+        async with self.get_session() as session:
+            result = await session.execute(select(text(query)), params or {})
+            rows = result.fetchall()
+            return [dict(row._mapping) for row in rows]
+
+    async def execute_raw_sql(
+        self,
+        sql: str,
+        params: Optional[Dict[str, Any]] = None
+    ) -> Any:
+        """
+        执行原始 SQL 语句 (INSERT/UPDATE/DELETE)
+
+        Args:
+            sql: SQL 语句
+            params: 语句参数
+
+        Returns:
+            执行结果
+        """
+        async with self.get_session() as session:
+            result = await session.execute(text(sql), params or {})
+            await session.commit()
+            return result.lastrowid if result.lastrowid else result.rowcount
+
+
+# ==================== 预定义的数据模型 ====================
+
+class DocumentTable(Base):
+    """文档元数据表 - 存储已解析文档的基本信息"""
+    __tablename__ = "document_tables"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    table_name = Column(String(255), unique=True, nullable=False, comment="表名")
+    display_name = Column(String(255), comment="显示名称")
+    description = Column(Text, comment="表描述")
+    source_file = Column(String(512), comment="来源文件")
+    column_count = Column(Integer, default=0, comment="列数")
+    row_count = Column(Integer, default=0, comment="行数")
+    file_size = Column(Integer, comment="文件大小(字节)")
+    created_at = Column(DateTime, comment="创建时间")
+    updated_at = Column(DateTime, comment="更新时间")
+
+
+class DocumentField(Base):
+    """文档字段表 - 存储每个表的字段信息"""
+    __tablename__ = "document_fields"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    table_id = Column(Integer, nullable=False, comment="所属表ID")
+    field_name = Column(String(255), nullable=False, comment="字段名")
+    field_type = Column(String(50), comment="字段类型")
+    field_description = Column(Text, comment="字段描述/语义")
+    is_key_field = Column(Integer, default=0, comment="是否主键")
+    is_nullable = Column(Integer, default=1, comment="是否可空")
+    sample_values = Column(Text, comment="示例值(逗号分隔)")
+    created_at = Column(DateTime, comment="创建时间")
+
+
+class TaskRecord(Base):
+    """任务记录表 - 存储异步任务信息"""
+    __tablename__ = "task_records"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    task_id = Column(String(255), unique=True, nullable=False, comment="Celery任务ID")
+    task_type = Column(String(50), comment="任务类型")
+    status = Column(String(50), default="pending", comment="任务状态")
+    input_params = Column(Text, comment="输入参数JSON")
+    result_data = Column(Text, comment="结果数据JSON")
+    error_message = Column(Text, comment="错误信息")
+    started_at = Column(DateTime, comment="开始时间")
+    completed_at = Column(DateTime, comment="完成时间")
+    created_at = Column(DateTime, comment="创建时间")
+
+
+# ==================== 全局单例 ====================
+
+mysql_db = MySQLDB()

backend/app/core/database/redis_db.py

@@ -0,0 +1,308 @@
+"""
+Redis 数据库连接管理模块
+
+提供缓存和任务队列功能
+"""
+import json
+import logging
+from datetime import timedelta
+from typing import Any, Dict, Optional
+
+import redis.asyncio as redis
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+
+class RedisDB:
+    """Redis 数据库管理类"""
+
+    def __init__(self):
+        self.client: Optional[redis.Redis] = None
+        self._connected = False
+
+    async def connect(self):
+        """建立 Redis 连接"""
+        try:
+            self.client = redis.from_url(
+                settings.REDIS_URL,
+                encoding="utf-8",
+                decode_responses=True,
+            )
+            # 验证连接
+            await self.client.ping()
+            self._connected = True
+            logger.info(f"Redis 连接成功: {settings.REDIS_URL}")
+        except Exception as e:
+            logger.error(f"Redis 连接失败: {e}")
+            raise
+
+    async def close(self):
+        """关闭 Redis 连接"""
+        if self.client:
+            await self.client.close()
+            self._connected = False
+            logger.info("Redis 连接已关闭")
+
+    @property
+    def is_connected(self) -> bool:
+        """检查连接状态"""
+        return self._connected
+
+    # ==================== 基础操作 ====================
+
+    async def get(self, key: str) -> Optional[str]:
+        """获取值"""
+        return await self.client.get(key)
+
+    async def set(
+        self,
+        key: str,
+        value: str,
+        expire: Optional[int] = None,
+    ) -> bool:
+        """
+        设置值
+
+        Args:
+            key: 键
+            value: 值
+            expire: 过期时间(秒)
+
+        Returns:
+            是否成功
+        """
+        return await self.client.set(key, value, ex=expire)
+
+    async def delete(self, key: str) -> int:
+        """删除键"""
+        return await self.client.delete(key)
+
+    async def exists(self, key: str) -> bool:
+        """检查键是否存在"""
+        return await self.client.exists(key) > 0
+
+    # ==================== JSON 操作 ====================
+
+    async def set_json(
+        self,
+        key: str,
+        data: Dict[str, Any],
+        expire: Optional[int] = None,
+    ) -> bool:
+        """
+        设置 JSON 数据
+
+        Args:
+            key: 键
+            data: 数据字典
+            expire: 过期时间(秒)
+
+        Returns:
+            是否成功
+        """
+        json_str = json.dumps(data, ensure_ascii=False, default=str)
+        return await self.set(key, json_str, expire)
+
+    async def get_json(self, key: str) -> Optional[Dict[str, Any]]:
+        """
+        获取 JSON 数据
+
+        Args:
+            key: 键
+
+        Returns:
+            数据字典，不存在返回 None
+        """
+        value = await self.get(key)
+        if value:
+            try:
+                return json.loads(value)
+            except json.JSONDecodeError:
+                return None
+        return None
+
+    # ==================== 任务状态管理 ====================
+
+    async def set_task_status(
+        self,
+        task_id: str,
+        status: str,
+        meta: Optional[Dict[str, Any]] = None,
+        expire: int = 86400,  # 默认24小时过期
+    ) -> bool:
+        """
+        设置任务状态
+
+        Args:
+            task_id: 任务ID
+            status: 状态 (pending/processing/success/failure)
+            meta: 附加信息
+            expire: 过期时间(秒)
+
+        Returns:
+            是否成功
+        """
+        if not self._connected or not self.client:
+            logger.warning(f"Redis未连接，跳过任务状态更新: {task_id}")
+            return False
+        try:
+            key = f"task:{task_id}"
+            data = {
+                "status": status,
+                "meta": meta or {},
+            }
+            return await self.set_json(key, data, expire)
+        except Exception as e:
+            logger.warning(f"设置任务状态失败: {task_id}, error: {e}")
+            return False
+
+    async def get_task_status(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """
+        获取任务状态
+
+        Args:
+            task_id: 任务ID
+
+        Returns:
+            状态信息
+        """
+        if not self._connected or not self.client:
+            logger.warning(f"Redis未连接，无法获取任务状态: {task_id}")
+            return None
+        try:
+            key = f"task:{task_id}"
+            return await self.get_json(key)
+        except Exception as e:
+            logger.warning(f"获取任务状态失败: {task_id}, error: {e}")
+            return None
+
+    async def update_task_progress(
+        self,
+        task_id: str,
+        progress: int,
+        message: Optional[str] = None,
+    ) -> bool:
+        """
+        更新任务进度
+
+        Args:
+            task_id: 任务ID
+            progress: 进度值 (0-100)
+            message: 进度消息
+
+        Returns:
+            是否成功
+        """
+        if not self._connected or not self.client:
+            logger.warning(f"Redis未连接，跳过任务进度更新: {task_id}")
+            return False
+        try:
+            data = await self.get_task_status(task_id)
+            if data:
+                data["meta"]["progress"] = progress
+                if message:
+                    data["meta"]["message"] = message
+                key = f"task:{task_id}"
+                return await self.set_json(key, data, expire=86400)
+            return False
+        except Exception as e:
+            logger.warning(f"更新任务进度失败: {task_id}, error: {e}")
+            return False
+
+    # ==================== 缓存操作 ====================
+
+    async def cache_document(
+        self,
+        doc_id: str,
+        data: Dict[str, Any],
+        expire: int = 3600,  # 默认1小时
+    ) -> bool:
+        """
+        缓存文档数据
+
+        Args:
+            doc_id: 文档ID
+            data: 文档数据
+            expire: 过期时间(秒)
+
+        Returns:
+            是否成功
+        """
+        key = f"doc:{doc_id}"
+        return await self.set_json(key, data, expire)
+
+    async def get_cached_document(self, doc_id: str) -> Optional[Dict[str, Any]]:
+        """
+        获取缓存的文档
+
+        Args:
+            doc_id: 文档ID
+
+        Returns:
+            文档数据
+        """
+        key = f"doc:{doc_id}"
+        return await self.get_json(key)
+
+    # ==================== 分布式锁 ====================
+
+    async def acquire_lock(
+        self,
+        lock_name: str,
+        expire: int = 30,
+    ) -> bool:
+        """
+        获取分布式锁
+
+        Args:
+            lock_name: 锁名称
+            expire: 过期时间(秒)
+
+        Returns:
+            是否获取成功
+        """
+        key = f"lock:{lock_name}"
+        # 使用 SET NX EX 原子操作
+        result = await self.client.set(key, "1", nx=True, ex=expire)
+        return result is not None
+
+    async def release_lock(self, lock_name: str) -> bool:
+        """
+        释放分布式锁
+
+        Args:
+            lock_name: 锁名称
+
+        Returns:
+            是否释放成功
+        """
+        key = f"lock:{lock_name}"
+        result = await self.client.delete(key)
+        return result > 0
+
+    # ==================== 计数器 ====================
+
+    async def incr(self, key: str, amount: int = 1) -> int:
+        """递增计数器"""
+        return await self.client.incrby(key, amount)
+
+    async def decr(self, key: str, amount: int = 1) -> int:
+        """递减计数器"""
+        return await self.client.decrby(key, amount)
+
+    # ==================== 过期时间管理 ====================
+
+    async def expire(self, key: str, seconds: int) -> bool:
+        """设置键的过期时间"""
+        return await self.client.expire(key, seconds)
+
+    async def ttl(self, key: str) -> int:
+        """获取键的剩余生存时间"""
+        return await self.client.ttl(key)
+
+
+# ==================== 全局单例 ====================
+
+redis_db = RedisDB()

backend/app/core/document_parser/__init__.py

@@ -1,7 +1,65 @@
 """
 文档解析模块 - 支持多种文件格式的解析
 """
-from .base import BaseParser
+from pathlib import Path
-from .xlsx_parser import XlsxParser
+from typing import Dict
 
-__all__ = ['BaseParser', 'XlsxParser']
+from .base import BaseParser, ParseResult
+from .xlsx_parser import XlsxParser
+from .docx_parser import DocxParser
+from .md_parser import MarkdownParser
+from .txt_parser import TxtParser
+
+
+class ParserFactory:
+    """解析器工厂，根据文件类型返回对应解析器"""
+
+    _parsers: Dict[str, BaseParser] = {
+        # Excel
+        '.xlsx': XlsxParser(),
+        '.xls': XlsxParser(),
+        # Word
+        '.docx': DocxParser(),
+        # Markdown
+        '.md': MarkdownParser(),
+        '.markdown': MarkdownParser(),
+        # 文本
+        '.txt': TxtParser(),
+    }
+
+    @classmethod
+    def get_parser(cls, file_path: str) -> BaseParser:
+        """根据文件扩展名获取解析器"""
+        ext = Path(file_path).suffix.lower()
+        parser = cls._parsers.get(ext)
+        if not parser:
+            supported = list(cls._parsers.keys())
+            raise ValueError(f"不支持的文件格式: {ext}，支持的格式: {supported}")
+        return parser
+
+    @classmethod
+    def parse(cls, file_path: str, **kwargs) -> ParseResult:
+        """统一解析接口"""
+        parser = cls.get_parser(file_path)
+        return parser.parse(file_path, **kwargs)
+
+    @classmethod
+    def register_parser(cls, ext: str, parser: BaseParser):
+        """注册新的解析器"""
+        cls._parsers[ext.lower()] = parser
+
+    @classmethod
+    def get_supported_extensions(cls) -> list:
+        """获取所有支持的扩展名"""
+        return list(cls._parsers.keys())
+
+
+__all__ = [
+    'BaseParser',
+    'ParseResult',
+    'ParserFactory',
+    'XlsxParser',
+    'DocxParser',
+    'MarkdownParser',
+    'TxtParser',
+]

backend/app/core/document_parser/docx_parser.py

@@ -0,0 +1,429 @@
+"""
+Word 文档 (.docx) 解析器
+"""
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from docx import Document
+
+from .base import BaseParser, ParseResult
+
+logger = logging.getLogger(__name__)
+
+
+class DocxParser(BaseParser):
+    """Word 文档解析器"""
+
+    def __init__(self):
+        super().__init__()
+        self.supported_extensions = ['.docx']
+        self.parser_name = "docx_parser"
+
+    def parse(
+        self,
+        file_path: str,
+        **kwargs
+    ) -> ParseResult:
+        """
+        解析 Word 文档
+
+        Args:
+            file_path: 文件路径
+            **kwargs: 其他参数
+
+        Returns:
+            ParseResult: 解析结果
+        """
+        path = Path(file_path)
+
+        # 检查文件是否存在
+        if not path.exists():
+            return ParseResult(
+                success=False,
+                error=f"文件不存在: {file_path}"
+            )
+
+        # 检查文件扩展名
+        if path.suffix.lower() not in self.supported_extensions:
+            return ParseResult(
+                success=False,
+                error=f"不支持的文件类型: {path.suffix}"
+            )
+
+        try:
+            # 读取 Word 文档
+            doc = Document(file_path)
+
+            # 提取文本内容
+            paragraphs = []
+            for para in doc.paragraphs:
+                if para.text.strip():
+                    paragraphs.append({
+                        "text": para.text,
+                        "style": str(para.style.name) if para.style else "Normal"
+                    })
+
+            # 提取段落纯文本（用于 AI 解析）
+            paragraphs_text = [p["text"] for p in paragraphs if p["text"].strip()]
+
+            # 提取表格内容
+            tables_data = []
+            for i, table in enumerate(doc.tables):
+                table_rows = []
+                for row in table.rows:
+                    row_data = [cell.text.strip() for cell in row.cells]
+                    table_rows.append(row_data)
+
+                if table_rows:
+                    tables_data.append({
+                        "table_index": i,
+                        "rows": table_rows,
+                        "row_count": len(table_rows),
+                        "column_count": len(table_rows[0]) if table_rows else 0
+                    })
+
+            # 提取图片/嵌入式对象信息
+            images_info = self._extract_images_info(doc, path)
+
+            # 合并所有文本（包括图片描述）
+            full_text_parts = []
+            full_text_parts.append("【文档正文】")
+            full_text_parts.extend(paragraphs_text)
+
+            if tables_data:
+                full_text_parts.append("\n【文档表格】")
+                for idx, table in enumerate(tables_data):
+                    full_text_parts.append(f"--- 表格 {idx + 1} ---")
+                    for row in table["rows"]:
+                        full_text_parts.append(" | ".join(str(cell) for cell in row))
+
+            if images_info.get("image_count", 0) > 0:
+                full_text_parts.append(f"\n【文档图片】文档包含 {images_info['image_count']} 张图片/图表")
+
+            full_text = "\n".join(full_text_parts)
+
+            # 构建元数据
+            metadata = {
+                "filename": path.name,
+                "extension": path.suffix.lower(),
+                "file_size": path.stat().st_size,
+                "paragraph_count": len(paragraphs),
+                "table_count": len(tables_data),
+                "word_count": len(full_text),
+                "char_count": len(full_text.replace("\n", "")),
+                "has_tables": len(tables_data) > 0,
+                "has_images": images_info.get("image_count", 0) > 0,
+                "image_count": images_info.get("image_count", 0)
+            }
+
+            # 返回结果
+            return ParseResult(
+                success=True,
+                data={
+                    "content": full_text,
+                    "paragraphs": paragraphs_text,
+                    "paragraphs_with_style": paragraphs,
+                    "tables": tables_data,
+                    "images": images_info,
+                    "word_count": len(full_text),
+                    "structured_data": {
+                        "paragraphs": paragraphs,
+                        "paragraphs_text": paragraphs_text,
+                        "tables": tables_data,
+                        "images": images_info
+                    }
+                },
+                metadata=metadata
+            )
+
+        except Exception as e:
+            logger.error(f"解析 Word 文档失败: {str(e)}")
+            return ParseResult(
+                success=False,
+                error=f"解析 Word 文档失败: {str(e)}"
+            )
+
+    def extract_images_as_base64(self, file_path: str) -> List[Dict[str, str]]:
+        """
+        提取 Word 文档中的所有图片，返回 base64 编码列表
+
+        Args:
+            file_path: Word 文件路径
+
+        Returns:
+            图片列表，每项包含 base64 编码和图片类型
+        """
+        import zipfile
+        import base64
+        from io import BytesIO
+
+        images = []
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as zf:
+                # 查找 word/media 目录下的图片文件
+                for filename in zf.namelist():
+                    if filename.startswith('word/media/'):
+                        # 获取图片类型
+                        ext = filename.split('.')[-1].lower()
+                        mime_types = {
+                            'png': 'image/png',
+                            'jpg': 'image/jpeg',
+                            'jpeg': 'image/jpeg',
+                            'gif': 'image/gif',
+                            'bmp': 'image/bmp'
+                        }
+                        mime_type = mime_types.get(ext, 'image/png')
+
+                        try:
+                            # 读取图片数据并转为 base64
+                            image_data = zf.read(filename)
+                            base64_data = base64.b64encode(image_data).decode('utf-8')
+
+                            images.append({
+                                "filename": filename,
+                                "mime_type": mime_type,
+                                "base64": base64_data,
+                                "size": len(image_data)
+                            })
+                            logger.info(f"提取图片: {filename}, 大小: {len(image_data)} bytes")
+                        except Exception as e:
+                            logger.warning(f"提取图片失败 {filename}: {str(e)}")
+
+        except Exception as e:
+            logger.error(f"打开 Word 文档提取图片失败: {str(e)}")
+
+        logger.info(f"共提取 {len(images)} 张图片")
+        return images
+
+    def extract_key_sentences(self, text: str, max_sentences: int = 10) -> List[str]:
+        """
+        从文本中提取关键句子
+
+        Args:
+            text: 文本内容
+            max_sentences: 最大句子数
+
+        Returns:
+            关键句子列表
+        """
+        # 简单实现：按句号分割，取前N个句子
+        sentences = [s.strip() for s in text.split("。") if s.strip()]
+        return sentences[:max_sentences]
+
+    def extract_structured_fields(self, text: str) -> Dict[str, Any]:
+        """
+        尝试提取结构化字段
+
+        针对合同、简历等有固定格式的文档
+
+        Args:
+            text: 文本内容
+
+        Returns:
+            提取的字段字典
+        """
+        fields = {}
+
+        # 常见字段模式
+        patterns = {
+            "姓名": r"姓名[：:]\s*(\S+)",
+            "电话": r"电话[：:]\s*(\d{11}|\d{3}-\d{8})",
+            "邮箱": r"邮箱[：:]\s*(\S+@\S+)",
+            "地址": r"地址[：:]\s*(.+?)(?:\n|$)",
+            "金额": r"金额[：:]\s*(\d+(?:\.\d+)?)",
+            "日期": r"日期[：:]\s*(\d{4}[年/-]\d{1,2}[月/-]\d{1,2})",
+        }
+
+        import re
+        for field_name, pattern in patterns.items():
+            match = re.search(pattern, text)
+            if match:
+                fields[field_name] = match.group(1)
+
+        return fields
+
+    def parse_tables_for_template(
+        self,
+        file_path: str
+    ) -> Dict[str, Any]:
+        """
+        解析 Word 文档中的表格，提取模板字段
+
+        专门用于比赛场景：解析表格模板，识别需要填写的字段
+
+        Args:
+            file_path: Word 文件路径
+
+        Returns:
+            包含表格字段信息的字典
+        """
+        from docx import Document
+        from docx.table import Table
+        from docx.oxml.ns import qn
+
+        doc = Document(file_path)
+
+        template_info = {
+            "tables": [],
+            "fields": [],
+            "field_count": 0
+        }
+
+        for table_idx, table in enumerate(doc.tables):
+            table_info = {
+                "table_index": table_idx,
+                "rows": [],
+                "headers": [],
+                "data_rows": [],
+                "field_hints": {}  # 字段名称 -> 提示词/描述
+            }
+
+            # 提取表头（第一行）
+            if table.rows:
+                header_cells = [cell.text.strip() for cell in table.rows[0].cells]
+                table_info["headers"] = header_cells
+
+                # 提取数据行
+                for row_idx, row in enumerate(table.rows[1:], 1):
+                    row_data = [cell.text.strip() for cell in row.cells]
+                    table_info["data_rows"].append(row_data)
+                    table_info["rows"].append({
+                        "row_index": row_idx,
+                        "cells": row_data
+                    })
+
+                # 尝试从第二列/第三列提取提示词
+                # 比赛模板通常格式为：字段名 | 提示词 | 填写值
+                if len(table.rows[0].cells) >= 2:
+                    for row_idx, row in enumerate(table.rows[1:], 1):
+                        cells = [cell.text.strip() for cell in row.cells]
+                        if len(cells) >= 2 and cells[0]:
+                            # 第一列是字段名
+                            field_name = cells[0]
+                            # 第二列可能是提示词或描述
+                            hint = cells[1] if len(cells) > 1 else ""
+                            table_info["field_hints"][field_name] = hint
+
+                            template_info["fields"].append({
+                                "table_index": table_idx,
+                                "row_index": row_idx,
+                                "field_name": field_name,
+                                "hint": hint,
+                                "expected_value": cells[2] if len(cells) > 2 else ""
+                            })
+
+            template_info["tables"].append(table_info)
+
+        template_info["field_count"] = len(template_info["fields"])
+        return template_info
+
+    def extract_template_fields_from_docx(
+        self,
+        file_path: str
+    ) -> List[Dict[str, Any]]:
+        """
+        从 Word 文档中提取模板字段定义
+
+        适用于比赛评分表格：表格第一列是字段名，第二列是提示词/填写示例
+
+        Args:
+            file_path: Word 文件路径
+
+        Returns:
+            字段定义列表
+        """
+        template_info = self.parse_tables_for_template(file_path)
+
+        fields = []
+        for field in template_info["fields"]:
+            fields.append({
+                "cell": f"T{field['table_index']}R{field['row_index']}",  # TableXRowY 格式
+                "name": field["field_name"],
+                "hint": field["hint"],
+                "table_index": field["table_index"],
+                "row_index": field["row_index"],
+                "field_type": self._infer_field_type_from_hint(field["hint"]),
+                "required": True
+            })
+
+        return fields
+
+    def _extract_images_info(self, doc: Document, path: Path) -> Dict[str, Any]:
+        """
+        提取 Word 文档中的图片/嵌入式对象信息
+
+        Args:
+            doc: Document 对象
+            path: 文件路径
+
+        Returns:
+            图片信息字典
+        """
+        import zipfile
+        from io import BytesIO
+
+        image_count = 0
+        image_descriptions = []
+        inline_shapes_count = 0
+
+        try:
+            # 方法1: 通过 inline shapes 统计图片
+            try:
+                inline_shapes_count = len(doc.inline_shapes)
+                if inline_shapes_count > 0:
+                    image_count = inline_shapes_count
+                    image_descriptions.append(f"文档包含 {inline_shapes_count} 个嵌入式图形/图片")
+            except Exception:
+                pass
+
+            # 方法2: 通过 ZIP 分析 document.xml 获取图片引用
+            try:
+                with zipfile.ZipFile(path, 'r') as zf:
+                    # 查找 word/media 目录下的图片文件
+                    media_files = [f for f in zf.namelist() if f.startswith('word/media/')]
+                    if media_files and not inline_shapes_count:
+                        image_count = len(media_files)
+                        image_descriptions.append(f"文档包含 {image_count} 个嵌入图片")
+
+                    # 检查是否有页眉页脚中的图片
+                    header_images = [f for f in zf.namelist() if 'header' in f.lower() and f.endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp'))]
+                    if header_images:
+                        image_descriptions.append(f"页眉/页脚包含 {len(header_images)} 个图片")
+            except Exception:
+                pass
+
+        except Exception as e:
+            logger.warning(f"提取图片信息失败: {str(e)}")
+
+        return {
+            "image_count": image_count,
+            "inline_shapes_count": inline_shapes_count,
+            "descriptions": image_descriptions,
+            "has_images": image_count > 0
+        }
+
+    def _infer_field_type_from_hint(self, hint: str) -> str:
+        """
+        从提示词推断字段类型
+
+        Args:
+            hint: 字段提示词
+
+        Returns:
+            字段类型 (text/number/date)
+        """
+        hint_lower = hint.lower()
+
+        # 日期关键词
+        date_keywords = ["年", "月", "日", "日期", "时间", "出生"]
+        if any(kw in hint for kw in date_keywords):
+            return "date"
+
+        # 数字关键词
+        number_keywords = ["数量", "金额", "人数", "面积", "增长", "比率", "%", "率"]
+        if any(kw in hint_lower for kw in number_keywords):
+            return "number"
+
+        return "text"

backend/app/core/document_parser/md_parser.py

@@ -0,0 +1,262 @@
+"""
+Markdown 文档解析器
+"""
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import markdown
+
+from .base import BaseParser, ParseResult
+
+logger = logging.getLogger(__name__)
+
+
+class MarkdownParser(BaseParser):
+    """Markdown 文档解析器"""
+
+    def __init__(self):
+        super().__init__()
+        self.supported_extensions = ['.md', '.markdown']
+        self.parser_name = "markdown_parser"
+
+    def parse(
+        self,
+        file_path: str,
+        **kwargs
+    ) -> ParseResult:
+        """
+        解析 Markdown 文档
+
+        Args:
+            file_path: 文件路径
+            **kwargs: 其他参数
+
+        Returns:
+            ParseResult: 解析结果
+        """
+        path = Path(file_path)
+
+        # 检查文件是否存在
+        if not path.exists():
+            return ParseResult(
+                success=False,
+                error=f"文件不存在: {file_path}"
+            )
+
+        # 检查文件扩展名
+        if path.suffix.lower() not in self.supported_extensions:
+            return ParseResult(
+                success=False,
+                error=f"不支持的文件类型: {path.suffix}"
+            )
+
+        try:
+            # 读取文件内容
+            with open(file_path, 'r', encoding='utf-8') as f:
+                raw_content = f.read()
+
+            # 解析 Markdown
+            md = markdown.Markdown(extensions=[
+                'markdown.extensions.tables',
+                'markdown.extensions.fenced_code',
+                'markdown.extensions.codehilite',
+                'markdown.extensions.toc',
+            ])
+
+            html_content = md.convert(raw_content)
+
+            # 提取标题结构
+            titles = self._extract_titles(raw_content)
+
+            # 提取代码块
+            code_blocks = self._extract_code_blocks(raw_content)
+
+            # 提取表格
+            tables = self._extract_tables(raw_content)
+
+            # 提取链接和图片
+            links_images = self._extract_links_images(raw_content)
+
+            # 清理后的纯文本（去除 Markdown 语法）
+            plain_text = self._strip_markdown(raw_content)
+
+            # 构建元数据
+            metadata = {
+                "filename": path.name,
+                "extension": path.suffix.lower(),
+                "file_size": path.stat().st_size,
+                "word_count": len(plain_text),
+                "char_count": len(raw_content),
+                "line_count": len(raw_content.splitlines()),
+                "title_count": len(titles),
+                "code_block_count": len(code_blocks),
+                "table_count": len(tables),
+                "link_count": len(links_images.get("links", [])),
+                "image_count": len(links_images.get("images", [])),
+            }
+
+            return ParseResult(
+                success=True,
+                data={
+                    "content": plain_text,
+                    "raw_content": raw_content,
+                    "html_content": html_content,
+                    "titles": titles,
+                    "code_blocks": code_blocks,
+                    "tables": tables,
+                    "links_images": links_images,
+                    "word_count": len(plain_text),
+                    "structured_data": {
+                        "titles": titles,
+                        "code_blocks": code_blocks,
+                        "tables": tables
+                    }
+                },
+                metadata=metadata
+            )
+
+        except Exception as e:
+            logger.error(f"解析 Markdown 文档失败: {str(e)}")
+            return ParseResult(
+                success=False,
+                error=f"解析 Markdown 文档失败: {str(e)}"
+            )
+
+    def _extract_titles(self, content: str) -> List[Dict[str, Any]]:
+        """提取标题结构"""
+        import re
+        titles = []
+
+        # 匹配 # 标题
+        for match in re.finditer(r'^(#{1,6})\s+(.+)$', content, re.MULTILINE):
+            level = len(match.group(1))
+            title_text = match.group(2).strip()
+            titles.append({
+                "level": level,
+                "text": title_text,
+                "line": content[:match.start()].count('\n') + 1
+            })
+
+        return titles
+
+    def _extract_code_blocks(self, content: str) -> List[Dict[str, str]]:
+        """提取代码块"""
+        import re
+        code_blocks = []
+
+        # 匹配 ```code ``` 格式
+        pattern = r'```(\w*)\n(.*?)```'
+        for match in re.finditer(pattern, content, re.DOTALL):
+            language = match.group(1) or "text"
+            code = match.group(2).strip()
+            code_blocks.append({
+                "language": language,
+                "code": code
+            })
+
+        return code_blocks
+
+    def _extract_tables(self, content: str) -> List[Dict[str, Any]]:
+        """提取表格"""
+        import re
+        tables = []
+
+        # 简单表格匹配（| col1 | col2 | 格式）
+        lines = content.split('\n')
+        i = 0
+        while i < len(lines):
+            line = lines[i].strip()
+
+            # 检查是否是表格行
+            if line.startswith('|') and line.endswith('|'):
+                # 找到表头
+                header_row = [cell.strip() for cell in line.split('|')[1:-1]]
+
+                # 检查下一行是否是分隔符
+                if i + 1 < len(lines) and re.match(r'^\|[\s\-:|]+\|$', lines[i + 1]):
+                    # 跳过分隔符，读取数据行
+                    data_rows = []
+                    for j in range(i + 2, len(lines)):
+                        row_line = lines[j].strip()
+                        if not (row_line.startswith('|') and row_line.endswith('|')):
+                            break
+                        row_data = [cell.strip() for cell in row_line.split('|')[1:-1]]
+                        data_rows.append(row_data)
+
+                    if header_row and data_rows:
+                        tables.append({
+                            "headers": header_row,
+                            "rows": data_rows,
+                            "row_count": len(data_rows),
+                            "column_count": len(header_row)
+                        })
+                        i = j - 1
+
+            i += 1
+
+        return tables
+
+    def _extract_links_images(self, content: str) -> Dict[str, List[Dict[str, str]]]:
+        """提取链接和图片"""
+        import re
+        result = {"links": [], "images": []}
+
+        # 提取链接 [text](url)
+        for match in re.finditer(r'\[([^\]]+)\]\(([^\)]+)\)', content):
+            result["links"].append({
+                "text": match.group(1),
+                "url": match.group(2)
+            })
+
+        # 提取图片 ![alt](url)
+        for match in re.finditer(r'!\[([^\]]*)\]\(([^\)]+)\)', content):
+            result["images"].append({
+                "alt": match.group(1),
+                "url": match.group(2)
+            })
+
+        return result
+
+    def _strip_markdown(self, content: str) -> str:
+        """去除 Markdown 语法，获取纯文本"""
+        import re
+
+        # 去除代码块
+        content = re.sub(r'```[\s\S]*?```', '', content)
+
+        # 去除行内代码
+        content = re.sub(r'`[^`]+`', '', content)
+
+        # 去除图片
+        content = re.sub(r'!\[([^\]]*)\]\([^\)]+\)', r'\1', content)
+
+        # 去除链接，保留文本
+        content = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', content)
+
+        # 去除标题标记
+        content = re.sub(r'^#{1,6}\s+', '', content, flags=re.MULTILINE)
+
+        # 去除加粗和斜体
+        content = re.sub(r'\*\*([^\*]+)\*\*', r'\1', content)
+        content = re.sub(r'\*([^\*]+)\*', r'\1', content)
+        content = re.sub(r'__([^_]+)__', r'\1', content)
+        content = re.sub(r'_([^_]+)_', r'\1', content)
+
+        # 去除引用标记
+        content = re.sub(r'^>\s+', '', content, flags=re.MULTILINE)
+
+        # 去除列表标记
+        content = re.sub(r'^[-*+]\s+', '', content, flags=re.MULTILINE)
+        content = re.sub(r'^\d+\.\s+', '', content, flags=re.MULTILINE)
+
+        # 去除水平线
+        content = re.sub(r'^[-*_]{3,}$', '', content, flags=re.MULTILINE)
+
+        # 去除表格分隔符
+        content = re.sub(r'^\|[\s\-:|]+\|$', '', content, flags=re.MULTILINE)
+
+        # 清理多余空行
+        content = re.sub(r'\n{3,}', '\n\n', content)
+
+        return content.strip()

backend/app/core/document_parser/txt_parser.py

@@ -0,0 +1,278 @@
+"""
+纯文本 (.txt) 解析器
+"""
+import logging
+import re
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import chardet
+
+from .base import BaseParser, ParseResult
+
+logger = logging.getLogger(__name__)
+
+
+class TxtParser(BaseParser):
+    """纯文本文档解析器"""
+
+    def __init__(self):
+        super().__init__()
+        self.supported_extensions = ['.txt']
+        self.parser_name = "txt_parser"
+
+    def parse(
+        self,
+        file_path: str,
+        encoding: Optional[str] = None,
+        **kwargs
+    ) -> ParseResult:
+        """
+        解析文本文件
+
+        Args:
+            file_path: 文件路径
+            encoding: 指定编码，不指定则自动检测
+            **kwargs: 其他参数
+
+        Returns:
+            ParseResult: 解析结果
+        """
+        path = Path(file_path)
+
+        # 检查文件是否存在
+        if not path.exists():
+            return ParseResult(
+                success=False,
+                error=f"文件不存在: {file_path}"
+            )
+
+        # 检查文件扩展名
+        if path.suffix.lower() not in self.supported_extensions:
+            return ParseResult(
+                success=False,
+                error=f"不支持的文件类型: {path.suffix}"
+            )
+
+        try:
+            # 检测编码
+            if not encoding:
+                encoding = self._detect_encoding(file_path)
+
+            # 读取文件内容
+            with open(file_path, 'r', encoding=encoding) as f:
+                raw_content = f.read()
+
+            # 清理文本
+            content = self._clean_text(raw_content)
+
+            # 提取行信息
+            lines = content.split('\n')
+
+            # 估算字数
+            word_count = len(content.replace('\n', '').replace(' ', ''))
+
+            # 构建元数据
+            metadata = {
+                "filename": path.name,
+                "extension": path.suffix.lower(),
+                "file_size": path.stat().st_size,
+                "encoding": encoding,
+                "line_count": len(lines),
+                "word_count": word_count,
+                "char_count": len(content),
+                "non_empty_line_count": len([l for l in lines if l.strip()])
+            }
+
+            return ParseResult(
+                success=True,
+                data={
+                    "content": content,
+                    "raw_content": raw_content,
+                    "lines": lines,
+                    "word_count": word_count,
+                    "char_count": len(content),
+                    "line_count": len(lines),
+                    "structured_data": {
+                        "line_count": len(lines),
+                        "non_empty_line_count": metadata["non_empty_line_count"]
+                    }
+                },
+                metadata=metadata
+            )
+
+        except Exception as e:
+            logger.error(f"解析文本文件失败: {str(e)}")
+            return ParseResult(
+                success=False,
+                error=f"解析文本文件失败: {str(e)}"
+            )
+
+    def _detect_encoding(self, file_path: str) -> str:
+        """
+        自动检测文件编码
+
+        Args:
+            file_path: 文件路径
+
+        Returns:
+            检测到的编码
+        """
+        try:
+            with open(file_path, 'rb') as f:
+                raw_data = f.read()
+
+            result = chardet.detect(raw_data)
+            encoding = result.get('encoding', 'utf-8')
+
+            # 验证编码是否有效
+            if encoding:
+                try:
+                    raw_data.decode(encoding)
+                    return encoding
+                except (UnicodeDecodeError, LookupError):
+                    pass
+
+            return 'utf-8'
+
+        except Exception as e:
+            logger.warning(f"编码检测失败，使用默认编码: {str(e)}")
+            return 'utf-8'
+
+    def _clean_text(self, text: str) -> str:
+        """
+        清理文本内容
+
+        - 去除多余空白字符
+        - 规范化换行符
+        - 去除特殊控制字符
+
+        Args:
+            text: 原始文本
+
+        Returns:
+            清理后的文本
+        """
+        # 规范化换行符
+        text = text.replace('\r\n', '\n').replace('\r', '\n')
+
+        # 去除控制字符（除了换行和tab）
+        text = re.sub(r'[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f]', '', text)
+
+        # 将多个连续空格合并为一个
+        text = re.sub(r'[ \t]+', ' ', text)
+
+        # 将多个连续空行合并为一个
+        text = re.sub(r'\n{3,}', '\n\n', text)
+
+        return text.strip()
+
+    def extract_structured_data(self, content: str) -> Dict[str, Any]:
+        """
+        尝试从文本中提取结构化数据
+
+        支持提取:
+        - 邮箱地址
+        - URL
+        - 电话号码
+        - 日期
+        - 金额
+
+        Args:
+            content: 文本内容
+
+        Returns:
+            结构化数据字典
+        """
+        data = {
+            "emails": [],
+            "urls": [],
+            "phones": [],
+            "dates": [],
+            "amounts": []
+        }
+
+        # 提取邮箱
+        emails = re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', content)
+        data["emails"] = list(set(emails))
+
+        # 提取 URL
+        urls = re.findall(r'https?://[^\s<>"{}|\\^`\[\]]+', content)
+        data["urls"] = list(set(urls))
+
+        # 提取电话号码 (支持多种格式)
+        phone_patterns = [
+            r'1[3-9]\d{9}',  # 手机号
+            r'\d{3,4}-\d{7,8}',  # 固话
+        ]
+        phones = []
+        for pattern in phone_patterns:
+            phones.extend(re.findall(pattern, content))
+        data["phones"] = list(set(phones))
+
+        # 提取日期
+        date_patterns = [
+            r'\d{4}[-/年]\d{1,2}[-/月]\d{1,2}[日]?',
+            r'\d{4}\.\d{1,2}\.\d{1,2}',
+        ]
+        dates = []
+        for pattern in date_patterns:
+            dates.extend(re.findall(pattern, content))
+        data["dates"] = list(set(dates))
+
+        # 提取金额
+        amount_patterns = [
+            r'¥\s*\d+(?:\.\d{1,2})?',
+            r'\$\s*\d+(?:\.\d{1,2})?',
+            r'\d+(?:\.\d{1,2})?\s*元',
+        ]
+        amounts = []
+        for pattern in amount_patterns:
+            amounts.extend(re.findall(pattern, content))
+        data["amounts"] = list(set(amounts))
+
+        return data
+
+    def split_into_chunks(
+        self,
+        content: str,
+        chunk_size: int = 1000,
+        overlap: int = 100
+    ) -> List[str]:
+        """
+        将长文本分割成块
+
+        用于 RAG 索引或 LLM 处理
+
+        Args:
+            content: 文本内容
+            chunk_size: 每块字符数
+            overlap: 块之间的重叠字符数
+
+        Returns:
+            文本块列表
+        """
+        if len(content) <= chunk_size:
+            return [content]
+
+        chunks = []
+        start = 0
+
+        while start < len(content):
+            end = start + chunk_size
+            chunk = content[start:end]
+
+            # 尝试在句子边界分割
+            if end < len(content):
+                last_period = chunk.rfind('。')
+                last_newline = chunk.rfind('\n')
+                split_pos = max(last_period, last_newline)
+
+                if split_pos > chunk_size // 2:
+                    chunk = chunk[:split_pos + 1]
+                    end = start + split_pos + 1
+
+            chunks.append(chunk)
+            start = end - overlap if end < len(content) else end
+
+        return chunks

backend/app/core/document_parser/xlsx_parser.py

@@ -67,11 +67,14 @@ class XlsxParser(BaseParser):
             xls_file = pd.ExcelFile(file_path)
             sheet_names = xls_file.sheet_names
 
+            # 如果 pandas 返回空列表，尝试从 XML 提取
             if not sheet_names:
-                return ParseResult(
+                sheet_names = self._extract_sheet_names_from_xml(file_path)
-                    success=False,
+                if not sheet_names:
-                    error=f"Excel 文件没有找到任何工作表: {file_path}"
+                    return ParseResult(
-                )
+                        success=False,
+                        error=f"Excel 文件没有找到任何工作表: {file_path}"
+                    )
 
             # 验证请求的工作表索引/名称
             target_sheet = None
@@ -88,15 +91,28 @@ class XlsxParser(BaseParser):
                 target_sheet = sheet_names[0]
 
             # 读取 Excel 文件
-            df = pd.read_excel(
+            df = None
-                file_path,
+            try:
-                sheet_name=target_sheet,
+                df = pd.read_excel(
-                header=header_row,
+                    file_path,
-                **kwargs
+                    sheet_name=target_sheet,
-            )
+                    header=header_row,
+                    **kwargs
+                )
+            except Exception as e:
+                logger.warning(f"pandas 读取 Excel 失败，尝试 XML 方式: {e}")
+                # pandas 读取失败，尝试 XML 方式
+                df = self._read_excel_sheet_xml(file_path, sheet_name=target_sheet, header_row=header_row)
 
-            # 检查 DataFrame 是否为空
+            # 检查 DataFrame 是否为空（但如果有列名，仍算有效）
-            if df.empty:
+            if df is None:
+                return ParseResult(
+                    success=False,
+                    error=f"工作表 '{target_sheet}' 读取失败"
+                )
+
+            # 如果 DataFrame 为空但有列名（比如模板文件），仍算有效
+            if df.empty and len(df.columns) == 0:
                 return ParseResult(
                     success=False,
                     error=f"工作表 '{target_sheet}' 为空，请检查 Excel 文件内容"
@@ -211,7 +227,26 @@ class XlsxParser(BaseParser):
 
         try:
             # 读取所有工作表
-            all_data = pd.read_excel(file_path, sheet_name=None, **kwargs)
+            all_data = None
+            try:
+                all_data = pd.read_excel(file_path, sheet_name=None, **kwargs)
+            except Exception as e:
+                logger.warning(f"pandas 读取所有工作表失败: {e}")
+
+            # 如果 pandas 失败，尝试 XML 方式
+            if all_data is None or len(all_data) == 0:
+                sheet_names = self._extract_sheet_names_from_xml(file_path)
+                if not sheet_names:
+                    return ParseResult(
+                        success=False,
+                        error=f"无法读取 Excel 文件或文件为空: {file_path}"
+                    )
+                # 使用 XML 方式读取每个工作表
+                all_data = {}
+                for sheet_name in sheet_names:
+                    df = self._read_excel_sheet_xml(file_path, sheet_name=sheet_name, header_row=0)
+                    if df is not None and not df.empty:
+                        all_data[sheet_name] = df
 
             # 检查是否成功读取到数据
             if not all_data or len(all_data) == 0:
@@ -257,13 +292,231 @@ class XlsxParser(BaseParser):
         try:
             xls = pd.ExcelFile(file_path)
             sheet_names = xls.sheet_names
-            if not sheet_names:
+            if sheet_names:
-                return []
+                return sheet_names
-            return sheet_names
+            # pandas 返回空列表，尝试从 XML 提取
+            return self._extract_sheet_names_from_xml(file_path)
         except Exception as e:
             logger.error(f"获取工作表名称失败: {str(e)}")
+            # 尝试从 XML 提取
+            return self._extract_sheet_names_from_xml(file_path)
+
+    def _extract_sheet_names_from_xml(self, file_path: str) -> List[str]:
+        """
+        从 Excel 文件的 XML 中提取工作表名称
+
+        某些 Excel 文件由于包含非标准元素（如 mc:AlternateContent），
+        pandas/openpyxl 无法正确解析工作表列表，此时需要直接从 XML 中提取。
+
+        Args:
+            file_path: Excel 文件路径
+
+        Returns:
+            工作表名称列表
+        """
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        # 常见的命名空间
+        COMMON_NAMESPACES = [
+            'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2005/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2004/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2003/main',
+        ]
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as z:
+                # 尝试多种可能的 workbook.xml 路径
+                possible_paths = ['xl/workbook.xml', 'xl\\workbook.xml', 'workbook.xml']
+                content = None
+                for path in possible_paths:
+                    if path in z.namelist():
+                        content = z.read(path)
+                        logger.info(f"找到 workbook.xml at: {path}")
+                        break
+
+                if content is None:
+                    logger.warning(f"未找到 workbook.xml，文件列表: {z.namelist()[:10]}")
+                    return []
+
+                root = ET.fromstring(content)
+
+                sheet_names = []
+
+                # 方法1：尝试带命名空间的查找
+                for ns in COMMON_NAMESPACES:
+                    sheet_elements = root.findall(f'.//{{{ns}}}sheet')
+                    if sheet_elements:
+                        for sheet in sheet_elements:
+                            name = sheet.get('name')
+                            if name:
+                                sheet_names.append(name)
+                        if sheet_names:
+                            logger.info(f"使用命名空间 {ns} 提取工作表: {sheet_names}")
+                            return sheet_names
+
+                # 方法2：不使用命名空间，直接查找所有 sheet 元素
+                if not sheet_names:
+                    for elem in root.iter():
+                        if elem.tag.endswith('sheet') and elem.tag != 'sheets':
+                            name = elem.get('name')
+                            if name:
+                                sheet_names.append(name)
+                            for child in elem:
+                                if child.tag.endswith('sheet') or child.tag == 'sheet':
+                                    name = child.get('name')
+                                    if name and name not in sheet_names:
+                                        sheet_names.append(name)
+
+                # 方法3：直接从 XML 文本中正则匹配 sheet name
+                if not sheet_names:
+                    import re
+                    xml_str = content.decode('utf-8', errors='ignore')
+                    matches = re.findall(r'<sheet\s+[^>]*name=["\']([^"\']+)["\']', xml_str, re.IGNORECASE)
+                    if matches:
+                        sheet_names = matches
+                        logger.info(f"使用正则提取工作表: {sheet_names}")
+
+                logger.info(f"从 XML 提取工作表: {sheet_names}")
+                return sheet_names
+
+        except Exception as e:
+            logger.error(f"从 XML 提取工作表名称失败: {e}")
             return []
 
+    def _read_excel_sheet_xml(self, file_path: str, sheet_name: str = None, header_row: int = 0) -> pd.DataFrame:
+        """
+        从 XML 直接读取 Excel 工作表数据
+
+        当 pandas 无法正确解析时使用此方法。
+
+        Args:
+            file_path: Excel 文件路径
+            sheet_name: 工作表名称（如果为 None，读取第一个工作表）
+            header_row: 表头行号（0-indexed）
+
+        Returns:
+            DataFrame
+        """
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        # 常见的命名空间
+        COMMON_NAMESPACES = [
+            'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2005/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2004/main',
+            'http://schemas.openxmlformats.org/spreadsheetml/2003/main',
+        ]
+
+        def find_elements_with_ns(root, tag_name):
+            """灵活查找元素，支持任意命名空间"""
+            results = []
+            # 方法1：用固定命名空间
+            for ns in COMMON_NAMESPACES:
+                try:
+                    elems = root.findall(f'.//{{{ns}}}{tag_name}')
+                    if elems:
+                        results.extend(elems)
+                except:
+                    pass
+            # 方法2：不带命名空间查找
+            if not results:
+                for elem in root.iter():
+                    if elem.tag.endswith('}' + tag_name):
+                        results.append(elem)
+            return results
+
+        with zipfile.ZipFile(file_path, 'r') as z:
+            # 获取工作表名称
+            sheet_names = self._extract_sheet_names_from_xml(file_path)
+            if not sheet_names:
+                raise ValueError("无法从 Excel 文件中找到工作表")
+
+            # 确定要读取的工作表
+            target_sheet = sheet_name if sheet_name and sheet_name in sheet_names else sheet_names[0]
+            sheet_index = sheet_names.index(target_sheet) + 1  # sheet1.xml, sheet2.xml, ...
+
+            # 读取 shared strings - 尝试多种路径
+            shared_strings = []
+            ss_paths = ['xl/sharedStrings.xml', 'xl\\sharedStrings.xml', 'sharedStrings.xml']
+            for ss_path in ss_paths:
+                if ss_path in z.namelist():
+                    try:
+                        ss_content = z.read(ss_path)
+                        ss_root = ET.fromstring(ss_content)
+                        for si in find_elements_with_ns(ss_root, 'si'):
+                            t_elements = [c for c in si if c.tag.endswith('}t') or c.tag == 't']
+                            if t_elements:
+                                shared_strings.append(t_elements[0].text or '')
+                            else:
+                                shared_strings.append('')
+                        break
+                    except Exception as e:
+                        logger.warning(f"读取 sharedStrings 失败: {e}")
+
+            # 读取工作表 - 尝试多种可能的路径
+            sheet_content = None
+            sheet_paths = [
+                f'xl/worksheets/sheet{sheet_index}.xml',
+                f'xl\\worksheets\\sheet{sheet_index}.xml',
+                f'worksheets/sheet{sheet_index}.xml',
+            ]
+            for sp in sheet_paths:
+                if sp in z.namelist():
+                    sheet_content = z.read(sp)
+                    break
+
+            if sheet_content is None:
+                raise ValueError(f"工作表文件 sheet{sheet_index}.xml 不存在")
+
+            root = ET.fromstring(sheet_content)
+
+            # 收集所有行数据
+            all_rows = []
+            headers = {}
+
+            for row in find_elements_with_ns(root, 'row'):
+                row_idx = int(row.get('r', 0))
+                row_cells = {}
+                for cell in find_elements_with_ns(row, 'c'):
+                    cell_ref = cell.get('r', '')
+                    col_letters = ''.join(filter(str.isalpha, cell_ref))
+                    cell_type = cell.get('t', 'n')
+                    v_elements = find_elements_with_ns(cell, 'v')
+                    v = v_elements[0] if v_elements else None
+
+                    if v is not None and v.text:
+                        if cell_type == 's':
+                            try:
+                                row_cells[col_letters] = shared_strings[int(v.text)]
+                            except (ValueError, IndexError):
+                                row_cells[col_letters] = v.text
+                        elif cell_type == 'b':
+                            row_cells[col_letters] = v.text == '1'
+                        else:
+                            row_cells[col_letters] = v.text
+                    else:
+                        row_cells[col_letters] = None
+
+                if row_idx == header_row + 1:
+                    headers = {**row_cells}
+                elif row_idx > header_row + 1:
+                    all_rows.append(row_cells)
+
+            # 构建 DataFrame
+            if headers:
+                col_order = list(headers.keys())
+                df = pd.DataFrame(all_rows)
+                if not df.empty:
+                    df = df[col_order]
+                df.columns = [headers.get(col, col) for col in df.columns]
+            else:
+                df = pd.DataFrame(all_rows)
+
+            return df
+
     def _df_to_dict(self, df: pd.DataFrame) -> Dict[str, Any]:
         """
         将 DataFrame 转换为字典，处理 NaN 值

backend/app/instruction/__init__.py

@@ -0,0 +1,14 @@
+"""
+指令执行模块
+
+支持文档智能操作交互，包括意图解析和指令执行
+"""
+from .intent_parser import IntentParser, intent_parser
+from .executor import InstructionExecutor, instruction_executor
+
+__all__ = [
+    "IntentParser",
+    "intent_parser",
+    "InstructionExecutor",
+    "instruction_executor",
+]

backend/app/instruction/executor.py

@@ -0,0 +1,572 @@
+"""
+指令执行器模块
+
+将自然语言指令转换为可执行操作
+"""
+import logging
+import json
+from typing import Any, Dict, List, Optional
+
+from app.services.template_fill_service import template_fill_service
+from app.services.rag_service import rag_service
+from app.services.markdown_ai_service import markdown_ai_service
+from app.core.database import mongodb
+
+logger = logging.getLogger(__name__)
+
+
+class InstructionExecutor:
+    """指令执行器"""
+
+    def __init__(self):
+        self.intent_parser = None  # 将通过 set_intent_parser 设置
+
+    def set_intent_parser(self, intent_parser):
+        """设置意图解析器"""
+        self.intent_parser = intent_parser
+
+    async def execute(self, instruction: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """
+        执行指令
+
+        Args:
+            instruction: 自然语言指令
+            context: 执行上下文（包含文档信息等）
+
+        Returns:
+            执行结果
+        """
+        if self.intent_parser is None:
+            from app.instruction.intent_parser import intent_parser
+            self.intent_parser = intent_parser
+
+        context = context or {}
+
+        # 解析意图
+        intent, params = await self.intent_parser.parse(instruction)
+
+        # 根据意图类型执行相应操作
+        if intent == "extract":
+            return await self._execute_extract(params, context)
+        elif intent == "fill_table":
+            return await self._execute_fill_table(params, context)
+        elif intent == "summarize":
+            return await self._execute_summarize(params, context)
+        elif intent == "question":
+            return await self._execute_question(params, context)
+        elif intent == "search":
+            return await self._execute_search(params, context)
+        elif intent == "compare":
+            return await self._execute_compare(params, context)
+        elif intent == "edit":
+            return await self._execute_edit(params, context)
+        elif intent == "transform":
+            return await self._execute_transform(params, context)
+        else:
+            return {
+                "success": False,
+                "error": f"未知意图类型: {intent}",
+                "message": "无法理解该指令，请尝试更明确的描述"
+            }
+
+    async def _execute_extract(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行信息提取"""
+        try:
+            target_fields = params.get("field_refs", [])
+            doc_ids = params.get("document_refs", [])
+
+            if not target_fields:
+                return {
+                    "success": False,
+                    "error": "未指定要提取的字段",
+                    "message": "请明确说明要提取哪些字段，如：'提取医院数量和床位数'"
+                }
+
+            # 如果指定了文档，验证文档存在
+            if doc_ids and "all_docs" not in doc_ids:
+                valid_docs = []
+                for doc_ref in doc_ids:
+                    doc_id = doc_ref.replace("doc_", "")
+                    doc = await mongodb.get_document(doc_id)
+                    if doc:
+                        valid_docs.append(doc)
+                if not valid_docs:
+                    return {
+                        "success": False,
+                        "error": "指定的文档不存在",
+                        "message": "请检查文档编号是否正确"
+                    }
+                context["source_docs"] = valid_docs
+
+            # 构建字段列表
+            fields = []
+            for i, field_name in enumerate(target_fields):
+                fields.append({
+                    "name": field_name,
+                    "cell": f"A{i+1}",
+                    "field_type": "text",
+                    "required": False
+                })
+
+            # 调用填表服务
+            result = await template_fill_service.fill_template(
+                template_fields=fields,
+                source_doc_ids=[doc.get("_id") for doc in context.get("source_docs", [])] if context.get("source_docs") else None,
+                user_hint=f"请提取字段: {', '.join(target_fields)}"
+            )
+
+            return {
+                "success": True,
+                "intent": "extract",
+                "extracted_data": result.get("filled_data", {}),
+                "fields": target_fields,
+                "message": f"成功提取 {len(result.get('filled_data', {}))} 个字段"
+            }
+
+        except Exception as e:
+            logger.error(f"提取执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"提取失败: {str(e)}"
+            }
+
+    async def _execute_fill_table(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行填表操作"""
+        try:
+            template_file = context.get("template_file")
+            if not template_file:
+                return {
+                    "success": False,
+                    "error": "未提供表格模板",
+                    "message": "请先上传要填写的表格模板"
+                }
+
+            # 获取源文档
+            source_docs = context.get("source_docs", [])
+            source_doc_ids = [doc.get("_id") for doc in source_docs if doc.get("_id")]
+
+            # 获取字段
+            fields = context.get("template_fields", [])
+
+            # 调用填表服务
+            result = await template_fill_service.fill_template(
+                template_fields=fields,
+                source_doc_ids=source_doc_ids if source_doc_ids else None,
+                source_file_paths=context.get("source_file_paths"),
+                user_hint=params.get("user_hint"),
+                template_id=template_file if isinstance(template_file, str) else None,
+                template_file_type=params.get("template", {}).get("type", "xlsx")
+            )
+
+            return {
+                "success": True,
+                "intent": "fill_table",
+                "result": result,
+                "message": f"填表完成，成功填写 {len(result.get('filled_data', {}))} 个字段"
+            }
+
+        except Exception as e:
+            logger.error(f"填表执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"填表失败: {str(e)}"
+            }
+
+    async def _execute_summarize(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行摘要总结"""
+        try:
+            docs = context.get("source_docs", [])
+            if not docs:
+                return {
+                    "success": False,
+                    "error": "没有可用的文档",
+                    "message": "请先上传要总结的文档"
+                }
+
+            summaries = []
+            for doc in docs[:5]:  # 最多处理5个文档
+                content = doc.get("content", "")[:5000]  # 限制内容长度
+                if content:
+                    summaries.append({
+                        "filename": doc.get("metadata", {}).get("original_filename", "未知"),
+                        "content_preview": content[:500] + "..." if len(content) > 500 else content
+                    })
+
+            return {
+                "success": True,
+                "intent": "summarize",
+                "summaries": summaries,
+                "message": f"找到 {len(summaries)} 个文档可供参考"
+            }
+
+        except Exception as e:
+            logger.error(f"摘要执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"摘要生成失败: {str(e)}"
+            }
+
+    async def _execute_question(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行问答"""
+        try:
+            question = params.get("question", "")
+            if not question:
+                return {
+                    "success": False,
+                    "error": "未提供问题",
+                    "message": "请输入要回答的问题"
+                }
+
+            # 使用 RAG 检索相关文档
+            docs = context.get("source_docs", [])
+            rag_results = []
+
+            for doc in docs:
+                doc_id = doc.get("_id", "")
+                if doc_id:
+                    results = rag_service.retrieve_by_doc_id(doc_id, top_k=3)
+                    rag_results.extend(results)
+
+            # 构建上下文
+            context_text = "\n\n".join([
+                r.get("content", "") for r in rag_results[:5]
+            ]) if rag_results else ""
+
+            # 如果没有 RAG 结果，使用文档内容
+            if not context_text:
+                context_text = "\n\n".join([
+                    doc.get("content", "")[:3000] for doc in docs[:3] if doc.get("content")
+                ])
+
+            return {
+                "success": True,
+                "intent": "question",
+                "question": question,
+                "context_preview": context_text[:500] + "..." if len(context_text) > 500 else context_text,
+                "message": "已找到相关上下文，可进行问答"
+            }
+
+        except Exception as e:
+            logger.error(f"问答执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"问答处理失败: {str(e)}"
+            }
+
+    async def _execute_search(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行搜索"""
+        try:
+            field_refs = params.get("field_refs", [])
+            query = " ".join(field_refs) if field_refs else params.get("question", "")
+
+            if not query:
+                return {
+                    "success": False,
+                    "error": "未提供搜索关键词",
+                    "message": "请输入要搜索的关键词"
+                }
+
+            # 使用 RAG 检索
+            results = rag_service.retrieve(query, top_k=10, min_score=0.3)
+
+            return {
+                "success": True,
+                "intent": "search",
+                "query": query,
+                "results": [
+                    {
+                        "content": r.get("content", "")[:200],
+                        "score": r.get("score", 0),
+                        "doc_id": r.get("doc_id", "")
+                    }
+                    for r in results[:10]
+                ],
+                "message": f"找到 {len(results)} 条相关结果"
+            }
+
+        except Exception as e:
+            logger.error(f"搜索执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"搜索失败: {str(e)}"
+            }
+
+    async def _execute_compare(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行对比分析"""
+        try:
+            docs = context.get("source_docs", [])
+            if len(docs) < 2:
+                return {
+                    "success": False,
+                    "error": "对比需要至少2个文档",
+                    "message": "请上传至少2个文档进行对比"
+                }
+
+            # 提取文档基本信息
+            comparison = []
+            for i, doc in enumerate(docs[:5]):
+                comparison.append({
+                    "index": i + 1,
+                    "filename": doc.get("metadata", {}).get("original_filename", "未知"),
+                    "doc_type": doc.get("doc_type", "未知"),
+                    "content_length": len(doc.get("content", "")),
+                    "has_tables": bool(doc.get("structured_data", {}).get("tables")),
+                })
+
+            return {
+                "success": True,
+                "intent": "compare",
+                "comparison": comparison,
+                "message": f"对比了 {len(comparison)} 个文档的基本信息"
+            }
+
+        except Exception as e:
+            logger.error(f"对比执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"对比分析失败: {str(e)}"
+            }
+
+    async def _execute_edit(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """执行文档编辑操作"""
+        try:
+            docs = context.get("source_docs", [])
+            if not docs:
+                return {
+                    "success": False,
+                    "error": "没有可用的文档",
+                    "message": "请先上传要编辑的文档"
+                }
+
+            doc = docs[0]  # 默认编辑第一个文档
+            content = doc.get("content", "")
+            original_filename = doc.get("metadata", {}).get("original_filename", "未知文档")
+
+            if not content:
+                return {
+                    "success": False,
+                    "error": "文档内容为空",
+                    "message": "该文档没有可编辑的内容"
+                }
+
+            # 使用 LLM 进行文本润色/编辑
+            prompt = f"""请对以下文档内容进行编辑处理。
+
+原文内容：
+{content[:8000]}
+
+编辑要求：
+- 润色表述，使其更加专业流畅
+- 修正明显的语法错误
+- 保持原意不变
+- 只返回编辑后的内容，不要解释
+
+请直接输出编辑后的内容："""
+
+            messages = [
+                {"role": "system", "content": "你是一个专业的文本编辑助手。请直接输出编辑后的内容。"},
+                {"role": "user", "content": prompt}
+            ]
+
+            from app.services.llm_service import llm_service
+            response = await llm_service.chat(messages=messages, temperature=0.3, max_tokens=8000)
+            edited_content = llm_service.extract_message_content(response)
+
+            return {
+                "success": True,
+                "intent": "edit",
+                "edited_content": edited_content,
+                "original_filename": original_filename,
+                "message": "文档编辑完成，内容已返回"
+            }
+
+        except Exception as e:
+            logger.error(f"编辑执行失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"编辑处理失败: {str(e)}"
+            }
+
+    async def _execute_transform(self, params: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        执行格式转换操作
+
+        支持：
+        - Word -> Excel
+        - Excel -> Word
+        - Markdown -> Word
+        - Word -> Markdown
+        """
+        try:
+            docs = context.get("source_docs", [])
+            if not docs:
+                return {
+                    "success": False,
+                    "error": "没有可用的文档",
+                    "message": "请先上传要转换的文档"
+                }
+
+            # 获取目标格式
+            template_info = params.get("template", {})
+            target_type = template_info.get("type", "")
+
+            if not target_type:
+                # 尝试从指令中推断
+                instruction = params.get("instruction", "")
+                if "excel" in instruction.lower() or "xlsx" in instruction.lower():
+                    target_type = "xlsx"
+                elif "word" in instruction.lower() or "docx" in instruction.lower():
+                    target_type = "docx"
+                elif "markdown" in instruction.lower() or "md" in instruction.lower():
+                    target_type = "md"
+
+            if not target_type:
+                return {
+                    "success": False,
+                    "error": "未指定目标格式",
+                    "message": "请说明要转换成什么格式（如：转成Excel、转成Word）"
+                }
+
+            doc = docs[0]
+            content = doc.get("content", "")
+            structured_data = doc.get("structured_data", {})
+            original_filename = doc.get("metadata", {}).get("original_filename", "未知文档")
+
+            # 构建转换内容
+            if structured_data.get("tables"):
+                # 有表格数据，生成表格格式的内容
+                tables = structured_data.get("tables", [])
+                table_content = []
+                for i, table in enumerate(tables[:3]):  # 最多处理3个表格
+                    headers = table.get("headers", [])
+                    rows = table.get("rows", [])[:20]  # 最多20行
+                    if headers:
+                        table_content.append(f"【表格 {i+1}】")
+                        table_content.append(" | ".join(str(h) for h in headers))
+                        table_content.append(" | ".join(["---"] * len(headers)))
+                        for row in rows:
+                            if isinstance(row, list):
+                                table_content.append(" | ".join(str(c) for c in row))
+                            elif isinstance(row, dict):
+                                table_content.append(" | ".join(str(row.get(h, "")) for h in headers))
+                        table_content.append("")
+
+                if target_type == "xlsx":
+                    # 生成 Excel 格式的数据（JSON）
+                    excel_data = []
+                    for table in tables[:1]:  # 只处理第一个表格
+                        headers = table.get("headers", [])
+                        rows = table.get("rows", [])[:100]
+                        for row in rows:
+                            if isinstance(row, list):
+                                excel_data.append(dict(zip(headers, row)))
+                            elif isinstance(row, dict):
+                                excel_data.append(row)
+
+                    return {
+                        "success": True,
+                        "intent": "transform",
+                        "transform_type": "to_excel",
+                        "target_format": "xlsx",
+                        "excel_data": excel_data,
+                        "headers": headers,
+                        "message": f"已转换为 Excel 格式，包含 {len(excel_data)} 行数据"
+                    }
+                elif target_type in ["docx", "word"]:
+                    # 生成 Word 格式的文本
+                    word_content = f"# {original_filename}\n\n"
+                    word_content += "\n".join(table_content)
+
+                    return {
+                        "success": True,
+                        "intent": "transform",
+                        "transform_type": "to_word",
+                        "target_format": "docx",
+                        "content": word_content,
+                        "message": "已转换为 Word 格式"
+                    }
+                elif target_type == "md":
+                    # 生成 Markdown 格式
+                    md_content = f"# {original_filename}\n\n"
+                    md_content += "\n".join(table_content)
+
+                    return {
+                        "success": True,
+                        "intent": "transform",
+                        "transform_type": "to_markdown",
+                        "target_format": "md",
+                        "content": md_content,
+                        "message": "已转换为 Markdown 格式"
+                    }
+
+            # 无表格数据，使用纯文本内容转换
+            if target_type == "xlsx":
+                # 将文本内容转为 Excel 格式（每行作为一列）
+                lines = [line.strip() for line in content.split("\n") if line.strip()][:100]
+                excel_data = [{"行号": i+1, "内容": line} for i, line in enumerate(lines)]
+
+                return {
+                    "success": True,
+                    "intent": "transform",
+                    "transform_type": "to_excel",
+                    "target_format": "xlsx",
+                    "excel_data": excel_data,
+                    "headers": ["行号", "内容"],
+                    "message": f"已将文本内容转换为 Excel，包含 {len(excel_data)} 行"
+                }
+            elif target_type in ["docx", "word"]:
+                return {
+                    "success": True,
+                    "intent": "transform",
+                    "transform_type": "to_word",
+                    "target_format": "docx",
+                    "content": content,
+                    "message": "文档内容已准备好，可下载为 Word 格式"
+                }
+            elif target_type == "md":
+                # 简单的文本转 Markdown
+                md_lines = []
+                for line in content.split("\n"):
+                    line = line.strip()
+                    if line:
+                        # 简单处理：如果行不长且不是列表格式，作为段落
+                        if len(line) < 100 and not line.startswith(("-", "*", "1.", "2.", "3.")):
+                            md_lines.append(line)
+                        else:
+                            md_lines.append(line)
+                    else:
+                        md_lines.append("")
+
+                return {
+                    "success": True,
+                    "intent": "transform",
+                    "transform_type": "to_markdown",
+                    "target_format": "md",
+                    "content": "\n".join(md_lines),
+                    "message": "已转换为 Markdown 格式"
+                }
+
+            return {
+                "success": False,
+                "error": "不支持的目标格式",
+                "message": f"暂不支持转换为 {target_type} 格式"
+            }
+
+        except Exception as e:
+            logger.error(f"格式转换失败: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"格式转换失败: {str(e)}"
+            }
+
+
+# 全局单例
+instruction_executor = InstructionExecutor()

backend/app/instruction/intent_parser.py

@@ -0,0 +1,242 @@
+"""
+意图解析器模块
+
+解析用户自然语言指令，识别意图和参数
+"""
+import re
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+class IntentParser:
+    """意图解析器"""
+
+    # 意图类型定义
+    INTENT_EXTRACT = "extract"           # 信息提取
+    INTENT_FILL_TABLE = "fill_table"    # 填表
+    INTENT_SUMMARIZE = "summarize"       # 摘要总结
+    INTENT_QUESTION = "question"         # 问答
+    INTENT_SEARCH = "search"              # 搜索
+    INTENT_COMPARE = "compare"            # 对比分析
+    INTENT_TRANSFORM = "transform"        # 格式转换
+    INTENT_EDIT = "edit"                  # 编辑文档
+    INTENT_UNKNOWN = "unknown"            # 未知
+
+    # 意图关键词映射
+    INTENT_KEYWORDS = {
+        INTENT_EXTRACT: ["提取", "抽取", "获取", "找出", "查找", "识别", "找到"],
+        INTENT_FILL_TABLE: ["填表", "填写", "填充", "录入", "导入到表格", "填写到"],
+        INTENT_SUMMARIZE: ["总结", "摘要", "概括", "概述", "归纳", "提炼"],
+        INTENT_QUESTION: ["问答", "回答", "解释", "什么是", "为什么", "如何", "怎样", "多少", "几个"],
+        INTENT_SEARCH: ["搜索", "查找", "检索", "查询", "找"],
+        INTENT_COMPARE: ["对比", "比较", "差异", "区别", "不同"],
+        INTENT_TRANSFORM: ["转换", "转化", "变成", "转为", "导出"],
+        INTENT_EDIT: ["修改", "编辑", "调整", "改写", "润色", "优化"],
+    }
+
+    # 实体模式定义
+    ENTITY_PATTERNS = {
+        "number": [r"\d+", r"[一二三四五六七八九十百千万]+"],
+        "date": [r"\d{4}年", r"\d{1,2}月", r"\d{1,2}日"],
+        "percentage": [r"\d+(\.\d+)?%", r"\d+(\.\d+)?‰"],
+        "currency": [r"\d+(\.\d+)?万元", r"\d+(\.\d+)?亿元", r"\d+(\.\d+)?元"],
+    }
+
+    def __init__(self):
+        self.intent_history: List[Dict[str, Any]] = []
+
+    async def parse(self, text: str) -> Tuple[str, Dict[str, Any]]:
+        """
+        解析自然语言指令
+
+        Args:
+            text: 用户输入的自然语言
+
+        Returns:
+            (意图类型, 参数字典)
+        """
+        text = text.strip()
+        if not text:
+            return self.INTENT_UNKNOWN, {}
+
+        # 记录历史
+        self.intent_history.append({"text": text, "intent": None})
+
+        # 识别意图
+        intent = self._recognize_intent(text)
+
+        # 提取参数
+        params = self._extract_params(text, intent)
+
+        # 更新历史
+        if self.intent_history:
+            self.intent_history[-1]["intent"] = intent
+
+        logger.info(f"意图解析: text={text[:50]}..., intent={intent}, params={params}")
+
+        return intent, params
+
+    def _recognize_intent(self, text: str) -> str:
+        """识别意图类型"""
+        intent_scores: Dict[str, float] = {}
+
+        for intent, keywords in self.INTENT_KEYWORDS.items():
+            score = 0
+            for keyword in keywords:
+                if keyword in text:
+                    score += 1
+            if score > 0:
+                intent_scores[intent] = score
+
+        if not intent_scores:
+            return self.INTENT_UNKNOWN
+
+        # 返回得分最高的意图
+        return max(intent_scores, key=intent_scores.get)
+
+    def _extract_params(self, text: str, intent: str) -> Dict[str, Any]:
+        """提取参数"""
+        params: Dict[str, Any] = {
+            "entities": self._extract_entities(text),
+            "document_refs": self._extract_document_refs(text),
+            "field_refs": self._extract_field_refs(text),
+            "template_refs": self._extract_template_refs(text),
+        }
+
+        # 根据意图类型提取特定参数
+        if intent == self.INTENT_QUESTION:
+            params["question"] = text
+            params["focus"] = self._extract_question_focus(text)
+        elif intent == self.INTENT_FILL_TABLE:
+            params["template"] = self._extract_template_info(text)
+        elif intent == self.INTENT_EXTRACT:
+            params["target_fields"] = self._extract_target_fields(text)
+
+        return params
+
+    def _extract_entities(self, text: str) -> Dict[str, List[str]]:
+        """提取实体"""
+        entities: Dict[str, List[str]] = {}
+
+        for entity_type, patterns in self.ENTITY_PATTERNS.items():
+            matches = []
+            for pattern in patterns:
+                found = re.findall(pattern, text)
+                matches.extend(found)
+            if matches:
+                entities[entity_type] = list(set(matches))
+
+        return entities
+
+    def _extract_document_refs(self, text: str) -> List[str]:
+        """提取文档引用"""
+        # 匹配 "文档1"、"doc1"、"第一个文档" 等
+        refs = []
+
+        # 数字索引: 文档1, doc1, 第1个文档
+        num_patterns = [
+            r"[文档doc]+(\d+)",
+            r"第(\d+)个文档",
+            r"第(\d+)份",
+        ]
+        for pattern in num_patterns:
+            matches = re.findall(pattern, text.lower())
+            refs.extend([f"doc_{m}" for m in matches])
+
+        # "所有文档"、"全部文档"
+        if any(kw in text for kw in ["所有", "全部", "整个"]):
+            refs.append("all_docs")
+
+        return refs
+
+    def _extract_field_refs(self, text: str) -> List[str]:
+        """提取字段引用"""
+        fields = []
+
+        # 匹配引号内的字段名
+        quoted = re.findall(r"['\"『「]([^'\"』」]+)['\"』」]", text)
+        fields.extend(quoted)
+
+        # 匹配 "xxx字段"、"xxx列" 等
+        field_patterns = [
+            r"([^\s]+)字段",
+            r"([^\s]+)列",
+            r"([^\s]+)数据",
+        ]
+        for pattern in field_patterns:
+            matches = re.findall(pattern, text)
+            fields.extend(matches)
+
+        return list(set(fields))
+
+    def _extract_template_refs(self, text: str) -> List[str]:
+        """提取模板引用"""
+        templates = []
+
+        # 匹配 "表格模板"、"Excel模板"、"表1" 等
+        template_patterns = [
+            r"([^\s]+模板)",
+            r"表(\d+)",
+            r"([^\s]+表格)",
+        ]
+        for pattern in template_patterns:
+            matches = re.findall(pattern, text)
+            templates.extend(matches)
+
+        return list(set(templates))
+
+    def _extract_question_focus(self, text: str) -> Optional[str]:
+        """提取问题焦点"""
+        # "什么是XXX"、"XXX是什么"
+        match = re.search(r"[什么是]([^?]+)", text)
+        if match:
+            return match.group(1).strip()
+
+        # "XXX有多少"
+        match = re.search(r"([^?]+)有多少", text)
+        if match:
+            return match.group(1).strip()
+
+        return None
+
+    def _extract_template_info(self, text: str) -> Optional[Dict[str, str]]:
+        """提取模板信息"""
+        template_info: Dict[str, str] = {}
+
+        # 提取模板类型
+        if "excel" in text.lower() or "xlsx" in text.lower() or "电子表格" in text:
+            template_info["type"] = "xlsx"
+        elif "word" in text.lower() or "docx" in text.lower() or "文档" in text:
+            template_info["type"] = "docx"
+
+        return template_info if template_info else None
+
+    def _extract_target_fields(self, text: str) -> List[str]:
+        """提取目标字段"""
+        fields = []
+
+        # 匹配 "提取XXX和YYY"、"抽取XXX、YYY"
+        patterns = [
+            r"提取([^(and|,|，)+]+?)(?:和|与|、|,|plus)",
+            r"抽取([^(and|,|，)+]+?)(?:和|与|、|,|plus)",
+        ]
+
+        for pattern in patterns:
+            matches = re.findall(pattern, text)
+            fields.extend([m.strip() for m in matches if m.strip()])
+
+        return list(set(fields))
+
+    def get_intent_history(self) -> List[Dict[str, Any]]:
+        """获取意图历史"""
+        return self.intent_history
+
+    def clear_history(self):
+        """清空历史"""
+        self.intent_history = []
+
+
+# 全局单例
+intent_parser = IntentParser()

backend/app/main.py

@@ -1,10 +1,194 @@
 """
 FastAPI 应用主入口
 """
-from fastapi import FastAPI
+# ========== 压制 MongoDB 疯狂刷屏日志 ==========
+import logging
+logging.getLogger("pymongo").setLevel(logging.WARNING)
+logging.getLogger("pymongo.topology").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+# ==============================================
+
+import logging
+import logging.handlers
+import sys
+import uuid
+from contextlib import asynccontextmanager
+from typing import Callable
+from functools import wraps
+
+from fastapi import FastAPI, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware
+
 from app.config import settings
 from app.api import api_router
+from app.core.database import mysql_db, mongodb, redis_db
+
+# ==================== 日志配置 ====================
+
+def setup_logging():
+    """配置应用日志系统"""
+    import os
+    from pathlib import Path
+
+    # 根日志配置
+    log_level = logging.DEBUG if settings.DEBUG else logging.INFO
+
+    # 日志目录
+    log_dir = Path("data/logs")
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    # 日志文件路径
+    log_file = log_dir / "app.log"
+    error_log_file = log_dir / "error.log"
+
+    # 控制台处理器
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+    console_formatter = logging.Formatter(
+        fmt="%(asctime)s | %(levelname)-8s | %(name)s:%(lineno)d | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    console_handler.setFormatter(console_formatter)
+
+    # 文件处理器 (所有日志)
+    file_handler = logging.handlers.RotatingFileHandler(
+        log_file,
+        maxBytes=10 * 1024 * 1024,  # 10MB
+        backupCount=5,
+        encoding="utf-8"
+    )
+    file_handler.setLevel(logging.DEBUG)
+    file_formatter = logging.Formatter(
+        fmt="%(asctime)s | %(levelname)-8s | %(name)s:%(lineno)d | %(funcName)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    file_handler.setFormatter(file_formatter)
+
+    # 错误日志处理器 (仅ERROR及以上)
+    error_file_handler = logging.handlers.RotatingFileHandler(
+        error_log_file,
+        maxBytes=10 * 1024 * 1024,  # 10MB
+        backupCount=5,
+        encoding="utf-8"
+    )
+    error_file_handler.setLevel(logging.ERROR)
+    error_file_handler.setFormatter(file_formatter)
+
+    # 根日志器
+    root_logger = logging.getLogger()
+    root_logger.setLevel(logging.DEBUG)
+    root_logger.handlers = []
+    root_logger.addHandler(console_handler)
+    root_logger.addHandler(file_handler)
+    root_logger.addHandler(error_file_handler)
+
+    # 第三方库日志级别
+    for lib in ["uvicorn", "uvicorn.access", "fastapi", "httpx", "sqlalchemy"]:
+        logging.getLogger(lib).setLevel(logging.WARNING)
+
+    root_logger.info(f"日志系统初始化完成 | 日志目录: {log_dir}")
+    root_logger.info(f"主日志文件: {log_file} | 错误日志: {error_log_file}")
+
+    return root_logger
+
+# 初始化日志
+setup_logging()
+logger = logging.getLogger(__name__)
+
+
+# ==================== 请求日志中间件 ====================
+
+class RequestLoggingMiddleware(BaseHTTPMiddleware):
+    """请求日志中间件 - 记录每个请求的详细信息"""
+
+    async def dispatch(self, request: Request, call_next: Callable) -> Response:
+        # 生成请求ID
+        request_id = str(uuid.uuid4())[:8]
+        request.state.request_id = request_id
+
+        # 记录请求
+        logger.info(f"→ [{request_id}] {request.method} {request.url.path}")
+
+        try:
+            response = await call_next(request)
+
+            # 记录响应
+            logger.info(
+                f"← [{request_id}] {request.method} {request.url.path} "
+                f"| 状态: {response.status_code} | 耗时: N/A"
+            )
+
+            # 添加请求ID到响应头
+            response.headers["X-Request-ID"] = request_id
+            return response
+
+        except Exception as e:
+            logger.error(f"✗ [{request_id}] {request.method} {request.url.path} | 异常: {str(e)}")
+            raise
+
+
+# ==================== 请求追踪装饰器 ====================
+
+def log_async_function(func: Callable) -> Callable:
+    """异步函数日志装饰器"""
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        func_name = func.__name__
+        logger.debug(f"→ {func_name} 开始执行")
+        try:
+            result = await func(*args, **kwargs)
+            logger.debug(f"← {func_name} 执行完成")
+            return result
+        except Exception as e:
+            logger.error(f"✗ {func_name} 执行失败: {str(e)}")
+            raise
+    return wrapper
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """
+    应用生命周期管理
+
+    启动时: 初始化数据库连接
+    关闭时: 关闭数据库连接
+    """
+    # 启动时
+    logger.info("正在初始化数据库连接...")
+
+    # 初始化 MySQL
+    try:
+        await mysql_db.init_db()
+        logger.info("✓ MySQL 初始化成功")
+    except Exception as e:
+        logger.error(f"✗ MySQL 初始化失败: {e}")
+
+    # 初始化 MongoDB
+    try:
+        await mongodb.connect()
+        await mongodb.create_indexes()
+        logger.info("✓ MongoDB 初始化成功")
+    except Exception as e:
+        logger.error(f"✗ MongoDB 初始化失败: {e}")
+
+    # 初始化 Redis
+    try:
+        await redis_db.connect()
+        logger.info("✓ Redis 初始化成功")
+    except Exception as e:
+        logger.error(f"✗ Redis 初始化失败: {e}")
+
+    logger.info("数据库初始化完成")
+    yield
+
+    # 关闭时
+    logger.info("正在关闭数据库连接...")
+    await mysql_db.close()
+    await mongodb.close()
+    await redis_db.close()
+    logger.info("数据库连接已关闭")
+
 
 # 创建 FastAPI 应用实例
 app = FastAPI(
@@ -13,7 +197,8 @@ app = FastAPI(
     version="1.0.0",
     openapi_url=f"{settings.API_V1_STR}/openapi.json",
     docs_url=f"{settings.API_V1_STR}/docs",
-    redoc_url=f"{settings.API_V1_STR}/redoc"
+    redoc_url=f"{settings.API_V1_STR}/redoc",
+    lifespan=lifespan,  # 添加生命周期管理
 )
 
 # 配置 CORS 中间件
@@ -25,6 +210,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# 添加请求日志中间件
+app.add_middleware(RequestLoggingMiddleware)
+
 # 注册 API 路由
 app.include_router(api_router, prefix=settings.API_V1_STR)
 
@@ -43,10 +231,24 @@ async def root():
 
 @app.get("/health")
 async def health_check():
-    """健康检查接口"""
+    """
+    健康检查接口
+
+    返回各数据库连接状态
+    """
+    # 检查各数据库连接状态
+    mysql_status = "connected" if mysql_db.async_engine else "disconnected"
+    mongodb_status = "connected" if mongodb.client else "disconnected"
+    redis_status = "connected" if redis_db.is_connected else "disconnected"
+
     return {
         "status": "healthy",
-        "service": settings.APP_NAME
+        "service": settings.APP_NAME,
+        "databases": {
+            "mysql": mysql_status,
+            "mongodb": mongodb_status,
+            "redis": redis_status,
+        }
     }
 
 

backend/app/models/__init__.py

@@ -0,0 +1,18 @@
+"""
+数据模型模块
+
+定义数据库表结构和数据模型
+"""
+from app.core.database.mysql import (
+    Base,
+    DocumentField,
+    DocumentTable,
+    TaskRecord,
+)
+
+__all__ = [
+    "Base",
+    "DocumentTable",
+    "DocumentField",
+    "TaskRecord",
+]

backend/app/models/document.py

@@ -0,0 +1,172 @@
+"""
+文档数据模型
+
+定义文档相关的 Pydantic 模型
+"""
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+class DocumentType(str, Enum):
+    """文档类型枚举"""
+    DOCX = "docx"
+    XLSX = "xlsx"
+    MD = "md"
+    TXT = "txt"
+
+
+class TaskStatus(str, Enum):
+    """任务状态枚举"""
+    PENDING = "pending"
+    PROCESSING = "processing"
+    SUCCESS = "success"
+    FAILURE = "failure"
+
+
+# ==================== 解析结果模型 ====================
+
+class DocumentMetadata(BaseModel):
+    """文档元数据"""
+    filename: str
+    extension: str
+    file_size: int = 0
+    doc_type: Optional[str] = None
+    sheet_count: Optional[int] = None
+    sheet_names: Optional[List[str]] = None
+    current_sheet: Optional[str] = None
+    row_count: Optional[int] = None
+    column_count: Optional[int] = None
+    columns: Optional[List[str]] = None
+    encoding: Optional[str] = None
+
+
+class ParseResultData(BaseModel):
+    """解析结果数据"""
+    columns: List[str] = Field(default_factory=list)
+    rows: List[Dict[str, Any]] = Field(default_factory=list)
+    row_count: int = 0
+    column_count: int = 0
+
+
+class ParseResult(BaseModel):
+    """文档解析结果"""
+    success: bool
+    data: Optional[ParseResultData] = None
+    metadata: Optional[DocumentMetadata] = None
+    error: Optional[str] = None
+
+
+# ==================== 存储模型 ====================
+
+class DocumentStore(BaseModel):
+    """文档存储模型"""
+    doc_id: str
+    doc_type: DocumentType
+    content: str
+    metadata: DocumentMetadata
+    structured_data: Optional[Dict[str, Any]] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: datetime = Field(default_factory=datetime.utcnow)
+
+
+class RAGEntry(BaseModel):
+    """RAG索引条目"""
+    table_name: str
+    field_name: str
+    field_description: str
+    embedding: List[float]
+    metadata: Optional[Dict[str, Any]] = None
+
+
+# ==================== 任务模型 ====================
+
+class TaskCreate(BaseModel):
+    """任务创建请求"""
+    task_type: str
+    input_params: Dict[str, Any]
+
+
+class TaskStatusResponse(BaseModel):
+    """任务状态响应"""
+    task_id: str
+    status: TaskStatus
+    progress: int = 0
+    message: Optional[str] = None
+    result: Optional[Any] = None
+    error: Optional[str] = None
+
+
+# ==================== 模板填写模型 ====================
+
+class TemplateField(BaseModel):
+    """模板字段"""
+    cell: str = Field(description="单元格位置, 如 A1")
+    name: str = Field(description="字段名称")
+    field_type: str = Field(default="text", description="字段类型: text/number/date")
+    required: bool = Field(default=True, description="是否必填")
+
+
+class TemplateSheet(BaseModel):
+    """模板工作表"""
+    name: str
+    fields: List[TemplateField]
+
+
+class TemplateInfo(BaseModel):
+    """模板信息"""
+    file_path: str
+    file_type: str  # xlsx/docx
+    sheets: List[TemplateSheet]
+
+
+class FillRequest(BaseModel):
+    """填写请求"""
+    template_path: str
+    template_fields: List[TemplateField]
+    source_doc_ids: Optional[List[str]] = None
+
+
+class FillResult(BaseModel):
+    """填写结果"""
+    success: bool
+    filled_data: Dict[str, Any]
+    fill_details: List[Dict[str, Any]]
+    source_documents: List[str] = Field(default_factory=list)
+
+
+# ==================== API 响应模型 ====================
+
+class UploadResponse(BaseModel):
+    """上传响应"""
+    task_id: str
+    file_count: int
+    message: str
+    status_url: str
+
+
+class AnalyzeResponse(BaseModel):
+    """分析响应"""
+    success: bool
+    analysis: Optional[str] = None
+    structured_data: Optional[Dict[str, Any]] = None
+    model: Optional[str] = None
+    error: Optional[str] = None
+
+
+class QueryRequest(BaseModel):
+    """查询请求"""
+    user_intent: str
+    table_name: Optional[str] = None
+    top_k: int = Field(default=5, ge=1, le=20)
+
+
+class QueryResponse(BaseModel):
+    """查询响应"""
+    success: bool
+    sql_query: Optional[str] = None
+    results: Optional[List[Dict[str, Any]]] = None
+    rag_context: Optional[List[str]] = None
+    error: Optional[str] = None

backend/app/services/excel_storage_service.py

@@ -0,0 +1,722 @@
+"""
+Excel 存储服务
+
+将 Excel 数据转换为 MySQL 表结构并存储
+"""
+import logging
+import re
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from sqlalchemy import (
+    Column,
+    DateTime,
+    Float,
+    Integer,
+    String,
+    Text,
+    inspect,
+    text,
+)
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.core.database.mysql import Base, mysql_db
+
+logger = logging.getLogger(__name__)
+# 设置该模块的日志级别
+logger.setLevel(logging.DEBUG)
+
+
+class ExcelStorageService:
+    """Excel 数据存储服务"""
+
+    def __init__(self):
+        self.mysql_db = mysql_db
+
+    def _extract_sheet_names_from_xml(self, file_path: str) -> list:
+        """从 Excel 文件的 XML 中提取工作表名称"""
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as z:
+                if 'xl/workbook.xml' not in z.namelist():
+                    return []
+                content = z.read('xl/workbook.xml')
+                root = ET.fromstring(content)
+
+                # 尝试多种命名空间
+                namespaces = [
+                    'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+                    'http://purl.oclc.org/ooxml/spreadsheetml/main',
+                ]
+
+                for ns_uri in namespaces:
+                    ns = {'main': ns_uri}
+                    sheets = root.findall('.//main:sheet', ns)
+                    if sheets:
+                        names = [s.get('name') for s in sheets if s.get('name')]
+                        if names:
+                            return names
+
+                # 尝试通配符
+                sheets = root.findall('.//{*}sheet')
+                if not sheets:
+                    sheets = root.findall('.//sheet')
+                return [s.get('name') for s in sheets if s.get('name')]
+        except Exception:
+            return []
+
+    def _read_excel_sheet(self, file_path: str, sheet_name: str = None, header_row: int = 0) -> pd.DataFrame:
+        """读取 Excel 工作表，支持 pandas 无法解析的特殊 Excel 文件"""
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        try:
+            df = pd.read_excel(file_path, sheet_name=sheet_name, header=header_row)
+            if df is not None and not df.empty:
+                return df
+        except Exception:
+            pass
+
+        # pandas 读取失败，从 XML 直接解析
+        logger.info(f"使用 XML 方式读取 Excel: {file_path}")
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as z:
+                sheet_names = self._extract_sheet_names_from_xml(file_path)
+                if not sheet_names:
+                    raise ValueError("无法从 Excel 文件中找到工作表")
+
+                target_sheet = sheet_name if sheet_name and sheet_name in sheet_names else sheet_names[0]
+                sheet_index = sheet_names.index(target_sheet) + 1
+
+                shared_strings = []
+                if 'xl/sharedStrings.xml' in z.namelist():
+                    ss_content = z.read('xl/sharedStrings.xml')
+                    ss_root = ET.fromstring(ss_content)
+                    for si in ss_root.iter():
+                        if si.tag.endswith('}si') or si.tag == 'si':
+                            t = si.find('.//{*}t')
+                            shared_strings.append(t.text if t is not None and t.text else '')
+
+                sheet_file = f'xl/worksheets/sheet{sheet_index}.xml'
+                sheet_content = z.read(sheet_file)
+                root = ET.fromstring(sheet_content)
+
+                rows_data = []
+                headers = {}
+
+                for row in root.iter():
+                    if row.tag.endswith('}row') or row.tag == 'row':
+                        row_idx = int(row.get('r', 0))
+
+                        # 收集表头行
+                        if row_idx == header_row + 1:
+                            for cell in row:
+                                if cell.tag.endswith('}c') or cell.tag == 'c':
+                                    cell_ref = cell.get('r', '')
+                                    col_letters = ''.join(filter(str.isalpha, cell_ref))
+                                    cell_type = cell.get('t', 'n')
+                                    v = cell.find('{*}v')
+                                    if v is not None and v.text:
+                                        if cell_type == 's':
+                                            try:
+                                                headers[col_letters] = shared_strings[int(v.text)]
+                                            except (ValueError, IndexError):
+                                                headers[col_letters] = v.text
+                                        else:
+                                            headers[col_letters] = v.text
+                                    else:
+                                        headers[col_letters] = col_letters
+                            continue
+
+                        if row_idx <= header_row + 1:
+                            continue
+
+                        row_cells = {}
+                        for cell in row:
+                            if cell.tag.endswith('}c') or cell.tag == 'c':
+                                cell_ref = cell.get('r', '')
+                                col_letters = ''.join(filter(str.isalpha, cell_ref))
+                                cell_type = cell.get('t', 'n')
+                                v = cell.find('{*}v')
+
+                                if v is not None and v.text:
+                                    if cell_type == 's':
+                                        try:
+                                            val = shared_strings[int(v.text)]
+                                        except (ValueError, IndexError):
+                                            val = v.text
+                                    elif cell_type == 'b':
+                                        val = v.text == '1'
+                                    else:
+                                        val = v.text
+                                else:
+                                    val = None
+                                row_cells[col_letters] = val
+
+                        if row_cells:
+                            rows_data.append(row_cells)
+
+                if not rows_data:
+                    return pd.DataFrame()
+
+                df = pd.DataFrame(rows_data)
+
+                if headers:
+                    df.columns = [headers.get(col, col) for col in df.columns]
+
+                return df
+        except Exception as e:
+            logger.error(f"XML 解析 Excel 失败: {e}")
+            raise
+
+    def _sanitize_table_name(self, filename: str) -> str:
+        """
+        将文件名转换为合法的表名
+
+        Args:
+            filename: 原始文件名
+
+        Returns:
+            合法的表名
+        """
+        # 移除扩展名
+        name = filename.rsplit('.', 1)[0] if '.' in filename else filename
+
+        # 只保留字母、数字、下划线
+        name = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+
+        # 确保以字母开头
+        if name and name[0].isdigit():
+            name = 't_' + name
+
+        # 限制长度
+        return name[:50]
+
+    def _sanitize_column_name(self, col_name: str) -> str:
+        """
+        将列名转换为合法的字段名
+
+        Args:
+            col_name: 原始列名
+
+        Returns:
+            合法的字段名
+        """
+        # MySQL 支持 UTF8 编码，中文字符可以直接使用
+        # 只处理非法字符（控制字符等）和首字符数字
+        name = str(col_name).strip()
+        # 移除控制字符
+        name = re.sub(r'[\x00-\x1f\x7f]', '', name)
+        # 确保以字母或中文开头
+        if name and name[0].isdigit():
+            name = 'col_' + name
+        # 限制长度 (MySQL 字段名最多64字符)
+        return name[:64]
+
+    def _get_unique_column_name(self, col_name: str, used_names: set) -> str:
+        """
+        获取唯一的列名，避免重复
+
+        Args:
+            col_name: 原始列名
+            used_names: 已使用的列名集合
+
+        Returns:
+            唯一的列名
+        """
+        sanitized = self._sanitize_column_name(col_name)
+        # "id" 是 MySQL 保留名，作为主键使用
+        if sanitized.lower() == "id":
+            sanitized = "col_id"
+        if sanitized not in used_names:
+            used_names.add(sanitized)
+            return sanitized
+
+        # 添加数字后缀直到唯一
+        base = sanitized if sanitized else "col"
+        counter = 1
+        while f"{base}_{counter}" in used_names:
+            counter += 1
+        unique_name = f"{base}_{counter}"
+        used_names.add(unique_name)
+        return unique_name
+
+    def _infer_column_type(self, series: pd.Series) -> str:
+        """
+        根据数据推断列类型
+
+        Args:
+            series: pandas Series
+
+        Returns:
+            类型名称
+        """
+        # 移除空值进行类型检查
+        non_null = series.dropna()
+        if len(non_null) == 0:
+            return "TEXT"
+
+        dtype = series.dtype
+
+        # 整数类型检查
+        if pd.api.types.is_integer_dtype(dtype):
+            # 检查是否所有值都能放入 INT 范围
+            try:
+                int_values = non_null.astype('int64')
+                if int_values.min() >= -2147483648 and int_values.max() <= 2147483647:
+                    return "INTEGER"
+                else:
+                    # 超出 INT 范围，使用 TEXT
+                    return "TEXT"
+            except (ValueError, OverflowError):
+                return "TEXT"
+        elif pd.api.types.is_float_dtype(dtype):
+            # 检查是否所有值都能放入 FLOAT
+            try:
+                float_values = non_null.astype('float64')
+                if float_values.min() >= -1e308 and float_values.max() <= 1e308:
+                    return "FLOAT"
+                else:
+                    return "TEXT"
+            except (ValueError, OverflowError):
+                return "TEXT"
+        elif pd.api.types.is_datetime64_any_dtype(dtype):
+            return "DATETIME"
+        elif pd.api.types.is_bool_dtype(dtype):
+            return "BOOLEAN"
+        else:
+            return "TEXT"
+
+    def _create_table_model(
+        self,
+        table_name: str,
+        columns: List[str],
+        column_types: Dict[str, str]
+    ) -> type:
+        """
+        动态创建 SQLAlchemy 模型类
+
+        Args:
+            table_name: 表名
+            columns: 列名列表
+            column_types: 列类型字典
+
+        Returns:
+            SQLAlchemy 模型类
+        """
+        # 创建属性字典
+        attrs = {
+            '__tablename__': table_name,
+            '__table_args__': {'extend_existing': True},
+        }
+
+        # 添加主键列
+        attrs['id'] = Column(Integer, primary_key=True, autoincrement=True)
+
+        # 添加数据列
+        for col in columns:
+            col_name = self._sanitize_column_name(col)
+            col_type = column_types.get(col, "TEXT")
+
+            if col_type == "INTEGER":
+                attrs[col_name] = Column(Integer, nullable=True)
+            elif col_type == "FLOAT":
+                attrs[col_name] = Column(Float, nullable=True)
+            elif col_type == "DATETIME":
+                attrs[col_name] = Column(DateTime, nullable=True)
+            elif col_type == "BOOLEAN":
+                attrs[col_name] = Column(Integer, nullable=True)  # MySQL 没有原生 BOOLEAN
+            else:
+                attrs[col_name] = Column(Text, nullable=True)
+
+        # 添加元数据列
+        attrs['created_at'] = Column(DateTime, default=datetime.utcnow)
+        attrs['updated_at'] = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+        # 创建类
+        return type(table_name, (Base,), attrs)
+
+    async def store_excel(
+        self,
+        file_path: str,
+        filename: str,
+        sheet_name: Optional[str] = None,
+        header_row: int = 0
+    ) -> Dict[str, Any]:
+        """
+        将 Excel 文件存储到 MySQL
+
+        Args:
+            file_path: Excel 文件路径
+            filename: 原始文件名
+            sheet_name: 工作表名称
+            header_row: 表头行号
+
+        Returns:
+            存储结果
+        """
+        table_name = self._sanitize_table_name(filename)
+        results = {
+            "success": True,
+            "table_name": table_name,
+            "row_count": 0,
+            "columns": []
+        }
+
+        try:
+            logger.info(f"开始读取Excel文件: {file_path}")
+            # 读取 Excel（使用 fallback 方式支持特殊格式文件）
+            df = self._read_excel_sheet(file_path, sheet_name=sheet_name, header_row=header_row)
+
+            logger.info(f"Excel读取完成，行数: {len(df)}, 列数: {len(df.columns)}")
+
+            if df.empty:
+                return {"success": False, "error": "Excel 文件为空"}
+
+            # 清理列名
+            df.columns = [str(c) for c in df.columns]
+
+            # 推断列类型，并生成唯一的列名
+            column_types = {}
+            column_name_map = {}  # 原始列名 -> 唯一合法列名
+            used_names = set()
+            for col in df.columns:
+                col_name = self._get_unique_column_name(col, used_names)
+                col_type = self._infer_column_type(df[col])
+                column_types[col] = col_type
+                column_name_map[col] = col_name
+                results["columns"].append({
+                    "original_name": col,
+                    "sanitized_name": col_name,
+                    "type": col_type
+                })
+
+            # 创建表 - 使用原始 SQL 以兼容异步
+            logger.info(f"正在创建MySQL表: {table_name}")
+            sql_columns = ["id INT AUTO_INCREMENT PRIMARY KEY"]
+            for col in df.columns:
+                col_name = column_name_map[col]
+                col_type = column_types.get(col, "TEXT")
+                sql_type = "INT" if col_type == "INTEGER" else "FLOAT" if col_type == "FLOAT" else "DATETIME" if col_type == "DATETIME" else "TEXT"
+                sql_columns.append(f"`{col_name}` {sql_type}")
+            sql_columns.append("created_at DATETIME DEFAULT CURRENT_TIMESTAMP")
+            sql_columns.append("updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP")
+            create_sql = text(f"CREATE TABLE IF NOT EXISTS `{table_name}` ({', '.join(sql_columns)})")
+            await self.mysql_db.execute_raw_sql(str(create_sql))
+            logger.info(f"MySQL表创建完成: {table_name}")
+
+            # 插入数据
+            records = []
+            for _, row in df.iterrows():
+                record = {}
+                for col in df.columns:
+                    col_name = column_name_map[col]
+                    value = row[col]
+
+                    # 处理 NaN 值
+                    if pd.isna(value):
+                        record[col_name] = None
+                    elif column_types[col] == "INTEGER":
+                        try:
+                            record[col_name] = int(value)
+                        except (ValueError, TypeError):
+                            record[col_name] = None
+                    elif column_types[col] == "FLOAT":
+                        try:
+                            record[col_name] = float(value)
+                        except (ValueError, TypeError):
+                            record[col_name] = None
+                    else:
+                        record[col_name] = str(value)
+
+                records.append(record)
+
+            logger.info(f"正在插入 {len(records)} 条数据到 MySQL (使用批量插入)...")
+            # 使用 pymysql 直接插入以避免 SQLAlchemy 异步问题
+            import pymysql
+            from app.config import settings
+
+            connection = pymysql.connect(
+                host=settings.MYSQL_HOST,
+                port=settings.MYSQL_PORT,
+                user=settings.MYSQL_USER,
+                password=settings.MYSQL_PASSWORD,
+                database=settings.MYSQL_DATABASE,
+                charset=settings.MYSQL_CHARSET
+            )
+            try:
+                columns_str = ', '.join(['`' + column_name_map[col] + '`' for col in df.columns])
+                placeholders = ', '.join(['%s' for _ in df.columns])
+                insert_sql = f"INSERT INTO `{table_name}` ({columns_str}) VALUES ({placeholders})"
+
+                # 转换为元组列表 (使用映射后的列名)
+                param_list = [tuple(record.get(column_name_map[col]) for col in df.columns) for record in records]
+
+                with connection.cursor() as cursor:
+                    cursor.executemany(insert_sql, param_list)
+                    connection.commit()
+                logger.info(f"数据插入完成: {len(records)} 条")
+            finally:
+                connection.close()
+
+            results["row_count"] = len(records)
+            logger.info(f"Excel 数据已存储到 MySQL 表 {table_name}，共 {len(records)} 行")
+
+            return results
+
+        except Exception as e:
+            logger.error(f"存储 Excel 到 MySQL 失败: {str(e)}", exc_info=True)
+            return {"success": False, "error": str(e)}
+
+    async def store_structured_data(
+        self,
+        table_name: str,
+        data: Dict[str, Any],
+        source_doc_id: str = None
+    ) -> Dict[str, Any]:
+        """
+        将结构化数据（从非结构化文档提取的表格）存储到 MySQL
+
+        Args:
+            table_name: 表名
+            data: 结构化数据，格式为:
+                {
+                    "columns": ["col1", "col2"],  # 列名
+                    "rows": [["val1", "val2"], ["val3", "val4"]]  # 数据行
+                }
+            source_doc_id: 源文档 ID
+
+        Returns:
+            存储结果
+        """
+        results = {
+            "success": True,
+            "table_name": table_name,
+            "row_count": 0,
+            "columns": []
+        }
+
+        try:
+            columns = data.get("columns", [])
+            rows = data.get("rows", [])
+
+            if not columns or not rows:
+                return {"success": False, "error": "数据为空"}
+
+            # 清理列名
+            sanitized_columns = [self._sanitize_column_name(c) for c in columns]
+
+            # 推断列类型
+            column_types = {}
+            for i, col in enumerate(columns):
+                col_values = [row[i] for row in rows if i < len(row)]
+                # 根据数据推断类型
+                col_type = self._infer_type_from_values(col_values)
+                column_types[col] = col_type
+                results["columns"].append({
+                    "original_name": col,
+                    "sanitized_name": self._sanitize_column_name(col),
+                    "type": col_type
+                })
+
+            # 创建表
+            model_class = self._create_table_model(table_name, columns, column_types)
+
+            # 创建表结构
+            async with self.mysql_db.get_session() as session:
+                model_class.__table__.create(session.bind, checkfirst=True)
+
+            # 插入数据
+            records = []
+            for row in rows:
+                record = {}
+                for i, col in enumerate(columns):
+                    if i >= len(row):
+                        continue
+                    col_name = self._sanitize_column_name(col)
+                    value = row[i]
+                    col_type = column_types.get(col, "TEXT")
+
+                    # 处理空值
+                    if value is None or str(value).strip() == '':
+                        record[col_name] = None
+                    elif col_type == "INTEGER":
+                        try:
+                            record[col_name] = int(value)
+                        except (ValueError, TypeError):
+                            record[col_name] = None
+                    elif col_type == "FLOAT":
+                        try:
+                            record[col_name] = float(value)
+                        except (ValueError, TypeError):
+                            record[col_name] = None
+                    else:
+                        record[col_name] = str(value)
+
+                records.append(record)
+
+            # 批量插入
+            async with self.mysql_db.get_session() as session:
+                for record in records:
+                    session.add(model_class(**record))
+                await session.commit()
+
+            results["row_count"] = len(records)
+            logger.info(f"结构化数据已存储到 MySQL 表 {table_name}，共 {len(records)} 行")
+
+            return results
+
+        except Exception as e:
+            logger.error(f"存储结构化数据到 MySQL 失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    def _infer_type_from_values(self, values: List[Any]) -> str:
+        """
+        根据值列表推断列类型
+
+        Args:
+            values: 值列表
+
+        Returns:
+            类型名称
+        """
+        non_null_values = [v for v in values if v is not None and str(v).strip() != '']
+        if not non_null_values:
+            return "TEXT"
+
+        # 检查是否全是整数
+        is_integer = all(self._is_integer(v) for v in non_null_values)
+        if is_integer:
+            return "INTEGER"
+
+        # 检查是否全是浮点数
+        is_float = all(self._is_float(v) for v in non_null_values)
+        if is_float:
+            return "FLOAT"
+
+        return "TEXT"
+
+    def _is_integer(self, value: Any) -> bool:
+        """判断值是否可以转为整数"""
+        try:
+            int(value)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    def _is_float(self, value: Any) -> bool:
+        """判断值是否可以转为浮点数"""
+        try:
+            float(value)
+            return True
+        except (ValueError, TypeError):
+            return False
+
+    async def query_table(
+        self,
+        table_name: str,
+        columns: Optional[List[str]] = None,
+        where: Optional[str] = None,
+        limit: int = 100
+    ) -> List[Dict[str, Any]]:
+        """
+        查询 MySQL 表数据
+
+        Args:
+            table_name: 表名
+            columns: 要查询的列
+            where: WHERE 条件
+            limit: 限制返回行数
+
+        Returns:
+            查询结果
+        """
+        try:
+            # 构建查询
+            sql = f"SELECT * FROM `{table_name}`"
+            if where:
+                sql += f" WHERE {where}"
+            sql += f" LIMIT {limit}"
+
+            results = await self.mysql_db.execute_query(sql)
+            return results
+
+        except Exception as e:
+            logger.error(f"查询表失败: {str(e)}")
+            return []
+
+    async def get_table_schema(self, table_name: str) -> Optional[Dict[str, Any]]:
+        """
+        获取表结构信息
+
+        Args:
+            table_name: 表名
+
+        Returns:
+            表结构信息
+        """
+        try:
+            sql = f"""
+                SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_KEY, COLUMN_COMMENT
+                FROM INFORMATION_SCHEMA.COLUMNS
+                WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = '{table_name}'
+                ORDER BY ORDINAL_POSITION
+            """
+            results = await self.mysql_db.execute_query(sql)
+            return results
+
+        except Exception as e:
+            logger.error(f"获取表结构失败: {str(e)}")
+            return None
+
+    async def delete_table(self, table_name: str) -> bool:
+        """
+        删除表
+
+        Args:
+            table_name: 表名
+
+        Returns:
+            是否成功
+        """
+        try:
+            # 安全检查：表名必须包含下划线（避免删除系统表）
+            if '_' not in table_name and not table_name.startswith('t_'):
+                raise ValueError("不允许删除此表")
+
+            sql = f"DROP TABLE IF EXISTS `{table_name}`"
+            await self.mysql_db.execute_raw_sql(sql)
+            logger.info(f"表 {table_name} 已删除")
+            return True
+
+        except Exception as e:
+            logger.error(f"删除表失败: {str(e)}")
+            return False
+
+    async def list_tables(self) -> List[str]:
+        """
+        列出所有用户表
+
+        Returns:
+            表名列表
+        """
+        try:
+            sql = """
+                SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES
+                WHERE TABLE_SCHEMA = DATABASE() AND TABLE_TYPE = 'BASE TABLE'
+            """
+            results = await self.mysql_db.execute_query(sql)
+            return [r['TABLE_NAME'] for r in results]
+
+        except Exception as e:
+            logger.error(f"列出表失败: {str(e)}")
+            return []
+
+
+# ==================== 全局单例 ====================
+
+excel_storage_service = ExcelStorageService()

backend/app/services/file_service.py

@@ -3,6 +3,7 @@
 """
 import os
 import shutil
+import logging
 from pathlib import Path
 from datetime import datetime
 from typing import Optional
@@ -10,6 +11,8 @@ import uuid
 
 from app.config import settings
 
+logger = logging.getLogger(__name__)
+
 
 class FileService:
     """文件服务类，负责文件的存储、读取和管理"""
@@ -17,6 +20,7 @@ class FileService:
     def __init__(self):
         self.upload_dir = Path(settings.UPLOAD_DIR)
         self._ensure_upload_dir()
+        logger.info(f"FileService 初始化，上传目录: {self.upload_dir}")
 
     def _ensure_upload_dir(self):
         """确保上传目录存在"""
@@ -56,6 +60,8 @@ class FileService:
         with open(file_path, 'wb') as f:
             f.write(file_content)
 
+        file_size = len(file_content)
+        logger.info(f"文件已保存: {filename} -> {file_path} ({file_size} bytes)")
         return str(file_path)
 
     def read_file(self, file_path: str) -> bytes:

backend/app/services/llm_service.py

@@ -2,7 +2,7 @@
 LLM 服务模块 - 封装大模型 API 调用
 """
 import logging
-from typing import Dict, Any, List, Optional
+from typing import Dict, Any, List, Optional, AsyncGenerator
 import httpx
 
 from app.config import settings
@@ -65,7 +65,17 @@ class LLMService:
                 return response.json()
 
         except httpx.HTTPStatusError as e:
-            logger.error(f"LLM API 请求失败: {e.response.status_code} - {e.response.text}")
+            error_detail = e.response.text
+            logger.error(f"LLM API 请求失败: {e.response.status_code} - {error_detail}")
+            # 尝试解析错误信息
+            try:
+                import json
+                err_json = json.loads(error_detail)
+                err_code = err_json.get("error", {}).get("code", "unknown")
+                err_msg = err_json.get("error", {}).get("message", "unknown")
+                logger.error(f"API 错误码: {err_code}, 错误信息: {err_msg}")
+            except:
+                pass
             raise
         except Exception as e:
             logger.error(f"LLM API 调用异常: {str(e)}")
@@ -87,6 +97,71 @@ class LLMService:
             logger.error(f"解析 API 响应失败: {str(e)}")
             raise
 
+    async def chat_stream(
+        self,
+        messages: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> AsyncGenerator[Dict[str, Any], None]:
+        """
+        流式调用聊天 API
+
+        Args:
+            messages: 消息列表
+            temperature: 温度参数
+            max_tokens: 最大 token 数
+            **kwargs: 其他参数
+
+        Yields:
+            Dict[str, Any]: 包含 delta 内容的块
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "temperature": temperature,
+            "stream": True
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        payload.update(kwargs)
+
+        try:
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                async with client.stream(
+                    "POST",
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=payload
+                ) as response:
+                    async for line in response.aiter_lines():
+                        if line.startswith("data: "):
+                            data = line[6:]  # Remove "data: " prefix
+                            if data == "[DONE]":
+                                break
+                            try:
+                                import json as json_module
+                                chunk = json_module.loads(data)
+                                delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
+                                if delta:
+                                    yield {"content": delta}
+                            except json_module.JSONDecodeError:
+                                continue
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"LLM 流式 API 请求失败: {e.response.status_code}")
+            raise
+        except Exception as e:
+            logger.error(f"LLM 流式 API 调用异常: {str(e)}")
+            raise
+
     async def analyze_excel_data(
         self,
         excel_data: Dict[str, Any],
@@ -263,6 +338,154 @@ Excel 数据概览:
                 "analysis": None
             }
 
+    async def chat_with_images(
+        self,
+        text: str,
+        images: List[Dict[str, str]],
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None
+    ) -> Dict[str, Any]:
+        """
+        调用视觉模型 API（支持图片输入）
+
+        Args:
+            text: 文本内容
+            images: 图片列表，每项包含 base64 编码和 mime_type
+                   格式: [{"base64": "...", "mime_type": "image/png"}, ...]
+            temperature: 温度参数
+            max_tokens: 最大 token 数
+
+        Returns:
+            Dict[str, Any]: API 响应结果
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        # 构建图片内容
+        image_contents = []
+        for img in images:
+            image_contents.append({
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{img['mime_type']};base64,{img['base64']}"
+                }
+            })
+
+        # 构建消息
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": text
+                    },
+                    *image_contents
+                ]
+            }
+        ]
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            "temperature": temperature
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        try:
+            async with httpx.AsyncClient(timeout=120.0) as client:
+                response = await client.post(
+                    f"{self.base_url}/chat/completions",
+                    headers=headers,
+                    json=payload
+                )
+                response.raise_for_status()
+                return response.json()
+
+        except httpx.HTTPStatusError as e:
+            error_detail = e.response.text
+            logger.error(f"视觉模型 API 请求失败: {e.response.status_code} - {error_detail}")
+            # 尝试解析错误信息
+            try:
+                import json
+                err_json = json.loads(error_detail)
+                err_code = err_json.get("error", {}).get("code", "unknown")
+                err_msg = err_json.get("error", {}).get("message", "unknown")
+                logger.error(f"API 错误码: {err_code}, 错误信息: {err_msg}")
+                logger.error(f"请求模型: {self.model_name}, base_url: {self.base_url}")
+            except:
+                pass
+            raise
+        except Exception as e:
+            logger.error(f"视觉模型 API 调用异常: {str(e)}")
+            raise
+
+    async def analyze_images(
+        self,
+        images: List[Dict[str, str]],
+        user_prompt: str = ""
+    ) -> Dict[str, Any]:
+        """
+        分析图片内容（使用视觉模型）
+
+        Args:
+            images: 图片列表，每项包含 base64 编码和 mime_type
+            user_prompt: 用户提示词
+
+        Returns:
+            Dict[str, Any]: 分析结果
+        """
+        prompt = f"""你是一个专业的视觉分析专家。请分析以下图片内容。
+
+{user_prompt if user_prompt else "请详细描述图片中的内容，包括文字、数据、图表、流程等所有可见信息。"}
+
+请按照以下 JSON 格式输出：
+{{
+    "description": "图片内容的详细描述",
+    "text_content": "图片中的文字内容（如有）",
+    "data_extracted": {{"键": "值"}}  // 如果图片中有表格或数据
+}}
+
+如果图片不包含有用信息，请返回空的描述。"""
+
+        try:
+            response = await self.chat_with_images(
+                text=prompt,
+                images=images,
+                temperature=0.1,
+                max_tokens=4000
+            )
+
+            content = self.extract_message_content(response)
+
+            # 解析 JSON
+            import json
+            try:
+                result = json.loads(content)
+                return {
+                    "success": True,
+                    "analysis": result,
+                    "model": self.model_name
+                }
+            except json.JSONDecodeError:
+                return {
+                    "success": True,
+                    "analysis": {"description": content},
+                    "model": self.model_name
+                }
+
+        except Exception as e:
+            logger.error(f"图片分析失败: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "analysis": None
+            }
+
 
 # 全局单例
 llm_service = LLMService()

backend/app/services/markdown_ai_service.py

@@ -0,0 +1,707 @@
+"""
+Markdown 文档 AI 分析服务
+
+支持：
+- 分章节解析（中文章节编号：一、二、三， （一）（二）（三））
+- 结构化数据提取
+- 流式输出
+- 多种分析类型
+- 可视化图表生成
+"""
+import asyncio
+import json
+import logging
+import re
+from typing import Any, AsyncGenerator, Dict, List, Optional
+
+from app.services.llm_service import llm_service
+from app.core.document_parser import MarkdownParser
+from app.services.visualization_service import visualization_service
+
+logger = logging.getLogger(__name__)
+
+
+class MarkdownSection:
+    """文档章节结构"""
+    def __init__(self, number: str, title: str, level: int, content: str, line_start: int, line_end: int):
+        self.number = number  # 章节编号，如 "一", "（一）", "1"
+        self.title = title
+        self.level = level  # 层级深度
+        self.content = content  # 章节内容（不含子章节）
+        self.line_start = line_start
+        self.line_end = line_end
+        self.subsections: List[MarkdownSection] = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "number": self.number,
+            "title": self.title,
+            "level": self.level,
+            "content_preview": self.content[:200] + "..." if len(self.content) > 200 else self.content,
+            "line_start": self.line_start,
+            "line_end": self.line_end,
+            "subsections": [s.to_dict() for s in self.subsections]
+        }
+
+
+class MarkdownAIService:
+    """Markdown 文档 AI 分析服务"""
+
+    # 中文章节编号模式
+    CHINESE_NUMBERS = ["一", "二", "三", "四", "五", "六", "七", "八", "九", "十"]
+    CHINESE_SUFFIX = "、"
+    PARENTHESIS_PATTERN = re.compile(r'^（([一二三四五六七八九十]+)\s*(.+)$')
+    CHINESE_SECTION_PATTERN = re.compile(r'^([一二三四五六七八九十]+)、\s*(.+)$')
+    ARABIC_SECTION_PATTERN = re.compile(r'^(\d+)\.\s+(.+)$')
+
+    def __init__(self):
+        self.parser = MarkdownParser()
+
+    def get_supported_analysis_types(self) -> list:
+        """获取支持的分析类型"""
+        return [
+            "summary",      # 文档摘要
+            "outline",      # 大纲提取
+            "key_points",   # 关键点提取
+            "questions",    # 生成问题
+            "tags",         # 生成标签
+            "qa",           # 问答对
+            "statistics",   # 统计数据分析（适合政府公报）
+            "section",      # 分章节详细分析
+            "charts"        # 可视化图表生成
+        ]
+
+    def extract_sections(self, content: str, titles: List[Dict]) -> List[MarkdownSection]:
+        """
+        从文档内容中提取章节结构
+
+        识别以下章节格式：
+        - 一级：一、二、三...
+        - 二级：（一）（二）（三）...
+        - 三级：1. 2. 3. ...
+        """
+        sections = []
+        lines = content.split('\n')
+
+        # 构建标题行到内容的映射
+        title_lines = {}
+        for t in titles:
+            title_lines[t.get('line', 0)] = t
+
+        current_section = None
+        section_stack = []
+
+        for i, line in enumerate(lines, 1):
+            stripped = line.strip()
+
+            # 检查是否是一级标题（中文数字 + 、）
+            match = self.CHINESE_SECTION_PATTERN.match(stripped)
+            if match:
+                # 结束当前章节
+                if current_section:
+                    current_section.content = self._get_section_content(
+                        lines, current_section.line_start, i - 1
+                    )
+
+                current_section = MarkdownSection(
+                    number=match.group(1),
+                    title=match.group(2),
+                    level=1,
+                    content="",
+                    line_start=i,
+                    line_end=len(lines)
+                )
+                sections.append(current_section)
+                section_stack = [current_section]
+                continue
+
+            # 检查是否是二级标题（（一）（二）...）
+            match = self.PARENTHESIS_PATTERN.match(stripped)
+            if match and current_section:
+                # 结束当前子章节
+                if section_stack and len(section_stack) > 1:
+                    parent = section_stack[-1]
+                    parent.content = self._get_section_content(
+                        lines, parent.line_start, i - 1
+                    )
+
+                subsection = MarkdownSection(
+                    number=match.group(1),
+                    title=match.group(2),
+                    level=2,
+                    content="",
+                    line_start=i,
+                    line_end=len(lines)
+                )
+                current_section.subsections.append(subsection)
+                section_stack = [current_section, subsection]
+                continue
+
+            # 检查是否是三级标题（1. 2. 3.）
+            match = self.ARABIC_SECTION_PATTERN.match(stripped)
+            if match and len(section_stack) > 1:
+                # 结束当前子章节
+                if len(section_stack) > 2:
+                    parent = section_stack[-1]
+                    parent.content = self._get_section_content(
+                        lines, parent.line_start, i - 1
+                    )
+
+                sub_subsection = MarkdownSection(
+                    number=match.group(1),
+                    title=match.group(2),
+                    level=3,
+                    content="",
+                    line_start=i,
+                    line_end=len(lines)
+                )
+                section_stack[-1].subsections.append(sub_subsection)
+                section_stack = section_stack[:-1] + [sub_subsection]
+                continue
+
+        # 处理最后一个章节
+        if current_section:
+            current_section.content = self._get_section_content(
+                lines, current_section.line_start, len(lines)
+            )
+
+        return sections
+
+    def _get_section_content(self, lines: List[str], start: int, end: int) -> str:
+        """获取指定行范围的内容"""
+        if start > end:
+            return ""
+        content_lines = lines[start-1:end]
+        # 清理：移除标题行和空行
+        cleaned = []
+        for line in content_lines:
+            stripped = line.strip()
+            if not stripped:
+                continue
+            # 跳过章节标题行
+            if self.CHINESE_SECTION_PATTERN.match(stripped):
+                continue
+            if self.PARENTHESIS_PATTERN.match(stripped):
+                continue
+            if self.ARABIC_SECTION_PATTERN.match(stripped):
+                continue
+            cleaned.append(stripped)
+        return '\n'.join(cleaned)
+
+    async def analyze_markdown(
+        self,
+        file_path: str,
+        analysis_type: str = "summary",
+        user_prompt: str = "",
+        section_number: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        使用 AI 分析 Markdown 文档
+
+        Args:
+            file_path: 文件路径
+            analysis_type: 分析类型
+            user_prompt: 用户自定义提示词
+            section_number: 指定分析的章节编号（如 "一" 或 "（一）"）
+
+        Returns:
+            dict: 分析结果
+        """
+        try:
+            parse_result = self.parser.parse(file_path)
+
+            if not parse_result.success:
+                return {
+                    "success": False,
+                    "error": parse_result.error
+                }
+
+            data = parse_result.data
+
+            # 提取章节结构
+            sections = self.extract_sections(data.get("content", ""), data.get("titles", []))
+
+            # 如果指定了章节，只分析该章节
+            target_content = data.get("content", "")
+            target_title = parse_result.metadata.get("filename", "")
+
+            if section_number:
+                section = self._find_section(sections, section_number)
+                if section:
+                    target_content = section.content
+                    target_title = f"{section.number}、{section.title}"
+                else:
+                    return {
+                        "success": False,
+                        "error": f"未找到章节: {section_number}"
+                    }
+
+            # 根据分析类型构建提示词
+            prompt = self._build_prompt(
+                content=target_content,
+                analysis_type=analysis_type,
+                user_prompt=user_prompt,
+                title=target_title
+            )
+
+            # 调用 LLM 分析
+            messages = [
+                {"role": "system", "content": self._get_system_prompt(analysis_type)},
+                {"role": "user", "content": prompt}
+            ]
+
+            response = await llm_service.chat(
+                messages=messages,
+                temperature=0.3,
+                max_tokens=4000
+            )
+
+            analysis = llm_service.extract_message_content(response)
+
+            # 构建基础返回
+            result = {
+                "success": True,
+                "filename": parse_result.metadata.get("filename", ""),
+                "analysis_type": analysis_type,
+                "section": target_title if section_number else None,
+                "word_count": len(target_content),
+                "structure": {
+                    "title_count": parse_result.metadata.get("title_count", 0),
+                    "code_block_count": parse_result.metadata.get("code_block_count", 0),
+                    "table_count": parse_result.metadata.get("table_count", 0),
+                    "section_count": len(sections)
+                },
+                "sections": [s.to_dict() for s in sections[:10]],  # 最多返回10个一级章节
+                "analysis": analysis
+            }
+
+            # 如果是 charts 类型，额外生成可视化
+            if analysis_type == "charts":
+                try:
+                    # 解析 LLM 返回的 JSON 数据
+                    chart_data = self._parse_chart_json(analysis)
+                    if chart_data and chart_data.get("tables"):
+                        # 使用可视化服务生成图表
+                        for table_info in chart_data.get("tables", []):
+                            columns = table_info.get("columns", [])
+                            rows = table_info.get("rows", [])
+                            if columns and rows:
+                                vis_result = visualization_service.analyze_and_visualize({
+                                    "columns": columns,
+                                    "rows": [dict(zip(columns, row)) for row in rows]
+                                })
+                                if vis_result.get("success"):
+                                    table_info["visualization"] = {
+                                        "statistics": vis_result.get("statistics"),
+                                        "charts": vis_result.get("charts"),
+                                        "distributions": vis_result.get("distributions")
+                                    }
+                    result["chart_data"] = chart_data
+                except Exception as e:
+                    logger.warning(f"生成可视化图表失败: {e}")
+                    result["chart_data"] = {"tables": [], "key_statistics": [], "chart_suggestions": []}
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Markdown AI 分析失败: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def analyze_markdown_stream(
+        self,
+        file_path: str,
+        analysis_type: str = "summary",
+        user_prompt: str = "",
+        section_number: Optional[str] = None
+    ) -> AsyncGenerator[str, None]:
+        """
+        流式分析 Markdown 文档 (SSE)
+
+        Yields:
+            str: SSE 格式的数据块
+        """
+        try:
+            parse_result = self.parser.parse(file_path)
+
+            if not parse_result.success:
+                yield f"data: {json.dumps({'error': parse_result.error}, ensure_ascii=False)}\n\n"
+                return
+
+            data = parse_result.data
+            sections = self.extract_sections(data.get("content", ""), data.get("titles", []))
+
+            target_content = data.get("content", "")
+            target_title = parse_result.metadata.get("filename", "")
+
+            if section_number:
+                section = self._find_section(sections, section_number)
+                if section:
+                    target_content = section.content
+                    target_title = f"{section.number}、{section.title}"
+                else:
+                    yield f"data: {json.dumps({'error': f'未找到章节: {section_number}'}, ensure_ascii=False)}\n\n"
+                    return
+
+            prompt = self._build_prompt(
+                content=target_content,
+                analysis_type=analysis_type,
+                user_prompt=user_prompt,
+                title=target_title
+            )
+
+            messages = [
+                {"role": "system", "content": self._get_system_prompt(analysis_type)},
+                {"role": "user", "content": prompt}
+            ]
+
+            # 发送初始元数据
+            yield f"data: {json.dumps({
+                'type': 'start',
+                'filename': parse_result.metadata.get("filename", ""),
+                'analysis_type': analysis_type,
+                'section': target_title if section_number else None,
+                'word_count': len(target_content)
+            }, ensure_ascii=False)}\n\n"
+
+            # 流式调用 LLM
+            full_response = ""
+            async for chunk in llm_service.chat_stream(messages, temperature=0.3, max_tokens=4000):
+                content = chunk.get("content", "")
+                if content:
+                    full_response += content
+                    yield f"data: {json.dumps({'type': 'content', 'delta': content}, ensure_ascii=False)}\n\n"
+
+            # 发送完成消息
+            yield f"data: {json.dumps({'type': 'done', 'full_response': full_response}, ensure_ascii=False)}\n\n"
+
+        except Exception as e:
+            logger.error(f"Markdown AI 流式分析失败: {str(e)}")
+            yield f"data: {json.dumps({'error': str(e)}, ensure_ascii=False)}\n\n"
+
+    def _find_section(self, sections: List[MarkdownSection], number: str) -> Optional[MarkdownSection]:
+        """查找指定编号的章节"""
+        # 标准化编号
+        num = number.strip()
+        for section in sections:
+            if section.number == num or section.title == num:
+                return section
+            # 在子章节中查找
+            found = self._find_section(section.subsections, number)
+            if found:
+                return found
+        return None
+
+    def _parse_chart_json(self, json_str: str) -> Optional[Dict[str, Any]]:
+        """
+        解析 LLM 返回的 JSON 字符串
+
+        Args:
+            json_str: LLM 返回的 JSON 字符串
+
+        Returns:
+            解析后的字典，如果解析失败返回 None
+        """
+        if not json_str:
+            return None
+
+        try:
+            # 尝试直接解析
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            pass
+
+        # 尝试提取 JSON 代码块
+        import re
+        # 匹配 ```json ... ``` 格式
+        match = re.search(r'```(?:json)?\s*([\s\S]*?)\s*```', json_str)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                pass
+
+        # 尝试找到 JSON 对象的开始和结束
+        start = json_str.find('{')
+        end = json_str.rfind('}')
+        if start != -1 and end != -1 and end > start:
+            try:
+                return json.loads(json_str[start:end+1])
+            except json.JSONDecodeError:
+                pass
+
+        return None
+
+    def _get_system_prompt(self, analysis_type: str) -> str:
+        """根据分析类型获取系统提示词"""
+        prompts = {
+            "summary": "你是一个专业的文档摘要助手，擅长从长文档中提取核心信息。",
+            "outline": "你是一个专业的文档结构分析助手，擅长提取文档大纲和层级结构。",
+            "key_points": "你是一个专业的知识提取助手，擅长从文档中提取关键信息和要点。",
+            "questions": "你是一个专业的教育助手，擅长生成帮助理解文档的问题。",
+            "tags": "你是一个专业的标签生成助手，擅长提取文档的主题标签。",
+            "qa": "你是一个专业的问答助手，擅长基于文档内容生成问答对。",
+            "statistics": "你是一个专业的统计数据分析助手，擅长分析政府统计公报中的数据。",
+            "section": "你是一个专业的章节分析助手，擅长对文档的特定章节进行深入分析。",
+            "charts": "你是一个专业的数据可视化助手，擅长从文档中提取数据并生成适合制作图表的数据结构。"
+        }
+        return prompts.get(analysis_type, "你是一个专业的文档分析助手。")
+
+    def _build_prompt(
+        self,
+        content: str,
+        analysis_type: str,
+        user_prompt: str,
+        title: str = ""
+    ) -> str:
+        """根据分析类型构建提示词"""
+
+        # 截断内容避免超出 token 限制
+        max_content_len = 6000
+        if len(content) > max_content_len:
+            content = content[:max_content_len] + "\n\n[内容已截断...]"
+
+        base_prompts = {
+            "summary": f"""请对以下文档进行摘要分析：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请提供：
+1. 文档主要内容摘要（300字以内）
+2. 文档的目的和用途
+3. 适合的读者群体
+
+请用中文回答，结构清晰。""",
+
+            "outline": f"""请提取以下文档的大纲结构：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请按层级列出文档大纲，用缩进表示层级关系。
+格式：
+一、一级标题
+   （一）二级标题
+      1. 三级标题
+
+请用中文回答。""",
+
+            "key_points": f"""请从以下文档中提取关键要点：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请列出文档的关键要点（5-10条），每条用简洁的语言描述，并说明其在文档中的重要性。
+
+请用中文回答，格式清晰。""",
+
+            "questions": f"""请根据以下文档生成有助于理解内容的问题：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请生成5-10个问题，帮助读者更好地理解文档内容。每个问题应该：
+1. 涵盖文档的重要信息点
+2. 易于理解和回答
+3. 具有思考价值
+
+请用中文回答。""",
+
+            "tags": f"""请为以下文档生成标签：
+
+文档标题：{title}
+
+文档内容：
+{content[:3000]}
+
+请生成5-8个标签，用逗号分隔。标签应该反映：
+- 文档的主题领域
+- 文档的类型
+- 文档的关键特征
+
+请用中文回答，只需输出标签，不要其他内容。""",
+
+            "qa": f"""请根据以下文档生成问答对：
+
+文档标题：{title}
+
+文档内容：
+{content[:4000]}
+
+请生成3-5个问答对，帮助读者通过问答形式理解文档内容。
+格式：
+Q1: 问题
+A1: 回答
+Q2: 问题
+A2: 回答
+
+请用中文回答，内容准确。""",
+
+            "statistics": f"""请分析以下政府统计公报中的数据和结论：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请提供：
+1. 文档中涉及的主要统计数据（列出关键数字和指标）
+2. 数据的变化趋势（增长/下降）
+3. 重要的百分比和对比
+4. 数据来源和统计口径说明
+
+请用中文回答，数据准确。""",
+
+            "section": f"""请详细分析以下文档章节：
+
+章节标题：{title}
+
+章节内容：
+{content}
+
+请提供：
+1. 章节主要内容概括
+2. 关键信息和数据
+3. 与其他部分的关联（如有）
+4. 重要结论
+
+请用中文回答，分析深入。""",
+
+            "charts": f"""请从以下文档中提取可用于可视化的数据，并生成适合制作图表的数据结构：
+
+文档标题：{title}
+
+文档内容：
+{content}
+
+请完成以下任务：
+1. 识别文档中的表格数据（Markdown表格格式）
+2. 识别文档中的关键统计数据（百分比、数量、趋势等）
+3. 识别可用于比较的分类数据
+
+请用 JSON 格式返回以下结构的数据（如果没有表格数据，返回空结构）：
+{{
+  "tables": [
+    {{
+      "description": "表格的描述",
+      "columns": ["列名1", "列名2", ...],
+      "rows": [
+        ["值1", "值2", ...],
+        ["值1", "值2", ...]
+      ]
+    }}
+  ],
+  "key_statistics": [
+    {{
+      "name": "指标名称",
+      "value": "数值",
+      "trend": "增长/下降/持平",
+      "description": "指标说明"
+    }}
+  ],
+  "chart_suggestions": [
+    {{
+      "chart_type": "bar/line/pie",
+      "title": "图表标题",
+      "data_source": "数据来源说明"
+    }}
+  ]
+}}
+
+请确保返回的是合法的 JSON 格式。"""
+        }
+
+        prompt = base_prompts.get(analysis_type, base_prompts["summary"])
+
+        if user_prompt and user_prompt.strip():
+            prompt += f"\n\n用户额外需求：{user_prompt}"
+
+        return prompt
+
+    async def extract_outline(self, file_path: str) -> Dict[str, Any]:
+        """提取文档大纲"""
+        try:
+            parse_result = self.parser.parse(file_path)
+
+            if not parse_result.success:
+                return {"success": False, "error": parse_result.error}
+
+            data = parse_result.data
+            sections = self.extract_sections(data.get("content", ""), data.get("titles", []))
+
+            # 构建结构化大纲
+            outline = []
+            for section in sections:
+                outline.append({
+                    "number": section.number,
+                    "title": section.title,
+                    "level": section.level,
+                    "line": section.line_start,
+                    "content_preview": section.content[:100] + "..." if len(section.content) > 100 else section.content,
+                    "subsections": [{
+                        "number": s.number,
+                        "title": s.title,
+                        "level": s.level,
+                        "line": s.line_start
+                    } for s in section.subsections]
+                })
+
+            return {
+                "success": True,
+                "outline": outline
+            }
+
+        except Exception as e:
+            logger.error(f"大纲提取失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    async def extract_tables_summary(self, file_path: str) -> Dict[str, Any]:
+        """提取并总结文档中的表格"""
+        try:
+            parse_result = self.parser.parse(file_path)
+
+            if not parse_result.success:
+                return {"success": False, "error": parse_result.error}
+
+            tables = parse_result.data.get("tables", [])
+
+            if not tables:
+                return {"success": True, "tables": [], "message": "文档中没有表格"}
+
+            # 提取每个表格的关键信息
+            table_summaries = []
+            for i, table in enumerate(tables):
+                summary = {
+                    "index": i + 1,
+                    "headers": table.get("headers", []),
+                    "row_count": table.get("row_count", 0),
+                    "column_count": table.get("column_count", 0),
+                    "preview_rows": table.get("rows", [])[:3],  # 只取前3行预览
+                    "first_column": [row[0] if row else "" for row in table.get("rows", [])[:5]]
+                }
+                table_summaries.append(summary)
+
+            return {
+                "success": True,
+                "tables": table_summaries,
+                "table_count": len(tables)
+            }
+
+        except Exception as e:
+            logger.error(f"表格提取失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+
+# 全局单例
+markdown_ai_service = MarkdownAIService()

backend/app/services/multi_doc_reasoning_service.py

@@ -0,0 +1,446 @@
+"""
+多文档关联推理服务
+
+跨文档信息关联和推理
+"""
+import logging
+import re
+from typing import Any, Dict, List, Optional, Set, Tuple
+from collections import defaultdict
+
+from app.services.llm_service import llm_service
+from app.services.rag_service import rag_service
+
+logger = logging.getLogger(__name__)
+
+
+class MultiDocReasoningService:
+    """
+    多文档关联推理服务
+
+    功能：
+    1. 实体跨文档追踪 - 追踪同一实体在不同文档中的描述
+    2. 关系抽取与推理 - 抽取实体间关系并进行推理
+    3. 信息补全 - 根据多个文档的信息互补填充缺失数据
+    4. 冲突检测 - 检测不同文档间的信息冲突
+    """
+
+    def __init__(self):
+        self.llm = llm_service
+
+    async def analyze_cross_documents(
+        self,
+        documents: List[Dict[str, Any]],
+        query: Optional[str] = None,
+        entity_types: Optional[List[str]] = None
+    ) -> Dict[str, Any]:
+        """
+        跨文档分析
+
+        Args:
+            documents: 文档列表
+            query: 查询意图（可选）
+            entity_types: 要追踪的实体类型列表，如 ["机构", "人物", "地点", "数量"]
+
+        Returns:
+            跨文档分析结果
+        """
+        if not documents:
+            return {"success": False, "error": "没有可用的文档"}
+
+        entity_types = entity_types or ["机构", "数量", "时间", "地点"]
+
+        try:
+            # 1. 提取各文档中的实体
+            entities_per_doc = await self._extract_entities_from_docs(documents, entity_types)
+
+            # 2. 跨文档实体对齐
+            aligned_entities = self._align_entities_across_docs(entities_per_doc)
+
+            # 3. 关系抽取
+            relations = await self._extract_relations(documents)
+
+            # 4. 构建知识图谱
+            knowledge_graph = self._build_knowledge_graph(aligned_entities, relations)
+
+            # 5. 信息补全
+            completed_info = await self._complete_missing_info(knowledge_graph, documents)
+
+            # 6. 冲突检测
+            conflicts = self._detect_conflicts(aligned_entities)
+
+            return {
+                "success": True,
+                "entities": aligned_entities,
+                "relations": relations,
+                "knowledge_graph": knowledge_graph,
+                "completed_info": completed_info,
+                "conflicts": conflicts,
+                "summary": self._generate_summary(aligned_entities, conflicts)
+            }
+
+        except Exception as e:
+            logger.error(f"跨文档分析失败: {e}")
+            return {"success": False, "error": str(e)}
+
+    async def _extract_entities_from_docs(
+        self,
+        documents: List[Dict[str, Any]],
+        entity_types: List[str]
+    ) -> List[Dict[str, Any]]:
+        """从各文档中提取实体"""
+        entities_per_doc = []
+
+        for idx, doc in enumerate(documents):
+            doc_id = doc.get("_id", f"doc_{idx}")
+            content = doc.get("content", "")[:8000]  # 限制长度
+
+            # 使用 LLM 提取实体
+            prompt = f"""从以下文档中提取指定的实体类型信息。
+
+实体类型: {', '.join(entity_types)}
+
+文档内容:
+{content}
+
+请按以下 JSON 格式输出（只需输出 JSON）：
+{{
+    "entities": [
+        {{"type": "机构", "name": "实体名称", "value": "相关数值（如有）", "context": "上下文描述"}},
+        ...
+    ]
+}}
+
+只提取在文档中明确提到的实体，不要推测。"""
+
+            messages = [
+                {"role": "system", "content": "你是一个实体提取专家。请严格按JSON格式输出。"},
+                {"role": "user", "content": prompt}
+            ]
+
+            try:
+                response = await self.llm.chat(messages=messages, temperature=0.1, max_tokens=3000)
+                content_response = self.llm.extract_message_content(response)
+
+                # 解析 JSON
+                import json
+                import re
+                cleaned = content_response.strip()
+                json_match = re.search(r'\{[\s\S]*\}', cleaned)
+                if json_match:
+                    result = json.loads(json_match.group())
+                    entities = result.get("entities", [])
+                    entities_per_doc.append({
+                        "doc_id": doc_id,
+                        "doc_name": doc.get("metadata", {}).get("original_filename", f"文档{idx+1}"),
+                        "entities": entities
+                    })
+                    logger.info(f"文档 {doc_id} 提取到 {len(entities)} 个实体")
+            except Exception as e:
+                logger.warning(f"文档 {doc_id} 实体提取失败: {e}")
+
+        return entities_per_doc
+
+    def _align_entities_across_docs(
+        self,
+        entities_per_doc: List[Dict[str, Any]]
+    ) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        跨文档实体对齐
+
+        将同一实体在不同文档中的描述进行关联
+        """
+        aligned: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+
+        for doc_data in entities_per_doc:
+            doc_id = doc_data["doc_id"]
+            doc_name = doc_data["doc_name"]
+
+            for entity in doc_data.get("entities", []):
+                entity_name = entity.get("name", "")
+                if not entity_name:
+                    continue
+
+                # 标准化实体名（去除空格和括号内容）
+                normalized = self._normalize_entity_name(entity_name)
+
+                aligned[normalized].append({
+                    "original_name": entity_name,
+                    "type": entity.get("type", "未知"),
+                    "value": entity.get("value", ""),
+                    "context": entity.get("context", ""),
+                    "source_doc": doc_name,
+                    "source_doc_id": doc_id
+                })
+
+        # 合并相同实体
+        result = {}
+        for normalized, appearances in aligned.items():
+            if len(appearances) > 1:
+                result[normalized] = appearances
+                logger.info(f"实体对齐: {normalized} 在 {len(appearances)} 个文档中出现")
+
+        return result
+
+    def _normalize_entity_name(self, name: str) -> str:
+        """标准化实体名称"""
+        # 去除空格
+        name = name.strip()
+        # 去除括号内容
+        name = re.sub(r'[（(].*?[）)]', '', name)
+        # 去除"第X名"等
+        name = re.sub(r'^第\d+[名位个]', '', name)
+        return name.strip()
+
+    async def _extract_relations(
+        self,
+        documents: List[Dict[str, Any]]
+    ) -> List[Dict[str, str]]:
+        """从文档中抽取关系"""
+        relations = []
+
+        # 合并所有文档内容
+        combined_content = "\n\n".join([
+            f"【{doc.get('metadata', {}).get('original_filename', f'文档{i}')}】\n{doc.get('content', '')[:3000]}"
+            for i, doc in enumerate(documents)
+        ])
+
+        prompt = f"""从以下文档内容中抽取实体之间的关系。
+
+文档内容:
+{combined_content[:8000]}
+
+请识别以下类型的关系：
+- 包含关系 (A包含B)
+- 隶属关系 (A隶属于B)
+- 合作关系 (A与B合作)
+- 对比关系 (A vs B)
+- 时序关系 (A先于B发生)
+
+请按以下 JSON 格式输出（只需输出 JSON）：
+{{
+    "relations": [
+        {{"entity1": "实体1", "entity2": "实体2", "relation": "关系类型", "description": "关系描述"}},
+        ...
+    ]
+}}
+
+如果没有找到明确的关系，返回空数组。"""
+
+        messages = [
+            {"role": "system", "content": "你是一个关系抽取专家。请严格按JSON格式输出。"},
+            {"role": "user", "content": prompt}
+        ]
+
+        try:
+            response = await self.llm.chat(messages=messages, temperature=0.1, max_tokens=3000)
+            content_response = self.llm.extract_message_content(response)
+
+            import json
+            import re
+            cleaned = content_response.strip()
+            json_match = re.search(r'\{{[\s\S]*\}}', cleaned)
+            if json_match:
+                result = json.loads(json_match.group())
+                relations = result.get("relations", [])
+                logger.info(f"抽取到 {len(relations)} 个关系")
+        except Exception as e:
+            logger.warning(f"关系抽取失败: {e}")
+
+        return relations
+
+    def _build_knowledge_graph(
+        self,
+        aligned_entities: Dict[str, List[Dict[str, Any]]],
+        relations: List[Dict[str, str]]
+    ) -> Dict[str, Any]:
+        """构建知识图谱"""
+        nodes = []
+        edges = []
+        node_ids = set()
+
+        # 添加实体节点
+        for entity_name, appearances in aligned_entities.items():
+            if len(appearances) < 1:
+                continue
+
+            first_appearance = appearances[0]
+            node_id = f"entity_{len(nodes)}"
+
+            # 收集该实体在所有文档中的值
+            values = [a.get("value", "") for a in appearances if a.get("value")]
+            primary_value = values[0] if values else ""
+
+            nodes.append({
+                "id": node_id,
+                "name": entity_name,
+                "type": first_appearance.get("type", "未知"),
+                "value": primary_value,
+                "occurrence_count": len(appearances),
+                "sources": [a.get("source_doc", "") for a in appearances]
+            })
+            node_ids.add(entity_name)
+
+        # 添加关系边
+        for relation in relations:
+            entity1 = self._normalize_entity_name(relation.get("entity1", ""))
+            entity2 = self._normalize_entity_name(relation.get("entity2", ""))
+
+            if entity1 in node_ids and entity2 in node_ids:
+                edges.append({
+                    "source": entity1,
+                    "target": entity2,
+                    "relation": relation.get("relation", "相关"),
+                    "description": relation.get("description", "")
+                })
+
+        return {
+            "nodes": nodes,
+            "edges": edges,
+            "stats": {
+                "entity_count": len(nodes),
+                "relation_count": len(edges)
+            }
+        }
+
+    async def _complete_missing_info(
+        self,
+        knowledge_graph: Dict[str, Any],
+        documents: List[Dict[str, Any]]
+    ) -> List[Dict[str, Any]]:
+        """根据多个文档补全信息"""
+        completed = []
+
+        for node in knowledge_graph.get("nodes", []):
+            if not node.get("value") and node.get("occurrence_count", 0) > 1:
+                # 实体在多个文档中出现但没有数值，尝试从 RAG 检索补充
+                query = f"{node['name']} 数值 数据"
+                results = rag_service.retrieve(query, top_k=3, min_score=0.3)
+
+                if results:
+                    completed.append({
+                        "entity": node["name"],
+                        "type": node.get("type", "未知"),
+                        "source": "rag_inference",
+                        "context": results[0].get("content", "")[:200],
+                        "confidence": results[0].get("score", 0)
+                    })
+
+        return completed
+
+    def _detect_conflicts(
+        self,
+        aligned_entities: Dict[str, List[Dict[str, Any]]]
+    ) -> List[Dict[str, Any]]:
+        """检测不同文档间的信息冲突"""
+        conflicts = []
+
+        for entity_name, appearances in aligned_entities.items():
+            if len(appearances) < 2:
+                continue
+
+            # 检查数值冲突
+            values = {}
+            for appearance in appearances:
+                val = appearance.get("value", "")
+                if val:
+                    source = appearance.get("source_doc", "未知来源")
+                    values[source] = val
+
+            if len(values) > 1:
+                unique_values = set(values.values())
+                if len(unique_values) > 1:
+                    conflicts.append({
+                        "entity": entity_name,
+                        "type": "value_conflict",
+                        "details": values,
+                        "description": f"实体 '{entity_name}' 在不同文档中有不同数值: {values}"
+                    })
+
+        return conflicts
+
+    def _generate_summary(
+        self,
+        aligned_entities: Dict[str, List[Dict[str, Any]]],
+        conflicts: List[Dict[str, Any]]
+    ) -> str:
+        """生成摘要"""
+        summary_parts = []
+
+        total_entities = sum(len(appearances) for appearances in aligned_entities.values())
+        multi_doc_entities = sum(1 for appearances in aligned_entities.values() if len(appearances) > 1)
+
+        summary_parts.append(f"跨文档分析完成：发现 {total_entities} 个实体")
+        summary_parts.append(f"其中 {multi_doc_entities} 个实体在多个文档中被提及")
+
+        if conflicts:
+            summary_parts.append(f"检测到 {len(conflicts)} 个潜在冲突")
+
+        return "; ".join(summary_parts)
+
+    async def answer_cross_doc_question(
+        self,
+        question: str,
+        documents: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        """
+        跨文档问答
+
+        Args:
+            question: 问题
+            documents: 文档列表
+
+        Returns:
+            答案结果
+        """
+        # 先进行跨文档分析
+        analysis_result = await self.analyze_cross_documents(documents, query=question)
+
+        # 构建上下文
+        context_parts = []
+
+        # 添加实体信息
+        for entity_name, appearances in analysis_result.get("entities", {}).items():
+            contexts = [f"{a.get('source_doc')}: {a.get('context', '')}" for a in appearances[:2]]
+            if contexts:
+                context_parts.append(f"【{entity_name}】{' | '.join(contexts)}")
+
+        # 添加关系信息
+        for relation in analysis_result.get("relations", [])[:5]:
+            context_parts.append(f"【关系】{relation.get('entity1')} {relation.get('relation')} {relation.get('entity2')}: {relation.get('description', '')}")
+
+        context_text = "\n\n".join(context_parts) if context_parts else "未找到相关实体和关系"
+
+        # 使用 LLM 生成答案
+        prompt = f"""基于以下跨文档分析结果，回答用户问题。
+
+问题: {question}
+
+分析结果:
+{context_text}
+
+请直接回答问题，如果分析结果中没有相关信息，请说明"根据提供的文档无法回答该问题"。"""
+
+        messages = [
+            {"role": "system", "content": "你是一个基于文档的问答助手。请根据提供的信息回答问题。"},
+            {"role": "user", "content": prompt}
+        ]
+
+        try:
+            response = await self.llm.chat(messages=messages, temperature=0.2, max_tokens=2000)
+            answer = self.llm.extract_message_content(response)
+
+            return {
+                "success": True,
+                "question": question,
+                "answer": answer,
+                "supporting_entities": list(analysis_result.get("entities", {}).keys())[:10],
+                "relations_count": len(analysis_result.get("relations", []))
+            }
+        except Exception as e:
+            logger.error(f"跨文档问答失败: {e}")
+            return {"success": False, "error": str(e)}
+
+
+# 全局单例
+multi_doc_reasoning_service = MultiDocReasoningService()

backend/app/services/prompt_service.py

@@ -0,0 +1,444 @@
+"""
+提示词工程服务
+
+管理和优化与大模型交互的提示词
+"""
+import json
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class PromptType(Enum):
+    """提示词类型"""
+    DOCUMENT_PARSING = "document_parsing"       # 文档解析
+    FIELD_EXTRACTION = "field_extraction"       # 字段提取
+    TABLE_FILLING = "table_filling"             # 表格填写
+    QUERY_GENERATION = "query_generation"       # 查询生成
+    TEXT_SUMMARY = "text_summary"               # 文本摘要
+    INTENT_CLASSIFICATION = "intent_classification"  # 意图分类
+    DATA_CLASSIFICATION = "data_classification" # 数据分类
+
+
+@dataclass
+class PromptTemplate:
+    """提示词模板"""
+    name: str
+    type: PromptType
+    system_prompt: str
+    user_template: str
+    examples: List[Dict[str, str]] = field(default_factory=list)  # Few-shot 示例
+    rules: List[str] = field(default_factory=list)  # 特殊规则
+
+    def format(
+        self,
+        context: Dict[str, Any],
+        user_input: Optional[str] = None
+    ) -> List[Dict[str, str]]:
+        """
+        格式化提示词
+
+        Args:
+            context: 上下文数据
+            user_input: 用户输入
+
+        Returns:
+            格式化后的消息列表
+        """
+        messages = []
+
+        # 系统提示词
+        system_content = self.system_prompt
+
+        # 添加规则
+        if self.rules:
+            system_content += "\n\n【输出规则】\n" + "\n".join([f"- {rule}" for rule in self.rules])
+
+        # 添加示例
+        if self.examples:
+            system_content += "\n\n【示例】\n"
+            for i, ex in enumerate(self.examples):
+                system_content += f"\n示例 {i+1}:\n"
+                system_content += f"输入: {ex.get('input', '')}\n"
+                system_content += f"输出: {ex.get('output', '')}\n"
+
+        messages.append({"role": "system", "content": system_content})
+
+        # 用户提示词
+        user_content = self._format_user_template(context, user_input)
+        messages.append({"role": "user", "content": user_content})
+
+        return messages
+
+    def _format_user_template(
+        self,
+        context: Dict[str, Any],
+        user_input: Optional[str]
+    ) -> str:
+        """格式化用户模板"""
+        content = self.user_template
+
+        # 替换上下文变量
+        for key, value in context.items():
+            placeholder = f"{{{key}}}"
+            if placeholder in content:
+                if isinstance(value, (dict, list)):
+                    content = content.replace(placeholder, json.dumps(value, ensure_ascii=False, indent=2))
+                else:
+                    content = content.replace(placeholder, str(value))
+
+        # 添加用户输入
+        if user_input:
+            content += f"\n\n【用户需求】\n{user_input}"
+
+        return content
+
+
+class PromptEngineeringService:
+    """提示词工程服务"""
+
+    def __init__(self):
+        self.templates: Dict[PromptType, PromptTemplate] = {}
+        self._init_templates()
+
+    def _init_templates(self):
+        """初始化所有提示词模板"""
+
+        # ==================== 文档解析模板 ====================
+        self.templates[PromptType.DOCUMENT_PARSING] = PromptTemplate(
+            name="文档解析",
+            type=PromptType.DOCUMENT_PARSING,
+            system_prompt="""你是一个专业的文档解析专家。你的任务是从各类文档（Word、Excel、Markdown、纯文本）中提取关键信息。
+
+请严格按照JSON格式输出解析结果：
+{
+    "success": true/false,
+    "document_type": "文档类型",
+    "key_fields": {"字段名": "字段值", ...},
+    "summary": "文档摘要（100字内）",
+    "structured_data": {...}  // 提取的表格或其他结构化数据
+}
+
+重要规则：
+- 只提取明确存在的信息，不要猜测
+- 如果是表格数据，请以数组格式输出
+- 日期请使用 YYYY-MM-DD 格式
+- 金额请使用数字格式
+- 如果无法提取某个字段，设置为 null""",
+            user_template="""请解析以下文档内容：
+
+=== 文档开始 ===
+{content}
+=== 文档结束 ===
+
+请提取文档中的关键信息。""",
+            examples=[
+                {
+                    "input": "合同金额：100万元\n签订日期：2024年1月15日\n甲方：张三\n乙方：某某公司",
+                    "output": '{"success": true, "document_type": "合同", "key_fields": {"金额": 1000000, "日期": "2024-01-15", "甲方": "张三", "乙方": "某某公司"}, "summary": "甲乙双方签订的金额为100万元的合同", "structured_data": null}'
+                }
+            ],
+            rules=[
+                "只输出JSON，不要添加任何解释",
+                "使用严格的JSON格式"
+            ]
+        )
+
+        # ==================== 字段提取模板 ====================
+        self.templates[PromptType.FIELD_EXTRACTION] = PromptTemplate(
+            name="字段提取",
+            type=PromptType.FIELD_EXTRACTION,
+            system_prompt="""你是一个专业的数据提取专家。你的任务是从文档内容中提取指定字段的信息。
+
+请严格按照以下JSON格式输出：
+{
+    "value": "提取到的值，找不到则为空字符串",
+    "source": "数据来源描述",
+    "confidence": 0.0到1.0之间的置信度
+}
+
+重要规则：
+- 严格按字段名称匹配，不要提取无关信息
+- 置信度反映你对提取结果的信心程度
+- 如果字段不存在或无法确定，value设为空字符串，confidence设为0.0
+- value必须是实际值，不能是"未找到"之类的描述""",
+            user_template="""请从以下文档内容中提取指定字段的信息。
+
+【需要提取的字段】
+字段名称：{field_name}
+字段类型：{field_type}
+是否必填：{required}
+
+【用户提示】
+{hint}
+
+【文档内容】
+{context}
+
+请提取字段值。""",
+            examples=[
+                {
+                    "input": "文档内容：姓名张三，电话13800138000，邮箱zhangsan@example.com",
+                    "output": '{"value": "张三", "source": "文档第1行", "confidence": 1.0}'
+                }
+            ],
+            rules=[
+                "只输出JSON，不要添加任何解释"
+            ]
+        )
+
+        # ==================== 表格填写模板 ====================
+        self.templates[PromptType.TABLE_FILLING] = PromptTemplate(
+            name="表格填写",
+            type=PromptType.TABLE_FILLING,
+            system_prompt="""你是一个专业的表格填写助手。你的任务是根据提供的文档内容，填写表格模板中的字段。
+
+请严格按照以下JSON格式输出：
+{
+    "filled_data": {{"字段1": "值1", "字段2": "值2", ...}},
+    "fill_details": [
+        {{"field": "字段1", "value": "值1", "source": "来源", "confidence": 0.95}},
+        ...
+    ]
+}
+
+重要规则：
+- 只填写模板中存在的字段
+- 值必须来自提供的文档内容，不要编造
+- 如果某个字段在文档中找不到对应值，设为空字符串
+- fill_details 中记录每个字段的详细信息""",
+            user_template="""请根据以下文档内容，填写表格模板。
+
+【表格模板字段】
+{fields}
+
+【用户需求】
+{hint}
+
+【参考文档内容】
+{context}
+
+请填写表格。""",
+            examples=[
+                {
+                    "input": "字段：姓名、电话\n文档：张三，电话是13800138000",
+                    "output": '{"filled_data": {"姓名": "张三", "电话": "13800138000"}, "fill_details": [{"field": "姓名", "value": "张三", "source": "文档第1行", "confidence": 1.0}, {"field": "电话", "value": "13800138000", "source": "文档第1行", "confidence": 1.0}]}'
+                }
+            ],
+            rules=[
+                "只输出JSON，不要添加任何解释"
+            ]
+        )
+
+        # ==================== 查询生成模板 ====================
+        self.templates[PromptType.QUERY_GENERATION] = PromptTemplate(
+            name="查询生成",
+            type=PromptType.QUERY_GENERATION,
+            system_prompt="""你是一个SQL查询生成专家。你的任务是根据用户的自然语言需求，生成相应的数据库查询语句。
+
+请严格按照以下JSON格式输出：
+{
+    "sql_query": "生成的SQL查询语句",
+    "explanation": "查询逻辑说明"
+}
+
+重要规则：
+- 只生成 SELECT 查询语句，不要生成 INSERT/UPDATE/DELETE
+- 必须包含 WHERE 条件限制查询范围
+- 表名和字段名使用反引号包裹
+- 确保SQL语法正确
+- 如果无法生成有效的查询，sql_query设为空字符串""",
+            user_template="""根据以下信息生成查询语句。
+
+【数据库表结构】
+{table_schema}
+
+【RAG检索到的上下文】
+{rag_context}
+
+【用户查询需求】
+{user_intent}
+
+请生成SQL查询。""",
+            examples=[
+                {
+                    "input": "表：orders(订单号, 金额, 日期, 客户)\n需求：查询2024年1月销售额超过10000的订单",
+                    "output": '{"sql_query": "SELECT * FROM `orders` WHERE `日期` >= \\'2024-01-01\\' AND `日期` < \\'2024-02-01\\' AND `金额` > 10000", "explanation": "筛选2024年1月销售额超过10000的订单"}'
+                }
+            ],
+            rules=[
+                "只输出JSON，不要添加任何解释",
+                "禁止生成 DROP、DELETE、TRUNCATE 等危险操作"
+            ]
+        )
+
+        # ==================== 文本摘要模板 ====================
+        self.templates[PromptType.TEXT_SUMMARY] = PromptTemplate(
+            name="文本摘要",
+            type=PromptType.TEXT_SUMMARY,
+            system_prompt="""你是一个专业的文本摘要专家。你的任务是对长文档进行压缩，提取关键信息。
+
+请严格按照以下JSON格式输出：
+{
+    "summary": "摘要内容（不超过200字）",
+    "key_points": ["要点1", "要点2", "要点3"],
+    "keywords": ["关键词1", "关键词2", "关键词3"]
+}""",
+            user_template="""请为以下文档生成摘要：
+
+=== 文档开始 ===
+{content}
+=== 文档结束 ===
+
+生成简明摘要。""",
+            rules=[
+                "只输出JSON，不要添加任何解释"
+            ]
+        )
+
+        # ==================== 意图分类模板 ====================
+        self.templates[PromptType.INTENT_CLASSIFICATION] = PromptTemplate(
+            name="意图分类",
+            type=PromptType.INTENT_CLASSIFICATION,
+            system_prompt="""你是一个意图分类专家。你的任务是分析用户的自然语言输入，判断用户的真实意图。
+
+支持的意图类型：
+- upload: 上传文档
+- parse: 解析文档
+- query: 查询数据
+- fill: 填写表格
+- export: 导出数据
+- analyze: 分析数据
+- other: 其他/未知
+
+请严格按照以下JSON格式输出：
+{
+    "intent": "意图类型",
+    "confidence": 0.0到1.0之间的置信度,
+    "entities": {{"实体名": "实体值", ...}},  // 识别出的关键实体
+    "suggestion": "建议的下一步操作"
+}""",
+            user_template="""请分析以下用户输入，判断其意图：
+
+【用户输入】
+{user_input}
+
+请分类。""",
+            rules=[
+                "只输出JSON，不要添加任何解释"
+            ]
+        )
+
+        # ==================== 数据分类模板 ====================
+        self.templates[PromptType.DATA_CLASSIFICATION] = PromptTemplate(
+            name="数据分类",
+            type=PromptType.DATA_CLASSIFICATION,
+            system_prompt="""你是一个数据分类专家。你的任务是判断数据的类型和格式。
+
+请严格按照以下JSON格式输出：
+{
+    "data_type": "text/number/date/email/phone/url/amount/other",
+    "format": "具体格式描述",
+    "is_valid": true/false,
+    "normalized_value": "规范化后的值"
+}""",
+            user_template="""请分析以下数据的类型和格式：
+
+【数据】
+{value}
+
+【期望类型（如果有）】
+{expected_type}
+
+请分类。""",
+            rules=[
+                "只输出JSON，不要添加任何解释"
+            ]
+        )
+
+    def get_prompt(
+        self,
+        type: PromptType,
+        context: Dict[str, Any],
+        user_input: Optional[str] = None
+    ) -> List[Dict[str, str]]:
+        """
+        获取格式化后的提示词
+
+        Args:
+            type: 提示词类型
+            context: 上下文数据
+            user_input: 用户输入
+
+        Returns:
+            消息列表
+        """
+        template = self.templates.get(type)
+        if not template:
+            logger.warning(f"未找到提示词模板: {type}")
+            return [{"role": "user", "content": str(context)}]
+
+        return template.format(context, user_input)
+
+    def get_template(self, type: PromptType) -> Optional[PromptTemplate]:
+        """获取提示词模板"""
+        return self.templates.get(type)
+
+    def add_template(self, template: PromptTemplate):
+        """添加自定义提示词模板"""
+        self.templates[template.type] = template
+        logger.info(f"已添加提示词模板: {template.name}")
+
+    def update_template(self, type: PromptType, **kwargs):
+        """更新提示词模板"""
+        template = self.templates.get(type)
+        if template:
+            for key, value in kwargs.items():
+                if hasattr(template, key):
+                    setattr(template, key, value)
+
+    def optimize_prompt(
+        self,
+        type: PromptType,
+        feedback: str,
+        iteration: int = 1
+    ) -> List[Dict[str, str]]:
+        """
+        根据反馈优化提示词
+
+        Args:
+            type: 提示词类型
+            feedback: 优化反馈
+            iteration: 迭代次数
+
+        Returns:
+            优化后的提示词
+        """
+        template = self.templates.get(type)
+        if not template:
+            return []
+
+        # 简单优化策略：根据反馈添加规则
+        optimization_rules = {
+            "准确率低": "提高要求，明确指出必须从原文提取，不要猜测",
+            "格式错误": "强调JSON格式要求，提供更详细的格式示例",
+            "遗漏信息": "添加提取更多细节的要求",
+        }
+
+        new_rules = []
+        for keyword, rule in optimization_rules.items():
+            if keyword in feedback:
+                new_rules.append(rule)
+
+        if new_rules:
+            template.rules.extend(new_rules)
+
+        return template.format({}, None)
+
+
+# ==================== 全局单例 ====================
+
+prompt_service = PromptEngineeringService()

backend/app/services/rag_service.py

@@ -0,0 +1,764 @@
+"""
+RAG 服务模块 - 检索增强生成
+
+使用 sentence-transformers + Faiss 实现向量检索
+支持 BM25 关键词检索 + 向量检索混合融合
+"""
+import logging
+import os
+import pickle
+import re
+import math
+from typing import Any, Dict, List, Optional, Tuple
+from collections import Counter, defaultdict
+
+import faiss
+import numpy as np
+
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+# 尝试导入 sentence-transformers
+try:
+    from sentence_transformers import SentenceTransformer
+    SENTENCE_TRANSFORMERS_AVAILABLE = True
+except ImportError as e:
+    logger.warning(f"sentence-transformers 导入失败: {e}")
+    SENTENCE_TRANSFORMERS_AVAILABLE = False
+    SentenceTransformer = None
+
+
+class SimpleDocument:
+    """简化文档对象"""
+    def __init__(self, page_content: str, metadata: Dict[str, Any]):
+        self.page_content = page_content
+        self.metadata = metadata
+
+
+class BM25:
+    """
+    BM25 关键词检索算法
+
+    一种基于词频和文档频率的信息检索算法，比纯向量搜索更适合关键词精确匹配
+    """
+
+    def __init__(self, k1: float = 1.5, b: float = 0.75):
+        self.k1 = k1  # 词频饱和参数
+        self.b = b    # 文档长度归一化参数
+        self.documents: List[str] = []
+        self.doc_ids: List[str] = []
+        self.avg_doc_length = 0
+        self.doc_freqs: Dict[str, int] = {}  # 词 -> 包含该词的文档数
+        self.idf: Dict[str, float] = {}      # 词 -> IDF 值
+        self.doc_lengths: List[int] = []
+        self.doc_term_freqs: List[Dict[str, int]] = []  # 每个文档的词频
+
+    def _tokenize(self, text: str) -> List[str]:
+        """分词（简单的中文分词）"""
+        if not text:
+            return []
+        # 简单分词：按标点和空格分割
+        tokens = re.findall(r'[\u4e00-\u9fff]+|[a-zA-Z0-9]+', text.lower())
+        # 过滤单字符
+        return [t for t in tokens if len(t) > 1]
+
+    def fit(self, documents: List[str], doc_ids: List[str]):
+        """
+        构建 BM25 索引
+
+        Args:
+            documents: 文档内容列表
+            doc_ids: 文档 ID 列表
+        """
+        self.documents = documents
+        self.doc_ids = doc_ids
+        n = len(documents)
+
+        # 统计文档频率
+        self.doc_freqs = defaultdict(int)
+        self.doc_lengths = []
+        self.doc_term_freqs = []
+
+        for doc in documents:
+            tokens = self._tokenize(doc)
+            self.doc_lengths.append(len(tokens))
+            doc_tf = Counter(tokens)
+            self.doc_term_freqs.append(doc_tf)
+
+            for term in doc_tf:
+                self.doc_freqs[term] += 1
+
+        # 计算平均文档长度
+        self.avg_doc_length = sum(self.doc_lengths) / n if n > 0 else 0
+
+        # 计算 IDF
+        for term, df in self.doc_freqs.items():
+            # IDF = log((n - df + 0.5) / (df + 0.5))
+            self.idf[term] = math.log((n - df + 0.5) / (df + 0.5) + 1)
+
+        logger.info(f"BM25 索引构建完成: {n} 个文档, {len(self.idf)} 个词项")
+
+    def search(self, query: str, top_k: int = 10) -> List[Tuple[int, float]]:
+        """
+        搜索相关文档
+
+        Args:
+            query: 查询文本
+            top_k: 返回前 k 个结果
+
+        Returns:
+            [(文档索引, BM25分数), ...]
+        """
+        if not self.documents:
+            return []
+
+        query_tokens = self._tokenize(query)
+        if not query_tokens:
+            return []
+
+        scores = []
+        n = len(self.documents)
+
+        for idx in range(n):
+            score = self._calculate_score(query_tokens, idx)
+            scores.append((idx, score))
+
+        # 按分数降序排序
+        scores.sort(key=lambda x: x[1], reverse=True)
+
+        return scores[:top_k]
+
+    def _calculate_score(self, query_tokens: List[str], doc_idx: int) -> float:
+        """计算单个文档的 BM25 分数"""
+        doc_tf = self.doc_term_freqs[doc_idx]
+        doc_len = self.doc_lengths[doc_idx]
+        score = 0.0
+
+        for term in query_tokens:
+            if term not in self.idf:
+                continue
+
+            tf = doc_tf.get(term, 0)
+            idf = self.idf[term]
+
+            # BM25 公式
+            numerator = tf * (self.k1 + 1)
+            denominator = tf + self.k1 * (1 - self.b + self.b * doc_len / self.avg_doc_length)
+
+            score += idf * numerator / denominator
+
+        return score
+
+    def get_scores(self, query: str) -> List[float]:
+        """获取所有文档的 BM25 分数"""
+        if not self.documents:
+            return []
+
+        query_tokens = self._tokenize(query)
+        if not query_tokens:
+            return [0.0] * len(self.documents)
+
+        return [self._calculate_score(query_tokens, idx) for idx in range(len(self.documents))]
+
+
+class RAGService:
+    """RAG 检索增强服务"""
+
+    # 默认分块参数
+    DEFAULT_CHUNK_SIZE = 500  # 每个文本块的大小（字符数）
+    DEFAULT_CHUNK_OVERLAP = 50  # 块之间的重叠（字符数）
+
+    def __init__(self):
+        self.embedding_model = None
+        self.index: Optional[faiss.Index] = None
+        self.documents: List[Dict[str, Any]] = []
+        self.doc_ids: List[str] = []
+        self._dimension: int = 384  # 默认维度
+        self._initialized = False
+        self._persist_dir = settings.FAISS_INDEX_DIR
+        # BM25 索引
+        self.bm25: Optional[BM25] = None
+        self._bm25_enabled = True  # 始终启用 BM25
+        # 检查是否可用
+        self._disabled = not SENTENCE_TRANSFORMERS_AVAILABLE
+        if self._disabled:
+            logger.warning("RAG 服务已禁用（sentence-transformers 不可用），将使用 BM25 关键词检索")
+        else:
+            logger.info("RAG 服务已启用（向量检索 + BM25 混合检索）")
+
+    def _init_embeddings(self):
+        """初始化嵌入模型"""
+        if self._disabled:
+            logger.debug("RAG 已禁用，跳过嵌入模型初始化")
+            return
+        if self.embedding_model is None:
+            # 使用轻量级本地模型，避免网络问题
+            model_name = 'all-MiniLM-L6-v2'
+            try:
+                self.embedding_model = SentenceTransformer(model_name)
+                self._dimension = self.embedding_model.get_sentence_embedding_dimension()
+                logger.info(f"RAG 嵌入模型初始化完成: {model_name}, 维度: {self._dimension}")
+            except Exception as e:
+                logger.warning(f"嵌入模型 {model_name} 加载失败: {e}")
+                # 如果本地模型也失败，使用简单hash作为后备
+                self.embedding_model = None
+                self._dimension = 384
+                logger.info("RAG 使用简化模式 (无向量嵌入)")
+
+    def _init_vector_store(self):
+        """初始化向量存储"""
+        if self.index is None:
+            self._init_embeddings()
+            if self.embedding_model is None:
+                # 无法加载嵌入模型，使用简化模式
+                self._dimension = 384
+                self.index = None
+                logger.warning("RAG 嵌入模型未加载，使用简化模式")
+            else:
+                self.index = faiss.IndexIDMap(faiss.IndexFlatIP(self._dimension))
+                logger.info("Faiss 向量存储初始化完成")
+
+    async def initialize(self):
+        """异步初始化"""
+        try:
+            self._init_vector_store()
+            self._initialized = True
+            logger.info("RAG 服务初始化成功")
+        except Exception as e:
+            logger.error(f"RAG 服务初始化失败: {e}")
+            raise
+
+    def _normalize_vectors(self, vectors: np.ndarray) -> np.ndarray:
+        """归一化向量"""
+        norms = np.linalg.norm(vectors, axis=1, keepdims=True)
+        norms = np.where(norms == 0, 1, norms)
+        return vectors / norms
+
+    def _split_into_chunks(self, text: str, chunk_size: int = None, overlap: int = None) -> List[str]:
+        """
+        将长文本分割成块
+
+        Args:
+            text: 待分割的文本
+            chunk_size: 每个块的大小（字符数）
+            overlap: 块之间的重叠字符数
+
+        Returns:
+            文本块列表
+        """
+        if chunk_size is None:
+            chunk_size = self.DEFAULT_CHUNK_SIZE
+        if overlap is None:
+            overlap = self.DEFAULT_CHUNK_OVERLAP
+
+        if len(text) <= chunk_size:
+            return [text] if text.strip() else []
+
+        chunks = []
+        start = 0
+        text_len = len(text)
+
+        while start < text_len:
+            # 计算当前块的结束位置
+            end = start + chunk_size
+
+            # 如果不是最后一块，尝试在句子边界处切割
+            if end < text_len:
+                # 向前查找最后一个句号、逗号、换行或分号
+                cut_positions = []
+                for i in range(end, max(start, end - 100), -1):
+                    if text[i] in '。；，,\n、':
+                        cut_positions.append(i + 1)
+                        break
+
+                if cut_positions:
+                    end = cut_positions[0]
+                else:
+                    # 如果没找到句子边界，尝试向后查找
+                    for i in range(end, min(text_len, end + 50)):
+                        if text[i] in '。；，,\n、':
+                            end = i + 1
+                            break
+
+            chunk = text[start:end].strip()
+            if chunk:
+                chunks.append(chunk)
+
+            # 移动起始位置（考虑重叠）
+            start = end - overlap
+            if start <= 0:
+                start = end
+
+        return chunks
+
+    def index_field(
+        self,
+        table_name: str,
+        field_name: str,
+        field_description: str,
+        sample_values: Optional[List[str]] = None
+    ):
+        """将字段信息索引到向量数据库"""
+        if self._disabled:
+            logger.info(f"[RAG DISABLED] 字段索引操作已跳过: {table_name}.{field_name}")
+            return
+
+        if not self._initialized:
+            self._init_vector_store()
+
+        # 如果没有嵌入模型，只记录到日志
+        if self.embedding_model is None:
+            logger.debug(f"字段跳过索引 (无嵌入模型): {table_name}.{field_name}")
+            return
+
+        text = f"表名: {table_name}, 字段: {field_name}, 描述: {field_description}"
+        if sample_values:
+            text += f", 示例值: {', '.join(sample_values)}"
+
+        doc_id = f"{table_name}.{field_name}"
+        doc = SimpleDocument(
+            page_content=text,
+            metadata={"table_name": table_name, "field_name": field_name, "doc_id": doc_id}
+        )
+        self._add_documents([doc], [doc_id])
+        logger.debug(f"已索引字段: {doc_id}")
+
+    def index_document_content(
+        self,
+        doc_id: str,
+        content: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        chunk_size: int = None,
+        chunk_overlap: int = None
+    ):
+        """
+        将文档内容索引到向量数据库（自动分块）
+
+        Args:
+            doc_id: 文档唯一标识
+            content: 文档内容
+            metadata: 文档元数据
+            chunk_size: 文本块大小（字符数），默认500
+            chunk_overlap: 块之间的重叠字符数，默认50
+        """
+        if self._disabled:
+            logger.info(f"[RAG DISABLED] 文档索引操作已跳过: {doc_id}")
+            return
+
+        if not self._initialized:
+            self._init_vector_store()
+
+        # 如果没有嵌入模型，只记录到日志
+        if self.embedding_model is None:
+            logger.debug(f"文档跳过索引 (无嵌入模型): {doc_id}")
+            return
+
+        # 分割文档为小块
+        if chunk_size is None:
+            chunk_size = self.DEFAULT_CHUNK_SIZE
+        if chunk_overlap is None:
+            chunk_overlap = self.DEFAULT_CHUNK_OVERLAP
+
+        chunks = self._split_into_chunks(content, chunk_size, chunk_overlap)
+
+        if not chunks:
+            logger.warning(f"文档内容为空，跳过索引: {doc_id}")
+            return
+
+        # 为每个块创建文档对象
+        documents = []
+        chunk_ids = []
+
+        for i, chunk in enumerate(chunks):
+            chunk_id = f"{doc_id}_chunk_{i}"
+            chunk_metadata = metadata.copy() if metadata else {}
+            chunk_metadata.update({
+                "chunk_index": i,
+                "total_chunks": len(chunks),
+                "doc_id": doc_id
+            })
+
+            documents.append(SimpleDocument(
+                page_content=chunk,
+                metadata=chunk_metadata
+            ))
+            chunk_ids.append(chunk_id)
+
+        # 批量添加文档
+        self._add_documents(documents, chunk_ids)
+        logger.info(f"已索引文档 {doc_id}，共 {len(chunks)} 个块")
+
+    def _add_documents(self, documents: List[SimpleDocument], doc_ids: List[str]):
+        """批量添加文档到向量索引"""
+        if not documents:
+            return
+
+        # 总是将文档存储在内存中（用于 BM25 和关键词搜索）
+        for doc, did in zip(documents, doc_ids):
+            self.documents.append({"id": did, "content": doc.page_content, "metadata": doc.metadata})
+            self.doc_ids.append(did)
+
+        # 构建 BM25 索引
+        if self._bm25_enabled and documents:
+            bm25_texts = [doc.page_content for doc in documents]
+            if self.bm25 is None:
+                self.bm25 = BM25()
+                self.bm25.fit(bm25_texts, doc_ids)
+            else:
+                # 增量添加：重新构建（BM25 不支持增量）
+                all_texts = [d["content"] for d in self.documents]
+                all_ids = self.doc_ids.copy()
+                self.bm25 = BM25()
+                self.bm25.fit(all_texts, all_ids)
+            logger.debug(f"BM25 索引更新: {len(documents)} 个文档")
+
+        # 如果没有嵌入模型，跳过向量索引
+        if self.embedding_model is None:
+            logger.debug(f"文档跳过向量索引 (无嵌入模型): {len(documents)} 个文档")
+            return
+
+        texts = [doc.page_content for doc in documents]
+        embeddings = self.embedding_model.encode(texts, convert_to_numpy=True)
+        embeddings = self._normalize_vectors(embeddings).astype('float32')
+
+        if self.index is None:
+            self._init_vector_store()
+
+        id_list = [hash(did) for did in doc_ids]
+        id_array = np.array(id_list, dtype='int64')
+        self.index.add_with_ids(embeddings, id_array)
+
+    def retrieve(self, query: str, top_k: int = 5, min_score: float = 0.3) -> List[Dict[str, Any]]:
+        """
+        根据查询检索相关文档块（混合检索：向量 + BM25）
+
+        Args:
+            query: 查询文本
+            top_k: 返回的最大结果数
+            min_score: 最低相似度分数阈值
+
+        Returns:
+            相关文档块列表，每项包含 content, metadata, score, doc_id, chunk_index
+        """
+        if self._disabled:
+            logger.info(f"[RAG DISABLED] 检索操作已跳过: query={query}, top_k={top_k}")
+            return []
+
+        if not self._initialized:
+            self._init_vector_store()
+
+        # 获取向量检索结果
+        vector_results = self._vector_search(query, top_k * 2, min_score)
+
+        # 获取 BM25 检索结果
+        bm25_results = self._bm25_search(query, top_k * 2)
+
+        # 混合融合
+        hybrid_results = self._hybrid_fusion(vector_results, bm25_results, top_k)
+
+        if hybrid_results:
+            logger.info(f"混合检索到 {len(hybrid_results)} 条相关文档块 (向量:{len(vector_results)}, BM25:{len(bm25_results)})")
+            return hybrid_results
+
+        # 降级：只使用 BM25
+        if bm25_results:
+            logger.info(f"降级到 BM25 检索: {len(bm25_results)} 条")
+            return bm25_results
+
+        # 降级：使用关键词搜索
+        logger.info("降级到关键词搜索")
+        return self._keyword_search(query, top_k)
+
+    def _vector_search(self, query: str, top_k: int, min_score: float) -> List[Dict[str, Any]]:
+        """向量检索"""
+        if self.index is None or self.index.ntotal == 0 or self.embedding_model is None:
+            return []
+
+        try:
+            query_embedding = self.embedding_model.encode([query], convert_to_numpy=True)
+            query_embedding = self._normalize_vectors(query_embedding).astype('float32')
+
+            scores, indices = self.index.search(query_embedding, min(top_k * 2, self.index.ntotal))
+
+            results = []
+            for score, idx in zip(scores[0], indices[0]):
+                if idx < 0:
+                    continue
+                if score < min_score:
+                    continue
+                doc = self.documents[idx]
+                results.append({
+                    "content": doc["content"],
+                    "metadata": doc["metadata"],
+                    "score": float(score),
+                    "doc_id": doc["id"],
+                    "chunk_index": doc["metadata"].get("chunk_index", 0),
+                    "search_type": "vector"
+                })
+
+            return results
+        except Exception as e:
+            logger.warning(f"向量检索失败: {e}")
+            return []
+
+    def _bm25_search(self, query: str, top_k: int) -> List[Dict[str, Any]]:
+        """BM25 检索"""
+        if not self.bm25 or not self.documents:
+            return []
+
+        try:
+            bm25_scores = self.bm25.get_scores(query)
+            if not bm25_scores:
+                return []
+
+            # 归一化 BM25 分数到 [0, 1]
+            max_score = max(bm25_scores) if bm25_scores else 1
+            min_score_bm = min(bm25_scores) if bm25_scores else 0
+            score_range = max_score - min_score_bm if max_score != min_score_bm else 1
+
+            results = []
+            for idx, score in enumerate(bm25_scores):
+                if score <= 0:
+                    continue
+                # 归一化
+                normalized_score = (score - min_score_bm) / score_range if score_range > 0 else 0
+                doc = self.documents[idx]
+                results.append({
+                    "content": doc["content"],
+                    "metadata": doc["metadata"],
+                    "score": float(normalized_score),
+                    "doc_id": doc["id"],
+                    "chunk_index": doc["metadata"].get("chunk_index", 0),
+                    "search_type": "bm25"
+                })
+
+            # 按分数降序
+            results.sort(key=lambda x: x["score"], reverse=True)
+            return results[:top_k]
+
+        except Exception as e:
+            logger.warning(f"BM25 检索失败: {e}")
+            return []
+
+    def _hybrid_fusion(
+        self,
+        vector_results: List[Dict[str, Any]],
+        bm25_results: List[Dict[str, Any]],
+        top_k: int
+    ) -> List[Dict[str, Any]]:
+        """
+        混合融合向量和 BM25 检索结果
+
+        使用 RRFR (Reciprocal Rank Fusion) 算法:
+        Score = weight_vector * (1 / rank_vector) + weight_bm25 * (1 / rank_bm25)
+
+        Args:
+            vector_results: 向量检索结果
+            bm25_results: BM25 检索结果
+            top_k: 返回数量
+
+        Returns:
+            融合后的结果
+        """
+        if not vector_results and not bm25_results:
+            return []
+
+        # 融合权重
+        weight_vector = 0.6
+        weight_bm25 = 0.4
+
+        # 构建文档分数映射
+        doc_scores: Dict[str, Dict[str, float]] = {}
+
+        # 添加向量检索结果
+        for rank, result in enumerate(vector_results):
+            doc_id = result["doc_id"]
+            if doc_id not in doc_scores:
+                doc_scores[doc_id] = {"vector": 0, "bm25": 0, "content": result["content"], "metadata": result["metadata"]}
+            # 使用倒数排名 (Reciprocal Rank)
+            doc_scores[doc_id]["vector"] = weight_vector / (rank + 1)
+
+        # 添加 BM25 检索结果
+        for rank, result in enumerate(bm25_results):
+            doc_id = result["doc_id"]
+            if doc_id not in doc_scores:
+                doc_scores[doc_id] = {"vector": 0, "bm25": 0, "content": result["content"], "metadata": result["metadata"]}
+            doc_scores[doc_id]["bm25"] = weight_bm25 / (rank + 1)
+
+        # 计算融合分数
+        fused_results = []
+        for doc_id, scores in doc_scores.items():
+            fused_score = scores["vector"] + scores["bm25"]
+            # 使用向量检索结果的原始分数作为参考
+            vector_score = next((r["score"] for r in vector_results if r["doc_id"] == doc_id), 0.5)
+            fused_results.append({
+                "content": scores["content"],
+                "metadata": scores["metadata"],
+                "score": fused_score,
+                "doc_id": doc_id,
+                "vector_score": vector_score,
+                "bm25_score": scores["bm25"],
+                "search_type": "hybrid"
+            })
+
+        # 按融合分数降序排序
+        fused_results.sort(key=lambda x: x["score"], reverse=True)
+
+        logger.debug(f"混合融合: {len(fused_results)} 个文档, 向量:{len(vector_results)}, BM25:{len(bm25_results)}")
+
+        return fused_results[:top_k]
+
+    def _keyword_search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+        """
+        关键词搜索后备方案
+
+        Args:
+            query: 查询文本
+            top_k: 返回的最大结果数
+
+        Returns:
+            相关文档块列表
+        """
+        if not self.documents:
+            return []
+
+        # 提取查询关键词
+        keywords = []
+        for char in query:
+            if '\u4e00' <= char <= '\u9fff':  # 中文字符
+                keywords.append(char)
+        # 添加英文单词
+        import re
+        english_words = re.findall(r'[a-zA-Z]+', query)
+        keywords.extend(english_words)
+
+        if not keywords:
+            return []
+
+        results = []
+        for doc in self.documents:
+            content = doc["content"]
+            # 计算关键词匹配分数
+            score = 0
+            matched_keywords = 0
+            for kw in keywords:
+                if kw in content:
+                    score += 1
+                    matched_keywords += 1
+
+            if matched_keywords > 0:
+                # 归一化分数
+                score = score / max(len(keywords), 1)
+                results.append({
+                    "content": content,
+                    "metadata": doc["metadata"],
+                    "score": score,
+                    "doc_id": doc["id"],
+                    "chunk_index": doc["metadata"].get("chunk_index", 0)
+                })
+
+        # 按分数排序
+        results.sort(key=lambda x: x["score"], reverse=True)
+
+        logger.debug(f"关键词搜索返回 {len(results[:top_k])} 条结果")
+        return results[:top_k]
+
+    def retrieve_by_doc_id(self, doc_id: str, top_k: int = 10) -> List[Dict[str, Any]]:
+        """
+        获取指定文档的所有块
+
+        Args:
+            doc_id: 文档ID
+            top_k: 返回的最大结果数
+
+        Returns:
+            该文档的所有块
+        """
+        # 获取属于该文档的所有块
+        doc_chunks = [d for d in self.documents if d["metadata"].get("doc_id") == doc_id]
+
+        # 按 chunk_index 排序
+        doc_chunks.sort(key=lambda x: x["metadata"].get("chunk_index", 0))
+
+        # 返回指定数量
+        return doc_chunks[:top_k]
+
+    def retrieve_by_table(self, table_name: str, top_k: int = 5) -> List[Dict[str, Any]]:
+        """检索指定表的字段"""
+        return self.retrieve(f"表名: {table_name}", top_k)
+
+    def get_vector_count(self) -> int:
+        """获取向量总数"""
+        if self._disabled:
+            logger.info("[RAG DISABLED] get_vector_count 返回 0")
+            return 0
+        if self.index is None:
+            return 0
+        return self.index.ntotal
+
+    def save_index(self, persist_path: str = None):
+        """保存向量索引到磁盘"""
+        if persist_path is None:
+            persist_path = self._persist_dir
+
+        if self.index is not None:
+            os.makedirs(persist_path, exist_ok=True)
+            faiss.write_index(self.index, os.path.join(persist_path, "index.faiss"))
+            with open(os.path.join(persist_path, "documents.pkl"), "wb") as f:
+                pickle.dump(self.documents, f)
+            logger.info(f"向量索引已保存到: {persist_path}")
+
+    def load_index(self, persist_path: str = None):
+        """从磁盘加载向量索引"""
+        if persist_path is None:
+            persist_path = self._persist_dir
+
+        index_file = os.path.join(persist_path, "index.faiss")
+        docs_file = os.path.join(persist_path, "documents.pkl")
+
+        if not os.path.exists(index_file):
+            logger.warning(f"向量索引文件不存在: {index_file}")
+            return
+
+        self._init_embeddings()
+        self.index = faiss.read_index(index_file)
+
+        with open(docs_file, "rb") as f:
+            self.documents = pickle.load(f)
+
+        self.doc_ids = [d["id"] for d in self.documents]
+        self._initialized = True
+        logger.info(f"向量索引已从 {persist_path} 加载，共 {len(self.documents)} 条")
+
+    def delete_by_doc_id(self, doc_id: str):
+        """根据文档ID删除索引"""
+        if self.index is not None:
+            remaining = [d for d in self.documents if d["id"] != doc_id]
+            self.documents = remaining
+            self.doc_ids = [d["id"] for d in self.documents]
+
+            self.index.reset()
+            if self.documents:
+                texts = [d["content"] for d in self.documents]
+                embeddings = self.embedding_model.encode(texts, convert_to_numpy=True)
+                embeddings = self._normalize_vectors(embeddings).astype('float32')
+                id_array = np.array([hash(did) for did in self.doc_ids], dtype='int64')
+                self.index.add_with_ids(embeddings, id_array)
+
+            logger.debug(f"已删除索引: {doc_id}")
+
+    def clear(self):
+        """清空所有索引"""
+        if self._disabled:
+            logger.info("[RAG DISABLED] clear 操作已跳过")
+            return
+        self._init_vector_store()
+        if self.index is not None:
+            self.index.reset()
+            self.documents = []
+            self.doc_ids = []
+            logger.info("已清空所有向量索引")
+
+
+rag_service = RAGService()

backend/app/services/table_rag_service.py

@@ -0,0 +1,724 @@
+"""
+表结构 RAG 索引服务
+
+AI 自动生成表字段的语义描述，并建立向量索引
+"""
+import logging
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from app.services.llm_service import llm_service
+from app.services.rag_service import rag_service
+from app.services.excel_storage_service import excel_storage_service
+from app.core.database.mysql import mysql_db
+
+logger = logging.getLogger(__name__)
+
+
+class TableRAGService:
+    """
+    表结构 RAG 索引服务
+
+    核心功能：
+    1. AI 根据表头和数据生成字段语义描述
+    2. 将字段描述存入向量数据库 (RAG)
+    3. 支持自然语言查询表字段
+    """
+
+    def __init__(self):
+        self.llm = llm_service
+        self.rag = rag_service
+        self.excel_storage = excel_storage_service
+        # 临时禁用 RAG 索引构建
+        self._disabled = True
+        logger.info("TableRAG 服务已禁用（_disabled=True），仅记录索引操作日志")
+
+    def _extract_sheet_names_from_xml(self, file_path: str) -> List[str]:
+        """
+        从 Excel 文件的 XML 中提取工作表名称
+
+        某些 Excel 文件由于包含非标准元素，pandas/openpyxl 无法正确解析工作表列表，
+        此时需要直接从 XML 中提取。
+
+        Args:
+            file_path: Excel 文件路径
+
+        Returns:
+            工作表名称列表
+        """
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        # 尝试多种命名空间
+        namespaces = [
+            'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'http://purl.oclc.org/ooxml/spreadsheetml/main',
+        ]
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as z:
+                # 读取 workbook.xml
+                if 'xl/workbook.xml' not in z.namelist():
+                    return []
+
+                content = z.read('xl/workbook.xml')
+                root = ET.fromstring(content)
+
+                # 尝试多种命名空间
+                for ns_uri in namespaces:
+                    ns = {'main': ns_uri}
+                    sheets = root.findall('.//main:sheet', ns)
+                    if sheets:
+                        names = [s.get('name') for s in sheets if s.get('name')]
+                        if names:
+                            logger.info(f"使用命名空间 {ns_uri} 提取到工作表: {names}")
+                            return names
+
+                # 如果都没找到，尝试不带命名空间
+                sheets = root.findall('.//sheet')
+                if not sheets:
+                    sheets = root.findall('.//{*}sheet')
+                names = [s.get('name') for s in sheets if s.get('name')]
+                if names:
+                    logger.info(f"使用通配符提取到工作表: {names}")
+                    return names
+
+                logger.warning(f"无法从 XML 提取工作表，尝试的文件: {file_path}")
+                return []
+
+        except Exception as e:
+            logger.warning(f"从 XML 提取工作表失败: {file_path}, error: {e}")
+            return []
+
+    def _read_excel_sheet(self, file_path: str, sheet_name: str = None, header_row: int = 0) -> pd.DataFrame:
+        """
+        读取 Excel 工作表，支持 pandas 无法解析的特殊 Excel 文件
+
+        当 pandas 的 ExcelFile 无法正确解析时，直接从 XML 读取数据。
+
+        Args:
+            file_path: Excel 文件路径
+            sheet_name: 工作表名称（如果为 None，读取第一个工作表）
+            header_row: 表头行号
+
+        Returns:
+            DataFrame
+        """
+        import zipfile
+        from xml.etree import ElementTree as ET
+
+        # 定义命名空间
+        namespaces = [
+            'http://schemas.openxmlformats.org/spreadsheetml/2006/main',
+            'http://purl.oclc.org/ooxml/spreadsheetml/main',
+        ]
+
+        try:
+            # 先尝试用 pandas 正常读取
+            df = pd.read_excel(file_path, sheet_name=sheet_name, header=header_row)
+            if df is not None and not df.empty:
+                return df
+        except Exception:
+            pass
+
+        # pandas 读取失败，从 XML 直接解析
+        logger.info(f"使用 XML 方式读取 Excel: {file_path}")
+
+        try:
+            with zipfile.ZipFile(file_path, 'r') as z:
+                # 获取工作表名称
+                sheet_names = self._extract_sheet_names_from_xml(file_path)
+                if not sheet_names:
+                    raise ValueError("无法从 Excel 文件中找到工作表")
+
+                # 确定要读取的工作表
+                target_sheet = sheet_name if sheet_name and sheet_name in sheet_names else sheet_names[0]
+                sheet_index = sheet_names.index(target_sheet) + 1  # sheet1.xml, sheet2.xml, ...
+
+                # 读取 shared strings
+                shared_strings = []
+                if 'xl/sharedStrings.xml' in z.namelist():
+                    ss_content = z.read('xl/sharedStrings.xml')
+                    ss_root = ET.fromstring(ss_content)
+                    # 使用通配符查找所有 si 元素
+                    for si in ss_root.iter():
+                        if si.tag.endswith('}si') or si.tag == 'si':
+                            t = si.find('.//{*}t')
+                            if t is not None and t.text:
+                                shared_strings.append(t.text)
+                            else:
+                                shared_strings.append('')
+
+                # 读取工作表
+                sheet_file = f'xl/worksheets/sheet{sheet_index}.xml'
+                if sheet_file not in z.namelist():
+                    raise ValueError(f"工作表文件 {sheet_file} 不存在")
+
+                sheet_content = z.read(sheet_file)
+                root = ET.fromstring(sheet_content)
+
+                # 解析行 - 使用通配符查找
+                rows_data = []
+                headers = {}
+
+                for row in root.iter():
+                    if row.tag.endswith('}row') or row.tag == 'row':
+                        row_idx = int(row.get('r', 0))
+
+                        # 收集表头行
+                        if row_idx == header_row + 1:
+                            for cell in row:
+                                if cell.tag.endswith('}c') or cell.tag == 'c':
+                                    cell_ref = cell.get('r', '')
+                                    col_letters = ''.join(filter(str.isalpha, cell_ref))
+                                    cell_type = cell.get('t', 'n')
+                                    v = cell.find('{*}v')
+                                    if v is not None and v.text:
+                                        if cell_type == 's':
+                                            try:
+                                                headers[col_letters] = shared_strings[int(v.text)]
+                                            except (ValueError, IndexError):
+                                                headers[col_letters] = v.text
+                                        else:
+                                            headers[col_letters] = v.text
+                                    else:
+                                        headers[col_letters] = col_letters
+                            continue
+
+                        # 跳过表头行之后的数据行
+                        if row_idx <= header_row + 1:
+                            continue
+
+                        row_cells = {}
+                        for cell in row:
+                            if cell.tag.endswith('}c') or cell.tag == 'c':
+                                cell_ref = cell.get('r', '')
+                                col_letters = ''.join(filter(str.isalpha, cell_ref))
+                                cell_type = cell.get('t', 'n')
+                                v = cell.find('{*}v')
+
+                                if v is not None and v.text:
+                                    if cell_type == 's':
+                                        try:
+                                            val = shared_strings[int(v.text)]
+                                        except (ValueError, IndexError):
+                                            val = v.text
+                                    elif cell_type == 'b':
+                                        val = v.text == '1'
+                                    else:
+                                        val = v.text
+                                else:
+                                    val = None
+
+                                row_cells[col_letters] = val
+
+                        if row_cells:
+                            rows_data.append(row_cells)
+
+                # 转换为 DataFrame
+                if not rows_data:
+                    logger.warning(f"XML 解析结果为空: {file_path}, sheet: {target_sheet}")
+                    return pd.DataFrame()
+
+                df = pd.DataFrame(rows_data)
+
+                # 应用表头
+                if headers:
+                    df.columns = [headers.get(col, col) for col in df.columns]
+
+                logger.info(f"XML 解析完成: {len(df)} 行, {len(df.columns)} 列")
+                return df
+
+        except Exception as e:
+            logger.error(f"XML 解析 Excel 失败: {e}")
+            raise
+
+    async def generate_field_description(
+        self,
+        table_name: str,
+        field_name: str,
+        sample_values: List[Any],
+        all_fields: Dict[str, List[Any]] = None
+    ) -> str:
+        """
+        使用 AI 生成字段的语义描述
+
+        Args:
+            table_name: 表名
+            field_name: 字段名
+            sample_values: 字段示例值 (前10个)
+            all_fields: 其他字段的示例值，用于上下文理解
+
+        Returns:
+            字段的语义描述
+        """
+        # 构建 Prompt
+        context = ""
+        if all_fields:
+            context = "\n其他字段示例：\n"
+            for fname, values in all_fields.items():
+                if fname != field_name and values:
+                    context += f"- {fname}: {', '.join([str(v) for v in values[:3]])}\n"
+
+        prompt = f"""你是一个数据语义分析专家。请根据字段名和示例值，推断该字段的语义含义。
+
+表名：{table_name}
+字段名：{field_name}
+示例值：{', '.join([str(v) for v in sample_values[:10] if v is not None])}
+{context}
+
+请生成一段简洁的字段语义描述（不超过50字），说明：
+1. 该字段代表什么含义
+2. 数据格式或单位（如果有）
+3. 可能的业务用途
+
+只输出描述文字，不要其他内容。"""
+
+        try:
+            messages = [
+                {"role": "system", "content": "你是一个专业的数据分析师。"},
+                {"role": "user", "content": prompt}
+            ]
+
+            response = await self.llm.chat(
+                messages=messages,
+                temperature=0.3,
+                max_tokens=200
+            )
+
+            description = self.llm.extract_message_content(response)
+            return description.strip()
+
+        except Exception as e:
+            logger.error(f"生成字段描述失败: {str(e)}")
+            return f"{field_name}: 数据字段"
+
+    async def build_table_rag_index(
+        self,
+        file_path: str,
+        filename: str,
+        sheet_name: Optional[str] = None,
+        header_row: int = 0,
+        sample_size: int = 10
+    ) -> Dict[str, Any]:
+        """
+        为 Excel 表构建完整的 RAG 索引
+
+        流程：
+        1. 读取 Excel 获取字段信息
+        2. AI 生成每个字段的语义描述
+        3. 将字段描述存入向量数据库
+
+        Args:
+            file_path: Excel 文件路径
+            filename: 原始文件名
+            sheet_name: 工作表名称
+            header_row: 表头行号
+            sample_size: 每个字段采样的数据条数
+
+        Returns:
+            索引构建结果
+        """
+        results = {
+            "success": True,
+            "table_name": "",
+            "field_count": 0,
+            "indexed_fields": [],
+            "errors": []
+        }
+
+        try:
+            # 1. 先检查 Excel 文件是否有效
+            logger.info(f"正在检查Excel文件: {file_path}")
+            try:
+                xls_file = pd.ExcelFile(file_path)
+                sheet_names = xls_file.sheet_names
+                logger.info(f"Excel文件工作表: {sheet_names}")
+
+                # 如果 sheet_names 为空，尝试从 XML 中手动提取
+                if not sheet_names:
+                    sheet_names = self._extract_sheet_names_from_xml(file_path)
+                    logger.info(f"从XML提取工作表: {sheet_names}")
+
+                if not sheet_names:
+                    return {"success": False, "error": "Excel 文件没有工作表"}
+            except Exception as e:
+                logger.error(f"读取Excel文件失败: {file_path}, error: {e}")
+                return {"success": False, "error": f"无法读取Excel文件: {str(e)}"}
+
+            # 2. 读取 Excel
+            if sheet_name:
+                # 验证指定的sheet_name是否存在
+                if sheet_name not in sheet_names:
+                    logger.warning(f"指定的工作表 '{sheet_name}' 不存在，使用第一个工作表: {sheet_names[0]}")
+                    sheet_name = sheet_names[0]
+            df = self._read_excel_sheet(file_path, sheet_name=sheet_name, header_row=header_row)
+
+            logger.info(f"读取到数据: {len(df)} 行, {len(df.columns)} 列")
+
+            if df.empty:
+                return {"success": False, "error": "Excel 文件为空"}
+
+            # 清理列名
+            df.columns = [str(c) for c in df.columns]
+            table_name = self.excel_storage._sanitize_table_name(filename)
+            results["table_name"] = table_name
+            results["field_count"] = len(df.columns)
+            logger.info(f"表名: {table_name}, 字段数: {len(df.columns)}")
+
+            # 3. 初始化 RAG (如果需要)
+            if not self.rag._initialized:
+                self.rag._init_vector_store()
+
+            # 4. 为每个字段生成描述并索引
+            all_fields_data = {}
+            for col in df.columns:
+                # 采样示例值
+                sample_values = df[col].dropna().head(sample_size).tolist()
+                all_fields_data[col] = sample_values
+
+            # 批量生成描述（避免过多 API 调用）
+            indexed_count = 0
+            for col in df.columns:
+                try:
+                    sample_values = all_fields_data[col]
+
+                    # 生成描述
+                    description = await self.generate_field_description(
+                        table_name=table_name,
+                        field_name=col,
+                        sample_values=sample_values,
+                        all_fields=all_fields_data
+                    )
+
+                    # 存入 RAG（如果未禁用）
+                    if self._disabled:
+                        logger.info(f"[RAG DISABLED] 字段索引已跳过: {table_name}.{col}")
+                    else:
+                        self.rag.index_field(
+                            table_name=table_name,
+                            field_name=col,
+                            field_description=description,
+                            sample_values=[str(v) for v in sample_values[:5]]
+                        )
+
+                    indexed_count += 1
+                    results["indexed_fields"].append({
+                        "field": col,
+                        "description": description
+                    })
+
+                    logger.info(f"字段已索引: {table_name}.{col}")
+
+                except Exception as e:
+                    error_msg = f"字段 {col} 索引失败: {str(e)}"
+                    logger.error(error_msg)
+                    results["errors"].append(error_msg)
+
+            # 5. 存储到 MySQL
+            logger.info(f"开始存储到MySQL: {filename}")
+            store_result = await self.excel_storage.store_excel(
+                file_path=file_path,
+                filename=filename,
+                sheet_name=sheet_name,
+                header_row=header_row
+            )
+
+            if store_result.get("success"):
+                results["mysql_table"] = store_result.get("table_name")
+                results["row_count"] = store_result.get("row_count")
+            else:
+                results["mysql_warning"] = "MySQL 存储失败: " + str(store_result.get("error"))
+
+            results["indexed_count"] = indexed_count
+            logger.info(f"表 {table_name} RAG 索引构建完成，共 {indexed_count} 个字段")
+
+            return results
+
+        except Exception as e:
+            logger.error(f"构建 RAG 索引失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    async def index_document_table(
+        self,
+        doc_id: str,
+        filename: str,
+        table_data: Dict[str, Any],
+        source_doc_type: str
+    ) -> Dict[str, Any]:
+        """
+        为非结构化文档中提取的表格建立 MySQL 存储和 RAG 索引
+
+        Args:
+            doc_id: 源文档 ID
+            filename: 源文件名
+            table_data: 表格数据，支持两种格式:
+                1. docx/txt格式: {"rows": [["col1", "col2"], ["val1", "val2"]], ...}
+                2. md格式: {"headers": [...], "rows": [...], ...}
+            source_doc_type: 源文档类型 (docx/md/txt)
+
+        Returns:
+            索引构建结果
+        """
+        results = {
+            "success": True,
+            "table_name": "",
+            "field_count": 0,
+            "indexed_fields": [],
+            "errors": []
+        }
+
+        try:
+            # 兼容两种格式
+            if "headers" in table_data:
+                # md 格式：headers 和 rows 分开
+                columns = table_data.get("headers", [])
+                data_rows = table_data.get("rows", [])
+            else:
+                # docx/txt 格式：第一行作为表头
+                rows = table_data.get("rows", [])
+                if not rows or len(rows) < 2:
+                    return {"success": False, "error": "表格数据不足"}
+                columns = rows[0]
+                data_rows = rows[1:]
+
+            # 生成表名：源文件 + 表格索引
+            base_name = self.excel_storage._sanitize_table_name(filename)
+            table_name = f"{base_name}_table{table_data.get('table_index', 0)}"
+
+            results["table_name"] = table_name
+            results["field_count"] = len(columns)
+
+            # 1. 初始化 RAG
+            if not self.rag._initialized:
+                self.rag._init_vector_store()
+
+            # 2. 准备结构化数据
+            structured_data = {
+                "columns": columns,
+                "rows": data_rows
+            }
+
+            # 3. 存储到 MySQL
+            store_result = await self.excel_storage.store_structured_data(
+                table_name=table_name,
+                data=structured_data,
+                source_doc_id=doc_id
+            )
+
+            if store_result.get("success"):
+                results["mysql_table"] = store_result.get("table_name")
+                results["row_count"] = store_result.get("row_count")
+            else:
+                results["mysql_warning"] = "MySQL 存储失败: " + str(store_result.get("error"))
+
+            # 4. 为每个字段生成描述并索引
+            all_fields_data = {}
+            for i, col in enumerate(columns):
+                col_values = [row[i] for row in data_rows if i < len(row)]
+                all_fields_data[col] = col_values
+
+            indexed_count = 0
+            for col in columns:
+                try:
+                    col_values = all_fields_data.get(col, [])
+
+                    # 生成描述
+                    description = await self.generate_field_description(
+                        table_name=table_name,
+                        field_name=col,
+                        sample_values=col_values[:10],
+                        all_fields=all_fields_data
+                    )
+
+                    # 存入 RAG（如果未禁用）
+                    if self._disabled:
+                        logger.info(f"[RAG DISABLED] 文档表格字段索引已跳过: {table_name}.{col}")
+                    else:
+                        self.rag.index_field(
+                            table_name=table_name,
+                            field_name=col,
+                            field_description=description,
+                            sample_values=[str(v) for v in col_values[:5]]
+                        )
+
+                    indexed_count += 1
+                    results["indexed_fields"].append({
+                        "field": col,
+                        "description": description
+                    })
+
+                    logger.info(f"文档表格字段已索引: {table_name}.{col}")
+
+                except Exception as e:
+                    error_msg = f"字段 {col} 索引失败: {str(e)}"
+                    logger.error(error_msg)
+                    results["errors"].append(error_msg)
+
+            results["indexed_count"] = indexed_count
+            logger.info(f"文档表格 {table_name} RAG 索引构建完成，共 {indexed_count} 个字段")
+
+            return results
+
+        except Exception as e:
+            logger.error(f"构建文档表格 RAG 索引失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    async def query_table_by_natural_language(
+        self,
+        user_query: str,
+        top_k: int = 5
+    ) -> Dict[str, Any]:
+        """
+        根据自然语言查询相关表字段
+
+        Args:
+            user_query: 用户查询
+            top_k: 返回数量
+
+        Returns:
+            匹配的字段信息
+        """
+        try:
+            # 1. RAG 检索
+            rag_results = self.rag.retrieve(user_query, top_k=top_k)
+
+            # 2. 解析检索结果
+            matched_fields = []
+            for result in rag_results:
+                metadata = result.get("metadata", {})
+                matched_fields.append({
+                    "table_name": metadata.get("table_name", ""),
+                    "field_name": metadata.get("field_name", ""),
+                    "description": result.get("content", ""),
+                    "score": result.get("score", 0),
+                    "sample_values": []  # 可以后续补充
+                })
+
+            return {
+                "success": True,
+                "query": user_query,
+                "matched_fields": matched_fields,
+                "count": len(matched_fields)
+            }
+
+        except Exception as e:
+            logger.error(f"查询失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+    async def get_table_fields_with_description(
+        self,
+        table_name: str
+    ) -> List[Dict[str, Any]]:
+        """
+        获取表的字段及其描述
+
+        Args:
+            table_name: 表名
+
+        Returns:
+            字段列表
+        """
+        try:
+            # 从 RAG 检索该表的所有字段
+            results = self.rag.retrieve_by_table(table_name, top_k=50)
+
+            fields = []
+            for result in results:
+                metadata = result.get("metadata", {})
+                fields.append({
+                    "table_name": metadata.get("table_name", ""),
+                    "field_name": metadata.get("field_name", ""),
+                    "description": result.get("content", ""),
+                    "score": result.get("score", 0)
+                })
+
+            return fields
+
+        except Exception as e:
+            logger.error(f"获取字段失败: {str(e)}")
+            return []
+
+    async def rebuild_all_table_indexes(self) -> Dict[str, Any]:
+        """
+        重建所有表的 RAG 索引
+
+        从 MySQL 读取所有表结构，重新生成描述并索引
+        """
+        try:
+            # 清空现有索引
+            self.rag.clear()
+
+            # 获取所有表
+            tables = await self.excel_storage.list_tables()
+
+            results = {
+                "success": True,
+                "tables_processed": 0,
+                "total_fields": 0,
+                "errors": []
+            }
+
+            for table_name in tables:
+                try:
+                    # 获取表结构
+                    schema = await self.excel_storage.get_table_schema(table_name)
+
+                    if not schema:
+                        continue
+
+                    # 初始化 RAG
+                    if not self.rag._initialized:
+                        self.rag._init_vector_store()
+
+                    # 为每个字段生成描述并索引
+                    for col_info in schema:
+                        field_name = col_info.get("COLUMN_NAME", "")
+                        if field_name in ["id", "created_at", "updated_at"]:
+                            continue
+
+                        # 采样数据
+                        samples = await self.excel_storage.query_table(
+                            table_name,
+                            columns=[field_name],
+                            limit=10
+                        )
+                        sample_values = [r.get(field_name) for r in samples if r.get(field_name)]
+
+                        # 生成描述
+                        description = await self.generate_field_description(
+                            table_name=table_name,
+                            field_name=field_name,
+                            sample_values=sample_values
+                        )
+
+                        # 索引
+                        self.rag.index_field(
+                            table_name=table_name,
+                            field_name=field_name,
+                            field_description=description,
+                            sample_values=[str(v) for v in sample_values[:5]]
+                        )
+
+                        results["total_fields"] += 1
+
+                    results["tables_processed"] += 1
+                    logger.info(f"表 {table_name} 索引重建完成")
+
+                except Exception as e:
+                    error_msg = f"表 {table_name} 索引失败: {str(e)}"
+                    logger.error(error_msg)
+                    results["errors"].append(error_msg)
+
+            logger.info(f"全部 {results['tables_processed']} 个表索引重建完成")
+            return results
+
+        except Exception as e:
+            logger.error(f"重建索引失败: {str(e)}")
+            return {"success": False, "error": str(e)}
+
+
+# ==================== 全局单例 ====================
+
+table_rag_service = TableRAGService()

backend/app/services/word_ai_service.py

@@ -0,0 +1,639 @@
+"""
+Word 文档 AI 解析服务
+
+使用 LLM (GLM) 对 Word 文档进行深度理解，提取结构化数据
+"""
+import logging
+from typing import Dict, Any, List, Optional
+import json
+
+from app.services.llm_service import llm_service
+from app.core.document_parser.docx_parser import DocxParser
+
+logger = logging.getLogger(__name__)
+
+
+class WordAIService:
+    """Word 文档 AI 解析服务"""
+
+    def __init__(self):
+        self.llm = llm_service
+        self.parser = DocxParser()
+
+    async def parse_word_with_ai(
+        self,
+        file_path: str,
+        user_hint: str = ""
+    ) -> Dict[str, Any]:
+        """
+        使用 AI 解析 Word 文档，提取结构化数据
+
+        适用于从非结构化的 Word 文档中提取表格数据、键值对等信息
+
+        Args:
+            file_path: Word 文件路径
+            user_hint: 用户提示词，指定要提取的内容类型
+
+        Returns:
+            Dict: 包含结构化数据的解析结果
+        """
+        try:
+            # 1. 先用基础解析器提取原始内容
+            parse_result = self.parser.parse(file_path)
+
+            if not parse_result.success:
+                return {
+                    "success": False,
+                    "error": parse_result.error,
+                    "structured_data": None
+                }
+
+            # 2. 获取原始数据
+            raw_data = parse_result.data
+            paragraphs = raw_data.get("paragraphs", [])
+            paragraphs_with_style = raw_data.get("paragraphs_with_style", [])
+            tables = raw_data.get("tables", [])
+            content = raw_data.get("content", "")
+            images_info = raw_data.get("images", {})
+            metadata = parse_result.metadata or {}
+
+            image_count = images_info.get("image_count", 0)
+            image_descriptions = images_info.get("descriptions", [])
+
+            logger.info(f"Word 基础解析完成: {len(paragraphs)} 个段落, {len(tables)} 个表格, {image_count} 张图片")
+
+            # 3. 提取图片数据（用于视觉分析）
+            images_base64 = []
+            if image_count > 0:
+                try:
+                    images_base64 = self.parser.extract_images_as_base64(file_path)
+                    logger.info(f"提取到 {len(images_base64)} 张图片的 base64 数据")
+                except Exception as e:
+                    logger.warning(f"提取图片 base64 失败: {str(e)}")
+
+            # 4. 根据内容类型选择 AI 解析策略
+            # 如果有图片，先分析图片
+            image_analysis = ""
+            if images_base64:
+                image_analysis = await self._analyze_images_with_ai(images_base64, user_hint)
+                logger.info(f"图片 AI 分析完成: {len(image_analysis)} 字符")
+
+            # 优先处理：表格 > (表格+文本) > 纯文本
+            if tables and len(tables) > 0:
+                structured_data = await self._extract_tables_with_ai(
+                    tables, paragraphs, image_count, user_hint, metadata, image_analysis
+                )
+            elif paragraphs and len(paragraphs) > 0:
+                structured_data = await self._extract_from_text_with_ai(
+                    paragraphs, content, image_count, image_descriptions, user_hint, image_analysis
+                )
+            else:
+                structured_data = {
+                    "success": True,
+                    "type": "empty",
+                    "message": "文档内容为空"
+                }
+
+            # 添加图片分析结果
+            if image_analysis:
+                structured_data["image_analysis"] = image_analysis
+
+            return structured_data
+
+        except Exception as e:
+            logger.error(f"AI 解析 Word 文档失败: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "structured_data": None
+            }
+
+    async def _extract_tables_with_ai(
+        self,
+        tables: List[Dict],
+        paragraphs: List[str],
+        image_count: int,
+        user_hint: str,
+        metadata: Dict,
+        image_analysis: str = ""
+    ) -> Dict[str, Any]:
+        """
+        使用 AI 从 Word 表格和文本中提取结构化数据
+
+        Args:
+            tables: 表格列表
+            paragraphs: 段落列表
+            image_count: 图片数量
+            user_hint: 用户提示
+            metadata: 文档元数据
+            image_analysis: 图片 AI 分析结果
+
+        Returns:
+            结构化数据
+        """
+        try:
+            # 构建表格文本描述
+            tables_text = self._build_tables_description(tables)
+
+            # 构建段落描述
+            paragraphs_text = "\n".join(paragraphs[:50]) if paragraphs else "（无正文文本）"
+            if len(paragraphs) > 50:
+                paragraphs_text += f"\n...（共 {len(paragraphs)} 个段落，仅显示前50个）"
+
+            # 图片提示
+            image_hint = f"注意：此文档包含 {image_count} 张图片/图表。" if image_count > 0 else ""
+
+            prompt = f"""你是一个专业的数据提取专家。请从以下 Word 文档的完整内容中提取结构化数据。
+
+【用户需求】
+{user_hint if user_hint else "请提取文档中的所有结构化数据，包括表格数据、键值对、列表项等。"}
+
+【文档正文（段落）】
+{paragraphs_text}
+
+【文档表格】
+{tables_text}
+
+【文档图片信息】
+{image_hint}
+
+请按照以下 JSON 格式输出：
+{{
+    "type": "table_data",
+    "headers": ["列1", "列2", ...],
+    "rows": [["行1列1", "行1列2", ...], ["行2列1", "行2列2", ...], ...],
+    "key_values": {{"键1": "值1", "键2": "值2", ...}},
+    "list_items": ["项1", "项2", ...],
+    "description": "文档内容描述"
+}}
+
+重点：
+- 优先从表格中提取结构化数据
+- 如果表格中有表头，headers 是表头，rows 是数据行
+- 如果文档中有键值对（如 名称: 张三），提取到 key_values 中
+- 如果文档中有列表项，提取到 list_items 中
+- 图片内容无法直接提取，但请在 description 中说明图片的大致主题（如"包含流程图"、"包含数据图表"等）
+"""
+
+            messages = [
+                {"role": "system", "content": "你是一个专业的数据提取助手。请严格按JSON格式输出。"},
+                {"role": "user", "content": prompt}
+            ]
+
+            response = await self.llm.chat(
+                messages=messages,
+                temperature=0.1,
+                max_tokens=50000
+            )
+
+            content = self.llm.extract_message_content(response)
+
+            # 解析 JSON
+            result = self._parse_json_response(content)
+
+            if result:
+                logger.info(f"AI 表格提取成功: {len(result.get('rows', []))} 行数据, key_values={len(result.get('key_values', {}))}, list_items={len(result.get('list_items', []))}")
+                return {
+                    "success": True,
+                    "type": "table_data",
+                    "headers": result.get("headers", []),
+                    "rows": result.get("rows", []),
+                    "description": result.get("description", ""),
+                    "key_values": result.get("key_values", {}),
+                    "list_items": result.get("list_items", [])
+                }
+            else:
+                # 如果 AI 返回格式不对，尝试直接解析表格
+                return self._fallback_table_parse(tables)
+
+        except Exception as e:
+            logger.error(f"AI 表格提取失败: {str(e)}")
+            return self._fallback_table_parse(tables)
+
+    async def _extract_from_text_with_ai(
+        self,
+        paragraphs: List[str],
+        full_text: str,
+        image_count: int,
+        image_descriptions: List[str],
+        user_hint: str,
+        image_analysis: str = ""
+    ) -> Dict[str, Any]:
+        """
+        使用 AI 从 Word 纯文本中提取结构化数据
+
+        Args:
+            paragraphs: 段落列表
+            full_text: 完整文本
+            image_count: 图片数量
+            image_descriptions: 图片描述列表
+            user_hint: 用户提示
+            image_analysis: 图片 AI 分析结果
+
+        Returns:
+            结构化数据
+        """
+        try:
+            # 限制文本长度
+            text_preview = full_text[:8000] if len(full_text) > 8000 else full_text
+
+            # 图片提示
+            image_hint = f"\n【文档图片】此文档包含 {image_count} 张图片/图表。" if image_count > 0 else ""
+            if image_descriptions:
+                image_hint += "\n" + "\n".join(image_descriptions)
+
+            prompt = f"""你是一个专业的数据提取专家。请从以下 Word 文档的完整内容中提取结构化数据。
+
+【用户需求】
+{user_hint if user_hint else "请识别并提取文档中的关键信息，包括：表格数据、键值对、列表项等。"}
+
+【文档正文】{image_hint}
+{text_preview}
+
+请按照以下 JSON 格式输出：
+{{
+    "type": "structured_text",
+    "tables": [{{"headers": [...], "rows": [...]}}],
+    "key_values": {{"键1": "值1", "键2": "值2", ...}},
+    "list_items": ["项1", "项2", ...],
+    "summary": "文档内容摘要"
+}}
+
+重点：
+- 如果文档包含表格数据，提取到 tables 中
+- 如果文档包含键值对（如 名称: 张三），提取到 key_values 中
+- 如果文档包含列表项，提取到 list_items 中
+- 如果文档包含图片，请根据上下文推断图片内容（如"流程图"、"数据折线图"等）并在 description 中说明
+- 如果无法提取到结构化数据，至少提供一个详细的摘要
+"""
+
+            messages = [
+                {"role": "system", "content": "你是一个专业的数据提取助手。请严格按JSON格式输出。"},
+                {"role": "user", "content": prompt}
+            ]
+
+            response = await self.llm.chat(
+                messages=messages,
+                temperature=0.1,
+                max_tokens=50000
+            )
+
+            content = self.llm.extract_message_content(response)
+
+            result = self._parse_json_response(content)
+
+            if result:
+                logger.info(f"AI 文本提取成功: type={result.get('type')}")
+                return {
+                    "success": True,
+                    "type": result.get("type", "structured_text"),
+                    "tables": result.get("tables", []),
+                    "key_values": result.get("key_values", {}),
+                    "list_items": result.get("list_items", []),
+                    "summary": result.get("summary", ""),
+                    "raw_text_preview": text_preview[:500]
+                }
+            else:
+                return {
+                    "success": True,
+                    "type": "text",
+                    "summary": text_preview[:500],
+                    "raw_text_preview": text_preview[:500]
+                }
+
+        except Exception as e:
+            logger.error(f"AI 文本提取失败: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e)
+            }
+
+    async def _analyze_images_with_ai(
+        self,
+        images: List[Dict[str, str]],
+        user_hint: str = ""
+    ) -> str:
+        """
+        使用视觉模型分析 Word 文档中的图片
+
+        Args:
+            images: 图片列表，每项包含 base64 和 mime_type
+            user_hint: 用户提示
+
+        Returns:
+            图片分析结果文本
+        """
+        try:
+            # 调用 LLM 的视觉分析功能
+            result = await self.llm.analyze_images(
+                images=images,
+                user_prompt=user_hint or "请详细描述图片内容，提取所有文字和数据信息。"
+            )
+
+            if result.get("success"):
+                analysis = result.get("analysis", {})
+                if isinstance(analysis, dict):
+                    description = analysis.get("description", "")
+                    text_content = analysis.get("text_content", "")
+                    data_extracted = analysis.get("data_extracted", {})
+
+                    result_text = f"【图片分析结果】\n{description}"
+                    if text_content:
+                        result_text += f"\n\n【图片中的文字】\n{text_content}"
+                    if data_extracted:
+                        result_text += f"\n\n【提取的数据】\n{json.dumps(data_extracted, ensure_ascii=False)}"
+                    return result_text
+                else:
+                    return str(analysis)
+            else:
+                logger.warning(f"图片 AI 分析失败: {result.get('error')}")
+                return ""
+
+        except Exception as e:
+            logger.error(f"图片 AI 分析异常: {str(e)}")
+            return ""
+
+    def _build_tables_description(self, tables: List[Dict]) -> str:
+        """构建表格的文本描述"""
+        result = []
+
+        for idx, table in enumerate(tables):
+            rows = table.get("rows", [])
+            if not rows:
+                continue
+
+            result.append(f"\n--- 表格 {idx + 1} ---")
+
+            for row_idx, row in enumerate(rows[:50]):  # 限制每表格最多50行
+                if isinstance(row, list):
+                    result.append(" | ".join(str(cell).strip() for cell in row))
+                elif isinstance(row, dict):
+                    result.append(str(row))
+
+            if len(rows) > 50:
+                result.append(f"...（共 {len(rows)} 行，仅显示前50行）")
+
+        return "\n".join(result) if result else "（无表格内容）"
+
+    def _parse_json_response(self, content: str) -> Optional[Dict]:
+        """解析 JSON 响应，处理各种格式问题"""
+        import re
+
+        # 清理 markdown 标记
+        cleaned = content.strip()
+        cleaned = re.sub(r'^```json\s*', '', cleaned, flags=re.MULTILINE)
+        cleaned = re.sub(r'^```\s*', '', cleaned, flags=re.MULTILINE)
+        cleaned = cleaned.strip()
+
+        # 找到 JSON 开始位置
+        json_start = -1
+        for i, c in enumerate(cleaned):
+            if c == '{':
+                json_start = i
+                break
+
+        if json_start == -1:
+            logger.warning("无法找到 JSON 开始位置")
+            return None
+
+        json_text = cleaned[json_start:]
+
+        # 尝试直接解析
+        try:
+            return json.loads(json_text)
+        except json.JSONDecodeError:
+            pass
+
+        # 尝试修复并解析
+        try:
+            # 找到闭合括号
+            depth = 0
+            end_pos = -1
+            for i, c in enumerate(json_text):
+                if c == '{':
+                    depth += 1
+                elif c == '}':
+                    depth -= 1
+                    if depth == 0:
+                        end_pos = i + 1
+                        break
+
+            if end_pos > 0:
+                fixed = json_text[:end_pos]
+                # 移除末尾逗号
+                fixed = re.sub(r',\s*([}]])', r'\1', fixed)
+                return json.loads(fixed)
+        except Exception as e:
+            logger.warning(f"JSON 修复失败: {e}")
+
+        return None
+
+    def _fallback_table_parse(self, tables: List[Dict]) -> Dict[str, Any]:
+        """当 AI 解析失败时，直接解析表格"""
+        if not tables:
+            return {
+                "success": True,
+                "type": "empty",
+                "data": {},
+                "message": "无表格内容"
+            }
+
+        all_rows = []
+        all_headers = None
+
+        for table in tables:
+            rows = table.get("rows", [])
+            if not rows:
+                continue
+
+            # 查找真正的表头行（跳过标题行）
+            header_row_idx = 0
+            for idx, row in enumerate(rows[:5]):  # 只检查前5行
+                if not isinstance(row, list):
+                    continue
+                # 如果某一行包含"表"字开头且单元格内容很长，这可能是标题行
+                first_cell = str(row[0]) if row else ""
+                if first_cell.startswith("表") and len(first_cell) > 15:
+                    header_row_idx = idx + 1
+                    continue
+                # 如果某一行有超过3个空单元格，可能是无效行
+                empty_count = sum(1 for cell in row if not str(cell).strip())
+                if empty_count > 3:
+                    header_row_idx = idx + 1
+                    continue
+                # 找到第一行看起来像表头的行（短单元格，大部分有内容）
+                avg_len = sum(len(str(c)) for c in row) / len(row) if row else 0
+                if avg_len < 20:  # 表头通常比数据行短
+                    header_row_idx = idx
+                    break
+
+            if header_row_idx >= len(rows):
+                continue
+
+            # 使用找到的表头行
+            if rows and isinstance(rows[header_row_idx], list):
+                headers = rows[header_row_idx]
+                if all_headers is None:
+                    all_headers = headers
+
+                # 数据行（从表头之后开始）
+                for row in rows[header_row_idx + 1:]:
+                    if isinstance(row, list) and len(row) == len(headers):
+                        all_rows.append(row)
+
+        if all_headers and all_rows:
+            return {
+                "success": True,
+                "type": "table_data",
+                "headers": all_headers,
+                "rows": all_rows,
+                "description": "直接从 Word 表格提取"
+            }
+
+        return {
+            "success": True,
+            "type": "raw",
+            "tables": tables,
+            "message": "表格数据（未AI处理）"
+        }
+
+    async def fill_template_with_ai(
+        self,
+        file_path: str,
+        template_fields: List[Dict[str, Any]],
+        user_hint: str = ""
+    ) -> Dict[str, Any]:
+        """
+        使用 AI 解析 Word 文档并填写模板
+
+        这是主要入口函数，前端调用此函数即可完成：
+        1. AI 解析 Word 文档
+        2. 根据模板字段提取数据
+        3. 返回填写结果
+
+        Args:
+            file_path: Word 文件路径
+            template_fields: 模板字段列表 [{"name": "字段名", "hint": "提示词"}, ...]
+            user_hint: 用户提示
+
+        Returns:
+            填写结果
+        """
+        try:
+            # 1. AI 解析文档
+            parse_result = await self.parse_word_with_ai(file_path, user_hint)
+
+            if not parse_result.get("success"):
+                return {
+                    "success": False,
+                    "error": parse_result.get("error", "解析失败"),
+                    "filled_data": {},
+                    "source": "ai_parse_failed"
+                }
+
+            # 2. 根据字段类型提取数据
+            filled_data = {}
+            extract_details = []
+
+            parse_type = parse_result.get("type", "")
+
+            if parse_type == "table_data":
+                # 表格数据：直接匹配列名
+                headers = parse_result.get("headers", [])
+                rows = parse_result.get("rows", [])
+
+                for field in template_fields:
+                    field_name = field.get("name", "")
+                    values = self._extract_field_from_table(headers, rows, field_name)
+                    filled_data[field_name] = values
+                    extract_details.append({
+                        "field": field_name,
+                        "values": values,
+                        "source": "ai_table_extraction",
+                        "confidence": 0.9 if values else 0.0
+                    })
+
+            elif parse_type == "structured_text":
+                # 结构化文本：尝试从 key_values 和 list_items 提取
+                key_values = parse_result.get("key_values", {})
+                list_items = parse_result.get("list_items", [])
+
+                for field in template_fields:
+                    field_name = field.get("name", "")
+                    value = key_values.get(field_name, "")
+                    if not value and list_items:
+                        value = list_items[0] if list_items else ""
+                    filled_data[field_name] = [value] if value else []
+                    extract_details.append({
+                        "field": field_name,
+                        "values": [value] if value else [],
+                        "source": "ai_text_extraction",
+                        "confidence": 0.7 if value else 0.0
+                    })
+
+            else:
+                # 其他类型：返回原始解析结果供后续处理
+                for field in template_fields:
+                    field_name = field.get("name", "")
+                    filled_data[field_name] = []
+                    extract_details.append({
+                        "field": field_name,
+                        "values": [],
+                        "source": "no_ai_data",
+                        "confidence": 0.0
+                    })
+
+            # 3. 返回结果
+            max_rows = max(len(v) for v in filled_data.values()) if filled_data else 1
+
+            return {
+                "success": True,
+                "filled_data": filled_data,
+                "fill_details": extract_details,
+                "ai_parse_result": {
+                    "type": parse_type,
+                    "description": parse_result.get("description", "")
+                },
+                "source_doc_count": 1,
+                "max_rows": max_rows
+            }
+
+        except Exception as e:
+            logger.error(f"AI 填表失败: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "filled_data": {},
+                "fill_details": []
+            }
+
+    def _extract_field_from_table(
+        self,
+        headers: List[str],
+        rows: List[List],
+        field_name: str
+    ) -> List[str]:
+        """从表格中提取指定字段的值"""
+        # 查找匹配的列
+        target_col_idx = None
+        for col_idx, header in enumerate(headers):
+            if field_name.lower() in str(header).lower() or str(header).lower() in field_name.lower():
+                target_col_idx = col_idx
+                break
+
+        if target_col_idx is None:
+            return []
+
+        # 提取该列所有值
+        values = []
+        for row in rows:
+            if isinstance(row, list) and target_col_idx < len(row):
+                val = str(row[target_col_idx]).strip()
+                if val:
+                    values.append(val)
+
+        return values
+
+
+# 全局单例
+word_ai_service = WordAIService()

backend/readme.md

@@ -103,12 +103,19 @@ git config user.email #同上
 #如果想看全局的，可以加上 --global，例如 git config --global user.name
 ```
 
+需要更新以下库
+先进入虚拟机
+```bash
+cd backend
+.\venv\Scripts\Activate.ph1
+pip install -r requirements.txt
+```
+
 ## 启动后端项目
 在终端输入以下命令：
 ```bash
 cd backend  #确保启动时在后端跟目录下
-./venv/Scripts/python.exe -m uvicorn app.main:app --host 127.0.0.1 --port 8000
+./venv/Scripts/python.exe -m uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload #启动后端项目
- --reload #启动后端项目
 ```
 先启动后端项目，再启动前端项目
 

backend/requirements.txt

@@ -1,24 +1,54 @@
+# ============================================================
+# 基于大语言模型的文档理解与多源数据融合系统
+# Python 依赖清单
+# ============================================================
+
+# ==================== Web 框架 ====================
 fastapi[all]==0.104.1
 uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+
+# ==================== 数据验证与配置 ====================
 pydantic==2.5.0
 pydantic-settings==2.1.0
-python-multipart==0.0.6
+python-dotenv==1.0.0
+
+# ==================== 数据库 - MySQL (结构化数据) ====================
+pymysql==1.1.0
+aiomysql==0.2.0
+sqlalchemy==2.0.25
+
+# ==================== 数据库 - MongoDB (非结构化数据) ====================
+motor==3.3.2
 pymongo==4.5.0
+
+# ==================== 数据库 - Redis (缓存/队列) ====================
 redis==5.0.0
+
+# ==================== 异步任务 ====================
 celery==5.3.4
-sentence-transformers==2.2.2
+
+# ==================== RAG / 向量数据库 ====================
+# chromadb==0.4.22  # Windows 需要 C++ 编译环境，如需安装请使用预编译版本或 WSL
+sentence-transformers==2.7.0
 faiss-cpu==1.8.0
-python-docx==0.8.11
+
+# ==================== 文档解析 ====================
 pandas==2.1.4
 openpyxl==3.1.2
+python-docx==0.8.11
+markdown-it-py==3.0.0
+chardet==5.2.0
+
+# ==================== AI / LLM ====================
+httpx==0.25.2
+
+# ==================== 数据处理与可视化 ====================
 matplotlib==3.8.2
 numpy==1.26.2
-markdown==3.5.1
+
-langchain==0.1.0
+# ==================== 工具库 ====================
-langchain-community==0.0.10
 requests==2.31.0
-httpx==0.25.2
-python-dotenv==1.0.0
 loguru==0.7.2
 tqdm==4.66.1
 PyYAML==6.0.1

backend/test_font_config.py

@@ -1,71 +0,0 @@
-"""
-测试字体配置是否正常工作
-"""
-import matplotlib.pyplot as plt
-import matplotlib
-import numpy as np
-from app.services.font_helper import configure_matplotlib_fonts
-import io
-import base64
-
-# 配置字体
-font_name = configure_matplotlib_fonts()
-
-print(f"当前使用字体: {font_name}")
-print(f"matplotlib 中文字体设置: {matplotlib.rcParams['font.sans-serif']}")
-
-# 创建测试图表
-fig, ax = plt.subplots(figsize=(10, 6))
-
-# 测试数据
-x = ['销售', '库存', '采购', '退货', '其他']
-y = [150, 200, 180, 50, 30]
-
-bars = ax.bar(x, y, color='#3b82f6', alpha=0.8)
-ax.set_xlabel('类别', fontsize=12, labelpad=10)
-ax.set_ylabel('数值', fontsize=12, labelpad=10)
-ax.set_title('测试图表 - 中文显示', fontsize=14, fontweight='bold', pad=15)
-ax.tick_params(axis='both', which='major', labelsize=10)
-
-# 添加数值标签
-for bar, value in zip(bars, y):
-    height = bar.get_height()
-    ax.text(bar.get_x() + bar.get_width() / 2., height,
-           f'{value}',
-           ha='center', va='bottom', fontsize=10, fontweight='bold')
-
-plt.grid(axis='y', alpha=0.3)
-plt.tight_layout(pad=1.5)
-
-# 转换为 base64
-buf = io.BytesIO()
-fig.savefig(buf, format='png', dpi=120, bbox_inches='tight', pad_inches=0.3, facecolor='white')
-plt.close(fig)
-
-buf.seek(0)
-img_base64 = base64.b64encode(buf.read()).decode('utf-8')
-data_url = f"data:image/png;base64,{img_base64}"
-
-print("\n=== 测试完成 ===")
-print(f"图表大小: {len(img_base64)} 字符")
-print("如果看到字体警告，请检查系统是否有安装中文字体")
-
-# 尝试获取所有可用字体
-import matplotlib.font_manager as fm
-available_fonts = set([f.name for f in fm.fontManager.ttflist])
-
-print(f"\n=== 可用字体列表（部分）===")
-chinese_fonts = [f for f in available_fonts if 'CJK' in f or 'Chinese' in f or 'YaHei' in f or 'SimHei' in f or 'PingFang' in f]
-for font in sorted(chinese_fonts)[:10]:
-    print(f"  - {font}")
-
-if not chinese_fonts:
-    print("  未找到中文字体！")
-
-print("\n=== 推荐安装的中文字体 ===")
-print("Windows: Microsoft YaHei (系统自带)")
-print("macOS: PingFang SC (系统自带)")
-print("Linux: fonts-noto-cjk 或 fonts-wqy-zenhei")
-
-print("\n=== 生成的 base64 数据（前100字符）===")
-print(data_url[:100] + "...")

backend/test_mongodb.py

@@ -0,0 +1,46 @@
+"""
+MongoDB 数据库连接测试
+"""
+import asyncio
+from app.core.database.mongodb import mongodb
+
+
+async def test_mongodb():
+    print("=" * 50)
+    print("MongoDB 数据库连接测试")
+    print("=" * 50)
+
+    try:
+        # 连接
+        await mongodb.connect()
+        print(f"✓ MongoDB 连接成功: {mongodb.client}")
+
+        # 测试插入
+        test_doc = {"test": "hello", "value": 123}
+        doc_id = await mongodb.client.test_database.test_collection.insert_one(test_doc)
+        print(f"✓ 写入测试成功, ID: {doc_id.inserted_id}")
+
+        # 测试查询
+        doc = await mongodb.client.test_database.test_collection.find_one({"test": "hello"})
+        print(f"✓ 读取测试成功: {doc}")
+
+        # 删除测试数据
+        await mongodb.client.test_database.test_collection.delete_one({"test": "hello"})
+        print(f"✓ 删除测试数据成功")
+
+        # 列出数据库
+        dbs = await mongodb.client.list_database_names()
+        print(f"✓ 数据库列表: {dbs}")
+
+        print("\n✓ MongoDB 测试通过!")
+        return True
+
+    except Exception as e:
+        print(f"\n✗ MongoDB 测试失败: {e}")
+        return False
+    finally:
+        await mongodb.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(test_mongodb())

backend/test_mysql.py

@@ -0,0 +1,37 @@
+"""
+MySQL 数据库连接测试
+"""
+import asyncio
+from sqlalchemy import text
+from app.core.database.mysql import mysql_db
+
+
+async def test_mysql():
+    print("=" * 50)
+    print("MySQL 数据库连接测试")
+    print("=" * 50)
+
+    try:
+        # 测试连接
+        async with mysql_db.async_session_factory() as session:
+            result = await session.execute(text("SELECT 1"))
+            print(f"✓ MySQL 连接成功: {result.fetchone()}")
+
+        # 测试查询数据库
+        async with mysql_db.async_session_factory() as session:
+            result = await session.execute(text("SHOW DATABASES"))
+            dbs = result.fetchall()
+            print(f"✓ 数据库列表: {[db[0] for db in dbs]}")
+
+        print("\n✓ MySQL 测试通过!")
+        return True
+
+    except Exception as e:
+        print(f"\n✗ MySQL 测试失败: {e}")
+        return False
+    finally:
+        await mysql_db.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(test_mysql())

backend/test_redis.py

@@ -0,0 +1,46 @@
+"""
+Redis 数据库连接测试
+"""
+import asyncio
+from app.core.database.redis_db import redis_db
+
+
+async def test_redis():
+    print("=" * 50)
+    print("Redis 数据库连接测试")
+    print("=" * 50)
+
+    try:
+        # 连接
+        await redis_db.connect()
+        print(f"✓ Redis 连接成功")
+
+        # 测试写入
+        await redis_db.client.set("test_key", "hello_redis")
+        print(f"✓ 写入测试成功")
+
+        # 测试读取
+        value = await redis_db.client.get("test_key")
+        print(f"✓ 读取测试成功: {value}")
+
+        # 测试删除
+        await redis_db.client.delete("test_key")
+        print(f"✓ 删除测试成功")
+
+        # 测试任务状态
+        await redis_db.set_task_status("test_task", "processing", {"progress": 50})
+        status = await redis_db.get_task_status("test_task")
+        print(f"✓ 任务状态测试成功: {status}")
+
+        print("\n✓ Redis 测试通过!")
+        return True
+
+    except Exception as e:
+        print(f"\n✗ Redis 测试失败: {e}")
+        return False
+    finally:
+        await redis_db.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(test_redis())

docs/test/test.md

@@ -1,113 +0,0 @@
- ✅ Excel 文件解析功能已完成并测试通过
-
-  已完成的工作
-
-  后端部分
-
-  1. 文件服务层 (backend/app/services/file_service.py)
-
-    - 文件保存、读取、删除功能
-    - 文件信息获取
-  2. Excel 解析模块 (backend/app/core/document_parser/)
-
-    - base.py - 解析器基类
-    - xlsx_parser.py - Excel 文件解析器
-    - utils.py - 工具函数
-  3. API 接口 (backend/app/api/endpoints/upload.py)
-
-    - POST /upload/excel - 上传并解析 Excel 文件
-    - GET /upload/excel/preview/{file_path} - 获取预览
-    - DELETE /upload/file - 删除文件
-  4. 主应用配置 (backend/app/main.py)
-
-    - CORS 中间件配置
-    - API 路由注册
-
-  前端部分
-
-  1. 后端 API 封装 (frontendTest/app-a6ww9j3ja3nl/src/db/backend-api.ts)
-
-    - Excel 上传、预览、删除函数
-  2. Excel 解析页面 (frontendTest/app-a6ww9j3ja3nl/src/pages/ExcelParse.tsx)
-
-    - 拖拽上传界面
-    - 解析选项配置
-    - 数据表格展示
-    - 多工作表支持
-  3. 路由配置 (frontendTest/app-a6ww9j3ja3nl/src/routes.tsx)
-
-    - 添加 /excel-parse 路由
-  4. 环境配置 (.env)
-
-    - 后端 API URL 配置
-
-  测试结果
-
-  后端 API 测试通过：
-  - ✅ 健康检查：http://127.0.0.1:8000/health
-  - ✅ Excel 上传解析：成功解析 5 行 6 列的测试数据
-
-  访问方式
-
-  1. 后端 API 文档：http://127.0.0.1:8000/api/v1/docs
-  2. 前端页面：
-
-    - 启动前端：cd frontendTest/app-a6ww9j3ja3nl && npm run dev
-    - 访问 Excel 解析页面：/excel-parse
-
-  下一步建议
-
-  1. 启动前端开发服务器测试完整的前端界面
-  2. 添加更多文档格式解析支持（docx, md, txt）
-  3. 完善错误处理和用户提示
-
-✻ Worked for 4m 18s · 1 background task still running (↓ to manage)
-
-> 如何启动后端呢
-
-● 后端启动步骤如下：
-
-  方法一：使用命令行启动（开发模式）
-
-  # 1. 进入后端目录
-  cd H:/OwnProject/FilesReadSysteam/backend
-
-  # 2. 激活虚拟环境
-  # PowerShell:
-  .\venv\Scripts\Activate.ps1
-
-  # 或 CMD:
-  .\venv\Scripts\Activate.bat
-
-  # 3. 启动后端服务器
-  python -m uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
-
-  方法二：直接使用虚拟环境中的 Python
-
-  cd H:/OwnProject/FilesReadSysteam/backend
-  ./venv/Scripts/python.exe -m uvicorn app.main:app --host 127.0.0.1 --port 8000 --reload
-
-  方法三：直接运行 main.py（开发调试）
-
-  cd H:/OwnProject/FilesReadSysteam/backend
-  ./venv/Scripts/python.exe app/main.py
-
-  启动成功的标志
-
-  INFO:     Uvicorn running on http://127.0.0.1:8000
-  INFO:     Started server process [xxxxx]
-  INFO:     Waiting for application startup.
-  INFO:     Application startup complete.
-
-  验证服务是否正常
-
-  # 健康检查
-  curl http://127.0.0.1:8000/health
-
-  # 访问 API 文档
-  # 浏览器打开: http://127.0.0.1:8000/api/v1/docs
-
----
-  当前状态：后端已在后台运行（任务 ID: b22jkg69j），可以直接访问 http://127.0.0.1:8000
-
-  需要停止的话告诉我即可。

frontend/.env

@@ -1,7 +1,7 @@
 VITE_APP_ID=app-a6ww9j3ja3nl
 
-VITE_SUPABASE_URL=https://backend.appmiaoda.com/projects/supabase290100332300644352
+VITE_SUPABASE_URL=https://ojtxpvjgqoybhmadimym.supabase.co
 
-VITE_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhdWQiOiJhdXRoZW50aWNhdGVkIiwiZXhwIjoyMDg4NTkyNTA5LCJpc3MiOiJzdXBhYmFzZSIsInJvbGUiOiJhbm9uIiwic3ViIjoiYW5vbiJ9.sdVzWIT_AjxVjEmBaEQcOoFGlHTTT8NH59fYdkaA4WU
+VITE_SUPABASE_ANON_KEY=sb_publishable_VMZMg44D-9bKE6bsbUiSsw_x3rUJbu2
 
 VITE_BACKEND_API_URL=http://localhost:8000/api/v1

frontend/.env.example

@@ -0,0 +1,7 @@
+VITE_APP_ID=
+
+VITE_SUPABASE_URL=
+
+VITE_SUPABASE_ANON_KEY=
+
+VITE_BACKEND_API_URL=http://localhost:8000/api/v1

frontend/src/App.tsx

@@ -1,13 +1,16 @@
 import { RouterProvider } from 'react-router-dom';
-import { AuthProvider } from '@/context/AuthContext';
+import { AuthProvider } from '@/contexts/AuthContext';
+import { TemplateFillProvider } from '@/context/TemplateFillContext';
 import { router } from '@/routes';
 import { Toaster } from 'sonner';
 
 function App() {
   return (
     <AuthProvider>
-      <RouterProvider router={router} />
+      <TemplateFillProvider>
-      <Toaster position="top-right" richColors closeButton />
+        <RouterProvider router={router} />
+        <Toaster position="top-right" richColors closeButton />
+      </TemplateFillProvider>
     </AuthProvider>
   );
 }

frontend/src/components/common/RouteGuard.tsx

@@ -1,6 +1,6 @@
 import React from 'react';
 import { Navigate, useLocation } from 'react-router-dom';
-import { useAuth } from '@/context/AuthContext';
+import { useAuth } from '@/contexts/AuthContext';
 
 export const RouteGuard: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const { user, loading } = useAuth();

frontend/src/components/layouts/MainLayout.tsx

@@ -1,39 +1,29 @@
 import React from 'react';
-import { Link, useLocation, Outlet, useNavigate } from 'react-router-dom';
+import { Link, useLocation, Outlet } from 'react-router-dom';
 import {
   LayoutDashboard,
   FileText,
   TableProperties,
   MessageSquareCode,
-  LogOut,
   Menu,
-  X,
   ChevronRight,
-  User,
+  Sparkles,
-  Sparkles
+  Clock
 } from 'lucide-react';
 import { Button } from '@/components/ui/button';
-import { useAuth } from '@/context/AuthContext';
 import { cn } from '@/lib/utils';
 import { Sheet, SheetContent, SheetTrigger } from '@/components/ui/sheet';
 
 const navItems = [
   { name: '控制台', path: '/', icon: LayoutDashboard },
   { name: '文档中心', path: '/documents', icon: FileText },
-  { name: 'Excel 解析', path: '/excel-parse', icon: Sparkles },
   { name: '智能填表', path: '/form-fill', icon: TableProperties },
   { name: '智能助手', path: '/assistant', icon: MessageSquareCode },
+  { name: '任务历史', path: '/task-history', icon: Clock },
 ];
 
 const MainLayout: React.FC = () => {
-  const { user, profile, signOut } = useAuth();
   const location = useLocation();
-  const navigate = useNavigate();
-
-  const handleSignOut = async () => {
-    await signOut();
-    navigate('/login');
-  };
 
   const SidebarContent = () => (
     <div className="flex flex-col h-full bg-sidebar py-6 border-r border-sidebar-border">
@@ -70,25 +60,17 @@ const MainLayout: React.FC = () => {
       </nav>
 
       <div className="px-4 mt-auto">
-        <div className="bg-sidebar-accent/50 rounded-2xl p-4 mb-4 border border-sidebar-border/50">
+        <div className="bg-sidebar-accent/50 rounded-2xl p-4 border border-sidebar-border/50">
           <div className="flex items-center gap-3">
             <div className="w-10 h-10 rounded-full bg-secondary flex items-center justify-center border-2 border-primary/10">
-              <User size={20} className="text-primary" />
+              <Sparkles size={20} className="text-primary" />
             </div>
             <div className="flex flex-col overflow-hidden">
-              <span className="font-semibold text-sm truncate">{((profile as any)?.email) || '用户'}</span>
+              <span className="font-semibold text-sm truncate">智联文档</span>
-              <span className="text-[10px] uppercase tracking-wider text-muted-foreground">{((profile as any)?.role) || 'User'}</span>
+              <span className="text-[10px] uppercase tracking-wider text-muted-foreground">多源数据融合</span>
             </div>
           </div>
         </div>
-        <Button 
-          variant="outline" 
-          className="w-full justify-start gap-3 border-none hover:bg-destructive/10 hover:text-destructive group rounded-xl"
-          onClick={handleSignOut}
-        >
-          <LogOut size={18} className="group-hover:rotate-180 transition-transform duration-300" />
-          <span>退出登录</span>
-        </Button>
       </div>
     </div>
   );

frontend/src/context/AuthContext.tsx

@@ -1,85 +0,0 @@
-import React, { createContext, useContext, useEffect, useState } from 'react';
-import { supabase } from '@/db/supabase';
-import { User } from '@supabase/supabase-js';
-import { Profile } from '@/types/types';
-
-interface AuthContextType {
-  user: User | null;
-  profile: Profile | null;
-  signIn: (email: string, password: string) => Promise<{ error: any }>;
-  signUp: (email: string, password: string) => Promise<{ error: any }>;
-  signOut: () => Promise<{ error: any }>;
-  loading: boolean;
-}
-
-const AuthContext = createContext<AuthContextType | undefined>(undefined);
-
-export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-  const [user, setUser] = useState<User | null>(null);
-  const [profile, setProfile] = useState<Profile | null>(null);
-  const [loading, setLoading] = useState(true);
-
-  useEffect(() => {
-    // Check active sessions and sets the user
-    supabase.auth.getSession().then(({ data: { session } }) => {
-      setUser(session?.user ?? null);
-      if (session?.user) fetchProfile(session.user.id);
-      else setLoading(false);
-    });
-
-    // Listen for changes on auth state (sign in, sign out, etc.)
-    const { data: { subscription } } = supabase.auth.onAuthStateChange((_event, session) => {
-      setUser(session?.user ?? null);
-      if (session?.user) fetchProfile(session.user.id);
-      else {
-        setProfile(null);
-        setLoading(false);
-      }
-    });
-
-    return () => subscription.unsubscribe();
-  }, []);
-
-  const fetchProfile = async (uid: string) => {
-    try {
-      const { data, error } = await supabase
-        .from('profiles')
-        .select('*')
-        .eq('id', uid)
-        .maybeSingle();
-      
-      if (error) throw error;
-      setProfile(data);
-    } catch (err) {
-      console.error('Error fetching profile:', err);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const signIn = async (email: string, password: string) => {
-    return await supabase.auth.signInWithPassword({ email, password });
-  };
-
-  const signUp = async (email: string, password: string) => {
-    return await supabase.auth.signUp({ email, password });
-  };
-
-  const signOut = async () => {
-    return await supabase.auth.signOut();
-  };
-
-  return (
-    <AuthContext.Provider value={{ user, profile, signIn, signUp, signOut, loading }}>
-      {children}
-    </AuthContext.Provider>
-  );
-};
-
-export const useAuth = () => {
-  const context = useContext(AuthContext);
-  if (context === undefined) {
-    throw new Error('useAuth must be used within an AuthProvider');
-  }
-  return context;
-};

frontend/src/context/TemplateFillContext.tsx

@@ -0,0 +1,136 @@
+import React, { createContext, useContext, useState, ReactNode } from 'react';
+
+type SourceFile = {
+  file: File;
+  preview?: string;
+};
+
+type TemplateField = {
+  cell: string;
+  name: string;
+  field_type: string;
+  required: boolean;
+  hint?: string;
+};
+
+type Step = 'upload' | 'filling' | 'preview';
+
+interface TemplateFillState {
+  step: Step;
+  templateFile: File | null;
+  templateFields: TemplateField[];
+  sourceFiles: SourceFile[];
+  sourceFilePaths: string[];
+  sourceDocIds: string[];
+  templateId: string;
+  filledResult: any;
+  setStep: (step: Step) => void;
+  setTemplateFile: (file: File | null) => void;
+  setTemplateFields: (fields: TemplateField[]) => void;
+  setSourceFiles: (files: SourceFile[]) => void;
+  addSourceFiles: (files: SourceFile[]) => void;
+  removeSourceFile: (index: number) => void;
+  setSourceFilePaths: (paths: string[]) => void;
+  setSourceDocIds: (ids: string[]) => void;
+  addSourceDocId: (id: string) => void;
+  removeSourceDocId: (id: string) => void;
+  setTemplateId: (id: string) => void;
+  setFilledResult: (result: any) => void;
+  reset: () => void;
+}
+
+const initialState = {
+  step: 'upload' as Step,
+  templateFile: null,
+  templateFields: [],
+  sourceFiles: [],
+  sourceFilePaths: [],
+  sourceDocIds: [],
+  templateId: '',
+  filledResult: null,
+  setStep: () => {},
+  setTemplateFile: () => {},
+  setTemplateFields: () => {},
+  setSourceFiles: () => {},
+  addSourceFiles: () => {},
+  removeSourceFile: () => {},
+  setSourceFilePaths: () => {},
+  setSourceDocIds: () => {},
+  addSourceDocId: () => {},
+  removeSourceDocId: () => {},
+  setTemplateId: () => {},
+  setFilledResult: () => {},
+  reset: () => {},
+};
+
+const TemplateFillContext = createContext<TemplateFillState>(initialState);
+
+export const TemplateFillProvider: React.FC<{ children: ReactNode }> = ({ children }) => {
+  const [step, setStep] = useState<Step>('upload');
+  const [templateFile, setTemplateFile] = useState<File | null>(null);
+  const [templateFields, setTemplateFields] = useState<TemplateField[]>([]);
+  const [sourceFiles, setSourceFiles] = useState<SourceFile[]>([]);
+  const [sourceFilePaths, setSourceFilePaths] = useState<string[]>([]);
+  const [sourceDocIds, setSourceDocIds] = useState<string[]>([]);
+  const [templateId, setTemplateId] = useState<string>('');
+  const [filledResult, setFilledResult] = useState<any>(null);
+
+  const addSourceFiles = (files: SourceFile[]) => {
+    setSourceFiles(prev => [...prev, ...files]);
+  };
+
+  const removeSourceFile = (index: number) => {
+    setSourceFiles(prev => prev.filter((_, i) => i !== index));
+  };
+
+  const addSourceDocId = (id: string) => {
+    setSourceDocIds(prev => prev.includes(id) ? prev : [...prev, id]);
+  };
+
+  const removeSourceDocId = (id: string) => {
+    setSourceDocIds(prev => prev.filter(docId => docId !== id));
+  };
+
+  const reset = () => {
+    setStep('upload');
+    setTemplateFile(null);
+    setTemplateFields([]);
+    setSourceFiles([]);
+    setSourceFilePaths([]);
+    setSourceDocIds([]);
+    setTemplateId('');
+    setFilledResult(null);
+  };
+
+  return (
+    <TemplateFillContext.Provider
+      value={{
+        step,
+        templateFile,
+        templateFields,
+        sourceFiles,
+        sourceFilePaths,
+        sourceDocIds,
+        templateId,
+        filledResult,
+        setStep,
+        setTemplateFile,
+        setTemplateFields,
+        setSourceFiles,
+        addSourceFiles,
+        removeSourceFile,
+        setSourceFilePaths,
+        setSourceDocIds,
+        addSourceDocId,
+        removeSourceDocId,
+        setTemplateId,
+        setFilledResult,
+        reset,
+      }}
+    >
+      {children}
+    </TemplateFillContext.Provider>
+  );
+};
+
+export const useTemplateFill = () => useContext(TemplateFillContext);

frontend/src/pages/Dashboard.tsx

@@ -1,72 +1,95 @@
 import React, { useEffect, useState } from 'react';
 import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
-import { useNavigate, Link } from 'react-router-dom';
+import { Link } from 'react-router-dom';
 import { Button } from '@/components/ui/button';
-import { 
+import {
-  FileText, 
+  FileText,
-  TableProperties, 
+  TableProperties,
-  MessageSquareCode, 
+  MessageSquareCode,
-  TrendingUp, 
+  TrendingUp,
-  Clock, 
+  Clock,
-  CheckCircle2, 
+  CheckCircle2,
   ArrowRight,
   UploadCloud,
   Layers,
-  Sparkles
+  Sparkles,
+  Database,
+  FileSpreadsheet,
+  RefreshCcw
 } from 'lucide-react';
-import { useAuth } from '@/context/AuthContext';
+import { backendApi } from '@/db/backend-api';
-import { documentApi, taskApi } from '@/db/api';
 import { formatDistanceToNow } from 'date-fns';
 import { zhCN } from 'date-fns/locale';
 import { cn } from '@/lib/utils';
 
-type Document = any;
+type DocumentItem = {
-type FillTask = any;
+  doc_id: string;
+  filename: string;
+  original_filename: string;
+  doc_type: string;
+  file_size: number;
+  created_at: string;
+  metadata?: {
+    row_count?: number;
+    column_count?: number;
+    columns?: string[];
+  };
+};
+
+type TaskItem = {
+  task_id: string;
+  status: string;
+  created_at: string;
+  message?: string;
+};
 
 const Dashboard: React.FC = () => {
-  const navigate = useNavigate();
+  const [stats, setStats] = useState({ docs: 0, excelFiles: 0, tasks: 0 });
-  const { profile } = useAuth();
+  const [recentDocs, setRecentDocs] = useState<DocumentItem[]>([]);
-  const [stats, setStats] = useState({ docs: 0, entities: 0, tasks: 0 });
+  const [recentTasks, setRecentTasks] = useState<TaskItem[]>([]);
-  const [recentDocs, setRecentDocs] = useState<Document[]>([]);
-  const [recentTasks, setRecentTasks] = useState<any[]>([]);
   const [loading, setLoading] = useState(true);
 
-  useEffect(() => {
+  const loadData = async () => {
-    if (!profile) return;
+    setLoading(true);
-    const loadData = async () => {
+    try {
-      try {
+      // 获取文档列表
-        const docs = await documentApi.listDocuments((profile as any).id);
+      const docsResult = await backendApi.getDocuments(undefined, 50);
-        const tasks = await taskApi.listTasks((profile as any).id);
+      if (docsResult.success && docsResult.documents) {
-        setRecentDocs(docs.slice(0, 5));
+        setRecentDocs(docsResult.documents.slice(0, 5));
-        setRecentTasks(tasks.slice(0, 5));
+
-        
+        // 分类统计
-        let entityCount = 0;
+        const docxMdTxt = docsResult.documents.filter((d: DocumentItem) =>
-        docs.forEach(d => {
+          ['docx', 'md', 'txt'].includes(d.doc_type)
-          if (d.extracted_entities) entityCount += (d.extracted_entities as any[]).length;
+        ).length;
-        });
+        const xlsx = docsResult.documents.filter((d: DocumentItem) =>
+          d.doc_type === 'xlsx'
+        ).length;
 
         setStats({
-          docs: docs.length,
+          docs: docxMdTxt,
-          entities: entityCount,
+          excelFiles: xlsx,
-          tasks: tasks.length
+          tasks: 0  // TODO: 后端任务接口
         });
-      } catch (err) {
-        console.error(err);
-      } finally {
-        setLoading(false);
       }
-    };
+    } catch (err) {
+      console.error('加载数据失败:', err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
     loadData();
-  }, [profile]);
+  }, []);
 
   return (
     <div className="space-y-8 animate-fade-in">
       <section className="flex flex-col md:flex-row md:items-center justify-between gap-4">
         <div className="space-y-1">
           <h1 className="text-3xl font-extrabold tracking-tight">
-            你好, <span className="text-primary">{((profile as any)?.email)?.split('@')[0] || '用户'}</span> 👋
+            欢迎使用 <span className="text-primary">智联文档</span> 系统 👋
           </h1>
-          <p className="text-muted-foreground">欢迎使用智联文档，今日已为你处理了多个任务。</p>
+          <p className="text-muted-foreground">基于大语言模型的文档理解与多源数据融合系统</p>
         </div>
         <div className="flex items-center gap-3">
           <Button variant="outline" className="rounded-xl" asChild>
@@ -84,9 +107,9 @@ const Dashboard: React.FC = () => {
       {/* Stats Grid */}
       <div className="grid grid-cols-1 md:grid-cols-3 gap-6">
         {[
-          { label: '已上传文档', value: stats.docs, icon: FileText, color: 'bg-blue-500', trend: '+12% 较上周' },
+          { label: '已上传文档', value: stats.docs, icon: FileText, color: 'bg-blue-500', trend: '非结构化文档', link: '/documents' },
-          { label: '提取实体', value: stats.entities, icon: Layers, color: 'bg-indigo-500', trend: '+25% 较上周' },
+          { label: 'Excel 文件', value: stats.excelFiles, icon: FileSpreadsheet, color: 'bg-emerald-500', trend: '结构化数据', link: '/excel-parse' },
-          { label: '生成表格', value: stats.tasks, icon: TableProperties, color: 'bg-emerald-500', trend: '+8% 较上周' }
+          { label: '填表任务', value: stats.tasks, icon: TableProperties, color: 'bg-indigo-500', trend: '待实现', link: '/form-fill' }
         ].map((stat, i) => (
           <Card key={i} className="border-none shadow-md overflow-hidden group hover:shadow-xl transition-all duration-300">
             <CardContent className="p-0">
@@ -94,8 +117,7 @@ const Dashboard: React.FC = () => {
                 <div className="space-y-2">
                   <p className="text-sm font-medium text-muted-foreground">{stat.label}</p>
                   <p className="text-3xl font-bold tracking-tight">{stat.value}</p>
-                  <div className="flex items-center gap-1 text-xs text-emerald-500 font-medium bg-emerald-500/10 px-2 py-1 rounded-full w-fit">
+                  <div className="flex items-center gap-1 text-xs text-muted-foreground bg-muted px-2 py-1 rounded-full w-fit">
-                    <TrendingUp size={12} />
                     <span>{stat.trend}</span>
                   </div>
                 </div>
@@ -118,7 +140,7 @@ const Dashboard: React.FC = () => {
                 <Clock className="text-primary" size={20} />
                 最近上传
               </CardTitle>
-              <CardDescription>你最近上传并处理的非结构化文档</CardDescription>
+              <CardDescription>您最近上传的文档文件</CardDescription>
             </div>
             <Button variant="ghost" size="sm" asChild className="text-primary hover:text-primary/80 hover:bg-primary/5">
               <Link to="/documents">查看全部 <ArrowRight size={14} className="ml-1" /></Link>
@@ -132,21 +154,18 @@ const Dashboard: React.FC = () => {
             ) : recentDocs.length > 0 ? (
               <div className="space-y-3">
                 {recentDocs.map(doc => (
-                  <div key={doc.id} className="flex items-center gap-4 p-3 rounded-xl border border-transparent hover:border-border hover:bg-muted/30 transition-all group">
+                  <div key={doc.doc_id} className="flex items-center gap-4 p-3 rounded-xl border border-transparent hover:border-border hover:bg-muted/30 transition-all group">
                     <div className="w-10 h-10 rounded-lg bg-blue-500/10 text-blue-500 flex items-center justify-center">
                       <FileText size={20} />
                     </div>
                     <div className="flex-1 min-w-0">
-                      <p className="font-semibold text-sm truncate">{doc.name}</p>
+                      <p className="font-semibold text-sm truncate">{doc.original_filename}</p>
                       <p className="text-xs text-muted-foreground">
-                        {formatDistanceToNow(new Date(doc.created_at!), { addSuffix: true, locale: zhCN })}
+                        {doc.doc_type.toUpperCase()} • {formatDistanceToNow(new Date(doc.created_at), { addSuffix: true, locale: zhCN })}
                       </p>
                     </div>
-                    <div className={cn(
+                    <div className="px-2 py-1 rounded-full text-[10px] font-bold uppercase tracking-wider bg-muted">
-                      "px-2 py-1 rounded-full text-[10px] font-bold uppercase tracking-wider",
+                      {doc.doc_type}
-                      doc.status === 'completed' ? "bg-emerald-500/10 text-emerald-500" : "bg-amber-500/10 text-amber-500"
-                    )}>
-                      {doc.status === 'completed' ? '已解析' : '处理中'}
                     </div>
                   </div>
                 ))}
@@ -163,58 +182,81 @@ const Dashboard: React.FC = () => {
           </CardContent>
         </Card>
 
-        {/* Recent Tasks */}
+        {/* Quick Actions */}
         <Card className="border-none shadow-md">
           <CardHeader className="flex flex-row items-center justify-between pb-2">
             <div className="space-y-1">
               <CardTitle className="text-xl flex items-center gap-2">
-                <CheckCircle2 className="text-primary" size={20} />
+                <Sparkles className="text-primary" size={20} />
-                填表记录
+                快速开始
               </CardTitle>
-              <CardDescription>自动化生成的表格与汇总结果</CardDescription>
+              <CardDescription>选择您需要的服务开始使用</CardDescription>
             </div>
-            <Button variant="ghost" size="sm" asChild className="text-primary hover:text-primary/80 hover:bg-primary/5">
-              <Link to="/form-fill">查看全部 <ArrowRight size={14} className="ml-1" /></Link>
-            </Button>
           </CardHeader>
           <CardContent>
-            {loading ? (
+            <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
-              <div className="space-y-4 py-4">
+              {[
-                {[1, 2, 3].map(i => <div key={i} className="h-12 bg-muted rounded-xl animate-pulse" />)}
+                { title: '上传文档', desc: '支持 docx/md/txt', icon: FileText, link: '/documents', color: 'bg-blue-500' },
-              </div>
+                { title: '解析 Excel', desc: '上传并分析数据', icon: FileSpreadsheet, link: '/excel-parse', color: 'bg-emerald-500' },
-            ) : recentTasks.length > 0 ? (
+                { title: '智能填表', desc: '自动填写表格模板', icon: TableProperties, link: '/form-fill', color: 'bg-indigo-500' },
-              <div className="space-y-3">
+                { title: 'AI 助手', desc: '自然语言交互', icon: MessageSquareCode, link: '/assistant', color: 'bg-amber-500' }
-                {recentTasks.map(task => (
+              ].map((item, i) => (
-                  <div key={task.id} className="flex items-center gap-4 p-3 rounded-xl border border-transparent hover:border-border hover:bg-muted/30 transition-all">
+                <Link
-                    <div className="w-10 h-10 rounded-lg bg-emerald-500/10 text-emerald-500 flex items-center justify-center">
+                  key={i}
-                      <TableProperties size={20} />
+                  to={item.link}
-                    </div>
+                  className="flex items-center gap-4 p-4 rounded-2xl border border-transparent hover:border-border hover:bg-muted/30 transition-all group"
-                    <div className="flex-1 min-w-0">
+                >
-                      <p className="font-semibold text-sm truncate">{task.templates?.name || '未知模板'}</p>
+                  <div className={cn("w-12 h-12 rounded-xl flex items-center justify-center text-white shadow-lg", item.color)}>
-                      <p className="text-xs text-muted-foreground">
+                    <item.icon size={24} />
-                        关联 {task.document_ids?.length || 0} 个文档 • {formatDistanceToNow(new Date(task.created_at!), { addSuffix: true, locale: zhCN })}
-                      </p>
-                    </div>
-                    <Button variant="ghost" size="icon" className="text-primary h-8 w-8" onClick={() => navigate('/form-fill')}>
-                      <ArrowRight size={16} />
-                    </Button>
                   </div>
-                ))}
+                  <div>
-              </div>
+                    <p className="font-semibold group-hover:text-primary transition-colors">{item.title}</p>
-            ) : (
+                    <p className="text-xs text-muted-foreground">{item.desc}</p>
-              <div className="flex flex-col items-center justify-center py-10 text-center space-y-3">
+                  </div>
-                <MessageSquareCode size={48} className="text-muted-foreground/30" />
+                  <ArrowRight size={16} className="ml-auto opacity-0 group-hover:opacity-100 transition-opacity" />
-                <p className="text-muted-foreground italic">暂无任务记录</p>
+                </Link>
-                <Button variant="outline" size="sm" asChild className="rounded-xl">
+              ))}
-                  <Link to="/form-fill">开始填表</Link>
+            </div>
-                </Button>
-              </div>
-            )}
           </CardContent>
         </Card>
       </div>
+
+      {/* System Status */}
+      <Card className="border-none shadow-md">
+        <CardHeader className="pb-2">
+          <CardTitle className="text-xl flex items-center gap-2">
+            <Database className="text-primary" size={20} />
+            系统状态
+          </CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+            <div className="flex items-center gap-3 p-4 rounded-xl bg-muted/30">
+              <div className="w-3 h-3 rounded-full bg-emerald-500" />
+              <div>
+                <p className="font-semibold text-sm">MySQL</p>
+                <p className="text-xs text-muted-foreground">结构化数据存储</p>
+              </div>
+            </div>
+            <div className="flex items-center gap-3 p-4 rounded-xl bg-muted/30">
+              <div className="w-3 h-3 rounded-full bg-emerald-500" />
+              <div>
+                <p className="font-semibold text-sm">MongoDB</p>
+                <p className="text-xs text-muted-foreground">非结构化数据存储</p>
+              </div>
+            </div>
+            <div className="flex items-center gap-3 p-4 rounded-xl bg-muted/30">
+              <div className="w-3 h-3 rounded-full bg-emerald-500" />
+              <div>
+                <p className="font-semibold text-sm">Faiss + RAG</p>
+                <p className="text-xs text-muted-foreground">向量检索索引</p>
+              </div>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
     </div>
   );
 };
 
-export default Dashboard;
+export default Dashboard;

frontend/src/pages/FormFill.tsx

@@ -1,603 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import {
-  TableProperties,
-  Plus,
-  FilePlus,
-  CheckCircle2,
-  Download,
-  Clock,
-  RefreshCcw,
-  Sparkles,
-  Zap,
-  FileCheck,
-  FileSpreadsheet,
-  Trash2,
-  ChevronDown,
-  ChevronUp,
-  BarChart3,
-  FileText,
-  TrendingUp,
-  Info,
-  AlertCircle,
-  Loader2
-} from 'lucide-react';
-import { Button } from '@/components/ui/button';
-import { Card, CardContent, CardHeader, CardTitle, CardDescription, CardFooter } from '@/components/ui/card';
-import { Badge } from '@/components/ui/badge';
-import { useAuth } from '@/context/AuthContext';
-import { templateApi, documentApi, taskApi } from '@/db/api';
-import { backendApi, aiApi } from '@/db/backend-api';
-import { supabase } from '@/db/supabase';
-import { format } from 'date-fns';
-import { toast } from 'sonner';
-import { cn } from '@/lib/utils';
-import { Skeleton } from '@/components/ui/skeleton';
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogTrigger,
-  DialogFooter,
-  DialogDescription
-} from '@/components/ui/dialog';
-import { Checkbox } from '@/components/ui/checkbox';
-import { ScrollArea } from '@/components/ui/scroll-area';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { Textarea } from '@/components/ui/textarea';
-import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
-import { useDropzone } from 'react-dropzone';
-import { Markdown } from '@/components/ui/markdown';
-
-type Template = any;
-type Document = any;
-type FillTask = any;
-
-const FormFill: React.FC = () => {
-  const { profile } = useAuth();
-  const [templates, setTemplates] = useState<Template[]>([]);
-  const [documents, setDocuments] = useState<Document[]>([]);
-  const [tasks, setTasks] = useState<any[]>([]);
-  const [loading, setLoading] = useState(true);
-
-  // Selection state
-  const [selectedTemplate, setSelectedTemplate] = useState<string | null>(null);
-  const [selectedDocs, setSelectedDocs] = useState<string[]>([]);
-  const [creating, setCreating] = useState(false);
-  const [openTaskDialog, setOpenTaskDialog] = useState(false);
-  const [viewingTask, setViewingTask] = useState<any | null>(null);
-
-  // Excel upload state
-  const [excelFile, setExcelFile] = useState<File | null>(null);
-  const [excelParseResult, setExcelParseResult] = useState<any>(null);
-  const [excelAnalysis, setExcelAnalysis] = useState<any>(null);
-  const [excelAnalyzing, setExcelAnalyzing] = useState(false);
-  const [expandedSheet, setExpandedSheet] = useState<string | null>(null);
-  const [aiOptions, setAiOptions] = useState({
-    userPrompt: '请分析这些数据，并提取关键信息用于填表，包括数值、分类、摘要等。',
-    analysisType: 'general' as 'general' | 'summary' | 'statistics' | 'insights'
-  });
-
-  const loadData = async () => {
-    if (!profile) return;
-    try {
-      const [t, d, ts] = await Promise.all([
-        templateApi.listTemplates((profile as any).id),
-        documentApi.listDocuments((profile as any).id),
-        taskApi.listTasks((profile as any).id)
-      ]);
-      setTemplates(t);
-      setDocuments(d);
-      setTasks(ts);
-    } catch (err: any) {
-      toast.error('数据加载失败');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  useEffect(() => {
-    loadData();
-  }, [profile]);
-
-  // Excel upload handlers
-  const onExcelDrop = async (acceptedFiles: File[]) => {
-    const file = acceptedFiles[0];
-    if (!file) return;
-
-    if (!file.name.match(/\.(xlsx|xls)$/i)) {
-      toast.error('仅支持 .xlsx 和 .xls 格式的 Excel 文件');
-      return;
-    }
-
-    setExcelFile(file);
-    setExcelParseResult(null);
-    setExcelAnalysis(null);
-    setExpandedSheet(null);
-
-    try {
-      const result = await backendApi.uploadExcel(file);
-      if (result.success) {
-        toast.success(`Excel 解析成功: ${file.name}`);
-        setExcelParseResult(result);
-      } else {
-        toast.error(result.error || '解析失败');
-      }
-    } catch (error: any) {
-      toast.error(error.message || '上传失败');
-    }
-  };
-
-  const { getRootProps, getInputProps, isDragActive } = useDropzone({
-    onDrop: onExcelDrop,
-    accept: {
-      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': ['.xlsx'],
-      'application/vnd.ms-excel': ['.xls']
-    },
-    maxFiles: 1
-  });
-
-  const handleAnalyzeExcel = async () => {
-    if (!excelFile || !excelParseResult?.success) {
-      toast.error('请先上传并解析 Excel 文件');
-      return;
-    }
-
-    setExcelAnalyzing(true);
-    setExcelAnalysis(null);
-
-    try {
-      const result = await aiApi.analyzeExcel(excelFile, {
-        userPrompt: aiOptions.userPrompt,
-        analysisType: aiOptions.analysisType
-      });
-
-      if (result.success) {
-        toast.success('AI 分析完成');
-        setExcelAnalysis(result);
-      } else {
-        toast.error(result.error || 'AI 分析失败');
-      }
-    } catch (error: any) {
-      toast.error(error.message || 'AI 分析失败');
-    } finally {
-      setExcelAnalyzing(false);
-    }
-  };
-
-  const handleUseExcelData = () => {
-    if (!excelParseResult?.success) {
-      toast.error('请先解析 Excel 文件');
-      return;
-    }
-
-    // 将 Excel 解析的数据标记为"文档"，添加到选择列表
-    toast.success('Excel 数据已添加到数据源，请在任务对话框中选择');
-    // 这里可以添加逻辑来将 Excel 数据传递给后端创建任务
-  };
-
-  const handleDeleteExcel = () => {
-    setExcelFile(null);
-    setExcelParseResult(null);
-    setExcelAnalysis(null);
-    setExpandedSheet(null);
-    toast.success('Excel 文件已清除');
-  };
-
-  const handleUploadTemplate = async (e: React.ChangeEvent<HTMLInputElement>) => {
-    const file = e.target.files?.[0];
-    if (!file || !profile) return;
-
-    try {
-      toast.loading('正在上传模板...');
-      await templateApi.uploadTemplate(file, (profile as any).id);
-      toast.dismiss();
-      toast.success('模板上传成功');
-      loadData();
-    } catch (err) {
-      toast.dismiss();
-      toast.error('上传模板失败');
-    }
-  };
-
-  const handleCreateTask = async () => {
-    if (!profile || !selectedTemplate || selectedDocs.length === 0) {
-      toast.error('请先选择模板和数据源文档');
-      return;
-    }
-
-    setCreating(true);
-    try {
-      const task = await taskApi.createTask((profile as any).id, selectedTemplate, selectedDocs);
-      if (task) {
-        toast.success('任务已创建，正在进行智能填表...');
-        setOpenTaskDialog(false);
-
-        // Invoke edge function
-        supabase.functions.invoke('fill-template', {
-          body: { taskId: task.id }
-        }).then(({ error }) => {
-          if (error) toast.error('填表任务执行失败');
-          else {
-            toast.success('表格填写完成！');
-            loadData();
-          }
-        });
-        loadData();
-      }
-    } catch (err: any) {
-      toast.error('创建任务失败');
-    } finally {
-      setCreating(false);
-    }
-  };
-
-  const getStatusColor = (status: string) => {
-    switch (status) {
-      case 'completed': return 'bg-emerald-500 text-white';
-      case 'failed': return 'bg-destructive text-white';
-      default: return 'bg-amber-500 text-white';
-    }
-  };
-
-  const formatFileSize = (bytes: number): string => {
-    if (bytes === 0) return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
-  };
-
-  return (
-    <div className="space-y-8 animate-fade-in pb-10">
-      <section className="flex flex-col md:flex-row md:items-center justify-between gap-4">
-        <div className="space-y-1">
-          <h1 className="text-3xl font-extrabold tracking-tight">智能填表</h1>
-          <p className="text-muted-foreground">根据您的表格模板，自动聚合多源文档信息进行精准填充，告别重复劳动。</p>
-        </div>
-        <div className="flex items-center gap-3">
-          <Dialog open={openTaskDialog} onOpenChange={setOpenTaskDialog}>
-            <DialogTrigger asChild>
-              <Button className="rounded-xl shadow-lg shadow-primary/20 gap-2 h-11 px-6">
-                <FilePlus size={18} />
-                <span>新建填表任务</span>
-              </Button>
-            </DialogTrigger>
-            <DialogContent className="max-w-4xl max-h-[90vh] flex flex-col p-0 overflow-hidden border-none shadow-2xl rounded-3xl">
-              <DialogHeader className="p-8 pb-4 bg-muted/50">
-                <DialogTitle className="text-2xl font-bold flex items-center gap-2">
-                  <Sparkles size={24} className="text-primary" />
-                  开启智能填表之旅
-                </DialogTitle>
-                <DialogDescription>
-                  选择一个表格模板及若干个数据源文档，AI 将自动为您分析并填写。
-                </DialogDescription>
-              </DialogHeader>
-
-              <ScrollArea className="flex-1 p-8 pt-4">
-                <div className="space-y-8">
-                  {/* Step 1: Select Template */}
-                  <div className="space-y-4">
-                    <div className="flex items-center justify-between">
-                      <h4 className="font-bold flex items-center gap-2 text-primary uppercase tracking-widest text-xs">
-                        <span className="w-5 h-5 rounded-full bg-primary text-white flex items-center justify-center text-[10px]">1</span>
-                        选择表格模板
-                      </h4>
-                      <label className="cursor-pointer text-xs font-semibold text-primary hover:underline flex items-center gap-1">
-                        <Plus size={12} /> 上传新模板
-                        <input type="file" className="hidden" onChange={handleUploadTemplate} accept=".docx,.xlsx" />
-                      </label>
-                    </div>
-                    {templates.length > 0 ? (
-                      <div className="grid grid-cols-1 sm:grid-cols-2 gap-3">
-                        {templates.map(t => (
-                          <div
-                            key={t.id}
-                            className={cn(
-                              "p-4 rounded-2xl border-2 transition-all cursor-pointer flex items-center gap-3 group relative overflow-hidden",
-                              selectedTemplate === t.id ? "border-primary bg-primary/5" : "border-border hover:border-primary/50"
-                            )}
-                            onClick={() => setSelectedTemplate(t.id)}
-                          >
-                            <div className={cn(
-                              "w-10 h-10 rounded-xl flex items-center justify-center shrink-0 transition-colors",
-                              selectedTemplate === t.id ? "bg-primary text-white" : "bg-muted text-muted-foreground"
-                            )}>
-                              <TableProperties size={20} />
-                            </div>
-                            <div className="flex-1 min-w-0">
-                              <p className="font-bold text-sm truncate">{t.name}</p>
-                              <p className="text-[10px] text-muted-foreground uppercase">{t.type}</p>
-                            </div>
-                            {selectedTemplate === t.id && (
-                              <div className="absolute top-0 right-0 w-8 h-8 bg-primary text-white flex items-center justify-center rounded-bl-xl">
-                                <CheckCircle2 size={14} />
-                              </div>
-                            )}
-                          </div>
-                        ))}
-                      </div>
-                    ) : (
-                      <div className="p-8 text-center bg-muted/30 rounded-2xl border border-dashed text-sm italic text-muted-foreground">
-                        暂无模板，请先点击右上角上传。
-                      </div>
-                    )}
-                  </div>
-
-                  {/* Step 2: Upload & Analyze Excel */}
-                  <div className="space-y-4">
-                    <h4 className="font-bold flex items-center gap-2 text-primary uppercase tracking-widest text-xs">
-                      <span className="w-5 h-5 rounded-full bg-primary text-white flex items-center justify-center text-[10px]">1.5</span>
-                      Excel 数据源
-                    </h4>
-                    <div className="bg-muted/20 rounded-2xl p-6">
-                      {!excelFile ? (
-                        <div
-                          {...getRootProps()}
-                          className={cn(
-                            "border-2 border-dashed rounded-xl p-8 transition-all duration-300 flex flex-col items-center justify-center text-center cursor-pointer group",
-                            isDragActive ? "border-primary bg-primary/5" : "border-muted-foreground/20 hover:border-primary/50 hover:bg-muted/30"
-                          )}
-                        >
-                          <input {...getInputProps()} />
-                          <div className="w-12 h-12 rounded-xl bg-primary/10 text-primary flex items-center justify-center mb-3 group-hover:scale-110 transition-transform">
-                            <FileSpreadsheet size={24} />
-                          </div>
-                          <p className="font-semibold text-sm">
-                            {isDragActive ? '释放以开始上传' : '点击或拖拽 Excel 文件'}
-                          </p>
-                          <p className="text-xs text-muted-foreground mt-1">支持 .xlsx 和 .xls 格式</p>
-                        </div>
-                      ) : (
-                        <div className="space-y-4">
-                          <div className="flex items-center gap-3 p-3 bg-background rounded-xl">
-                            <div className="w-10 h-10 rounded-lg bg-emerald-500/10 text-emerald-500 flex items-center justify-center">
-                              <FileSpreadsheet size={20} />
-                            </div>
-                            <div className="flex-1 min-w-0">
-                              <p className="font-semibold text-sm truncate">{excelFile.name}</p>
-                              <p className="text-xs text-muted-foreground">{formatFileSize(excelFile.size)}</p>
-                            </div>
-                            <div className="flex gap-2">
-                              <Button
-                                variant="ghost"
-                                size="icon"
-                                className="text-destructive hover:bg-destructive/10"
-                                onClick={handleDeleteExcel}
-                              >
-                                <Trash2 size={16} />
-                              </Button>
-                            </div>
-                          </div>
-
-                          {/* AI Analysis Options */}
-                          {excelParseResult?.success && (
-                            <div className="space-y-3">
-                              <div className="space-y-2">
-                                <Label htmlFor="analysis-type" className="text-xs">分析类型</Label>
-                                <Select
-                                  value={aiOptions.analysisType}
-                                  onValueChange={(value: any) => setAiOptions({ ...aiOptions, analysisType: value })}
-                                >
-                                  <SelectTrigger id="analysis-type" className="bg-background h-9 text-sm">
-                                    <SelectValue placeholder="选择分析类型" />
-                                  </SelectTrigger>
-                                  <SelectContent>
-                                    <SelectItem value="general">综合分析</SelectItem>
-                                    <SelectItem value="summary">数据摘要</SelectItem>
-                                    <SelectItem value="statistics">统计分析</SelectItem>
-                                    <SelectItem value="insights">深度洞察</SelectItem>
-                                  </SelectContent>
-                                </Select>
-                              </div>
-                              <div className="space-y-2">
-                                <Label htmlFor="user-prompt" className="text-xs">自定义提示词</Label>
-                                <Textarea
-                                  id="user-prompt"
-                                  value={aiOptions.userPrompt}
-                                  onChange={(e) => setAiOptions({ ...aiOptions, userPrompt: e.target.value })}
-                                  className="bg-background resize-none text-sm"
-                                  rows={2}
-                                />
-                              </div>
-                              <Button
-                                onClick={handleAnalyzeExcel}
-                                disabled={excelAnalyzing}
-                                className="w-full gap-2 h-9"
-                                variant="outline"
-                              >
-                                {excelAnalyzing ? <Loader2 className="animate-spin" size={14} /> : <Sparkles size={14} />}
-                                {excelAnalyzing ? '分析中...' : 'AI 分析'}
-                              </Button>
-                              {excelParseResult?.success && (
-                                <Button
-                                  onClick={handleUseExcelData}
-                                  className="w-full gap-2 h-9"
-                                >
-                                  <CheckCircle2 size={14} />
-                                  使用此数据源
-                                </Button>
-                              )}
-                            </div>
-                          )}
-
-                          {/* Excel Analysis Result */}
-                          {excelAnalysis && (
-                            <div className="mt-4 p-4 bg-background rounded-xl max-h-60 overflow-y-auto">
-                              <div className="flex items-center gap-2 mb-3">
-                                <Sparkles size={16} className="text-primary" />
-                                <span className="font-semibold text-sm">AI 分析结果</span>
-                              </div>
-                              <Markdown content={excelAnalysis.analysis?.analysis || ''} className="text-sm" />
-                            </div>
-                          )}
-                        </div>
-                      )}
-                    </div>
-                  </div>
-
-                  {/* Step 3: Select Documents */}
-                  <div className="space-y-4">
-                    <h4 className="font-bold flex items-center gap-2 text-primary uppercase tracking-widest text-xs">
-                      <span className="w-5 h-5 rounded-full bg-primary text-white flex items-center justify-center text-[10px]">2</span>
-                      选择其他数据源文档
-                    </h4>
-                    {documents.filter(d => d.status === 'completed').length > 0 ? (
-                      <div className="space-y-2 max-h-40 overflow-y-auto pr-2 custom-scrollbar">
-                        {documents.filter(d => d.status === 'completed').map(doc => (
-                          <div
-                            key={doc.id}
-                            className={cn(
-                              "flex items-center gap-3 p-3 rounded-xl border transition-all cursor-pointer",
-                              selectedDocs.includes(doc.id) ? "border-primary/50 bg-primary/5 shadow-sm" : "border-border hover:bg-muted/30"
-                            )}
-                            onClick={() => {
-                              setSelectedDocs(prev =>
-                                prev.includes(doc.id) ? prev.filter(id => id !== doc.id) : [...prev, doc.id]
-                              );
-                            }}
-                          >
-                            <Checkbox checked={selectedDocs.includes(doc.id)} onCheckedChange={() => {}} />
-                            <div className="w-8 h-8 rounded-lg bg-blue-500/10 text-blue-500 flex items-center justify-center">
-                              <Zap size={16} />
-                            </div>
-                            <span className="font-semibold text-sm truncate">{doc.name}</span>
-                          </div>
-                        ))}
-                      </div>
-                    ) : (
-                      <div className="p-6 text-center bg-muted/30 rounded-xl border border-dashed text-xs italic text-muted-foreground">
-                        暂无其他已解析的文档
-                      </div>
-                    )}
-                  </div>
-                </div>
-              </ScrollArea>
-
-              <DialogFooter className="p-8 pt-4 bg-muted/20 border-t border-dashed">
-                <Button variant="outline" className="rounded-xl h-12 px-6" onClick={() => setOpenTaskDialog(false)}>取消</Button>
-                <Button
-                  className="rounded-xl h-12 px-8 shadow-lg shadow-primary/20 gap-2"
-                  onClick={handleCreateTask}
-                  disabled={creating || !selectedTemplate || (selectedDocs.length === 0 && !excelParseResult?.success)}
-                >
-                  {creating ? <RefreshCcw className="animate-spin h-5 w-5" /> : <Zap className="h-5 w-5 fill-current" />}
-                  <span>启动智能填表引擎</span>
-                </Button>
-              </DialogFooter>
-            </DialogContent>
-          </Dialog>
-        </div>
-      </section>
-
-      {/* Task List */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
-        {loading ? (
-          Array.from({ length: 3 }).map((_, i) => (
-            <Skeleton key={i} className="h-48 w-full rounded-3xl bg-muted" />
-          ))
-        ) : tasks.length > 0 ? (
-          tasks.map((task) => (
-            <Card key={task.id} className="border-none shadow-md hover:shadow-xl transition-all group rounded-3xl overflow-hidden flex flex-col">
-              <div className="h-1.5 w-full" style={{ backgroundColor: task.status === 'completed' ? '#10b981' : task.status === 'failed' ? '#ef4444' : '#f59e0b' }} />
-              <CardHeader className="p-6 pb-2">
-                <div className="flex justify-between items-start mb-2">
-                  <div className="w-12 h-12 rounded-2xl bg-emerald-500/10 text-emerald-500 flex items-center justify-center shadow-inner group-hover:scale-110 transition-transform">
-                    <TableProperties size={24} />
-                  </div>
-                  <Badge className={cn("text-[10px] uppercase font-bold tracking-widest", getStatusColor(task.status))}>
-                    {task.status === 'completed' ? '已完成' : task.status === 'failed' ? '失败' : '执行中'}
-                  </Badge>
-                </div>
-                <CardTitle className="text-lg font-bold truncate group-hover:text-primary transition-colors">{task.templates?.name || '未知模板'}</CardTitle>
-                <CardDescription className="text-xs flex items-center gap-1 font-medium italic">
-                  <Clock size={12} /> {format(new Date(task.created_at!), 'yyyy/MM/dd HH:mm')}
-                </CardDescription>
-              </CardHeader>
-              <CardContent className="p-6 pt-2 flex-1">
-                <div className="space-y-4">
-                  <div className="flex flex-wrap gap-2">
-                    <Badge variant="outline" className="bg-muted/50 border-none text-[10px] font-bold">关联 {task.document_ids?.length} 份数据源</Badge>
-                  </div>
-                  {task.status === 'completed' && (
-                    <div className="p-3 bg-emerald-500/5 rounded-2xl border border-emerald-500/10 flex items-center gap-3">
-                      <CheckCircle2 className="text-emerald-500" size={18} />
-                      <span className="text-xs font-semibold text-emerald-700">内容已精准聚合，表格生成完毕</span>
-                    </div>
-                  )}
-                </div>
-              </CardContent>
-              <CardFooter className="p-6 pt-0">
-                <Button
-                  className="w-full rounded-2xl h-11 bg-primary group-hover:shadow-lg group-hover:shadow-primary/30 transition-all gap-2"
-                  disabled={task.status !== 'completed'}
-                  onClick={() => setViewingTask(task)}
-                >
-                  <Download size={18} />
-                  <span>下载汇总表格</span>
-                </Button>
-              </CardFooter>
-            </Card>
-          ))
-        ) : (
-          <div className="col-span-full py-24 flex flex-col items-center justify-center text-center space-y-6">
-            <div className="w-24 h-24 rounded-full bg-muted flex items-center justify-center text-muted-foreground/30 border-4 border-dashed">
-              <TableProperties size={48} />
-            </div>
-            <div className="space-y-2 max-w-sm">
-              <p className="text-2xl font-extrabold tracking-tight">暂无生成任务</p>
-              <p className="text-muted-foreground text-sm">上传模板后，您可以将多个文档的数据自动填充到汇总表格中。</p>
-            </div>
-            <Button className="rounded-xl h-12 px-8" onClick={() => setOpenTaskDialog(true)}>立即创建首个任务</Button>
-          </div>
-        )}
-      </div>
-
-      {/* Task Result View Modal */}
-      <Dialog open={!!viewingTask} onOpenChange={(open) => !open && setViewingTask(null)}>
-        <DialogContent className="max-w-4xl max-h-[90vh] flex flex-col p-0 overflow-hidden border-none shadow-2xl rounded-3xl">
-          <DialogHeader className="p-8 pb-4 bg-primary text-primary-foreground">
-            <div className="flex items-center gap-3 mb-2">
-              <FileCheck size={28} />
-              <DialogTitle className="text-2xl font-extrabold">表格生成结果预览</DialogTitle>
-            </div>
-            <DialogDescription className="text-primary-foreground/80 italic">
-              系统已根据 {viewingTask?.document_ids?.length} 份文档信息自动填充完毕。
-            </DialogDescription>
-          </DialogHeader>
-          <ScrollArea className="flex-1 p-8 bg-muted/10">
-            <div className="prose dark:prose-invert max-w-none">
-              <div className="bg-card p-8 rounded-2xl shadow-sm border min-h-[400px]">
-                <Badge variant="outline" className="mb-4">数据已脱敏</Badge>
-                <div className="whitespace-pre-wrap font-sans text-sm leading-relaxed">
-                  <h2 className="text-xl font-bold mb-4">汇总结果报告</h2>
-                  <p className="text-muted-foreground mb-6">以下是根据您上传的多个文档提取并生成的汇总信息：</p>
-
-                  <div className="p-4 bg-muted/30 rounded-xl border border-dashed border-primary/20 italic">
-                    正在从云端安全下载解析结果并渲染渲染视图...
-                  </div>
-
-                  <div className="mt-8 space-y-4">
-                    <p className="font-semibold text-primary">✓ 核心实体已对齐</p>
-                    <p className="font-semibold text-primary">✓ 逻辑勾稽关系校验通过</p>
-                    <p className="font-semibold text-primary">✓ 格式符合模板规范</p>
-                  </div>
-                </div>
-              </div>
-            </div>
-          </ScrollArea>
-          <DialogFooter className="p-8 pt-4 border-t border-dashed">
-            <Button variant="outline" className="rounded-xl" onClick={() => setViewingTask(null)}>关闭</Button>
-            <Button className="rounded-xl px-8 gap-2 shadow-lg shadow-primary/20" onClick={() => toast.success("正在导出文件...")}>
-              <Download size={18} />
-              导出为 {viewingTask?.templates?.type?.toUpperCase() || '文件'}
-            </Button>
-          </DialogFooter>
-        </DialogContent>
-      </Dialog>
-    </div>
-  );
-};
-
-export default FormFill;

frontend/src/pages/InstructionChat.tsx

@@ -0,0 +1,409 @@
+import React, { useState, useRef, useEffect } from 'react';
+import {
+  Send,
+  Bot,
+  User,
+  Sparkles,
+  Trash2,
+  RefreshCcw,
+  FileText,
+  TableProperties,
+  ChevronRight,
+  ArrowRight,
+  Loader2,
+  Download,
+  Search,
+  MessageSquare,
+  CheckCircle
+} from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { Badge } from '@/components/ui/badge';
+import { backendApi } from '@/db/backend-api';
+import { toast } from 'sonner';
+import { cn } from '@/lib/utils';
+
+type ChatMessage = {
+  id: string;
+  role: 'user' | 'assistant';
+  content: string;
+  created_at: string;
+  intent?: string;
+  result?: any;
+};
+
+const InstructionChat: React.FC = () => {
+  const [messages, setMessages] = useState<ChatMessage[]>([]);
+  const [input, setInput] = useState('');
+  const [loading, setLoading] = useState(false);
+  const [currentDocIds, setCurrentDocIds] = useState<string[]>([]);
+  const scrollAreaRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    // Initial welcome message
+    if (messages.length === 0) {
+      setMessages([
+        {
+          id: 'welcome',
+          role: 'assistant',
+          content: `您好！我是智联文档 AI 助手。
+
+**📄 文档智能操作**
+- "提取文档中的医院数量和床位数"
+- "帮我找出所有机构的名称"
+
+**📊 数据填表**
+- "根据这些数据填表"
+- "将提取的信息填写到Excel模板"
+
+**📝 内容处理**
+- "总结一下这份文档"
+- "对比这两个文档的差异"
+
+**🔍 智能问答**
+- "文档里说了些什么？"
+- "有多少家医院？"
+
+请告诉我您想做什么？`,
+          created_at: new Date().toISOString()
+        }
+      ]);
+
+      // 获取已上传的文档ID列表
+      loadDocuments();
+    }
+  }, []);
+
+  const loadDocuments = async () => {
+    try {
+      const result = await backendApi.getDocuments(undefined, 50);
+      if (result.success && result.documents) {
+        const docIds = result.documents.map((d: any) => d.doc_id);
+        setCurrentDocIds(docIds);
+        if (docIds.length > 0) {
+          console.log(`已加载 ${docIds.length} 个文档`);
+        }
+      }
+    } catch (err) {
+      console.error('获取文档列表失败:', err);
+    }
+  };
+
+  useEffect(() => {
+    // Scroll to bottom
+    if (scrollAreaRef.current) {
+      const scrollElement = scrollAreaRef.current.querySelector('[data-radix-scroll-area-viewport]');
+      if (scrollElement) {
+        scrollElement.scrollTop = scrollElement.scrollHeight;
+      }
+    }
+  }, [messages]);
+
+  const handleSend = async () => {
+    if (!input.trim()) return;
+
+    const userMessage: ChatMessage = {
+      id: Math.random().toString(36).substring(7),
+      role: 'user',
+      content: input.trim(),
+      created_at: new Date().toISOString()
+    };
+
+    setMessages(prev => [...prev, userMessage]);
+    setInput('');
+    setLoading(true);
+
+    try {
+      // 使用真实的智能指令 API
+      const response = await backendApi.instructionChat(
+        input.trim(),
+        currentDocIds.length > 0 ? currentDocIds : undefined
+      );
+
+      // 根据意图类型生成友好响应
+      let responseContent = '';
+      const resultData = response.result;
+
+      switch (response.intent) {
+        case 'extract':
+          // 信息提取结果
+          const extracted = resultData?.extracted_data || {};
+          const keys = Object.keys(extracted);
+          if (keys.length > 0) {
+            responseContent = `✅ 已提取到 ${keys.length} 个字段的数据：\n\n`;
+            for (const [key, value] of Object.entries(extracted)) {
+              const values = Array.isArray(value) ? value : [value];
+              responseContent += `**${key}**: ${values.slice(0, 3).join(', ')}${values.length > 3 ? '...' : ''}\n`;
+            }
+            responseContent += `\n💡 您可以将这些数据填入表格。`;
+          } else {
+            responseContent = '未能从文档中提取到相关数据。请尝试更明确的字段名称。';
+          }
+          break;
+
+        case 'fill_table':
+          // 填表结果
+          const filled = resultData?.result?.filled_data || {};
+          const filledKeys = Object.keys(filled);
+          if (filledKeys.length > 0) {
+            responseContent = `✅ 填表完成！成功填写 ${filledKeys.length} 个字段：\n\n`;
+            for (const [key, value] of Object.entries(filled)) {
+              const values = Array.isArray(value) ? value : [value];
+              responseContent += `**${key}**: ${values.slice(0, 3).join(', ')}\n`;
+            }
+            responseContent += `\n📋 请到【智能填表】页面查看或导出结果。`;
+          } else {
+            responseContent = '填表未能提取到数据。请检查模板表头和数据源内容。';
+          }
+          break;
+
+        case 'summarize':
+          // 摘要结果
+          const summaries = resultData?.summaries || [];
+          if (summaries.length > 0) {
+            responseContent = `📄 找到 ${summaries.length} 个文档的摘要：\n\n`;
+            summaries.forEach((s: any, idx: number) => {
+              responseContent += `**${idx + 1}. ${s.filename}**\n${s.content_preview}\n\n`;
+            });
+          } else {
+            responseContent = '未能生成摘要。请确保已上传文档。';
+          }
+          break;
+
+        case 'question':
+          // 问答结果
+          if (resultData?.answer) {
+            responseContent = `**问题**: ${resultData.question}\n\n**答案**: ${resultData.answer}`;
+          } else {
+            responseContent = resultData?.message || '我找到了相关信息，请查看上文。';
+          }
+          break;
+
+        case 'search':
+          // 搜索结果
+          const searchResults = resultData?.results || [];
+          if (searchResults.length > 0) {
+            responseContent = `🔍 找到 ${searchResults.length} 条相关内容：\n\n`;
+            searchResults.slice(0, 5).forEach((r: any, idx: number) => {
+              responseContent += `**${idx + 1}.** ${r.content?.substring(0, 100)}...\n\n`;
+            });
+          } else {
+            responseContent = '未找到相关内容。请尝试其他关键词。';
+          }
+          break;
+
+        case 'compare':
+          // 对比结果
+          const comparison = resultData?.comparison || [];
+          if (comparison.length > 0) {
+            responseContent = `📊 对比了 ${comparison.length} 个文档：\n\n`;
+            comparison.forEach((c: any) => {
+              responseContent += `- **${c.filename}**: ${c.doc_type}, ${c.content_length} 字\n`;
+            });
+          } else {
+            responseContent = '需要至少2个文档才能进行对比。';
+          }
+          break;
+
+        case 'unknown':
+          responseContent = `我理解您想要： "${input.trim()}"\n\n但我目前无法完成此操作。您可以尝试：\n\n1. **提取数据**: "提取医院数量和床位数"\n2. **填表**: "根据这些数据填表"\n3. **总结**: "总结这份文档"\n4. **问答**: "文档里说了什么？"\n5. **搜索**: "搜索相关内容"`;
+          break;
+
+        default:
+          responseContent = response.message || resultData?.message || '已完成您的请求。';
+      }
+
+      const assistantMessage: ChatMessage = {
+        id: Math.random().toString(36).substring(7),
+        role: 'assistant',
+        content: responseContent,
+        created_at: new Date().toISOString(),
+        intent: response.intent,
+        result: resultData
+      };
+
+      setMessages(prev => [...prev, assistantMessage]);
+    } catch (err: any) {
+      console.error('指令执行失败:', err);
+      toast.error(err.message || '请求失败，请重试');
+
+      const errorMessage: ChatMessage = {
+        id: Math.random().toString(36).substring(7),
+        role: 'assistant',
+        content: `抱歉，处理您的请求时遇到了问题：${err.message}\n\n请稍后重试，或尝试更简单的指令。`,
+        created_at: new Date().toISOString()
+      };
+      setMessages(prev => [...prev, errorMessage]);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const clearChat = () => {
+    setMessages([messages[0]]);
+    toast.success('对话已清空');
+  };
+
+  const quickActions = [
+    { label: '提取医院数量', icon: Search, action: () => setInput('提取文档中的医院数量和床位数') },
+    { label: '智能填表', icon: TableProperties, action: () => setInput('根据这些数据填表') },
+    { label: '总结文档', icon: MessageSquare, action: () => setInput('总结一下这份文档') },
+    { label: '智能问答', icon: Bot, action: () => setInput('文档里说了些什么？') }
+  ];
+
+  return (
+    <div className="h-[calc(100vh-8rem)] flex flex-col gap-6 animate-fade-in relative">
+      <section className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+        <div className="space-y-1">
+          <h1 className="text-3xl font-extrabold tracking-tight flex items-center gap-3">
+            <Sparkles className="text-primary animate-pulse" />
+            智能助手
+          </h1>
+          <p className="text-muted-foreground">通过自然语言指令，极速操控您的整个文档数据库。</p>
+        </div>
+        <Button
+          variant="outline"
+          size="sm"
+          className="rounded-xl gap-2 h-10 border-none bg-card shadow-sm hover:bg-destructive/10 hover:text-destructive"
+          onClick={clearChat}
+        >
+          <Trash2 size={16} />
+          <span>清除历史</span>
+        </Button>
+      </section>
+
+      <div className="flex-1 flex flex-col lg:flex-row gap-6 min-h-0">
+        {/* Chat Area */}
+        <Card className="flex-1 flex flex-col border-none shadow-xl overflow-hidden rounded-3xl bg-card/50 backdrop-blur-sm">
+          <ScrollArea className="flex-1 p-6" ref={scrollAreaRef}>
+            <div className="space-y-8 pb-4">
+              {messages.map((m) => (
+                <div
+                  key={m.id}
+                  className={cn(
+                    "flex gap-4 max-w-[85%]",
+                    m.role === 'user' ? "ml-auto flex-row-reverse" : "mr-auto"
+                  )}
+                >
+                  <div className={cn(
+                    "w-10 h-10 rounded-2xl flex items-center justify-center shrink-0 shadow-lg",
+                    m.role === 'user' ? "bg-primary text-primary-foreground" : "bg-white text-primary border border-primary/20"
+                  )}>
+                    {m.role === 'user' ? <User size={20} /> : <Bot size={22} />}
+                  </div>
+                  <div className={cn(
+                    "space-y-2 p-5 rounded-3xl",
+                    m.role === 'user'
+                      ? "bg-primary text-primary-foreground shadow-xl shadow-primary/20 rounded-tr-none"
+                      : "bg-white border border-border/50 shadow-md rounded-tl-none"
+                  )}>
+                    <p className="text-sm leading-relaxed whitespace-pre-wrap font-medium">
+                      {m.content}
+                    </p>
+                    <span className={cn(
+                      "text-[10px] block opacity-50 font-bold tracking-widest",
+                      m.role === 'user' ? "text-right" : "text-left"
+                    )}>
+                      {new Date(m.created_at).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })}
+                    </span>
+                  </div>
+                </div>
+              ))}
+              {loading && (
+                <div className="flex gap-4 mr-auto max-w-[85%] animate-pulse">
+                  <div className="w-10 h-10 rounded-2xl bg-muted flex items-center justify-center shrink-0 border border-border/50">
+                    <Bot size={22} className="text-muted-foreground" />
+                  </div>
+                  <div className="p-5 rounded-3xl rounded-tl-none bg-muted/50 border border-border/50">
+                    <div className="flex gap-2">
+                      <div className="w-2 h-2 rounded-full bg-primary/40 animate-bounce [animation-delay:-0.3s]" />
+                      <div className="w-2 h-2 rounded-full bg-primary/40 animate-bounce [animation-delay:-0.15s]" />
+                      <div className="w-2 h-2 rounded-full bg-primary/40 animate-bounce" />
+                    </div>
+                  </div>
+                </div>
+              )}
+            </div>
+          </ScrollArea>
+
+          <CardContent className="p-6 bg-white/50 backdrop-blur-xl border-t border-border/50">
+            <form
+              onSubmit={(e) => { e.preventDefault(); handleSend(); }}
+              className="w-full flex gap-3 bg-muted/30 p-2 rounded-2xl border border-border/50 focus-within:border-primary/50 transition-all shadow-inner"
+            >
+              <Input
+                placeholder="尝试输入：帮我分析最近上传的 Excel 文件..."
+                className="flex-1 bg-transparent border-none focus-visible:ring-0 shadow-none h-12 text-base font-medium"
+                value={input}
+                onChange={(e) => setInput(e.target.value)}
+                disabled={loading}
+              />
+              <Button
+                type="submit"
+                size="icon"
+                className="w-12 h-12 rounded-xl bg-primary hover:scale-105 transition-all shadow-lg shadow-primary/20"
+                disabled={loading || !input.trim()}
+              >
+                <Send size={20} />
+              </Button>
+            </form>
+          </CardContent>
+        </Card>
+
+        {/* Quick Actions Panel */}
+        <aside className="w-full lg:w-80 space-y-6">
+          <Card className="border-none shadow-lg rounded-3xl bg-gradient-to-br from-primary/5 via-background to-background">
+            <CardHeader className="p-6">
+              <CardTitle className="text-sm font-bold uppercase tracking-widest text-primary flex items-center gap-2">
+                <Sparkles size={16} />
+                快捷操作
+              </CardTitle>
+            </CardHeader>
+            <CardContent className="p-6 pt-0 space-y-3">
+              {quickActions.map((action, i) => (
+                <button
+                  key={i}
+                  className="w-full flex items-center gap-3 p-3 rounded-2xl hover:bg-white hover:shadow-md transition-all group text-left border border-transparent hover:border-primary/10"
+                  onClick={action.action}
+                >
+                  <div className="w-8 h-8 rounded-lg bg-primary/10 text-primary flex items-center justify-center shrink-0">
+                    <action.icon size={16} />
+                  </div>
+                  <span className="text-sm font-semibold truncate group-hover:text-primary transition-colors">{action.label}</span>
+                  <ArrowRight size={14} className="ml-auto opacity-0 group-hover:opacity-100 -translate-x-2 group-hover:translate-x-0 transition-all" />
+                </button>
+              ))}
+            </CardContent>
+          </Card>
+
+          <Card className="border-none shadow-lg rounded-3xl bg-gradient-to-br from-indigo-500/10 to-blue-500/10 overflow-hidden relative">
+            <div className="absolute top-0 right-0 p-4 opacity-20">
+              <Sparkles size={100} />
+            </div>
+            <CardHeader className="p-6 relative z-10">
+              <CardTitle className="text-lg font-bold">功能说明</CardTitle>
+            </CardHeader>
+            <CardContent className="p-6 pt-0 relative z-10 space-y-4 text-sm text-muted-foreground">
+              <div className="flex items-start gap-2">
+                <FileText size={16} className="mt-0.5 text-blue-500 shrink-0" />
+                <span>上传 docx/md/txt 文档到 MongoDB</span>
+              </div>
+              <div className="flex items-start gap-2">
+                <TableProperties size={16} className="mt-0.5 text-emerald-500 shrink-0" />
+                <span>上传 xlsx 文档到 MySQL</span>
+              </div>
+              <div className="flex items-start gap-2">
+                <Sparkles size={16} className="mt-0.5 text-indigo-500 shrink-0" />
+                <span>使用 RAG 智能检索和填表</span>
+              </div>
+            </CardContent>
+          </Card>
+        </aside>
+      </div>
+    </div>
+  );
+};
+
+export default InstructionChat;

frontend/src/pages/Login.tsx

@@ -1,184 +0,0 @@
-import React, { useState } from 'react';
-import { useNavigate, useLocation } from 'react-router-dom';
-import { useAuth } from '@/context/AuthContext';
-import { Button } from '@/components/ui/button';
-import { Input } from '@/components/ui/input';
-import { Label } from '@/components/ui/label';
-import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card';
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
-import { FileText, Lock, User, CheckCircle2, AlertCircle } from 'lucide-react';
-import { toast } from 'sonner';
-
-const Login: React.FC = () => {
-  const [username, setUsername] = useState('');
-  const [password, setPassword] = useState('');
-  const [loading, setLoading] = useState(false);
-  const { signIn, signUp } = useAuth();
-  const navigate = useNavigate();
-  const location = useLocation();
-
-  const handleLogin = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!username || !password) return toast.error('请输入用户名和密码');
-    
-    setLoading(true);
-    try {
-      const email = `${username}@miaoda.com`;
-      const { error } = await signIn(email, password);
-      if (error) throw error;
-      toast.success('登录成功');
-      navigate('/');
-    } catch (err: any) {
-      toast.error(err.message || '登录失败');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const handleSignUp = async (e: React.FormEvent) => {
-    e.preventDefault();
-    if (!username || !password) return toast.error('请输入用户名和密码');
-    
-    setLoading(true);
-    try {
-      const email = `${username}@miaoda.com`;
-      const { error } = await signUp(email, password);
-      if (error) throw error;
-      toast.success('注册成功，请登录');
-    } catch (err: any) {
-      toast.error(err.message || '注册失败');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  return (
-    <div className="min-h-screen flex items-center justify-center bg-[radial-gradient(ellipse_at_top_left,_var(--tw-gradient-stops))] from-primary/10 via-background to-background p-4 relative overflow-hidden">
-      {/* Decorative elements */}
-      <div className="absolute top-0 left-0 w-96 h-96 bg-primary/5 rounded-full blur-3xl -translate-x-1/2 -translate-y-1/2" />
-      <div className="absolute bottom-0 right-0 w-64 h-64 bg-primary/5 rounded-full blur-3xl translate-x-1/3 translate-y-1/3" />
-
-      <div className="w-full max-w-md space-y-8 relative animate-fade-in">
-        <div className="text-center space-y-2">
-          <div className="inline-flex items-center justify-center w-16 h-16 rounded-2xl bg-primary text-primary-foreground shadow-2xl shadow-primary/30 mb-4 animate-slide-in">
-            <FileText size={32} />
-          </div>
-          <h1 className="text-4xl font-extrabold tracking-tight gradient-text">智联文档</h1>
-          <p className="text-muted-foreground">多源数据融合与智能文档处理系统</p>
-        </div>
-
-        <Card className="border-border/50 shadow-2xl backdrop-blur-sm bg-card/95">
-          <Tabs defaultValue="login" className="w-full">
-            <TabsList className="grid w-full grid-cols-2 rounded-t-xl h-12 bg-muted/50 p-1">
-              <TabsTrigger value="login" className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm">登录</TabsTrigger>
-              <TabsTrigger value="signup" className="rounded-lg data-[state=active]:bg-background data-[state=active]:shadow-sm">注册</TabsTrigger>
-            </TabsList>
-            
-            <TabsContent value="login">
-              <form onSubmit={handleLogin}>
-                <CardHeader>
-                  <CardTitle>欢迎回来</CardTitle>
-                  <CardDescription>使用您的账号登录智联文档系统</CardDescription>
-                </CardHeader>
-                <CardContent className="space-y-4">
-                  <div className="space-y-2">
-                    <Label htmlFor="username">用户名</Label>
-                    <div className="relative">
-                      <User className="absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                      <Input 
-                        id="username" 
-                        placeholder="请输入用户名" 
-                        className="pl-9 bg-muted/30 border-none focus-visible:ring-primary"
-                        value={username} 
-                        onChange={(e) => setUsername(e.target.value)} 
-                      />
-                    </div>
-                  </div>
-                  <div className="space-y-2">
-                    <Label htmlFor="password">密码</Label>
-                    <div className="relative">
-                      <Lock className="absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                      <Input 
-                        id="password" 
-                        type="password" 
-                        placeholder="请输入密码" 
-                        className="pl-9 bg-muted/30 border-none focus-visible:ring-primary"
-                        value={password} 
-                        onChange={(e) => setPassword(e.target.value)} 
-                      />
-                    </div>
-                  </div>
-                </CardContent>
-                <CardFooter>
-                  <Button className="w-full h-11 text-lg font-semibold rounded-xl" type="submit" disabled={loading}>
-                    {loading ? '登录中...' : '立即登录'}
-                  </Button>
-                </CardFooter>
-              </form>
-            </TabsContent>
-
-            <TabsContent value="signup">
-              <form onSubmit={handleSignUp}>
-                <CardHeader>
-                  <CardTitle>创建账号</CardTitle>
-                  <CardDescription>开启智能文档处理的新体验</CardDescription>
-                </CardHeader>
-                <CardContent className="space-y-4">
-                  <div className="space-y-2">
-                    <Label htmlFor="signup-username">用户名</Label>
-                    <div className="relative">
-                      <User className="absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                      <Input 
-                        id="signup-username" 
-                        placeholder="仅字母、数字和下划线" 
-                        className="pl-9 bg-muted/30 border-none focus-visible:ring-primary"
-                        value={username} 
-                        onChange={(e) => setUsername(e.target.value)} 
-                      />
-                    </div>
-                  </div>
-                  <div className="space-y-2">
-                    <Label htmlFor="signup-password">密码</Label>
-                    <div className="relative">
-                      <Lock className="absolute left-3 top-2.5 h-4 w-4 text-muted-foreground" />
-                      <Input 
-                        id="signup-password" 
-                        type="password" 
-                        placeholder="不少于 6 位" 
-                        className="pl-9 bg-muted/30 border-none focus-visible:ring-primary"
-                        value={password} 
-                        onChange={(e) => setPassword(e.target.value)} 
-                      />
-                    </div>
-                  </div>
-                </CardContent>
-                <CardFooter>
-                  <Button className="w-full h-11 text-lg font-semibold rounded-xl" type="submit" disabled={loading}>
-                    {loading ? '注册中...' : '注册账号'}
-                  </Button>
-                </CardFooter>
-              </form>
-            </TabsContent>
-          </Tabs>
-        </Card>
-
-        <div className="grid grid-cols-2 gap-4 text-center text-xs text-muted-foreground">
-          <div className="flex flex-col items-center gap-1">
-            <CheckCircle2 size={16} className="text-primary" />
-            <span>智能解析</span>
-          </div>
-          <div className="flex flex-col items-center gap-1">
-            <CheckCircle2 size={16} className="text-primary" />
-            <span>极速填表</span>
-          </div>
-        </div>
-
-        <div className="text-center text-sm text-muted-foreground">
-          &copy; 2026 智联文档 | 多源数据融合系统
-        </div>
-      </div>
-    </div>
-  );
-};
-
-export default Login;

frontend/src/pages/SamplePage.tsx

@@ -1,16 +0,0 @@
-/**
- * Sample Page
- */
-
-import PageMeta from "../components/common/PageMeta";
-
-export default function SamplePage() {
-  return (
-    <>
-      <PageMeta title="Home" description="Home Page Introduction" />
-      <div>
-        <h3>This is a sample page</h3>
-      </div>
-    </>
-  );
-}

frontend/src/pages/TaskHistory.tsx

@@ -0,0 +1,302 @@
+import React, { useState, useEffect } from 'react';
+import {
+  Clock,
+  CheckCircle2,
+  XCircle,
+  RefreshCcw,
+  Download,
+  FileText,
+  FileSpreadsheet,
+  Loader2,
+  ChevronDown,
+  ChevronUp,
+  Trash2,
+  AlertCircle,
+  HelpCircle
+} from 'lucide-react';
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Badge } from '@/components/ui/badge';
+import { backendApi } from '@/db/backend-api';
+import { format } from 'date-fns';
+import { toast } from 'sonner';
+import { cn } from '@/lib/utils';
+import { Skeleton } from '@/components/ui/skeleton';
+
+type Task = {
+  task_id: string;
+  status: 'pending' | 'processing' | 'success' | 'failure' | 'unknown';
+  created_at: string;
+  updated_at?: string;
+  message?: string;
+  result?: any;
+  error?: string;
+  task_type?: string;
+};
+
+const TaskHistory: React.FC = () => {
+  const [tasks, setTasks] = useState<Task[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [expandedTask, setExpandedTask] = useState<string | null>(null);
+
+  // 获取任务历史数据
+  const fetchTasks = async () => {
+    try {
+      setLoading(true);
+      const response = await backendApi.getTasks(50, 0);
+      if (response.success && response.tasks) {
+        // 转换后端数据格式为前端格式
+        const convertedTasks: Task[] = response.tasks.map((t: any) => ({
+          task_id: t.task_id,
+          status: t.status || 'unknown',
+          created_at: t.created_at || new Date().toISOString(),
+          updated_at: t.updated_at,
+          message: t.message || '',
+          result: t.result,
+          error: t.error,
+          task_type: t.task_type || 'document_parse'
+        }));
+        setTasks(convertedTasks);
+      } else {
+        setTasks([]);
+      }
+    } catch (error) {
+      console.error('获取任务列表失败:', error);
+      toast.error('获取任务列表失败');
+      setTasks([]);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    fetchTasks();
+  }, []);
+
+  const getStatusBadge = (status: string) => {
+    switch (status) {
+      case 'success':
+        return <Badge className="bg-emerald-500 text-white text-[10px]"><CheckCircle2 size={12} className="mr-1" />成功</Badge>;
+      case 'failure':
+        return <Badge className="bg-destructive text-white text-[10px]"><XCircle size={12} className="mr-1" />失败</Badge>;
+      case 'processing':
+        return <Badge className="bg-amber-500 text-white text-[10px]"><Loader2 size={12} className="mr-1 animate-spin" />处理中</Badge>;
+      case 'unknown':
+        return <Badge className="bg-gray-500 text-white text-[10px]"><HelpCircle size={12} className="mr-1" />未知</Badge>;
+      default:
+        return <Badge className="bg-gray-500 text-white text-[10px]"><Clock size={12} className="mr-1" />等待</Badge>;
+    }
+  };
+
+  const getTaskTypeLabel = (type?: string) => {
+    switch (type) {
+      case 'document_parse':
+        return '文档解析';
+      case 'excel_analysis':
+        return 'Excel 分析';
+      case 'template_fill':
+        return '智能填表';
+      case 'rag_index':
+        return 'RAG 索引';
+      default:
+        return '未知任务';
+    }
+  };
+
+  const getTaskIcon = (type?: string) => {
+    switch (type) {
+      case 'document_parse':
+      case 'rag_index':
+        return <FileText size={20} />;
+      case 'excel_analysis':
+        return <FileSpreadsheet size={20} />;
+      default:
+        return <Clock size={20} />;
+    }
+  };
+
+  const handleRetry = async (taskId: string) => {
+    toast.info('任务重试功能开发中...');
+  };
+
+  const handleDelete = async (taskId: string) => {
+    try {
+      await backendApi.deleteTask(taskId);
+      setTasks(prev => prev.filter(t => t.task_id !== taskId));
+      toast.success('任务已删除');
+    } catch (error) {
+      console.error('删除任务失败:', error);
+      toast.error('删除任务失败');
+    }
+  };
+
+  const stats = {
+    total: tasks.length,
+    success: tasks.filter(t => t.status === 'success').length,
+    processing: tasks.filter(t => t.status === 'processing').length,
+    failure: tasks.filter(t => t.status === 'failure').length,
+    unknown: tasks.filter(t => t.status === 'unknown').length
+  };
+
+  return (
+    <div className="space-y-8 pb-10">
+      <section className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+        <div className="space-y-1">
+          <h1 className="text-3xl font-extrabold tracking-tight">任务历史</h1>
+          <p className="text-muted-foreground">查看和管理您所有的文档处理任务记录</p>
+        </div>
+        <Button variant="outline" className="rounded-xl gap-2" onClick={() => fetchTasks()}>
+          <RefreshCcw size={18} />
+          <span>刷新</span>
+        </Button>
+      </section>
+
+      {/* Stats Cards */}
+      <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
+        {[
+          { label: '总任务数', value: stats.total, icon: Clock, color: 'text-blue-500', bg: 'bg-blue-500/10' },
+          { label: '成功', value: stats.success, icon: CheckCircle2, color: 'text-emerald-500', bg: 'bg-emerald-500/10' },
+          { label: '处理中', value: stats.processing, icon: Loader2, color: 'text-amber-500', bg: 'bg-amber-500/10' },
+          { label: '失败', value: stats.failure, icon: XCircle, color: 'text-destructive', bg: 'bg-destructive/10' }
+        ].map((stat, i) => (
+          <Card key={i} className="border-none shadow-sm">
+            <CardContent className="p-4 flex items-center gap-4">
+              <div className={cn("w-12 h-12 rounded-xl flex items-center justify-center", stat.bg)}>
+                <stat.icon size={24} className={stat.color} />
+              </div>
+              <div>
+                <p className="text-2xl font-bold">{stat.value}</p>
+                <p className="text-xs text-muted-foreground">{stat.label}</p>
+              </div>
+            </CardContent>
+          </Card>
+        ))}
+      </div>
+
+      {/* Task List */}
+      <div className="space-y-4">
+        {loading ? (
+          Array.from({ length: 3 }).map((_, i) => (
+            <Skeleton key={i} className="h-24 w-full rounded-2xl" />
+          ))
+        ) : tasks.length > 0 ? (
+          tasks.map((task) => (
+            <Card key={task.task_id} className="border-none shadow-sm overflow-hidden">
+              <div className="flex flex-col">
+                <div className="p-6 flex flex-col md:flex-row md:items-center gap-4">
+                  <div className={cn(
+                    "w-12 h-12 rounded-xl flex items-center justify-center shrink-0",
+                    task.status === 'success' ? "bg-emerald-500/10 text-emerald-500" :
+                    task.status === 'failure' ? "bg-destructive/10 text-destructive" :
+                    task.status === 'processing' ? "bg-amber-500/10 text-amber-500" :
+                    "bg-gray-500/10 text-gray-500"
+                  )}>
+                    {task.status === 'processing' ? (
+                      <Loader2 size={24} className="animate-spin" />
+                    ) : (
+                      getTaskIcon(task.task_type)
+                    )}
+                  </div>
+
+                  <div className="flex-1 min-w-0 space-y-1">
+                    <div className="flex items-center gap-3 flex-wrap">
+                      <h3 className="font-bold">{getTaskTypeLabel(task.task_type)}</h3>
+                      {getStatusBadge(task.status)}
+                      <Badge variant="outline" className="text-[10px]">
+                        {task.task_id}
+                      </Badge>
+                    </div>
+                    <p className="text-sm text-muted-foreground">
+                      {task.message || (task.status === 'unknown' ? '无法获取状态' : '任务执行中...')}
+                    </p>
+                    <div className="flex items-center gap-4 text-xs text-muted-foreground">
+                      <span className="flex items-center gap-1">
+                        <Clock size={12} />
+                        {task.created_at ? format(new Date(task.created_at), 'yyyy-MM-dd HH:mm:ss') : '时间未知'}
+                      </span>
+                      {task.updated_at && task.status !== 'processing' && (
+                        <span>
+                          更新: {format(new Date(task.updated_at), 'HH:mm:ss')}
+                        </span>
+                      )}
+                    </div>
+                  </div>
+
+                  <div className="flex items-center gap-2">
+                    {task.status === 'failure' && (
+                      <Button
+                        variant="outline"
+                        size="sm"
+                        className="rounded-xl gap-1 h-9"
+                        onClick={() => handleRetry(task.task_id)}
+                      >
+                        <RefreshCcw size={14} />
+                        <span>重试</span>
+                      </Button>
+                    )}
+                    <Button
+                      variant="ghost"
+                      size="icon"
+                      className="rounded-lg text-destructive hover:bg-destructive/10"
+                      onClick={() => handleDelete(task.task_id)}
+                    >
+                      <Trash2 size={18} />
+                    </Button>
+                    {task.result && (
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        className="rounded-xl gap-1 h-9"
+                        onClick={() => setExpandedTask(expandedTask === task.task_id ? null : task.task_id)}
+                      >
+                        {expandedTask === task.task_id ? <ChevronUp size={14} /> : <ChevronDown size={14} />}
+                        <span>详情</span>
+                      </Button>
+                    )}
+                  </div>
+                </div>
+
+                {/* Expanded Details */}
+                {expandedTask === task.task_id && task.result && (
+                  <div className="px-6 pb-6 pt-2 border-t border-dashed animate-in slide-in-from-top-2 duration-300">
+                    <div className="p-4 bg-muted/30 rounded-xl">
+                      <p className="text-xs font-bold uppercase tracking-widest text-muted-foreground mb-3">任务结果</p>
+                      <pre className="text-sm whitespace-pre-wrap font-mono">
+                        {JSON.stringify(task.result, null, 2)}
+                      </pre>
+                    </div>
+                  </div>
+                )}
+
+                {/* Error Details */}
+                {task.status === 'failure' && task.error && (
+                  <div className="px-6 pb-6 pt-2 border-t border-dashed">
+                    <div className="p-4 bg-destructive/5 rounded-xl border border-destructive/20">
+                      <p className="text-xs font-bold uppercase tracking-widest text-destructive mb-3 flex items-center gap-2">
+                        <AlertCircle size={14} />
+                        错误详情
+                      </p>
+                      <p className="text-sm text-destructive">{task.error}</p>
+                    </div>
+                  </div>
+                )}
+              </div>
+            </Card>
+          ))
+        ) : (
+          <div className="py-20 flex flex-col items-center justify-center text-center space-y-4">
+            <div className="w-24 h-24 rounded-full bg-muted flex items-center justify-center text-muted-foreground/30">
+              <Clock size={48} />
+            </div>
+            <div className="space-y-1">
+              <p className="text-xl font-bold">暂无任务记录</p>
+              <p className="text-muted-foreground">上传文档或创建填表任务后，这里会显示处理记录</p>
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default TaskHistory;

frontend/src/pages/TemplateFill.tsx

@@ -0,0 +1,664 @@
+import React, { useState, useEffect, useCallback, useRef } from 'react';
+import { useDropzone } from 'react-dropzone';
+import {
+  TableProperties,
+  Upload,
+  FileSpreadsheet,
+  FileText,
+  CheckCircle2,
+  Download,
+  Clock,
+  Sparkles,
+  X,
+  FilePlus,
+  RefreshCcw,
+  ChevronDown,
+  ChevronUp,
+  Loader2,
+  Files,
+  Trash2,
+  Eye,
+  File,
+  Plus
+} from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { backendApi } from '@/db/backend-api';
+import { format } from 'date-fns';
+import { toast } from 'sonner';
+import { cn } from '@/lib/utils';
+import { Skeleton } from '@/components/ui/skeleton';
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { useTemplateFill } from '@/context/TemplateFillContext';
+
+type DocumentItem = {
+  doc_id: string;
+  filename: string;
+  original_filename: string;
+  doc_type: string;
+  file_size: number;
+  created_at: string;
+  metadata?: {
+    row_count?: number;
+    column_count?: number;
+    columns?: string[];
+  };
+};
+
+const TemplateFill: React.FC = () => {
+  const {
+    step, setStep,
+    templateFile, setTemplateFile,
+    templateFields, setTemplateFields,
+    sourceFiles, setSourceFiles, addSourceFiles, removeSourceFile,
+    sourceFilePaths, setSourceFilePaths,
+    sourceDocIds, setSourceDocIds, addSourceDocId, removeSourceDocId,
+    templateId, setTemplateId,
+    filledResult, setFilledResult,
+    reset
+  } = useTemplateFill();
+
+  const [loading, setLoading] = useState(false);
+  const [previewDoc, setPreviewDoc] = useState<{ name: string; content: string } | null>(null);
+  const [previewOpen, setPreviewOpen] = useState(false);
+  const [sourceMode, setSourceMode] = useState<'upload' | 'select'>('upload');
+  const [uploadedDocuments, setUploadedDocuments] = useState<DocumentItem[]>([]);
+  const [docsLoading, setDocsLoading] = useState(false);
+  const sourceFileInputRef = useRef<HTMLInputElement>(null);
+
+  // 模板拖拽
+  const onTemplateDrop = useCallback((acceptedFiles: File[]) => {
+    const file = acceptedFiles[0];
+    if (file) {
+      setTemplateFile(file);
+    }
+  }, []);
+
+  const { getRootProps: getTemplateProps, getInputProps: getTemplateInputProps, isDragActive: isTemplateDragActive } = useDropzone({
+    onDrop: onTemplateDrop,
+    accept: {
+      'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': ['.xlsx'],
+      'application/vnd.ms-excel': ['.xls'],
+      'application/vnd.openxmlformats-officedocument.wordprocessingml.document': ['.docx']
+    },
+    maxFiles: 1,
+    multiple: false
+  });
+
+  // 源文档拖拽
+  const onSourceDrop = useCallback((e: React.DragEvent) => {
+    e.preventDefault();
+    const files = Array.from(e.dataTransfer.files).filter(f => {
+      const ext = f.name.split('.').pop()?.toLowerCase();
+      return ['xlsx', 'xls', 'docx', 'md', 'txt'].includes(ext || '');
+    });
+    if (files.length > 0) {
+      addSourceFiles(files.map(f => ({ file: f })));
+    }
+  }, [addSourceFiles]);
+
+  const handleSourceFileSelect = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const files = Array.from(e.target.files || []);
+    if (files.length > 0) {
+      addSourceFiles(files.map(f => ({ file: f })));
+      toast.success(`已添加 ${files.length} 个文件`);
+    }
+    e.target.value = '';
+  };
+
+  // 仅添加源文档不上传
+  const handleAddSourceFiles = () => {
+    if (sourceFiles.length === 0) {
+      toast.error('请先选择源文档');
+      return;
+    }
+    toast.success(`已添加 ${sourceFiles.length} 个源文档，可继续添加更多`);
+  };
+
+  // 加载已上传文档
+  const loadUploadedDocuments = useCallback(async () => {
+    setDocsLoading(true);
+    try {
+      const result = await backendApi.getDocuments(undefined, 100);
+      if (result.success) {
+        // 过滤可作为数据源的文档类型
+        const docs = (result.documents || []).filter((d: DocumentItem) =>
+          ['docx', 'md', 'txt', 'xlsx', 'xls'].includes(d.doc_type)
+        );
+        setUploadedDocuments(docs);
+      }
+    } catch (err: any) {
+      console.error('加载文档失败:', err);
+    } finally {
+      setDocsLoading(false);
+    }
+  }, []);
+
+  // 删除文档
+  const handleDeleteDocument = async (docId: string, e: React.MouseEvent) => {
+    e.stopPropagation();
+    if (!confirm('确定要删除该文档吗？')) return;
+    try {
+      const result = await backendApi.deleteDocument(docId);
+      if (result.success) {
+        setUploadedDocuments(prev => prev.filter(d => d.doc_id !== docId));
+        removeSourceDocId(docId);
+        toast.success('文档已删除');
+      } else {
+        toast.error(result.message || '删除失败');
+      }
+    } catch (err: any) {
+      toast.error('删除失败: ' + (err.message || '未知错误'));
+    }
+  };
+
+  useEffect(() => {
+    if (sourceMode === 'select') {
+      loadUploadedDocuments();
+    }
+  }, [sourceMode, loadUploadedDocuments]);
+
+  const handleJointUploadAndFill = async () => {
+    if (!templateFile) {
+      toast.error('请先上传模板文件');
+      return;
+    }
+
+    // 检查是否选择了数据源
+    if (sourceMode === 'upload' && sourceFiles.length === 0) {
+      toast.error('请上传源文档或从已上传文档中选择');
+      return;
+    }
+    if (sourceMode === 'select' && sourceDocIds.length === 0) {
+      toast.error('请选择源文档');
+      return;
+    }
+
+    setLoading(true);
+
+    try {
+      if (sourceMode === 'select') {
+        // 使用已上传文档作为数据源
+        const result = await backendApi.uploadTemplate(templateFile);
+
+        if (result.success) {
+          setTemplateFields(result.fields || []);
+          setTemplateId(result.template_id || 'temp');
+          toast.success('开始智能填表');
+          setStep('filling');
+
+          // 使用 source_doc_ids 进行填表
+          const fillResult = await backendApi.fillTemplate(
+            result.template_id || 'temp',
+            result.fields || [],
+            sourceDocIds,
+            [],
+            '请从以下文档中提取相关信息填写表格'
+          );
+
+          setFilledResult(fillResult);
+          setStep('preview');
+          toast.success('表格填写完成');
+        }
+      } else {
+        // 使用联合上传API
+        const result = await backendApi.uploadTemplateAndSources(
+          templateFile,
+          sourceFiles.map(sf => sf.file)
+        );
+
+        if (result.success) {
+          setTemplateFields(result.fields || []);
+          setTemplateId(result.template_id);
+          setSourceFilePaths(result.source_file_paths || []);
+          toast.success('文档上传成功，开始智能填表');
+          setStep('filling');
+
+          // 自动开始填表
+          const fillResult = await backendApi.fillTemplate(
+            result.template_id,
+            result.fields || [],
+            [],
+            result.source_file_paths || [],
+            '请从以下文档中提取相关信息填写表格'
+          );
+
+          setFilledResult(fillResult);
+          setStep('preview');
+          toast.success('表格填写完成');
+        }
+      }
+    } catch (err: any) {
+      toast.error('处理失败: ' + (err.message || '未知错误'));
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleExport = async () => {
+    if (!templateFile || !filledResult) return;
+
+    try {
+      const blob = await backendApi.exportFilledTemplate(
+        templateId || 'temp',
+        filledResult.filled_data || {},
+        'xlsx'
+      );
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `filled_${templateFile.name}`;
+      a.click();
+      URL.revokeObjectURL(url);
+      toast.success('导出成功');
+    } catch (err: any) {
+      toast.error('导出失败: ' + (err.message || '未知错误'));
+    }
+  };
+
+  const getFileIcon = (filename: string) => {
+    const ext = filename.split('.').pop()?.toLowerCase();
+    if (['xlsx', 'xls'].includes(ext || '')) {
+      return <FileSpreadsheet size={20} className="text-emerald-500" />;
+    }
+    if (ext === 'docx') {
+      return <FileText size={20} className="text-blue-500" />;
+    }
+    if (['md', 'txt'].includes(ext || '')) {
+      return <FileText size={20} className="text-orange-500" />;
+    }
+    return <File size={20} className="text-gray-500" />;
+  };
+
+  return (
+    <div className="space-y-8 pb-10">
+      <section className="flex flex-col md:flex-row md:items-center justify-between gap-4">
+        <div className="space-y-1">
+          <h1 className="text-3xl font-extrabold tracking-tight">智能填表</h1>
+          <p className="text-muted-foreground">
+            根据您的表格模板，自动聚合多源文档信息进行精准填充
+          </p>
+        </div>
+        {step !== 'upload' && (
+          <Button variant="outline" className="rounded-xl gap-2" onClick={reset}>
+            <RefreshCcw size={18} />
+            <span>重新开始</span>
+          </Button>
+        )}
+      </section>
+
+      {/* Step 1: Upload - Joint Upload of Template + Source Docs */}
+      {step === 'upload' && (
+        <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+          {/* Template Upload */}
+          <Card className="border-none shadow-md">
+            <CardHeader className="pb-4">
+              <CardTitle className="text-lg flex items-center gap-2">
+                <FileSpreadsheet className="text-primary" size={20} />
+                表格模板
+              </CardTitle>
+              <CardDescription>
+                上传需要填写的 Excel/Word 模板文件
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              {!templateFile ? (
+                <div
+                  {...getTemplateProps()}
+                  className={cn(
+                    "border-2 border-dashed rounded-2xl p-8 transition-all duration-300 flex flex-col items-center justify-center text-center cursor-pointer group min-h-[200px]",
+                    isTemplateDragActive ? "border-primary bg-primary/5" : "border-muted-foreground/20 hover:border-primary/50 hover:bg-primary/5"
+                  )}
+                >
+                  <input {...getTemplateInputProps()} />
+                  <div className="w-14 h-14 rounded-xl bg-primary/10 text-primary flex items-center justify-center mb-4 group-hover:scale-110 transition-transform">
+                    {loading ? <Loader2 className="animate-spin" size={28} /> : <Upload size={28} />}
+                  </div>
+                  <p className="font-medium">
+                    {isTemplateDragActive ? '释放以上传' : '点击或拖拽上传模板'}
+                  </p>
+                  <p className="text-xs text-muted-foreground mt-1">
+                    支持 .xlsx .xls .docx
+                  </p>
+                </div>
+              ) : (
+                <div className="flex items-center gap-3 p-4 bg-emerald-500/5 rounded-xl border border-emerald-200">
+                  <div className="w-10 h-10 rounded-lg bg-emerald-500/10 text-emerald-500 flex items-center justify-center">
+                    <FileSpreadsheet size={20} />
+                  </div>
+                  <div className="flex-1 min-w-0">
+                    <p className="font-medium truncate">{templateFile.name}</p>
+                    <p className="text-xs text-muted-foreground">
+                      {(templateFile.size / 1024).toFixed(1)} KB
+                    </p>
+                  </div>
+                  <Button variant="ghost" size="sm" onClick={() => setTemplateFile(null)}>
+                    <X size={16} />
+                  </Button>
+                </div>
+              )}
+            </CardContent>
+          </Card>
+
+          {/* Source Documents Upload */}
+          <Card className="border-none shadow-md">
+            <CardHeader className="pb-4">
+              <CardTitle className="text-lg flex items-center gap-2">
+                <Files className="text-primary" size={20} />
+                源文档
+              </CardTitle>
+              <CardDescription>
+                选择包含数据的源文档作为填表依据
+              </CardDescription>
+              {/* Source Mode Tabs */}
+              <div className="flex gap-2 mt-2">
+                <Button
+                  variant={sourceMode === 'upload' ? 'default' : 'outline'}
+                  size="sm"
+                  onClick={() => setSourceMode('upload')}
+                >
+                  <Upload size={14} className="mr-1" />
+                  上传文件
+                </Button>
+                <Button
+                  variant={sourceMode === 'select' ? 'default' : 'outline'}
+                  size="sm"
+                  onClick={() => setSourceMode('select')}
+                >
+                  <Files size={14} className="mr-1" />
+                  从文档中心选择
+                </Button>
+              </div>
+            </CardHeader>
+            <CardContent>
+              {sourceMode === 'upload' ? (
+                <>
+                  <div className="border-2 border-dashed rounded-2xl p-8 transition-all duration-300 flex flex-col items-center justify-center text-center cursor-pointer group min-h-[200px] border-muted-foreground/20 hover:border-primary/50 hover:bg-primary/5">
+                    <input
+                      id="source-file-input"
+                      type="file"
+                      multiple={true}
+                      accept=".xlsx,.xls,.docx,.md,.txt"
+                      onChange={handleSourceFileSelect}
+                      className="hidden"
+                    />
+                    <label htmlFor="source-file-input" className="cursor-pointer flex flex-col items-center">
+                      <div className="w-14 h-14 rounded-xl bg-blue-500/10 text-blue-500 flex items-center justify-center mb-4 group-hover:scale-110 transition-transform">
+                        {loading ? <Loader2 className="animate-spin" size={28} /> : <Upload size={28} />}
+                      </div>
+                      <p className="font-medium">
+                        点击上传源文档
+                      </p>
+                      <p className="text-xs text-muted-foreground mt-1">
+                        支持 .xlsx .xls .docx .md .txt
+                      </p>
+                    </label>
+                  </div>
+                  <div
+                    onDragOver={(e) => { e.preventDefault(); }}
+                    onDrop={onSourceDrop}
+                    className="mt-2 text-center text-xs text-muted-foreground"
+                  >
+                    或拖拽文件到此处
+                  </div>
+
+                  {/* Selected Source Files */}
+                  {sourceFiles.length > 0 && (
+                    <div className="mt-4 space-y-2">
+                      {sourceFiles.map((sf, idx) => (
+                        <div key={idx} className="flex items-center gap-3 p-3 bg-muted/50 rounded-xl">
+                          {getFileIcon(sf.file.name)}
+                          <div className="flex-1 min-w-0">
+                            <p className="text-sm font-medium truncate">{sf.file.name}</p>
+                            <p className="text-xs text-muted-foreground">
+                              {(sf.file.size / 1024).toFixed(1)} KB
+                            </p>
+                          </div>
+                          <Button variant="ghost" size="sm" onClick={() => removeSourceFile(idx)}>
+                            <Trash2 size={14} className="text-red-500" />
+                          </Button>
+                        </div>
+                      ))}
+                      <div className="flex justify-center pt-2">
+                        <Button variant="outline" size="sm" onClick={() => document.getElementById('source-file-input')?.click()}>
+                          <Plus size={14} className="mr-1" />
+                          继续添加更多文档
+                        </Button>
+                      </div>
+                    </div>
+                  )}
+                </>
+              ) : (
+                <>
+                  {/* Uploaded Documents Selection */}
+                  {docsLoading ? (
+                    <div className="space-y-2">
+                      {[1, 2, 3].map(i => (
+                        <Skeleton key={i} className="h-16 w-full rounded-xl" />
+                      ))}
+                    </div>
+                  ) : uploadedDocuments.length > 0 ? (
+                    <div className="space-y-2">
+                      {sourceDocIds.length > 0 && (
+                        <div className="flex items-center justify-between p-3 bg-primary/5 rounded-xl border border-primary/20">
+                          <span className="text-sm font-medium">已选择 {sourceDocIds.length} 个文档</span>
+                          <Button variant="ghost" size="sm" onClick={() => loadUploadedDocuments()}>
+                            <RefreshCcw size={14} className="mr-1" />
+                            刷新列表
+                          </Button>
+                        </div>
+                      )}
+                      <div className="max-h-[300px] overflow-y-auto space-y-2">
+                        {uploadedDocuments.map((doc) => (
+                          <div
+                            key={doc.doc_id}
+                            className={cn(
+                              "flex items-center gap-3 p-3 rounded-xl border-2 transition-all cursor-pointer",
+                              sourceDocIds.includes(doc.doc_id)
+                                ? "border-primary bg-primary/5"
+                                : "border-border hover:bg-muted/30"
+                            )}
+                            onClick={() => {
+                              if (sourceDocIds.includes(doc.doc_id)) {
+                                removeSourceDocId(doc.doc_id);
+                              } else {
+                                addSourceDocId(doc.doc_id);
+                              }
+                            }}
+                          >
+                            <div className={cn(
+                              "w-6 h-6 rounded-md border-2 flex items-center justify-center transition-all shrink-0",
+                              sourceDocIds.includes(doc.doc_id)
+                                ? "border-primary bg-primary text-white"
+                                : "border-muted-foreground/30"
+                            )}>
+                              {sourceDocIds.includes(doc.doc_id) && <CheckCircle2 size={14} />}
+                            </div>
+                            {getFileIcon(doc.original_filename)}
+                            <div className="flex-1 min-w-0">
+                              <p className="text-sm font-medium truncate">{doc.original_filename}</p>
+                              <p className="text-xs text-muted-foreground">
+                                {doc.doc_type.toUpperCase()} • {format(new Date(doc.created_at), 'yyyy-MM-dd')}
+                              </p>
+                            </div>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              onClick={(e) => handleDeleteDocument(doc.doc_id, e)}
+                              className="shrink-0"
+                            >
+                              <Trash2 size={14} className="text-red-500" />
+                            </Button>
+                          </div>
+                        ))}
+                      </div>
+                    </div>
+                  ) : (
+                    <div className="text-center py-8 text-muted-foreground">
+                      <Files size={32} className="mx-auto mb-2 opacity-30" />
+                      <p className="text-sm">暂无可用的已上传文档</p>
+                    </div>
+                  )}
+                </>
+              )}
+            </CardContent>
+          </Card>
+
+          {/* Action Button */}
+          <div className="col-span-1 lg:col-span-2 flex justify-center">
+            <Button
+              size="lg"
+              className="rounded-xl px-12 shadow-lg shadow-primary/20 gap-2"
+              disabled={!templateFile || loading}
+              onClick={handleJointUploadAndFill}
+            >
+              {loading ? (
+                <>
+                  <Loader2 className="animate-spin" size={20} />
+                  <span>正在处理...</span>
+                </>
+              ) : (
+                <>
+                  <Sparkles size={20} />
+                  <span>上传并智能填表</span>
+                </>
+              )}
+            </Button>
+          </div>
+        </div>
+      )}
+
+      {/* Step 2: Filling State */}
+      {step === 'filling' && (
+        <Card className="border-none shadow-md">
+          <CardContent className="py-16 flex flex-col items-center justify-center">
+            <div className="w-16 h-16 rounded-full bg-primary/10 flex items-center justify-center mb-6">
+              <Loader2 className="animate-spin text-primary" size={32} />
+            </div>
+            <h3 className="text-xl font-bold mb-2">AI 正在智能分析并填表</h3>
+            <p className="text-muted-foreground text-center max-w-md">
+              系统正在从 {sourceFiles.length || sourceFilePaths.length} 份文档中检索相关信息...
+            </p>
+          </CardContent>
+        </Card>
+      )}
+
+      {/* Step 3: Preview Results */}
+      {step === 'preview' && filledResult && (
+        <div className="space-y-6">
+          <Card className="border-none shadow-md">
+            <CardHeader>
+              <CardTitle className="text-lg flex items-center gap-2">
+                <CheckCircle2 className="text-emerald-500" size={20} />
+                填表完成
+              </CardTitle>
+              <CardDescription>
+                系统已根据 {sourceFiles.length || sourceFilePaths.length} 份文档自动完成表格填写
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              {/* Filled Data Preview */}
+              <div className="p-6 bg-muted/30 rounded-2xl">
+                <div className="space-y-4">
+                  {templateFields.map((field, idx) => {
+                    const value = filledResult.filled_data?.[field.name];
+                    const displayValue = Array.isArray(value)
+                      ? value.filter(v => v && String(v).trim()).join(', ') || '-'
+                      : value || '-';
+                    return (
+                      <div key={idx} className="flex items-center gap-4">
+                        <div className="w-40 text-sm font-medium text-muted-foreground">{field.name}</div>
+                        <div className="flex-1 p-3 bg-background rounded-xl border">
+                          {displayValue}
+                        </div>
+                      </div>
+                    );
+                  })}
+                </div>
+              </div>
+
+              {/* Source Files Info */}
+              <div className="mt-4 flex flex-wrap gap-2">
+                {sourceFiles.map((sf, idx) => (
+                  <Badge key={idx} variant="outline" className="bg-blue-500/5">
+                    {getFileIcon(sf.file.name)}
+                    <span className="ml-1">{sf.file.name}</span>
+                  </Badge>
+                ))}
+              </div>
+
+              {/* Action Buttons */}
+              <div className="flex justify-center gap-4 mt-6">
+                <Button variant="outline" className="rounded-xl gap-2" onClick={reset}>
+                  <RefreshCcw size={18} />
+                  <span>继续填表</span>
+                </Button>
+                <Button className="rounded-xl gap-2 shadow-lg shadow-primary/20" onClick={handleExport}>
+                  <Download size={18} />
+                  <span>导出结果</span>
+                </Button>
+              </div>
+            </CardContent>
+          </Card>
+
+          {/* Fill Details */}
+          {filledResult.fill_details && filledResult.fill_details.length > 0 && (
+            <Card className="border-none shadow-md">
+              <CardHeader>
+                <CardTitle className="text-lg">填写详情</CardTitle>
+              </CardHeader>
+              <CardContent>
+                <div className="space-y-3">
+                  {filledResult.fill_details.map((detail: any, idx: number) => (
+                    <div key={idx} className="flex items-start gap-3 p-3 bg-muted/30 rounded-xl text-sm">
+                      <div className="w-1 h-1 rounded-full bg-primary mt-2" />
+                      <div className="flex-1">
+                        <div className="font-medium">{detail.field}</div>
+                        <div className="text-muted-foreground text-xs mt-1">
+                          来源: {detail.source} | 置信度: {detail.confidence ? (detail.confidence * 100).toFixed(0) + '%' : 'N/A'}
+                        </div>
+                        {detail.warning && (
+                          <div className="mt-2 p-2 bg-yellow-50 border border-yellow-200 rounded-lg text-yellow-700 text-xs">
+                            ⚠️ {detail.warning}
+                          </div>
+                        )}
+                        {detail.values && detail.values.length > 1 && !detail.warning && (
+                          <div className="mt-2 text-xs text-muted-foreground">
+                            多值: {detail.values.join(', ')}
+                          </div>
+                        )}
+                      </div>
+                    </div>
+                  ))}
+                </div>
+              </CardContent>
+            </Card>
+          )}
+        </div>
+      )}
+
+      {/* Preview Dialog */}
+      <Dialog open={previewOpen} onOpenChange={setPreviewOpen}>
+        <DialogContent className="max-w-2xl">
+          <DialogHeader>
+            <DialogTitle>{previewDoc?.name || '文档预览'}</DialogTitle>
+          </DialogHeader>
+          <ScrollArea className="max-h-[60vh]">
+            <pre className="text-sm whitespace-pre-wrap">{previewDoc?.content}</pre>
+          </ScrollArea>
+        </DialogContent>
+      </Dialog>
+    </div>
+  );
+};
+
+export default TemplateFill;

frontend/src/routes.tsx

@@ -1,25 +1,15 @@
 import { createBrowserRouter, Navigate } from 'react-router-dom';
-import Login from '@/pages/Login';
 import Dashboard from '@/pages/Dashboard';
 import Documents from '@/pages/Documents';
-import FormFill from '@/pages/FormFill';
+import TemplateFill from '@/pages/TemplateFill';
-import Assistant from '@/pages/Assistant';
+import InstructionChat from '@/pages/InstructionChat';
-import ExcelParse from '@/pages/ExcelParse';
+import TaskHistory from '@/pages/TaskHistory';
 import MainLayout from '@/components/layouts/MainLayout';
-import { RouteGuard } from '@/components/common/RouteGuard';
 
 export const routes = [
-  {
-    path: '/login',
-    element: <Login />,
-  },
   {
     path: '/',
-    element: (
+    element: <MainLayout />,
-      <RouteGuard>
-        <MainLayout />
-      </RouteGuard>
-    ),
     children: [
       {
         path: '/',
@@ -31,15 +21,15 @@ export const routes = [
       },
       {
         path: '/form-fill',
-        element: <FormFill />,
+        element: <TemplateFill />,
       },
       {
         path: '/assistant',
-        element: <Assistant />,
+        element: <InstructionChat />,
       },
       {
-        path: '/excel-parse',
+        path: '/task-history',
-        element: <ExcelParse />,
+        element: <TaskHistory />,
       },
     ],
   },