cantonbio-ra-doc-mcp 0.1.0__py3-none-any.whl

cantonbio_ra_doc_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cantonbio-ra-doc-mcp
+Version: 0.1.0
+Summary: RA注册文档助手，协助处理注册文档的编写和校验工作
+Requires-Python: >=3.13
+Requires-Dist: mcp[cli]>=1.15.0
+Requires-Dist: python-docx>=1.1.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'

cantonbio_ra_doc_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+src/__init__.py,sha256=rk3ufImwp6WyVkeYJUbgj7IDfXBzCYgnchd0lvKjOzc,4979
+src/extract_quality_standards.py,sha256=TR0Yf060P956ksZSK6OPz9OSbRcNeNjPwVvtyb_n4L8,14721
+src/fill_quality_standards.py,sha256=vqqBCkZ0WPSICXVj4WchTXn6B0-TPDsSLszY8P_pI3M,20779
+src/server.py,sha256=12b8hYTEa9l7kVT80bZBPGc0s4OvxlEmrBlMBbCJvIA,4985
+cantonbio_ra_doc_mcp-0.1.0.dist-info/METADATA,sha256=WrTwfxsNshT5fLRqXJDH9MBuTsbPF5UtgkFbjN_wxFE,349
+cantonbio_ra_doc_mcp-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+cantonbio_ra_doc_mcp-0.1.0.dist-info/RECORD,,

cantonbio_ra_doc_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

src/__init__.py

@@ -0,0 +1,158 @@
+"""
+RA Document MCP Server
+
+Run:
+    uv run src.server fastmcp_quickstart stdio
+"""
+
+from mcp.server.fastmcp import FastMCP
+from src import extract_quality_standards
+from src import fill_quality_standards
+import os
+import logging
+import traceback
+# Create an MCP server
+mcp = FastMCP("ra-doc-mcp")
+
+
+# Initialize LOG_FILE variable without assigning a value
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+LOG_FILE = os.path.join(ROOT_DIR, "ra-file-mcp.log")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_FILE, encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize EXCEL_FILES_PATH variable without assigning a value
+DOCX_FILES_PATH = None
+
+def get_docx_path(filename: str) -> str:
+    """Get full path to Excel file.
+    
+    Args:
+        filename: Name of Excel file
+        
+    Returns:
+        Full path to Excel file
+    """
+    # If filename is already an absolute path, return it
+    if os.path.isabs(filename):
+        return filename
+
+    # Check if in SSE mode (EXCEL_FILES_PATH is not None)
+    if DOCX_FILES_PATH is None:
+        # Must use absolute path
+        raise ValueError(f"Invalid filename: {filename}, must be an absolute path when not in SSE mode")
+
+    # In SSE mode, if it's a relative path, resolve it based on EXCEL_FILES_PATH
+    return os.path.join(DOCX_FILES_PATH, filename)
+
+
+# Add an addition tool
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b + 1
+
+
+# Add an addition tool
+@mcp.tool()
+def extract_quality_standards_table(doc_path: str) -> str:
+    """Extract quality standards table from docx file"""
+    try:
+        logger.info(f"Starting quality standards extraction for: {doc_path}")
+        full_path = get_docx_path(doc_path)
+        logger.debug(f"Resolved full path: {full_path}")
+
+        result = extract_quality_standards.extract_quality_standards_table_from_docx(full_path)
+        logger.info(f"Successfully extracted quality standards from: {full_path}")
+        return result
+
+    except Exception as e:
+        error_msg = f"Error in extract_quality_standards_table: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return f"Error: {error_msg}"
+
+
+@mcp.tool()
+def fill_quality_standards_table(doc_path: str, markdown_content: str, table_index: int = None) -> str:
+    """Fill Word document table with quality standards data from markdown format (modifies file in-place)
+
+    Args:
+        doc_path: Path to Word document to modify (absolute path or relative to DOCX_FILES_PATH)
+        markdown_content: Markdown table content as string
+        table_index: Specific table index to fill (None for auto-detection)
+
+    Returns:
+        Success message or error description
+    """
+    try:
+        logger.info(f"Starting in-place table filling for: {doc_path}")
+
+        # Resolve path
+        full_doc_path = get_docx_path(doc_path)
+        logger.debug(f"Resolved document path: {full_doc_path}")
+
+        # Fill the document in-place
+        result = fill_quality_standards.fill_quality_standards_inplace(
+            full_doc_path, markdown_content, table_index, auto_merge=True
+        )
+
+        logger.info(f"Successfully filled quality standards table in-place: {result}")
+        return result
+
+    except Exception as e:
+        error_msg = f"Error in fill_quality_standards_table: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return f"Error: {error_msg}"
+
+
+# @mcp.tool()
+# def extract_quality_standards_from_content(file_content_base64: str) -> str:
+#     """
+#     Extract quality standards table from Word document content (not file path)
+
+#     Args:
+#         file_content_base64: Base64 encoded Word document content
+
+#     Returns:
+#         Markdown formatted quality standards table
+#     """
+#     try:
+#         file_bytes = base64.b64decode(file_content_base64)
+#         return extract_quality_standards.extract_quality_standards_table_from_bytes(file_bytes)
+#     except Exception as e:
+#         return f"Error decoding or processing file content: {e}"
+
+
+# Add a dynamic greeting resource
+@mcp.resource("greeting://{name}")
+def get_greeting(name: str) -> str:
+    """Get a personalized greeting"""
+    return f"Hello, {name}!"
+
+
+# Add a prompt
+@mcp.prompt()
+def greet_user(name: str, style: str = "friendly") -> str:
+    """Generate a greeting prompt"""
+    styles = {
+        "friendly": "Please write a warm, friendly greeting",
+        "formal": "Please write a formal, professional greeting",
+        "casual": "Please write a casual, relaxed greeting",
+    }
+
+    return f"{styles.get(style, styles['friendly'])} for someone named {name}."
+
+
+def main() -> None:
+    mcp.run(transport='stdio')

src/extract_quality_standards.py

@@ -0,0 +1,342 @@
+"""
+Extract quality standards table from SPE-原液质量标准.docx
+Specifically looking for section 4.3 检验项目、方法和标准
+"""
+
+from docx import Document
+from docx.oxml.ns import qn
+import re
+import io
+import logging
+import traceback
+
+# Get logger for this module
+logger = logging.getLogger(__name__)
+
+def extract_text_with_formatting(cell):
+    """
+    Extract text from cell while preserving superscript and subscript formatting with error handling
+    """
+    result = ""
+
+    try:
+        logger.debug(f"Processing cell with {len(cell.paragraphs)} paragraphs")
+
+        for paragraph_idx, paragraph in enumerate(cell.paragraphs):
+            try:
+                logger.debug(f"Processing paragraph {paragraph_idx} with {len(paragraph.runs)} runs")
+
+                for run_idx, run in enumerate(paragraph.runs):
+                    try:
+                        text = run.text
+                        if text:
+                            logger.debug(f"Processing run {run_idx}: '{text[:50]}...' (length: {len(text)})")
+
+                            # Check for superscript
+                            if run.font.superscript:
+                                logger.debug(f"Detected superscript in run {run_idx}")
+                                # Convert to superscript Unicode characters when possible
+                                superscript_map = {
+                                    '0': '⁰', '1': '¹', '2': '²', '3': '³', '4': '⁴', '5': '⁵',
+                                    '6': '⁶', '7': '⁷', '8': '⁸', '9': '⁹', '+': '⁺', '-': '⁻',
+                                    '=': '⁼', '(': '⁽', ')': '⁾', 'n': 'ⁿ'
+                                }
+                                converted_text = ""
+                                for char in text:
+                                    converted_text += superscript_map.get(char, f"^{char}")
+                                result += converted_text
+                            # Check for subscript
+                            elif run.font.subscript:
+                                logger.debug(f"Detected subscript in run {run_idx}")
+                                # Convert to subscript Unicode characters when possible
+                                subscript_map = {
+                                    '0': '₀', '1': '₁', '2': '₂', '3': '₃', '4': '₄', '5': '₅',
+                                    '6': '₆', '7': '₇', '8': '₈', '9': '₉', '+': '₊', '-': '₋',
+                                    '=': '₌', '(': '₍', ')': '₎', 'a': 'ₐ', 'e': 'ₑ', 'i': 'ᵢ',
+                                    'o': 'ₒ', 'u': 'ᵤ', 'x': 'ₓ', 'h': 'ₕ', 'k': 'ₖ', 'l': 'ₗ',
+                                    'm': 'ₘ', 'n': 'ₙ', 'p': 'ₚ', 's': 'ₛ', 't': 'ₜ'
+                                }
+                                converted_text = ""
+                                for char in text:
+                                    converted_text += subscript_map.get(char, f"_{char}")
+                                result += converted_text
+                            else:
+                                result += text
+                    except Exception as e:
+                        logger.error(f"Error processing run {run_idx} in paragraph {paragraph_idx}: {str(e)}")
+                        # Add the text as-is if formatting extraction fails
+                        try:
+                            if run.text:
+                                result += run.text
+                        except:
+                            logger.error(f"Failed to get text from run {run_idx}")
+                            continue
+
+            except Exception as e:
+                logger.error(f"Error processing paragraph {paragraph_idx}: {str(e)}")
+                # Try to get paragraph text as fallback
+                try:
+                    if paragraph.text:
+                        result += paragraph.text
+                except:
+                    logger.error(f"Failed to get text from paragraph {paragraph_idx}")
+                    continue
+
+            # Add space between paragraphs if there are multiple
+            if len(cell.paragraphs) > 1:
+                result += " "
+
+    except Exception as e:
+        logger.error(f"Critical error in extract_text_with_formatting: {str(e)}")
+        logger.error(f"Traceback: {traceback.format_exc()}")
+        # Try to get cell text as last resort
+        try:
+            result = cell.text if hasattr(cell, 'text') else ""
+        except:
+            result = ""
+
+    final_result = result.strip()
+    logger.debug(f"Cell extraction result: '{final_result[:100]}...' (length: {len(final_result)})")
+    return final_result
+
+def extract_quality_standards_table(docx_path):
+    """
+    Extract quality standards table from Word document section 4.3 with detailed logging
+    """
+    logger.info(f"Loading document: {docx_path}")
+
+    try:
+        # Load the document
+        doc = Document(docx_path)
+        logger.debug(f"Document loaded successfully, contains {len(doc.paragraphs)} paragraphs")
+
+        # Find section 4.3
+        found_section_43 = False
+        table_data = []
+
+        logger.info("Searching for section 4.3 in document content...")
+
+        # First, let's examine all paragraphs to find section 4.3
+        for i, paragraph in enumerate(doc.paragraphs):
+            try:
+                text = paragraph.text.strip()
+                if text:
+                    logger.debug(f"Paragraph {i}: {text[:100]}...")
+
+                    # Look for section 4.3
+                    if re.search(r'4\.3.*检验项目.*方法.*标准', text, re.IGNORECASE):
+                        logger.info(f"Found section 4.3 at paragraph {i}: {text}")
+                        found_section_43 = True
+                        break
+            except Exception as e:
+                logger.error(f"Error processing paragraph {i}: {str(e)}")
+                continue
+
+        logger.debug(f"Section 4.3 search completed. Found: {found_section_43}")
+
+        # Now look for tables near section 4.3
+        logger.info(f"Found {len(doc.tables)} tables in the document")
+
+        for table_idx, table in enumerate(doc.tables):
+            try:
+                logger.debug(f"Processing table {table_idx + 1}")
+                logger.debug(f"Table dimensions: {len(table.rows)} rows, {len(table.columns)} columns")
+
+                # Extract table data with formatting
+                table_content = []
+                for row_idx, row in enumerate(table.rows):
+                    try:
+                        row_data = []
+                        for cell_idx, cell in enumerate(row.cells):
+                            try:
+                                # Use new function to extract text with formatting
+                                cell_text = extract_text_with_formatting(cell)
+                                # Clean up excessive whitespace but preserve formatting
+                                cell_text = ' '.join(cell_text.split())
+                                row_data.append(cell_text)
+                            except Exception as e:
+                                logger.error(f"Error processing cell [{row_idx}, {cell_idx}]: {str(e)}")
+                                row_data.append("")  # Add empty string for failed cells
+
+                        table_content.append(row_data)
+                        logger.debug(f"Row {row_idx}: {row_data}")
+                    except Exception as e:
+                        logger.error(f"Error processing row {row_idx} in table {table_idx + 1}: {str(e)}")
+                        continue
+
+                # Check if this table contains quality standards data
+                if table_content:
+                    header_row = table_content[0] if table_content else []
+                    header_text = ' '.join(header_row).lower()
+
+                    # Look for keywords that indicate this is the quality standards table
+                    quality_keywords = ['检验项目', '检验方法', '质量标准', '类型', '项目', '方法', '标准']
+                    keyword_count = sum(1 for keyword in quality_keywords if keyword in header_text)
+
+                    logger.debug(f"Table {table_idx + 1} header keywords found: {keyword_count}")
+                    if keyword_count >= 2:  # At least 2 keywords match
+                        logger.info(f"Table {table_idx + 1} appears to be the quality standards table (keyword matches: {keyword_count})")
+                        table_data = table_content
+                        break
+                else:
+                    logger.warning(f"Table {table_idx + 1} has no content")
+
+            except Exception as e:
+                logger.error(f"Error processing table {table_idx + 1}: {str(e)}")
+                logger.error(f"Table processing traceback: {traceback.format_exc()}")
+                continue
+
+        if not table_data:
+            logger.warning("No quality standards table found in document")
+
+        return table_data
+
+    except Exception as e:
+        logger.error(f"Critical error in extract_quality_standards_table: {str(e)}")
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        raise
+
+def format_as_markdown_table(table_data, target_columns=['类型', '检验项目', '检验方法', '质量标准']):
+    """
+    Convert table data to markdown format
+    """
+    if not table_data:
+        return "No table data found"
+
+    # Try to map columns to target format
+    header_row = table_data[0] if table_data else []
+    print(f"\nOriginal headers: {header_row}")
+
+    # Create markdown table
+    markdown_lines = []
+
+    # Header
+    markdown_lines.append(f"| {' | '.join(target_columns)} |")
+    markdown_lines.append(f"| {' | '.join(['---'] * len(target_columns))} |")
+
+    # Data rows
+    for row in table_data[1:]:  # Skip header row
+        # Pad row to match target columns length
+        padded_row = row + [''] * (len(target_columns) - len(row))
+        # Truncate if too long
+        padded_row = padded_row[:len(target_columns)]
+
+        markdown_lines.append(f"| {' | '.join(padded_row)} |")
+
+    return '\n'.join(markdown_lines)
+
+# def extract_quality_standards_table_from_bytes(file_bytes: bytes) -> str:
+#     """
+#     Extract quality standards table from Word document bytes
+
+#     Args:
+#         file_bytes: Binary content of the Word document
+
+#     Returns:
+#         Markdown formatted table string
+#     """
+#     print("Extracting quality standards table from Word document bytes...")
+
+#     try:
+#         doc = Document(io.BytesIO(file_bytes))
+
+#         found_section_43 = False
+#         table_data = []
+
+#         print("Searching through document content...")
+
+#         for i, paragraph in enumerate(doc.paragraphs):
+#             text = paragraph.text.strip()
+#             if text:
+#                 print(f"Paragraph {i}: {text[:100]}...")
+
+#                 if re.search(r'4\.3.*检验项目.*方法.*标准', text, re.IGNORECASE):
+#                     print(f"Found section 4.3 at paragraph {i}: {text}")
+#                     found_section_43 = True
+#                     break
+
+#         print(f"\nFound {len(doc.tables)} tables in the document")
+
+#         for table_idx, table in enumerate(doc.tables):
+#             print(f"\n--- Table {table_idx + 1} ---")
+#             print(f"Rows: {len(table.rows)}, Columns: {len(table.columns)}")
+
+#             table_content = []
+#             for row_idx, row in enumerate(table.rows):
+#                 row_data = []
+#                 for cell in row.cells:
+#                     cell_text = extract_text_with_formatting(cell)
+#                     cell_text = ' '.join(cell_text.split())
+#                     row_data.append(cell_text)
+#                 table_content.append(row_data)
+#                 print(f"Row {row_idx}: {row_data}")
+
+#             if table_content:
+#                 header_row = table_content[0] if table_content else []
+#                 header_text = ' '.join(header_row).lower()
+
+#                 quality_keywords = ['检验项目', '检验方法', '质量标准', '类型', '项目', '方法', '标准']
+#                 keyword_count = sum(1 for keyword in quality_keywords if keyword in header_text)
+
+#                 if keyword_count >= 2:
+#                     print(f"Table {table_idx + 1} appears to be the quality standards table (keyword matches: {keyword_count})")
+#                     table_data = table_content
+#                     break
+
+#         if table_data:
+#             print(f"\n=== Extracted Table Data ({len(table_data)} rows) ===")
+#             for i, row in enumerate(table_data):
+#                 print(f"Row {i}: {row}")
+
+#             print(f"\n=== Markdown Format ===")
+#             markdown_table = format_as_markdown_table(table_data)
+#             return markdown_table
+#         else:
+#             return "No quality standards table found in the document"
+
+#     except Exception as e:
+#         error_msg = f"Error processing document: {e}"
+#         print(error_msg)
+#         import traceback
+#         traceback.print_exc()
+#         return error_msg
+
+def extract_quality_standards_table_from_docx(docx_path: str):
+    """
+    Extract quality standards table from Word document with comprehensive error handling and debugging
+    """
+    logger.info(f"Starting extraction from document: {docx_path}")
+
+    try:
+        # Check if file exists
+        import os
+        if not os.path.exists(docx_path):
+            error_msg = f"File not found: {docx_path}"
+            logger.error(error_msg)
+            return f"Error: {error_msg}"
+
+        logger.debug(f"File exists, size: {os.path.getsize(docx_path)} bytes")
+
+        # Extract table data
+        table_data = extract_quality_standards_table(docx_path)
+
+        if table_data:
+            logger.info(f"Successfully extracted table with {len(table_data)} rows")
+            logger.debug("Extracted table content:")
+            for i, row in enumerate(table_data):
+                logger.debug(f"Row {i}: {row}")
+
+            # Convert to markdown
+            markdown_table = format_as_markdown_table(table_data)
+            logger.debug(f"Generated markdown table:\n{markdown_table}")
+            return markdown_table
+        else:
+            error_msg = "No quality standards table found in the document"
+            logger.warning(error_msg)
+            return f"Warning: {error_msg}"
+
+    except Exception as e:
+        error_msg = f"Error processing document {docx_path}: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return f"Error: {error_msg}"

src/fill_quality_standards.py

@@ -0,0 +1,536 @@
+"""
+Fill Word document table with quality standards data from markdown format
+基于fill_word_table.py和merge_word_cells.py的功能，实现将markdown格式的质量标准表格填写到指定docx文件中
+"""
+
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_ALIGN_PARAGRAPH
+import re
+import logging
+import traceback
+from typing import List, Tuple, Optional, Dict
+
+# Get logger for this module
+logger = logging.getLogger(__name__)
+
+def parse_markdown_table_from_string(markdown_content: str) -> List[List[str]]:
+    """
+    Parse markdown table from string content to extract data
+
+    Args:
+        markdown_content: Markdown table content as string
+
+    Returns:
+        List of rows, each row is a list of cell values
+    """
+    logger.debug(f"Parsing markdown table from string content")
+
+    data = []
+    lines = markdown_content.strip().split('\n')
+
+    # Find table lines (skip header separator line with ---)
+    table_started = False
+    header_found = False
+
+    for line_num, line in enumerate(lines):
+        line = line.strip()
+        logger.debug(f"Processing line {line_num}: '{line}'")
+
+        if line.startswith('|') and line.endswith('|'):
+            if '---' in line:
+                # This is the separator line, skip it
+                logger.debug(f"Skipping separator line: {line}")
+                continue
+
+            # Parse table row
+            cells = [cell.strip() for cell in line.split('|')[1:-1]]  # Remove first and last empty elements
+
+            if not header_found:
+                # This is the header row
+                logger.debug(f"Found header row: {cells}")
+                header_found = True
+                # Store header for reference but don't include in data
+                continue
+            else:
+                # This is a data row
+                if cells and any(cell.strip() for cell in cells):  # Skip empty rows
+                    logger.debug(f"Found data row: {cells}")
+                    data.append(cells)
+
+    logger.info(f"Parsed {len(data)} data rows from markdown table")
+    return data
+
+def parse_markdown_table_from_file(md_file_path: str) -> List[List[str]]:
+    """
+    Parse markdown table from file to extract data
+
+    Args:
+        md_file_path: Path to markdown file
+
+    Returns:
+        List of rows, each row is a list of cell values
+    """
+    logger.info(f"Reading markdown table from file: {md_file_path}")
+
+    try:
+        with open(md_file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return parse_markdown_table_from_string(content)
+    except Exception as e:
+        logger.error(f"Error reading markdown file {md_file_path}: {str(e)}")
+        raise
+
+def restore_formatting_to_cell(cell, text: str):
+    """
+    Restore superscript and subscript formatting from Unicode characters to Word formatting
+
+    Args:
+        cell: Word table cell
+        text: Text with Unicode super/subscript characters
+    """
+    try:
+        # Clear existing content
+        cell.text = ""
+        paragraph = cell.paragraphs[0]
+
+        # Maps for converting Unicode back to normal characters
+        superscript_map = {
+            '⁰': '0', '¹': '1', '²': '2', '³': '3', '⁴': '4', '⁵': '5',
+            '⁶': '6', '⁷': '7', '⁸': '8', '⁹': '9', '⁺': '+', '⁻': '-',
+            '⁼': '=', '⁽': '(', '⁾': ')', 'ⁿ': 'n'
+        }
+
+        subscript_map = {
+            '₀': '0', '₁': '1', '₂': '2', '₃': '3', '₄': '4', '₅': '5',
+            '₆': '6', '₇': '7', '₈': '8', '₉': '9', '₊': '+', '₋': '-',
+            '₌': '=', '₍': '(', '₎': ')', 'ₐ': 'a', 'ₑ': 'e', 'ᵢ': 'i',
+            'ₒ': 'o', 'ᵤ': 'u', 'ₓ': 'x', 'ₕ': 'h', 'ₖ': 'k', 'ₗ': 'l',
+            'ₘ': 'm', 'ₙ': 'n', 'ₚ': 'p', 'ₛ': 's', 'ₜ': 't'
+        }
+
+        # Also handle ^{} and _{} notation
+        # Pattern for ^{text} and _{text}
+        super_pattern = r'\^\{([^}]+)\}'
+        sub_pattern = r'_\{([^}]+)\}'
+
+        # Replace ^{text} and _{text} patterns first
+        def replace_super(match):
+            return ''.join(superscript_map.get(c, f'^{c}') for c in match.group(1))
+
+        def replace_sub(match):
+            return ''.join(subscript_map.get(c, f'_{c}') for c in match.group(1))
+
+        text = re.sub(super_pattern, replace_super, text)
+        text = re.sub(sub_pattern, replace_sub, text)
+
+        # Process character by character to handle formatting
+        i = 0
+        while i < len(text):
+            char = text[i]
+
+            if char in superscript_map:
+                # Add superscript character
+                run = paragraph.add_run(superscript_map[char])
+                run.font.superscript = True
+            elif char in subscript_map:
+                # Add subscript character
+                run = paragraph.add_run(subscript_map[char])
+                run.font.subscript = True
+            elif char == '^' and i + 1 < len(text):
+                # Handle ^character notation
+                i += 1
+                next_char = text[i]
+                run = paragraph.add_run(next_char)
+                run.font.superscript = True
+            elif char == '_' and i + 1 < len(text):
+                # Handle _character notation
+                i += 1
+                next_char = text[i]
+                run = paragraph.add_run(next_char)
+                run.font.subscript = True
+            else:
+                # Normal character
+                run = paragraph.add_run(char)
+
+            i += 1
+
+    except Exception as e:
+        logger.warning(f"Error restoring formatting to cell, using plain text: {str(e)}")
+        # Fallback to plain text
+        cell.text = text
+
+def clear_table_content(table, keep_header: bool = True):
+    """
+    Clear all rows in the table except optionally the header row
+
+    Args:
+        table: Word table object
+        keep_header: Whether to keep the first row (header)
+    """
+    start_row = 1 if keep_header else 0
+    rows_to_remove = len(table.rows) - start_row
+
+    logger.debug(f"Clearing {rows_to_remove} existing rows (keeping header: {keep_header})...")
+
+    # Remove rows from the end to avoid index issues
+    for _ in range(rows_to_remove):
+        if len(table.rows) > start_row:
+            # Remove the last row
+            table._tbl.remove(table.rows[-1]._tr)
+
+    logger.debug(f"Table now has {len(table.rows)} rows")
+
+def insert_table_rows(table, num_rows: int):
+    """
+    Insert the specified number of empty rows into the table
+
+    Args:
+        table: Word table object
+        num_rows: Number of rows to insert
+    """
+    logger.debug(f"Inserting {num_rows} new empty rows...")
+
+    for _ in range(num_rows):
+        # Add a new row to the table
+        new_row = table.add_row()
+        # Initialize cells with empty strings
+        for cell in new_row.cells:
+            cell.text = ""
+
+    logger.debug(f"Table now has {len(table.rows)} total rows")
+
+def find_quality_standards_table(doc: Document) -> Optional[int]:
+    """
+    Find the quality standards table in the document
+
+    Args:
+        doc: Word document object
+
+    Returns:
+        Table index if found, None otherwise
+    """
+    logger.debug(f"Searching for quality standards table in {len(doc.tables)} tables")
+
+    for table_idx, table in enumerate(doc.tables):
+        try:
+            if len(table.rows) > 0:
+                # Check header row for quality standards keywords
+                header_row = table.rows[0]
+                header_text = ' '.join(cell.text for cell in header_row.cells).lower()
+
+                quality_keywords = ['检验项目', '检验方法', '质量标准', '类型', '项目', '方法', '标准']
+                keyword_count = sum(1 for keyword in quality_keywords if keyword in header_text)
+
+                logger.debug(f"Table {table_idx}: header keywords found: {keyword_count}")
+
+                if keyword_count >= 2:  # At least 2 keywords match
+                    logger.info(f"Found quality standards table at index {table_idx}")
+                    return table_idx
+
+        except Exception as e:
+            logger.warning(f"Error checking table {table_idx}: {str(e)}")
+            continue
+
+    logger.warning("No quality standards table found")
+    return None
+
+def merge_cells_in_column(table, col_index: int, start_row: int, end_row: int):
+    """
+    Merge cells in a column from start_row to end_row (inclusive)
+
+    Note: This function prevents duplicate content by clearing subsequent cells before merging
+
+    Args:
+        table: Word table object
+        col_index: Column index to merge
+        start_row: Starting row index
+        end_row: Ending row index
+    """
+    if start_row >= end_row or end_row >= len(table.rows):
+        logger.debug(f"Skipping merge for column {col_index}, rows {start_row}-{end_row} (invalid range)")
+        return
+
+    try:
+        logger.debug(f"Merging column {col_index}, rows {start_row}-{end_row}")
+
+        # Get the first cell to merge into
+        first_cell = table.rows[start_row].cells[col_index]
+
+        # Store the original content from the first cell
+        original_content = first_cell.text.strip()
+
+        # Clear content from cells to be merged to prevent duplication
+        for row_idx in range(start_row + 1, end_row + 1):
+            if row_idx < len(table.rows):
+                cell = table.rows[row_idx].cells[col_index]
+                cell.text = ""  # Clear content before merging
+
+        # Now merge the cells (they're empty, so no duplicate content)
+        for row_idx in range(start_row + 1, end_row + 1):
+            if row_idx < len(table.rows):
+                cell_to_merge = table.rows[row_idx].cells[col_index]
+                first_cell.merge(cell_to_merge)
+
+        # Ensure the merged cell has the correct content
+        if first_cell.text.strip() != original_content:
+            first_cell.text = original_content
+
+        logger.debug(f"Successfully merged column {col_index}, rows {start_row}-{end_row}")
+
+    except Exception as e:
+        logger.warning(f"Could not merge cells {start_row}-{end_row} in column {col_index}: {str(e)}")
+        # If merging fails, at least clear the duplicate text in subsequent cells
+        try:
+            for row_idx in range(start_row + 1, end_row + 1):
+                if row_idx < len(table.rows):
+                    cell = table.rows[row_idx].cells[col_index]
+                    cell.text = ""
+        except Exception as e2:
+            logger.warning(f"Could not clear duplicate text: {str(e2)}")
+
+def auto_merge_duplicate_cells(table, target_columns: List[str] = ['类型', '检验项目']):
+    """
+    Automatically merge cells with duplicate content in specified columns
+
+    Args:
+        table: Word table object
+        target_columns: List of column names to check for merging
+    """
+    if len(table.rows) <= 1:
+        logger.debug("Not enough rows for merging")
+        return
+
+    # Get header row to find column indices
+    header_row = table.rows[0]
+    column_mapping = {}
+
+    for col_idx, cell in enumerate(header_row.cells):
+        header_text = cell.text.strip()
+        for target_col in target_columns:
+            if target_col in header_text:
+                column_mapping[target_col] = col_idx
+                break
+
+    logger.debug(f"Column mapping for merging: {column_mapping}")
+
+    # Merge 类型 column
+    if '类型' in column_mapping:
+        col_idx = column_mapping['类型']
+        logger.debug(f"Processing 类型 column (index {col_idx}) for merging")
+
+        current_type = ""
+        merge_start = -1
+
+        for row_idx in range(1, len(table.rows)):  # Skip header
+            cell_text = table.rows[row_idx].cells[col_idx].text.strip()
+
+            if cell_text != current_type:
+                # Different type found, merge previous group if needed
+                if merge_start != -1 and row_idx - merge_start > 1:
+                    merge_cells_in_column(table, col_idx, merge_start, row_idx - 1)
+
+                current_type = cell_text
+                merge_start = row_idx
+
+        # Handle last group
+        if merge_start != -1 and len(table.rows) - merge_start > 1:
+            merge_cells_in_column(table, col_idx, merge_start, len(table.rows) - 1)
+
+    # Merge 检验项目 column within same 类型
+    if '检验项目' in column_mapping and '类型' in column_mapping:
+        type_col_idx = column_mapping['类型']
+        item_col_idx = column_mapping['检验项目']
+
+        logger.debug(f"Processing 检验项目 column (index {item_col_idx}) for merging within same 类型")
+
+        current_type = ""
+        current_item = ""
+        item_start = -1
+
+        for row_idx in range(1, len(table.rows)):
+            type_text = table.rows[row_idx].cells[type_col_idx].text.strip()
+            item_text = table.rows[row_idx].cells[item_col_idx].text.strip()
+
+            if type_text != current_type:
+                # Different type, merge previous item group if needed
+                if item_start != -1 and row_idx - item_start > 1 and current_item:
+                    merge_cells_in_column(table, item_col_idx, item_start, row_idx - 1)
+
+                current_type = type_text
+                current_item = item_text
+                item_start = row_idx
+            elif item_text == current_item and item_text != "" and current_item != "":
+                # Same item in same type - continue the group
+                continue
+            else:
+                # Different item in same type, merge previous group if needed
+                if item_start != -1 and row_idx - item_start > 1 and current_item:
+                    merge_cells_in_column(table, item_col_idx, item_start, row_idx - 1)
+
+                current_item = item_text
+                item_start = row_idx
+
+        # Handle last group
+        if item_start != -1 and len(table.rows) - item_start > 1 and current_item:
+            merge_cells_in_column(table, item_col_idx, item_start, len(table.rows) - 1)
+
+def fill_word_document_table(doc_path: str, output_path: str, table_data: List[List[str]],
+                           table_index: Optional[int] = None,
+                           target_columns: List[str] = ['类型', '检验项目', '检验方法', '质量标准'],
+                           auto_merge: bool = True) -> str:
+    """
+    Fill Word document table with quality standards data
+
+    Args:
+        doc_path: Path to input Word document
+        output_path: Path to save output document
+        table_data: List of rows, each row is a list of cell values
+        table_index: Specific table index to fill (None for auto-detection)
+        target_columns: Expected column order
+        auto_merge: Whether to automatically merge duplicate cells
+
+    Returns:
+        Success message or error description
+    """
+    try:
+        logger.info(f"Loading document: {doc_path}")
+        doc = Document(doc_path)
+
+        # Find target table
+        if table_index is None:
+            table_index = find_quality_standards_table(doc)
+            if table_index is None:
+                return "Error: No quality standards table found in document"
+
+        if table_index >= len(doc.tables):
+            return f"Error: Table index {table_index} not found in document (only {len(doc.tables)} tables)"
+
+        target_table = doc.tables[table_index]
+        logger.info(f"Using table {table_index} with {len(target_table.rows)} rows and {len(target_table.columns)} columns")
+
+        # Validate data
+        if not table_data:
+            return "Error: No table data provided"
+
+        logger.info(f"Filling table with {len(table_data)} data rows")
+
+        # Step 1: Clear existing table content (except header)
+        clear_table_content(target_table, keep_header=True)
+
+        # Step 2: Insert required number of rows
+        num_data_rows = len(table_data)
+        insert_table_rows(target_table, num_data_rows)
+
+        # Step 3: Fill the table with data
+        for i, row_data in enumerate(table_data):
+            row_index = i + 1  # Skip header row
+            if row_index < len(target_table.rows):
+                row = target_table.rows[row_index]
+
+                # Fill cells based on available data and columns
+                max_cols = min(len(row_data), len(row.cells), len(target_columns))
+
+                for col_idx in range(max_cols):
+                    cell_text = row_data[col_idx] if col_idx < len(row_data) else ""
+                    cell = row.cells[col_idx]
+
+                    # Restore formatting for the cell content
+                    restore_formatting_to_cell(cell, cell_text)
+
+                logger.debug(f"Filled row {row_index}: {row_data[:max_cols]}")
+            else:
+                logger.warning(f"Skipping row {row_index}, table doesn't have enough rows")
+
+        # Step 4: Auto-merge duplicate cells if requested
+        if auto_merge:
+            logger.info("Performing automatic cell merging...")
+            auto_merge_duplicate_cells(target_table, target_columns[:2])  # Only merge 类型 and 检验项目
+
+        # Step 5: Save the modified document
+        doc.save(output_path)
+        logger.info(f"Document saved to: {output_path}")
+
+        return f"Successfully filled table with {len(table_data)} rows and saved to {output_path}"
+
+    except Exception as e:
+        error_msg = f"Error filling Word document table: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg
+
+def fill_quality_standards_from_markdown(doc_path: str, output_path: str, markdown_content: str,
+                                       table_index: Optional[int] = None, auto_merge: bool = True) -> str:
+    """
+    Fill Word document table with quality standards data from markdown content
+
+    Args:
+        doc_path: Path to input Word document
+        output_path: Path to save output document
+        markdown_content: Markdown table content as string
+        table_index: Specific table index to fill (None for auto-detection)
+        auto_merge: Whether to automatically merge duplicate cells
+
+    Returns:
+        Success message or error description
+    """
+    try:
+        logger.info("Parsing markdown table content...")
+        table_data = parse_markdown_table_from_string(markdown_content)
+
+        if not table_data:
+            return "Error: No valid table data found in markdown content"
+
+        return fill_word_document_table(doc_path, output_path, table_data, table_index, auto_merge=auto_merge)
+
+    except Exception as e:
+        error_msg = f"Error processing markdown content: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg
+
+def fill_quality_standards_from_file(doc_path: str, output_path: str, markdown_file_path: str,
+                                   table_index: Optional[int] = None, auto_merge: bool = True) -> str:
+    """
+    Fill Word document table with quality standards data from markdown file
+
+    Args:
+        doc_path: Path to input Word document
+        output_path: Path to save output document
+        markdown_file_path: Path to markdown file containing table data
+        table_index: Specific table index to fill (None for auto-detection)
+        auto_merge: Whether to automatically merge duplicate cells
+
+    Returns:
+        Success message or error description
+    """
+    try:
+        logger.info(f"Reading markdown file: {markdown_file_path}")
+        table_data = parse_markdown_table_from_file(markdown_file_path)
+
+        if not table_data:
+            return "Error: No valid table data found in markdown file"
+
+        return fill_word_document_table(doc_path, output_path, table_data, table_index, auto_merge=auto_merge)
+
+    except Exception as e:
+        error_msg = f"Error processing markdown file: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return error_msg
+
+def fill_quality_standards_inplace(doc_path: str, markdown_content: str,
+                                 table_index: Optional[int] = None, auto_merge: bool = True) -> str:
+    """
+    Fill Word document table with quality standards data from markdown content (modifies file in-place)
+
+    Args:
+        doc_path: Path to Word document to modify in-place
+        markdown_content: Markdown table content as string
+        table_index: Specific table index to fill (None for auto-detection)
+        auto_merge: Whether to automatically merge duplicate cells
+
+    Returns:
+        Success message or error description
+    """
+    return fill_quality_standards_from_markdown(doc_path, doc_path, markdown_content, table_index, auto_merge)

src/server.py

@@ -0,0 +1,157 @@
+"""
+RA Document MCP Server
+
+Run:
+    uv run src.server fastmcp_quickstart stdio
+"""
+
+from mcp.server.fastmcp import FastMCP
+from src import extract_quality_standards
+from src import fill_quality_standards
+import os
+import logging
+import traceback
+# Create an MCP server
+mcp = FastMCP("ra-doc-mcp")
+
+
+# Initialize LOG_FILE variable without assigning a value
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+LOG_FILE = os.path.join(ROOT_DIR, "ra-file-mcp.log")
+
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_FILE, encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize EXCEL_FILES_PATH variable without assigning a value
+DOCX_FILES_PATH = None
+
+def get_docx_path(filename: str) -> str:
+    """Get full path to Excel file.
+    
+    Args:
+        filename: Name of Excel file
+        
+    Returns:
+        Full path to Excel file
+    """
+    # If filename is already an absolute path, return it
+    if os.path.isabs(filename):
+        return filename
+
+    # Check if in SSE mode (EXCEL_FILES_PATH is not None)
+    if DOCX_FILES_PATH is None:
+        # Must use absolute path
+        raise ValueError(f"Invalid filename: {filename}, must be an absolute path when not in SSE mode")
+
+    # In SSE mode, if it's a relative path, resolve it based on EXCEL_FILES_PATH
+    return os.path.join(DOCX_FILES_PATH, filename)
+
+
+# Add an addition tool
+@mcp.tool()
+def add(a: int, b: int) -> int:
+    """Add two numbers"""
+    return a + b + 1
+
+
+# Add an addition tool
+@mcp.tool()
+def extract_quality_standards_table(doc_path: str) -> str:
+    """Extract quality standards table from docx file"""
+    try:
+        logger.info(f"Starting quality standards extraction for: {doc_path}")
+        full_path = get_docx_path(doc_path)
+        logger.debug(f"Resolved full path: {full_path}")
+
+        result = extract_quality_standards.extract_quality_standards_table_from_docx(full_path)
+        logger.info(f"Successfully extracted quality standards from: {full_path}")
+        return result
+
+    except Exception as e:
+        error_msg = f"Error in extract_quality_standards_table: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return f"Error: {error_msg}"
+
+
+@mcp.tool()
+def fill_quality_standards_table(doc_path: str, markdown_content: str, table_index: int = None) -> str:
+    """Fill Word document table with quality standards data from markdown format (modifies file in-place)
+
+    Args:
+        doc_path: Path to Word document to modify (absolute path or relative to DOCX_FILES_PATH)
+        markdown_content: Markdown table content as string
+        table_index: Specific table index to fill (None for auto-detection)
+
+    Returns:
+        Success message or error description
+    """
+    try:
+        logger.info(f"Starting in-place table filling for: {doc_path}")
+
+        # Resolve path
+        full_doc_path = get_docx_path(doc_path)
+        logger.debug(f"Resolved document path: {full_doc_path}")
+
+        # Fill the document in-place
+        result = fill_quality_standards.fill_quality_standards_inplace(
+            full_doc_path, markdown_content, table_index, auto_merge=True
+        )
+
+        logger.info(f"Successfully filled quality standards table in-place: {result}")
+        return result
+
+    except Exception as e:
+        error_msg = f"Error in fill_quality_standards_table: {str(e)}"
+        logger.error(error_msg)
+        logger.error(f"Full traceback: {traceback.format_exc()}")
+        return f"Error: {error_msg}"
+
+
+# @mcp.tool()
+# def extract_quality_standards_from_content(file_content_base64: str) -> str:
+#     """
+#     Extract quality standards table from Word document content (not file path)
+
+#     Args:
+#         file_content_base64: Base64 encoded Word document content
+
+#     Returns:
+#         Markdown formatted quality standards table
+#     """
+#     try:
+#         file_bytes = base64.b64decode(file_content_base64)
+#         return extract_quality_standards.extract_quality_standards_table_from_bytes(file_bytes)
+#     except Exception as e:
+#         return f"Error decoding or processing file content: {e}"
+
+
+# Add a dynamic greeting resource
+@mcp.resource("greeting://{name}")
+def get_greeting(name: str) -> str:
+    """Get a personalized greeting"""
+    return f"Hello, {name}!"
+
+
+# Add a prompt
+@mcp.prompt()
+def greet_user(name: str, style: str = "friendly") -> str:
+    """Generate a greeting prompt"""
+    styles = {
+        "friendly": "Please write a warm, friendly greeting",
+        "formal": "Please write a formal, professional greeting",
+        "casual": "Please write a casual, relaxed greeting",
+    }
+
+    return f"{styles.get(style, styles['friendly'])} for someone named {name}."
+
+if __name__ == "__main__":
+    mcp.run(transport='stdio')