Update pybedtools/mcp_output/mcp_plugin/mcp_service.py

pybedtools/mcp_output/mcp_plugin/mcp_service.py

@@ -1,140 +1,670 @@
+import os
+import sys
+from typing import List, Optional
+
 from fastmcp import FastMCP
-from pybedtools import BedTool
+
+# 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
 
 # Create the FastMCP service application
 mcp = FastMCP("pybedtools_service")
 
-@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:
+
+# =============================================================================
+# 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.
     """
-    Create a BedTool object from a file or a string.
+    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)}
 
-    Parameters:
-    - file_path: Path to the BED file.
-    - from_string: String containing BED file content.
 
-    Returns:
-    - dict: Success status and BedTool object information.
+@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.
     """
     try:
-        if file_path:
-            bedtool = BedTool(file_path)
-        elif from_string:
-            bedtool = BedTool(from_string, from_string=True)
+        a = BedTool(file)
+        if both > 0:
+            result = a.flank(genome=genome, b=both)
         else:
-            return {"success": False, "error": "Either file_path or from_string must be provided."}
+            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)}
 
-        return {
-            "success": True,
-            "message": "BedTool object created successfully.",
-            "bedtool": str(bedtool)
-        }
+
+@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.
+    """
+    try:
+        a = BedTool(file)
+        if both > 0:
+            result = a.slop(genome=genome, b=both)
+        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, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
 
-@mcp.tool(name="intersect_bedtools", description="Find the intersection of two BedTool objects")
-def intersect_bedtools(file1: str, file2: str) -> dict:
+@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:
     """
-    Find the intersection of two BedTool objects.
+    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)}
 
-    Parameters:
-    - file1: Path to the first BED file.
-    - file2: Path to the second BED file.
 
-    Returns:
-    - dict: Success status and intersection result.
+@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:
-        bed1 = BedTool(file1)
-        bed2 = BedTool(file2)
-        intersection = bed1.intersect(bed2)
+        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)}
 
-        return {
-            "success": True,
-            "message": "Intersection computed successfully.",
-            "result": str(intersection)
-        }
+
+@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, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
+
+
+# =============================================================================
+# 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.
 
-@mcp.tool(name="union_bedtools", description="Find the union of two BedTool objects")
-def union_bedtools(file1: str, file2: str) -> dict:
+    :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.
     """
-    Find the union of two BedTool objects.
+    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)}
 
-    Parameters:
-    - file1: Path to the first BED file.
-    - file2: Path to the second BED file.
 
-    Returns:
-    - dict: Success status and union result.
+@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:
-        bed1 = BedTool(file1)
-        bed2 = BedTool(file2)
-        union = bed1.cat(bed2, postmerge=True)
+        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,
-            "message": "Union computed successfully.",
-            "result": str(union)
+            "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
         }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
 
-@mcp.tool(name="filter_bedtool", description="Filter a BedTool object based on a condition")
-def filter_bedtool(file_path: str, condition: str) -> dict:
-    """
-    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="fisher_test", description="Perform Fisher's exact test on interval overlaps.")
+def fisher_test(file1: str, file2: str, genome: str) -> dict:
+    """
+    Performs Fisher's exact test on the overlap between two BED files.
 
-    Returns:
-    - dict: Success status and filtered result.
+    :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.
     """
     try:
-        bedtool = BedTool(file_path)
-        filtered = bedtool.filter(eval(condition))
-
+        a = BedTool(file1)
+        b = BedTool(file2)
+        result = a.fisher(b, genome=genome)
         return {
             "success": True,
-            "message": "Filtering completed successfully.",
-            "result": str(filtered)
+            "result": str(result),
+            "error": None
         }
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "error": str(e)}
 
-@mcp.tool(name="sort_bedtool", description="Sort a BedTool object")
-def sort_bedtool(file_path: str) -> dict:
+
+@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.
     """
-    Sort a BedTool object.
+    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)}
 
-    Parameters:
-    - file_path: Path to the BED file.
 
-    Returns:
-    - dict: Success status and sorted result.
+@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:
-        bedtool = BedTool(file_path)
-        sorted_bed = bedtool.sort()
+        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)}
 
-        return {
-            "success": True,
-            "message": "Sorting completed successfully.",
-            "result": str(sorted_bed)
+
+# =============================================================================
+# 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)}
+
+
+# =============================================================================
+# 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:
+    """
+    Extracts sequences from a FASTA file based on BED coordinates.
+
+    :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.
+
+    :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.
+    """
+    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.
+
+    :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}
+    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.
+
+    :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.
+    """
+    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)}
+
+
+@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.
+    """
+    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
+# =============================================================================
+
+@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, "result": info, "error": None}
     except Exception as e:
-        return {"success": False, "error": str(e)}
+        return {"success": False, "result": None, "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:
+    """
+    Returns the first N features from a BED file.
+
+    :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.
+
+    :param genome: Genome name (e.g., 'hg19', 'hg38', 'mm10').
+    :return: Dictionary containing chromosome sizes.
+    """
+    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.
+
+    :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}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
 
-@mcp.tool(name="create_app", description="Create and return the FastMCP application instance")
 def create_app() -> FastMCP:
     """
-    Create and return the FastMCP application instance.
+    Creates and returns the FastMCP application instance.
 
-    Returns:
-    - FastMCP: The FastMCP application instance.
+    :return: FastMCP instance.
     """
     return mcp