Update pybedtools/mcp_output/mcp_plugin/mcp_service.py

pybedtools/mcp_output/mcp_plugin/mcp_service.py

@@ -1,670 +1,140 @@
-import os
-import sys
-from typing import List, Optional
-
 from fastmcp import FastMCP
-
-# pybedtools requires compiled Cython extensions, so we must use the installed package
-# Do NOT import from source directory as cbedtools needs to be compiled
-import pybedtools
-from pybedtools import BedTool, cleanup
+from pybedtools import BedTool
 
 # Create the FastMCP service application
 mcp = FastMCP("pybedtools_service")
 
-
-# =============================================================================
-# Basic BED Operations
-# =============================================================================
-
-@mcp.tool(name="intersect_bed", description="Intersect two BED files and return the result.")
-def intersect_bed(file1: str, file2: str) -> dict:
-    """
-    Intersects two BED files using BedTool and returns the result.
-
-    :param file1: Path to the first BED file.
-    :param file2: Path to the second BED file.
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.intersect(b)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="merge_bed", description="Merge overlapping intervals in a BED file.")
-def merge_bed(file: str) -> dict:
-    """
-    Merges overlapping intervals in a BED file using BedTool.
-
-    :param file: Path to the BED file.
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file)
-        result = a.merge()
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="annotate_bed", description="Annotate a BED file with additional information.")
-def annotate_bed(file: str, annotation_file: str) -> dict:
-    """
-    Annotates a BED file with additional information from another file.
-
-    :param file: Path to the BED file to be annotated.
-    :param annotation_file: Path to the annotation file.
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file)
-        result = a.annotate(files=annotation_file)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="subtract_bed", description="Subtract intervals in file2 from file1.")
-def subtract_bed(file1: str, file2: str) -> dict:
-    """
-    Removes portions of intervals in file1 that overlap with intervals in file2.
-
-    :param file1: Path to the first BED file (features to subtract from).
-    :param file2: Path to the second BED file (features to subtract).
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.subtract(b)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="sort_bed", description="Sort a BED file by chromosome and position.")
-def sort_bed(file: str) -> dict:
-    """
-    Sorts a BED file by chromosome and then by start position.
-
-    :param file: Path to the BED file.
-    :return: Dictionary containing success status and sorted result.
-    """
-    try:
-        a = BedTool(file)
-        result = a.sort()
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="closest_bed", description="Find the closest features between two BED files.")
-def closest_bed(file1: str, file2: str, report_distance: bool = True) -> dict:
-    """
-    For each feature in file1, finds the closest feature in file2.
-
-    :param file1: Path to the first BED file.
-    :param file2: Path to the second BED file.
-    :param report_distance: If True, report the distance to the closest feature.
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.closest(b, d=report_distance)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="window_bed", description="Find overlapping features within a window.")
-def window_bed(file1: str, file2: str, window_size: int = 1000) -> dict:
-    """
-    Reports features in file2 that are within a window of features in file1.
-
-    :param file1: Path to the first BED file.
-    :param file2: Path to the second BED file.
-    :param window_size: Window size in base pairs (default: 1000).
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.window(b, w=window_size)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="complement_bed", description="Get regions not covered by the BED file.")
-def complement_bed(file: str, genome: str) -> dict:
-    """
-    Returns regions of the genome not covered by the BED file.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file)
-        result = a.complement(g=pybedtools.chromsizes_to_file(pybedtools.chromsizes(genome)))
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="flank_bed", description="Create flanking regions for each feature.")
-def flank_bed(file: str, genome: str, left: int = 0, right: int = 0, both: int = 0) -> dict:
-    """
-    Creates flanking regions for each feature in the BED file.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param left: Number of bases to extend on the left (5' for + strand).
-    :param right: Number of bases to extend on the right (3' for + strand).
-    :param both: Number of bases to extend on both sides.
-    :return: Dictionary containing success status and result or error message.
+@mcp.tool(name="create_bedtool", description="Create a BedTool object from a file or string")
+def create_bedtool(file_path: str = None, from_string: str = None) -> dict:
     """
-    try:
-        a = BedTool(file)
-        if both > 0:
-            result = a.flank(genome=genome, b=both)
-        else:
-            result = a.flank(genome=genome, l=left, r=right)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    Create a BedTool object from a file or a string.
 
+    Parameters:
+    - file_path: Path to the BED file.
+    - from_string: String containing BED file content.
 
-@mcp.tool(name="slop_bed", description="Extend features by a specified number of bases.")
-def slop_bed(file: str, genome: str, left: int = 0, right: int = 0, both: int = 0) -> dict:
-    """
-    Extends features by a specified number of bases.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param left: Number of bases to extend on the left.
-    :param right: Number of bases to extend on the right.
-    :param both: Number of bases to extend on both sides.
-    :return: Dictionary containing success status and result or error message.
+    Returns:
+    - dict: Success status and BedTool object information.
     """
     try:
-        a = BedTool(file)
-        if both > 0:
-            result = a.slop(genome=genome, b=both)
+        if file_path:
+            bedtool = BedTool(file_path)
+        elif from_string:
+            bedtool = BedTool(from_string, from_string=True)
         else:
-            result = a.slop(genome=genome, l=left, r=right)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="shift_bed", description="Shift features by a specified number of bases.")
-def shift_bed(file: str, genome: str, shift_amount: int) -> dict:
-    """
-    Shifts all features by a specified number of bases.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param shift_amount: Number of bases to shift (positive or negative).
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file)
-        result = a.shift(genome=genome, s=shift_amount)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="shuffle_bed", description="Randomly shuffle features within a genome.")
-def shuffle_bed(file: str, genome: str, seed: int = None) -> dict:
-    """
-    Randomly repositions features within the genome.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param seed: Random seed for reproducibility (optional).
-    :return: Dictionary containing success status and result or error message.
-    """
-    try:
-        a = BedTool(file)
-        kwargs = {"genome": genome}
-        if seed is not None:
-            kwargs["seed"] = seed
-        result = a.shuffle(**kwargs)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="cluster_bed", description="Cluster overlapping or nearby features.")
-def cluster_bed(file: str, distance: int = 0) -> dict:
-    """
-    Clusters overlapping or nearby features together.
-
-    :param file: Path to the BED file.
-    :param distance: Maximum distance between features to cluster (default: 0).
-    :return: Dictionary containing success status and result with cluster IDs.
-    """
-    try:
-        a = BedTool(file)
-        result = a.cluster(d=distance)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+            return {"success": False, "error": "Either file_path or from_string must be provided."}
 
-# =============================================================================
-# Coverage and Statistics
-# =============================================================================
-
-@mcp.tool(name="coverage_bed", description="Calculate coverage of features.")
-def coverage_bed(file1: str, file2: str) -> dict:
-    """
-    Computes the depth and breadth of coverage of features in file1 by file2.
-
-    :param file1: Path to the first BED file (features to check coverage on).
-    :param file2: Path to the second BED file (features to use for coverage).
-    :return: Dictionary containing success status and coverage result.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.coverage(b)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="genome_coverage", description="Calculate genome-wide coverage histogram.")
-def genome_coverage(file: str, genome: str) -> dict:
-    """
-    Computes a histogram of genome-wide coverage.
-
-    :param file: Path to the BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :return: Dictionary containing success status and coverage histogram.
-    """
-    try:
-        a = BedTool(file)
-        result = a.genome_coverage(g=pybedtools.chromsizes_to_file(pybedtools.chromsizes(genome)))
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="jaccard_index", description="Calculate Jaccard index between two BED files.")
-def jaccard_index(file1: str, file2: str) -> dict:
-    """
-    Calculates the Jaccard index (intersection over union) between two BED files.
-
-    :param file1: Path to the first BED file.
-    :param file2: Path to the second BED file.
-    :return: Dictionary containing Jaccard statistics.
-    """
-    try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.jaccard(b)
         return {
             "success": True,
-            "result": {
-                "intersection": result.get("intersection", 0),
-                "union": result.get("union-intersection", 0),
-                "jaccard": result.get("jaccard", 0),
-                "n_intersections": result.get("n_intersections", 0)
-            },
-            "error": None
+            "message": "BedTool object created successfully.",
+            "bedtool": str(bedtool)
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
-@mcp.tool(name="fisher_test", description="Perform Fisher's exact test on interval overlaps.")
-def fisher_test(file1: str, file2: str, genome: str) -> dict:
+@mcp.tool(name="intersect_bedtools", description="Find the intersection of two BedTool objects")
+def intersect_bedtools(file1: str, file2: str) -> dict:
     """
-    Performs Fisher's exact test on the overlap between two BED files.
+    Find the intersection of two BedTool objects.
 
-    :param file1: Path to the first BED file.
-    :param file2: Path to the second BED file.
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :return: Dictionary containing Fisher's test results.
+    Parameters:
+    - file1: Path to the first BED file.
+    - file2: Path to the second BED file.
+
+    Returns:
+    - dict: Success status and intersection result.
     """
     try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.fisher(b, genome=genome)
+        bed1 = BedTool(file1)
+        bed2 = BedTool(file2)
+        intersection = bed1.intersect(bed2)
+
         return {
             "success": True,
-            "result": str(result),
-            "error": None
+            "message": "Intersection computed successfully.",
+            "result": str(intersection)
         }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="count_features", description="Count the number of features in a BED file.")
-def count_features(file: str) -> dict:
-    """
-    Counts the number of features (lines) in a BED file.
-
-    :param file: Path to the BED file.
-    :return: Dictionary containing the feature count.
-    """
-    try:
-        a = BedTool(file)
-        count = len(a)
-        return {"success": True, "result": {"count": count}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="total_coverage_bp", description="Calculate total base pairs covered.")
-def total_coverage_bp(file: str) -> dict:
-    """
-    Calculates the total number of base pairs covered by the BED file.
-    Merges overlapping regions first to avoid double-counting.
-
-    :param file: Path to the BED file.
-    :return: Dictionary containing total covered base pairs.
-    """
-    try:
-        a = BedTool(file)
-        total_bp = a.total_coverage()
-        return {"success": True, "result": {"total_bp": total_bp}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# =============================================================================
-# Multi-file Operations
-# =============================================================================
-
-@mcp.tool(name="multi_intersect", description="Find intersection of multiple BED files.")
-def multi_intersect(files: List[str]) -> dict:
-    """
-    Identifies regions that are common to multiple BED files.
-
-    :param files: List of paths to BED files.
-    :return: Dictionary containing multi-intersection result.
-    """
-    try:
-        x = BedTool()
-        result = x.multi_intersect(i=files)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="union_bedgraphs", description="Combine multiple BedGraph files.")
-def union_bedgraphs(files: List[str]) -> dict:
-    """
-    Combines multiple BedGraph files into a single unified BedGraph.
-
-    :param files: List of paths to BedGraph files.
-    :return: Dictionary containing union result.
-    """
-    try:
-        x = BedTool()
-        result = x.union_bedgraphs(i=files)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
-# =============================================================================
-# Feature Manipulation
-# =============================================================================
-
-@mcp.tool(name="get_fasta", description="Extract sequences from a FASTA file for BED regions.")
-def get_fasta(bed_file: str, fasta_file: str, strand: bool = False) -> dict:
+@mcp.tool(name="union_bedtools", description="Find the union of two BedTool objects")
+def union_bedtools(file1: str, file2: str) -> dict:
     """
-    Extracts sequences from a FASTA file based on BED coordinates.
+    Find the union of two BedTool objects.
 
-    :param bed_file: Path to the BED file.
-    :param fasta_file: Path to the FASTA file.
-    :param strand: If True, sequences on - strand are reverse complemented.
-    :return: Dictionary containing extracted sequences.
-    """
-    try:
-        a = BedTool(bed_file)
-        result = a.sequence(fi=fasta_file, s=strand)
-        # Read the sequence file
-        with open(result.seqfn, 'r') as f:
-            sequences = f.read()
-        return {"success": True, "result": sequences, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="map_features", description="Map values from one BED file to another.")
-def map_features(file1: str, file2: str, column: int = 5, operation: str = "mean") -> dict:
-    """
-    Maps values from file2 onto features in file1.
+    Parameters:
+    - file1: Path to the first BED file.
+    - file2: Path to the second BED file.
 
-    :param file1: Path to the first BED file (features to map onto).
-    :param file2: Path to the second BED file (source of values).
-    :param column: Column number in file2 to extract values from (1-based).
-    :param operation: Operation to apply (mean, sum, min, max, count, etc.).
-    :return: Dictionary containing mapped result.
+    Returns:
+    - dict: Success status and union result.
     """
     try:
-        a = BedTool(file1)
-        b = BedTool(file2)
-        result = a.map(b, c=column, o=operation)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="groupby_bed", description="Group features and apply operations.")
-def groupby_bed(file: str, group_columns: List[int], operation_column: int, operation: str = "sum") -> dict:
-    """
-    Groups features by specified columns and applies an operation.
+        bed1 = BedTool(file1)
+        bed2 = BedTool(file2)
+        union = bed1.cat(bed2, postmerge=True)
 
-    :param file: Path to the BED file.
-    :param group_columns: List of column numbers to group by (1-based).
-    :param operation_column: Column number to apply operation on (1-based).
-    :param operation: Operation to apply (sum, mean, count, min, max, etc.).
-    :return: Dictionary containing grouped result.
-    """
-    try:
-        a = BedTool(file)
-        result = a.groupby(g=group_columns, c=operation_column, o=operation)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="sample_bed", description="Randomly sample features from a BED file.")
-def sample_bed(file: str, n: int = None, fraction: float = None, seed: int = None) -> dict:
-    """
-    Randomly samples features from a BED file.
-
-    :param file: Path to the BED file.
-    :param n: Number of features to sample.
-    :param fraction: Fraction of features to sample (0.0 to 1.0).
-    :param seed: Random seed for reproducibility.
-    :return: Dictionary containing sampled features.
-    """
-    try:
-        a = BedTool(file)
-        result = a.random_subset(n=n, f=fraction, seed=seed)
-        return {"success": True, "result": str(result), "error": None}
+        return {
+            "success": True,
+            "message": "Union computed successfully.",
+            "result": str(union)
+        }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# =============================================================================
-# Window and Genome Operations
-# =============================================================================
-
-@mcp.tool(name="make_windows", description="Create windows across a genome or BED file.")
-def make_windows(genome: str = None, window_size: int = 1000, step_size: int = None) -> dict:
-    """
-    Creates fixed-size windows across a genome.
+        return {"success": False, "error": str(e)}
 
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param window_size: Size of each window in base pairs.
-    :param step_size: Step size for sliding windows (default: same as window_size).
-    :return: Dictionary containing window coordinates.
+@mcp.tool(name="filter_bedtool", description="Filter a BedTool object based on a condition")
+def filter_bedtool(file_path: str, condition: str) -> dict:
     """
-    try:
-        x = BedTool()
-        kwargs = {"genome": genome, "w": window_size}
-        if step_size is not None:
-            kwargs["s"] = step_size
-        result = x.window_maker(**kwargs)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
+    Filter a BedTool object based on a condition.
 
+    Parameters:
+    - file_path: Path to the BED file.
+    - condition: A lambda function as a string to filter intervals.
 
-@mcp.tool(name="random_intervals", description="Generate random intervals in a genome.")
-def random_intervals(genome: str, length: int = 100, num_intervals: int = 10, seed: int = None) -> dict:
-    """
-    Generates random intervals within a genome.
-
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :param length: Length of each interval in base pairs.
-    :param num_intervals: Number of intervals to generate.
-    :param seed: Random seed for reproducibility.
-    :return: Dictionary containing random intervals.
+    Returns:
+    - dict: Success status and filtered result.
     """
     try:
-        x = BedTool()
-        kwargs = {"genome": genome, "l": length, "n": num_intervals}
-        if seed is not None:
-            kwargs["seed"] = seed
-        result = x.random(**kwargs)
-        return {"success": True, "result": str(result), "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# =============================================================================
-# File Information
-# =============================================================================
+        bedtool = BedTool(file_path)
+        filtered = bedtool.filter(eval(condition))
 
-@mcp.tool(name="get_bed_info", description="Get information about a BED file.")
-def get_bed_info(file: str) -> dict:
-    """
-    Returns information about a BED file including feature count, field count, and file type.
-
-    :param file: Path to the BED file.
-    :return: Dictionary containing file information.
-    """
-    try:
-        a = BedTool(file)
-        info = {
-            "feature_count": len(a),
-            "field_count": a.field_count(),
-            "file_type": a.file_type,
+        return {
+            "success": True,
+            "message": "Filtering completed successfully.",
+            "result": str(filtered)
         }
-        return {"success": True, "result": info, "error": None}
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
-@mcp.tool(name="head_bed", description="Get the first N features from a BED file.")
-def head_bed(file: str, n: int = 10) -> dict:
+@mcp.tool(name="sort_bedtool", description="Sort a BedTool object")
+def sort_bedtool(file_path: str) -> dict:
     """
-    Returns the first N features from a BED file.
+    Sort a BedTool object.
 
-    :param file: Path to the BED file.
-    :param n: Number of features to return (default: 10).
-    :return: Dictionary containing the first N features.
-    """
-    try:
-        a = BedTool(file)
-        result = a.head(n=n, as_string=True)
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="get_chromsizes", description="Get chromosome sizes for a genome.")
-def get_chromsizes(genome: str) -> dict:
-    """
-    Returns chromosome sizes for a specified genome.
+    Parameters:
+    - file_path: Path to the BED file.
 
-    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
-    :return: Dictionary containing chromosome sizes.
+    Returns:
+    - dict: Success status and sorted result.
     """
     try:
-        chromsizes = pybedtools.chromsizes(genome)
-        # Convert to serializable format
-        result = {chrom: {"start": coords[0], "end": coords[1]} 
-                  for chrom, coords in chromsizes.items()}
-        return {"success": True, "result": result, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-# =============================================================================
-# Utility Functions
-# =============================================================================
-
-@mcp.tool(name="create_bed_from_string", description="Create a BED file from a string.")
-def create_bed_from_string(bed_content: str, output_file: str = None) -> dict:
-    """
-    Creates a BED file from a string content.
-
-    :param bed_content: BED content as a string (tab or space separated).
-    :param output_file: Optional output file path. If not provided, returns temp file path.
-    :return: Dictionary containing the file path.
-    """
-    try:
-        a = BedTool(bed_content, from_string=True)
-        if output_file:
-            a.saveas(output_file)
-            return {"success": True, "result": {"file_path": output_file}, "error": None}
-        else:
-            return {"success": True, "result": {"file_path": a.fn, "content": str(a)}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="save_bed", description="Save BED operation result to a file.")
-def save_bed(file: str, output_file: str) -> dict:
-    """
-    Saves a BED file to a specified location.
+        bedtool = BedTool(file_path)
+        sorted_bed = bedtool.sort()
 
-    :param file: Path to the input BED file.
-    :param output_file: Path to save the output file.
-    :return: Dictionary containing save status.
-    """
-    try:
-        a = BedTool(file)
-        a.saveas(output_file)
-        return {"success": True, "result": {"saved_to": output_file}, "error": None}
-    except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
-
-@mcp.tool(name="cleanup_temp_files", description="Clean up temporary files created by pybedtools.")
-def cleanup_temp_files() -> dict:
-    """
-    Cleans up all temporary files created by pybedtools.
-
-    :return: Dictionary containing cleanup status.
-    """
-    try:
-        cleanup()
-        return {"success": True, "result": "Temporary files cleaned up", "error": None}
+        return {
+            "success": True,
+            "message": "Sorting completed successfully.",
+            "result": str(sorted_bed)
+        }
     except Exception as e:
-        return {"success": False, "result": None, "error": str(e)}
-
+        return {"success": False, "error": str(e)}
 
+@mcp.tool(name="create_app", description="Create and return the FastMCP application instance")
 def create_app() -> FastMCP:
     """
-    Creates and returns the FastMCP application instance.
+    Create and return the FastMCP application instance.
 
-    :return: FastMCP instance.
+    Returns:
+    - FastMCP: The FastMCP application instance.
     """
     return mcp