Update biotite/mcp_output/mcp_plugin/mcp_service.py

biotite/mcp_output/mcp_plugin/mcp_service.py

@@ -1,911 +1,181 @@
-import os
-import sys
-from typing import List, Optional, Tuple
-
-# Add the local source directory to sys.path
-source_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))), "source")
-if source_path not in sys.path:
-    sys.path.insert(0, source_path)
-
 from fastmcp import FastMCP
-import numpy as np
 
-# Create the FastMCP service application
+# 创建 FastMCP 服务应用
 mcp = FastMCP("biotite_service")
 
-
-# =============================================================================
-# Sequence Tools
-# =============================================================================
-
-@mcp.tool(name="align_sequences", description="Align biological sequences using Biotite.")
-def align_sequences(seq1: str, seq2: str) -> dict:
-    """
-    Align two biological sequences using optimal alignment algorithm.
-    
-    Parameters:
-    - seq1: The first sequence to align (DNA, RNA, or protein).
-    - seq2: The second sequence to align (DNA, RNA, or protein).
-    
-    Returns:
-    A dictionary containing the alignment result with score and aligned sequences.
-    """
-    try:
-        from biotite.sequence import NucleotideSequence, ProteinSequence
-        from biotite.sequence.align import align_optimal, SubstitutionMatrix
-        
-        # Try to detect sequence type and create appropriate sequence objects
-        seq1_upper = seq1.upper()
-        seq2_upper = seq2.upper()
-        
-        # Check if sequences are nucleotide or protein
-        nucleotide_chars = set("ACGTURYSWKMBDHVN")
-        is_nucleotide = all(c in nucleotide_chars for c in seq1_upper if c not in "-. ")
-        
-        if is_nucleotide:
-            sequence1 = NucleotideSequence(seq1_upper.replace("U", "T"))
-            sequence2 = NucleotideSequence(seq2_upper.replace("U", "T"))
-            matrix = SubstitutionMatrix.std_nucleotide_matrix()
-        else:
-            sequence1 = ProteinSequence(seq1_upper)
-            sequence2 = ProteinSequence(seq2_upper)
-            matrix = SubstitutionMatrix.std_protein_matrix()
-        
-        # Perform alignment
-        alignments = align_optimal(sequence1, sequence2, matrix)
-        alignment = alignments[0]
-        
-        # Format output
-        aligned_seq1, aligned_seq2 = alignment.get_gapped_sequences()
-        
-        return {
-            "success": True,
-            "result": {
-                "aligned_seq1": str(aligned_seq1),
-                "aligned_seq2": str(aligned_seq2),
-                "score": int(alignment.score),
-                "alignment_length": len(alignment.trace),
-                "sequence_type": "nucleotide" if is_nucleotide else "protein"
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="get_sequence_identity", description="Calculate sequence identity between two aligned sequences.")
-def get_sequence_identity(seq1: str, seq2: str) -> dict:
-    """
-    Calculate the sequence identity between two sequences after alignment.
-    
-    Parameters:
-    - seq1: The first sequence.
-    - seq2: The second sequence.
-    
-    Returns:
-    A dictionary containing identity percentage and match statistics.
-    """
-    try:
-        from biotite.sequence import NucleotideSequence, ProteinSequence
-        from biotite.sequence.align import align_optimal, SubstitutionMatrix, get_sequence_identity as calc_identity
-        
-        seq1_upper = seq1.upper()
-        seq2_upper = seq2.upper()
-        
-        nucleotide_chars = set("ACGTURYSWKMBDHVN")
-        is_nucleotide = all(c in nucleotide_chars for c in seq1_upper if c not in "-. ")
-        
-        if is_nucleotide:
-            sequence1 = NucleotideSequence(seq1_upper.replace("U", "T"))
-            sequence2 = NucleotideSequence(seq2_upper.replace("U", "T"))
-            matrix = SubstitutionMatrix.std_nucleotide_matrix()
-        else:
-            sequence1 = ProteinSequence(seq1_upper)
-            sequence2 = ProteinSequence(seq2_upper)
-            matrix = SubstitutionMatrix.std_protein_matrix()
-        
-        alignments = align_optimal(sequence1, sequence2, matrix)
-        alignment = alignments[0]
-        identity = calc_identity(alignment)
-        
-        return {
-            "success": True,
-            "result": {
-                "identity": float(identity),
-                "identity_percent": float(identity * 100),
-                "alignment_score": int(alignment.score)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="create_nucleotide_sequence", description="Create a nucleotide sequence object and get its properties.")
-def create_nucleotide_sequence(sequence: str) -> dict:
-    """
-    Create a nucleotide sequence and return its properties.
-    
-    Parameters:
-    - sequence: DNA or RNA sequence string (e.g., "ATGCGATCGA").
-    
-    Returns:
-    A dictionary containing sequence length, GC content, and complement.
-    """
-    try:
-        from biotite.sequence import NucleotideSequence
-        
-        # Convert U to T for DNA compatibility
-        seq_upper = sequence.upper().replace("U", "T")
-        nuc_seq = NucleotideSequence(seq_upper)
-        
-        # Calculate GC content
-        gc_count = str(nuc_seq).count("G") + str(nuc_seq).count("C")
-        gc_content = gc_count / len(nuc_seq) if len(nuc_seq) > 0 else 0
-        
-        # Get complement
-        complement = nuc_seq.complement()
-        
-        return {
-            "success": True,
-            "result": {
-                "sequence": str(nuc_seq),
-                "length": len(nuc_seq),
-                "gc_content": float(gc_content),
-                "gc_percent": float(gc_content * 100),
-                "complement": str(complement),
-                "reverse_complement": str(complement[::-1])
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="create_protein_sequence", description="Create a protein sequence object and get its properties.")
-def create_protein_sequence(sequence: str) -> dict:
-    """
-    Create a protein sequence and return its properties.
-    
-    Parameters:
-    - sequence: Amino acid sequence string (e.g., "MKVLWAALLV").
-    
-    Returns:
-    A dictionary containing sequence length and amino acid composition.
-    """
-    try:
-        from biotite.sequence import ProteinSequence
-        
-        prot_seq = ProteinSequence(sequence.upper())
-        
-        # Calculate amino acid composition
-        aa_composition = {}
-        seq_str = str(prot_seq)
-        for aa in set(seq_str):
-            aa_composition[aa] = seq_str.count(aa)
-        
-        return {
-            "success": True,
-            "result": {
-                "sequence": str(prot_seq),
-                "length": len(prot_seq),
-                "amino_acid_composition": aa_composition,
-                "unique_amino_acids": len(aa_composition)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="translate_dna", description="Translate a DNA sequence into a protein sequence.")
-def translate_dna(dna_sequence: str, codon_table: str = "Standard") -> dict:
-    """
-    Translate a DNA sequence to protein using specified codon table.
-    
-    Parameters:
-    - dna_sequence: The DNA sequence to translate.
-    - codon_table: The codon table to use (default: "Standard").
-    
-    Returns:
-    A dictionary containing the translated protein sequence.
-    """
-    try:
-        from biotite.sequence import NucleotideSequence, ProteinSequence
-        from biotite.sequence.codon import CodonTable
-        
-        dna_seq = NucleotideSequence(dna_sequence.upper().replace("U", "T"))
-        table = CodonTable.load(codon_table)
-        
-        # Translate
-        protein_seq, _ = table.translate(dna_seq)
-        
-        return {
-            "success": True,
-            "result": {
-                "dna_sequence": str(dna_seq),
-                "protein_sequence": str(protein_seq),
-                "dna_length": len(dna_seq),
-                "protein_length": len(protein_seq),
-                "codon_table": codon_table
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# =============================================================================
-# Structure Tools
-# =============================================================================
-
-@mcp.tool(name="analyze_atoms", description="Analyze atoms in a molecular structure.")
-def analyze_atoms(structure_file: str) -> dict:
-    """
-    Load and analyze atoms in a given molecular structure file.
-    
-    Parameters:
-    - structure_file: Path to the molecular structure file (PDB, mmCIF, etc.).
-    
-    Returns:
-    A dictionary containing structural information including atom count,
-    chains, residues, and element composition.
-    """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import get_chains, get_residues
-        
-        atoms = load_structure(structure_file)
-        
-        # Get basic statistics
-        chains = get_chains(atoms)
-        residues = get_residues(atoms)
-        
-        # Element composition
-        element_counts = {}
-        for elem in atoms.element:
-            element_counts[elem] = element_counts.get(elem, 0) + 1
-        
-        return {
-            "success": True,
-            "result": {
-                "atom_count": atoms.array_length(),
-                "chain_ids": list(set(chains[1])),
-                "chain_count": len(set(chains[1])),
-                "residue_count": len(residues[0]),
-                "element_composition": element_counts,
-                "has_bonds": atoms.bonds is not None
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="calculate_rmsd", description="Calculate RMSD between two structures.")
-def calculate_rmsd(structure_file1: str, structure_file2: str) -> dict:
-    """
-    Calculate Root Mean Square Deviation between two structures.
-    
-    Parameters:
-    - structure_file1: Path to the first structure file.
-    - structure_file2: Path to the second structure file.
-    
-    Returns:
-    A dictionary containing RMSD value in Angstroms.
-    """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import superimpose, rmsd
-        
-        atoms1 = load_structure(structure_file1)
-        atoms2 = load_structure(structure_file2)
-        
-        # Superimpose structures
-        atoms2_superimposed, transformation = superimpose(atoms1, atoms2)
-        
-        # Calculate RMSD
-        rmsd_value = rmsd(atoms1, atoms2_superimposed)
-        
-        return {
-            "success": True,
-            "result": {
-                "rmsd": float(rmsd_value),
-                "rmsd_unit": "Angstrom",
-                "atom_count": atoms1.array_length()
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="superimpose_structures", description="Superimpose one structure onto another.")
-def superimpose_structures(fixed_file: str, mobile_file: str, output_file: str) -> dict:
-    """
-    Superimpose one structure onto another and save the result.
-    
-    Parameters:
-    - fixed_file: Path to the fixed (reference) structure file.
-    - mobile_file: Path to the mobile structure file.
-    - output_file: Path for the output superimposed structure.
-    
-    Returns:
-    A dictionary containing RMSD before and after superimposition.
-    """
-    try:
-        from biotite.structure.io import load_structure, save_structure
-        from biotite.structure import superimpose, rmsd
-        
-        fixed = load_structure(fixed_file)
-        mobile = load_structure(mobile_file)
-        
-        # Calculate RMSD before superimposition
-        rmsd_before = rmsd(fixed, mobile)
-        
-        # Superimpose
-        mobile_superimposed, transformation = superimpose(fixed, mobile)
-        
-        # Calculate RMSD after superimposition
-        rmsd_after = rmsd(fixed, mobile_superimposed)
-        
-        # Save result
-        save_structure(output_file, mobile_superimposed)
-        
-        return {
-            "success": True,
-            "result": {
-                "rmsd_before": float(rmsd_before),
-                "rmsd_after": float(rmsd_after),
-                "improvement": float(rmsd_before - rmsd_after),
-                "output_file": output_file
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="calculate_distance", description="Calculate distance between two atoms by index.")
-def calculate_distance(structure_file: str, atom_index1: int, atom_index2: int) -> dict:
+@mcp.tool(name="list_available_modules", description="列出 Biotite 中的所有模块")
+def list_available_modules() -> dict:
     """
-    Calculate the distance between two atoms in a structure.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    - atom_index1: Index of the first atom (0-based).
-    - atom_index2: Index of the second atom (0-based).
-    
-    Returns:
-    A dictionary containing the distance in Angstroms.
-    """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import distance
-        
-        atoms = load_structure(structure_file)
-        
-        # Get atom information
-        atom1_info = {
-            "index": atom_index1,
-            "element": atoms.element[atom_index1],
-            "atom_name": atoms.atom_name[atom_index1],
-            "res_name": atoms.res_name[atom_index1],
-            "res_id": int(atoms.res_id[atom_index1])
-        }
-        atom2_info = {
-            "index": atom_index2,
-            "element": atoms.element[atom_index2],
-            "atom_name": atoms.atom_name[atom_index2],
-            "res_name": atoms.res_name[atom_index2],
-            "res_id": int(atoms.res_id[atom_index2])
-        }
-        
-        # Calculate distance
-        dist = distance(atoms[atom_index1], atoms[atom_index2])
-        
-        return {
-            "success": True,
-            "result": {
-                "distance": float(dist),
-                "distance_unit": "Angstrom",
-                "atom1": atom1_info,
-                "atom2": atom2_info
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    列出 Biotite 中的所有模块。
 
-
-@mcp.tool(name="calculate_angle", description="Calculate angle between three atoms.")
-def calculate_angle(structure_file: str, atom_index1: int, atom_index2: int, atom_index3: int) -> dict:
-    """
-    Calculate the angle formed by three atoms.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    - atom_index1: Index of the first atom (0-based).
-    - atom_index2: Index of the central atom (0-based).
-    - atom_index3: Index of the third atom (0-based).
-    
-    Returns:
-    A dictionary containing the angle in degrees and radians.
+    返回：
+    - dict: 包含成功状态和模块列表的字典。
     """
     try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import angle
-        
-        atoms = load_structure(structure_file)
-        
-        # Calculate angle
-        ang = angle(atoms[atom_index1], atoms[atom_index2], atoms[atom_index3])
-        
+        modules = [
+            "sequence",
+            "structure",
+            "application",
+            "database",
+            "interface",
+        ]
         return {
             "success": True,
-            "result": {
-                "angle_radians": float(ang),
-                "angle_degrees": float(np.degrees(ang)),
-                "atom_indices": [atom_index1, atom_index2, atom_index3]
-            },
-            "error": None
+            "modules": modules,
+            "count": len(modules)
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="calculate_dihedral", description="Calculate dihedral angle between four atoms.")
-def calculate_dihedral(structure_file: str, atom_index1: int, atom_index2: int, 
-                       atom_index3: int, atom_index4: int) -> dict:
-    """
-    Calculate the dihedral angle formed by four atoms.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    - atom_index1-4: Indices of the four atoms (0-based).
-    
-    Returns:
-    A dictionary containing the dihedral angle in degrees and radians.
+@mcp.tool(name="get_module_info", description="获取 Biotite 模块的详细信息")
+def get_module_info(module_name: str) -> dict:
     """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import dihedral
-        
-        atoms = load_structure(structure_file)
-        
-        # Calculate dihedral
-        dih = dihedral(atoms[atom_index1], atoms[atom_index2], 
-                       atoms[atom_index3], atoms[atom_index4])
-        
-        return {
-            "success": True,
-            "result": {
-                "dihedral_radians": float(dih),
-                "dihedral_degrees": float(np.degrees(dih)),
-                "atom_indices": [atom_index1, atom_index2, atom_index3, atom_index4]
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    获取 Biotite 模块的详细信息。
 
+    参数：
+    - module_name: 模块名称（例如 'sequence'）
 
-@mcp.tool(name="calculate_centroid", description="Calculate the centroid of a structure.")
-def calculate_centroid(structure_file: str) -> dict:
-    """
-    Calculate the geometric centroid of a structure.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    
-    Returns:
-    A dictionary containing the centroid coordinates (x, y, z).
+    返回：
+    - dict: 包含模块信息的字典。
     """
     try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import centroid
-        
-        atoms = load_structure(structure_file)
-        center = centroid(atoms)
-        
-        return {
-            "success": True,
-            "result": {
-                "centroid": {
-                    "x": float(center[0]),
-                    "y": float(center[1]),
-                    "z": float(center[2])
-                },
-                "unit": "Angstrom"
-            },
-            "error": None
+        module_info = {
+            "sequence": "提供序列操作和分析功能，包括对齐、注释和可视化。",
+            "structure": "提供分子结构的操作和分析功能，包括超位移和比较。",
+            "application": "提供与外部生物信息学工具的接口，例如 BLAST、DSSP 等。",
+            "database": "支持从生物数据库中搜索和获取数据。",
+            "interface": "提供与其他生物信息学库（如 RDKit）的接口。"
         }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="calculate_sasa", description="Calculate Solvent Accessible Surface Area.")
-def calculate_sasa(structure_file: str, probe_radius: float = 1.4) -> dict:
-    """
-    Calculate the Solvent Accessible Surface Area (SASA) of a structure.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    - probe_radius: Radius of the solvent probe in Angstroms (default: 1.4).
-    
-    Returns:
-    A dictionary containing total SASA and per-atom SASA values.
-    """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import sasa
-        
-        atoms = load_structure(structure_file)
-        atom_sasa = sasa(atoms, probe_radius=probe_radius)
-        
-        # Filter out NaN values
-        valid_sasa = atom_sasa[~np.isnan(atom_sasa)]
-        total_sasa = np.sum(valid_sasa)
-        
+        if module_name not in module_info:
+            return {
+                "success": False,
+                "error": f"模块 '{module_name}' 不存在。请使用 list_available_modules 查看可用模块。"
+            }
         return {
             "success": True,
-            "result": {
-                "total_sasa": float(total_sasa),
-                "sasa_unit": "Angstrom^2",
-                "probe_radius": probe_radius,
-                "atoms_calculated": len(valid_sasa),
-                "mean_atom_sasa": float(np.mean(valid_sasa)) if len(valid_sasa) > 0 else 0
-            },
-            "error": None
+            "module_name": module_name,
+            "description": module_info[module_name]
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="find_hydrogen_bonds", description="Find hydrogen bonds in a structure.")
-def find_hydrogen_bonds(structure_file: str, cutoff_dist: float = 2.5, 
-                        cutoff_angle: float = 120.0) -> dict:
-    """
-    Find hydrogen bonds in a molecular structure.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    - cutoff_dist: Maximum H-A distance in Angstroms (default: 2.5).
-    - cutoff_angle: Minimum D-H-A angle in degrees (default: 120).
-    
-    Returns:
-    A dictionary containing hydrogen bond triplets (Donor, H, Acceptor).
+@mcp.tool(name="analyze_sequence", description="分析生物序列")
+def analyze_sequence(sequence: str) -> dict:
     """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import hbond
-        
-        atoms = load_structure(structure_file)
-        
-        triplets = hbond(atoms, cutoff_dist=cutoff_dist, cutoff_angle=cutoff_angle)
-        
-        # Format results
-        hbond_list = []
-        for i in range(len(triplets)):
-            d_idx, h_idx, a_idx = triplets[i]
-            hbond_list.append({
-                "donor_index": int(d_idx),
-                "hydrogen_index": int(h_idx),
-                "acceptor_index": int(a_idx),
-                "donor_element": atoms.element[d_idx],
-                "acceptor_element": atoms.element[a_idx]
-            })
-        
-        return {
-            "success": True,
-            "result": {
-                "hydrogen_bond_count": len(hbond_list),
-                "hydrogen_bonds": hbond_list[:50],  # Limit output
-                "cutoff_distance": cutoff_dist,
-                "cutoff_angle": cutoff_angle
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    分析给定的生物序列。
 
+    参数：
+    - sequence: 生物序列字符串
 
-@mcp.tool(name="annotate_secondary_structure", description="Annotate secondary structure elements.")
-def annotate_secondary_structure(structure_file: str) -> dict:
-    """
-    Annotate secondary structure elements (alpha helix, beta strand, coil) in a protein.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    
-    Returns:
-    A dictionary containing SSE annotations for each residue.
+    返回：
+    - dict: 包含分析结果的字典。
     """
     try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import annotate_sse, get_residues
-        
-        atoms = load_structure(structure_file)
-        sse = annotate_sse(atoms)
-        
-        # Count SSE types
-        sse_counts = {
-            "alpha_helix": int(np.sum(sse == 'a')),
-            "beta_strand": int(np.sum(sse == 'b')),
-            "coil": int(np.sum(sse == 'c')),
-            "other": int(np.sum(sse == ''))
-        }
-        
-        # Get residue info
-        residues = get_residues(atoms)
-        
+        from biotite.sequence import NucleotideSequence
+        seq = NucleotideSequence(sequence)
         return {
             "success": True,
-            "result": {
-                "sse_sequence": ''.join(sse),
-                "sse_counts": sse_counts,
-                "residue_count": len(sse),
-                "helix_percentage": float(sse_counts["alpha_helix"] / len(sse) * 100) if len(sse) > 0 else 0,
-                "strand_percentage": float(sse_counts["beta_strand"] / len(sse) * 100) if len(sse) > 0 else 0
-            },
-            "error": None
+            "length": len(seq),
+            "alphabet": str(seq.alphabet),
+            "sequence": str(seq)
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+        return {"success": False, "error": str(e)}
 
-
-@mcp.tool(name="filter_amino_acids", description="Filter and extract amino acid residues from a structure.")
-def filter_amino_acids(structure_file: str) -> dict:
-    """
-    Filter a structure to keep only amino acid residues.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    
-    Returns:
-    A dictionary containing information about filtered amino acids.
+@mcp.tool(name="calculate_rmsd", description="计算两种分子结构的 RMSD")
+def calculate_rmsd(reference: list, subject: list) -> dict:
     """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import filter_amino_acids as filter_aa, get_residues
-        
-        atoms = load_structure(structure_file)
-        aa_mask = filter_aa(atoms)
-        aa_atoms = atoms[aa_mask]
-        
-        # Get unique residue names
-        unique_res = set(aa_atoms.res_name)
-        
-        return {
-            "success": True,
-            "result": {
-                "original_atom_count": atoms.array_length(),
-                "amino_acid_atom_count": aa_atoms.array_length(),
-                "unique_residues": list(unique_res),
-                "residue_types_count": len(unique_res)
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    计算两种分子结构的 RMSD（均方根偏差）。
 
+    参数：
+    - reference: 参考分子结构的坐标列表
+    - subject: 待比较分子结构的坐标列表
 
-@mcp.tool(name="transform_rotate", description="Rotate a structure around an axis.")
-def transform_rotate(structure_file: str, axis: List[float], angle_degrees: float, 
-                     output_file: str) -> dict:
-    """
-    Rotate a structure around a specified axis.
-    
-    Parameters:
-    - structure_file: Path to the input structure file.
-    - axis: Rotation axis as [x, y, z] vector.
-    - angle_degrees: Rotation angle in degrees.
-    - output_file: Path for the output rotated structure.
-    
-    Returns:
-    A dictionary confirming the rotation operation.
+    返回：
+    - dict: 包含 RMSD 值的字典。
     """
     try:
-        from biotite.structure.io import load_structure, save_structure
-        from biotite.structure import rotate
-        
-        atoms = load_structure(structure_file)
-        
-        # Rotate
-        rotated = rotate(atoms, axis, np.radians(angle_degrees))
-        
-        # Save
-        save_structure(output_file, rotated)
+        from biotite.structure import rmsd
+        import numpy as np
         
+        reference_array = np.array(reference)
+        subject_array = np.array(subject)
+        rmsd_value = rmsd(reference_array, subject_array)
         return {
             "success": True,
-            "result": {
-                "rotation_axis": axis,
-                "rotation_angle_degrees": angle_degrees,
-                "output_file": output_file
-            },
-            "error": None
+            "rmsd": rmsd_value
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
-@mcp.tool(name="transform_translate", description="Translate a structure by a vector.")
-def transform_translate(structure_file: str, translation: List[float], 
-                        output_file: str) -> dict:
+@mcp.tool(name="fetch_biological_data", description="从生物数据库中获取数据")
+def fetch_biological_data(database: str, query: str) -> dict:
     """
-    Translate a structure by a specified vector.
-    
-    Parameters:
-    - structure_file: Path to the input structure file.
-    - translation: Translation vector as [x, y, z] in Angstroms.
-    - output_file: Path for the output translated structure.
-    
-    Returns:
-    A dictionary confirming the translation operation.
-    """
-    try:
-        from biotite.structure.io import load_structure, save_structure
-        from biotite.structure import translate
-        
-        atoms = load_structure(structure_file)
-        
-        # Translate
-        translated = translate(atoms, translation)
-        
-        # Save
-        save_structure(output_file, translated)
-        
-        return {
-            "success": True,
-            "result": {
-                "translation_vector": translation,
-                "output_file": output_file
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    从指定的生物数据库中获取数据。
 
+    参数：
+    - database: 数据库名称（例如 'NCBI', 'RCSB', 'UniProt'）
+    - query: 查询字符串
 
-@mcp.tool(name="get_backbone_angles", description="Calculate backbone dihedral angles (phi, psi, omega).")
-def get_backbone_angles(structure_file: str) -> dict:
-    """
-    Calculate backbone dihedral angles (phi, psi, omega) for protein residues.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    
-    Returns:
-    A dictionary containing backbone dihedral angles.
-    """
-    try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import dihedral_backbone
-        
-        atoms = load_structure(structure_file)
-        phi, psi, omega = dihedral_backbone(atoms)
-        
-        # Convert to degrees and handle NaN
-        phi_deg = np.degrees(phi)
-        psi_deg = np.degrees(psi)
-        omega_deg = np.degrees(omega)
-        
-        # Calculate Ramachandran statistics
-        valid_phi = phi_deg[~np.isnan(phi_deg)]
-        valid_psi = psi_deg[~np.isnan(psi_deg)]
-        
-        return {
-            "success": True,
-            "result": {
-                "residue_count": len(phi),
-                "phi_mean": float(np.nanmean(phi_deg)) if len(valid_phi) > 0 else None,
-                "psi_mean": float(np.nanmean(psi_deg)) if len(valid_psi) > 0 else None,
-                "phi_range": [float(np.nanmin(phi_deg)), float(np.nanmax(phi_deg))] if len(valid_phi) > 0 else None,
-                "psi_range": [float(np.nanmin(psi_deg)), float(np.nanmax(psi_deg))] if len(valid_psi) > 0 else None,
-                "unit": "degrees"
-            },
-            "error": None
-        }
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="extract_chain", description="Extract a specific chain from a structure.")
-def extract_chain(structure_file: str, chain_id: str, output_file: str) -> dict:
-    """
-    Extract a specific chain from a multi-chain structure.
-    
-    Parameters:
-    - structure_file: Path to the input structure file.
-    - chain_id: The chain ID to extract (e.g., "A", "B").
-    - output_file: Path for the output structure file.
-    
-    Returns:
-    A dictionary containing extracted chain information.
+    返回：
+    - dict: 包含查询结果的字典。
     """
     try:
-        from biotite.structure.io import load_structure, save_structure
-        
-        atoms = load_structure(structure_file)
-        
-        # Filter by chain
-        chain_mask = atoms.chain_id == chain_id
-        chain_atoms = atoms[chain_mask]
-        
-        if chain_atoms.array_length() == 0:
+        if database.lower() == "ncbi":
+            from biotite.database.entrez import fetch
+            data = fetch(query, "fasta", "nucleotide", "test.fasta")
+        elif database.lower() == "rcsb":
+            from biotite.database.rcsb import fetch
+            data = fetch(query, "pdb")
+        elif database.lower() == "uniprot":
+            from biotite.database.uniprot import fetch
+            data = fetch(query, "fasta")
+        else:
             return {
                 "success": False,
-                "result": None,
-                "error": f"Chain '{chain_id}' not found in structure"
+                "error": f"数据库 '{database}' 不受支持。支持的数据库包括: NCBI, RCSB, UniProt。"
             }
-        
-        # Save
-        save_structure(output_file, chain_atoms)
-        
         return {
             "success": True,
-            "result": {
-                "chain_id": chain_id,
-                "extracted_atom_count": chain_atoms.array_length(),
-                "original_atom_count": atoms.array_length(),
-                "output_file": output_file
-            },
-            "error": None
+            "database": database,
+            "query": query,
+            "data": data
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
-@mcp.tool(name="get_structure_sequence", description="Extract the amino acid sequence from a protein structure.")
-def get_structure_sequence(structure_file: str) -> dict:
+@mcp.tool(name="superimpose_structures", description="对齐两种分子结构")
+def superimpose_structures(fixed: list, mobile: list) -> dict:
     """
-    Extract the amino acid sequence from a protein structure file.
-    
-    Parameters:
-    - structure_file: Path to the structure file.
-    
-    Returns:
-    A dictionary containing the extracted sequence(s) for each chain.
+    对齐两种分子结构。
+
+    参数：
+    - fixed: 固定分子结构的坐标列表
+    - mobile: 待对齐的分子结构的坐标列表
+
+    返回：
+    - dict: 包含对齐结果的字典。
     """
     try:
-        from biotite.structure.io import load_structure
-        from biotite.structure import get_chains
-        from biotite.structure.sequence import to_sequence
-        
-        atoms = load_structure(structure_file)
-        
-        # Get chains
-        chain_starts, chain_ids = get_chains(atoms)
-        unique_chains = list(set(chain_ids))
-        
-        sequences = {}
-        for chain_id in unique_chains:
-            chain_mask = atoms.chain_id == chain_id
-            chain_atoms = atoms[chain_mask]
-            try:
-                seq = to_sequence(chain_atoms)
-                sequences[chain_id] = str(seq)
-            except:
-                sequences[chain_id] = "Unable to extract sequence"
+        from biotite.structure import superimpose
+        import numpy as np
         
+        fixed_array = np.array(fixed)
+        mobile_array = np.array(mobile)
+        transformation = superimpose(fixed_array, mobile_array)
         return {
             "success": True,
-            "result": {
-                "chain_sequences": sequences,
-                "chain_count": len(unique_chains)
-            },
-            "error": None
+            "transformation": transformation.tolist()
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
+# 创建 FastMCP 应用实例
 def create_app() -> FastMCP:
     """
-    Create and return the FastMCP application instance.
-    
-    Returns:
-    The FastMCP instance for the service.
+    创建并返回 FastMCP 应用实例。
+
+    返回：
+    - FastMCP: FastMCP 应用实例。
     """
     return mcp