Update biotite/mcp_output/mcp_plugin/mcp_service.py

biotite/mcp_output/mcp_plugin/mcp_service.py

@@ -1,5 +1,6 @@
 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")
@@ -7,50 +8,899 @@ if source_path not in sys.path:
     sys.path.insert(0, source_path)
 
 from fastmcp import FastMCP
-from biotite.sequence.align import alignment
-from biotite.structure import atoms
+import numpy as np
 
 # Create the FastMCP service application
 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.
+    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:
-    - seq1: The first sequence to align.
-    - seq2: The second sequence to align.
+    - sequence: Amino acid sequence string (e.g., "MKVLWAALLV").
     
     Returns:
-    A dictionary containing the alignment result.
+    A dictionary containing sequence length and amino acid composition.
     """
     try:
-        # Perform sequence alignment
-        result = alignment.align(seq1, seq2)
-        return {"success": True, "result": result, "error": None}
+        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:
     """
-    Analyze atoms in a given molecular structure file.
+    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:
+    """
+    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)}
+
+
+@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.
+    """
+    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])
+        
+        return {
+            "success": True,
+            "result": {
+                "angle_radians": float(ang),
+                "angle_degrees": float(np.degrees(ang)),
+                "atom_indices": [atom_index1, atom_index2, atom_index3]
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "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.
+    """
+    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)}
+
+
+@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).
+    """
+    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
+        }
+    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)
+        
+        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
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "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).
+    """
+    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)}
+
+
+@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 molecular structure file.
+    - structure_file: Path to the structure file.
     
     Returns:
-    A dictionary containing the atom analysis result.
+    A dictionary containing SSE annotations for each residue.
     """
     try:
-        # Load and analyze atoms
-        atom_array = atoms.load_structure(structure_file)
-        analysis_result = atoms.analyze(atom_array)
-        return {"success": True, "result": analysis_result, "error": None}
+        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)
+        
+        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
+        }
     except Exception as e:
         return {"success": False, "result": None, "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.
+    """
+    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)}
+
+
+@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.
+    """
+    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)
+        
+        return {
+            "success": True,
+            "result": {
+                "rotation_axis": axis,
+                "rotation_angle_degrees": angle_degrees,
+                "output_file": output_file
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "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:
+    """
+    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)}
+
+
+@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.
+    """
+    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:
+            return {
+                "success": False,
+                "result": None,
+                "error": f"Chain '{chain_id}' not found in structure"
+            }
+        
+        # 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
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "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:
+    """
+    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.
+    """
+    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"
+        
+        return {
+            "success": True,
+            "result": {
+                "chain_sequences": sequences,
+                "chain_count": len(unique_chains)
+            },
+            "error": None
+        }
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+
 def create_app() -> FastMCP:
     """
     Create and return the FastMCP application instance.