Upload 10 files

Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY alphagenome_mcp.py .
+COPY tools/ tools/
+RUN mkdir -p /app/data/upload /data/tmp_inputs /data/tmp_outputs && chmod -R 777 /app/data/upload /data
+EXPOSE 7860
+CMD ["uvicorn", "alphagenome_mcp:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,10 @@
 ---
-title: Alphagenome Mcp
-emoji: 🐨
-colorFrom: purple
-colorTo: yellow
+title: AlphaGenome Mcp
+emoji: 🔥
+colorFrom: red
+colorTo: green
 sdk: docker
 pinned: false
-license: apache-2.0
-short_description: Paper2Agent-generated AlphaGenome MCP server
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

alphagenome_mcp.py

@@ -0,0 +1,107 @@
+"""
+Model Context Protocol (MCP) for AlphaGenome
+
+AlphaGenome provides state-of-the-art AI-driven tools for genomic sequence analysis, variant effect prediction, and functional genomics visualization. The platform enables researchers to predict regulatory elements, assess variant impacts, and explore molecular mechanisms across diverse cell types and tissues.
+
+This MCP Server contains the tools extracted from the following tutorials with their tools:
+1. batch_variant_scoring
+    - score_variants_batch: Score multiple genetic variants in batch using configurable variant scorers
+    - filter_variant_scores: Filter variant scores by ontology criteria (e.g., cell types)
+2. essential_commands
+    - create_genomic_interval: Create genomic intervals for DNA regions
+    - create_genomic_variant: Create genomic variants for genetic changes  
+    - create_track_data: Create TrackData objects from arrays and metadata
+    - create_variant_scores: Create AnnData objects for variant scoring results
+    - genomic_interval_operations: Perform operations on genomic intervals
+    - variant_interval_operations: Check variant overlaps with intervals  
+    - track_data_operations: Filter, resize, slice and transform TrackData
+    - track_data_resolution_conversion: Convert between track data resolutions
+3. quick_start
+    - predict_dna_sequence: Predict genomic tracks from DNA sequence
+    - predict_genome_interval: Predict genomic tracks for reference genome intervals  
+    - ism_analysis: Perform in silico mutagenesis analysis with sequence logos
+4. tissue_ontology_mapping
+    - explore_output_metadata: Explore and filter output metadata for specific organisms and search terms
+    - count_tracks_by_output_type: Count tracks by output type for human and mouse organisms
+5. variant_scoring_ui
+    - visualize_variant_effects: Generate comprehensive variant effect visualization across multiple modalities
+6. visualization_modality_tour
+    - visualize_gene_expression: Visualize RNA_SEQ and CAGE gene expression predictions
+    - visualize_chromatin_accessibility: Visualize DNASE and ATAC chromatin accessibility
+    - visualize_splicing_effects: Visualize splicing predictions with SPLICE_SITES, SPLICE_SITE_USAGE, SPLICE_JUNCTIONS
+    - visualize_histone_modifications: Visualize CHIP_HISTONE predictions with custom colors
+    - visualize_tf_binding: Visualize CHIP_TF transcription factor binding predictions
+    - visualize_contact_maps: Visualize CONTACT_MAPS DNA-DNA contact predictions
+"""
+from fastmcp import FastMCP
+
+# Import the MCP tools from the tools folder
+from tools.batch_variant_scoring import batch_variant_scoring_mcp
+from tools.essential_commands import essential_commands_mcp
+from tools.quick_start import quick_start_mcp
+from tools.tissue_ontology_mapping import tissue_ontology_mapping_mcp
+from tools.variant_scoring_ui import variant_scoring_ui_mcp
+from tools.visualization_modality_tour import visualization_modality_tour_mcp
+
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse, JSONResponse
+import os
+from fastapi.staticfiles import StaticFiles
+import uuid
+
+# Define the MCP server
+mcp = FastMCP(name = "AlphaGenome")
+
+# Mount the tools
+mcp.mount(batch_variant_scoring_mcp)
+mcp.mount(essential_commands_mcp)
+mcp.mount(quick_start_mcp)
+mcp.mount(tissue_ontology_mapping_mcp)
+mcp.mount(variant_scoring_ui_mcp)
+mcp.mount(visualization_modality_tour_mcp)
+
+# Use absolute directory for uploads
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+UPLOAD_DIR = os.path.join(BASE_DIR, "/data/upload")
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+@mcp.custom_route("/health", methods=["GET"])
+async def health_check(request: Request) -> PlainTextResponse:
+    return PlainTextResponse("OK")
+
+
+@mcp.custom_route("/", methods=["GET"])
+async def index(request: Request) -> PlainTextResponse:
+    return PlainTextResponse("MCP is on https://Paper2Agent-alphagenome-mcp.hf.space/mcp")
+
+# Upload route
+@mcp.custom_route("/upload", methods=["POST"])
+async def upload(request: Request):
+    form = await request.form()
+    up = form.get("file")
+    if up is None:
+        return JSONResponse({"error": "missing form field 'file'"}, status_code=400)
+
+    # Generate a safe filename
+    orig = getattr(up, "filename", "") or ""
+    ext = os.path.splitext(orig)[1]
+    name = f"{uuid.uuid4().hex}{ext}"
+    dst = os.path.join(UPLOAD_DIR, name)
+    
+    # up is a Starlette UploadFile-like object
+    with open(dst, "wb") as out:
+        out.write(await up.read())
+
+    # Return only the absolute local path
+    abs_path = os.path.abspath(dst)
+    return JSONResponse({"path": abs_path})
+
+app = mcp.http_app(path="/mcp")
+# Saved uploaded input files
+app.mount("/files", StaticFiles(directory=UPLOAD_DIR), name="files")
+# Saved output files
+app.mount("/outputs", StaticFiles(directory="/data/tmp_outputs"), name="outputs")
+
+    
+if __name__ == "__main__":
+    mcp.run(transport="http", host="0.0.0.0", port=int(os.getenv("PORT", 7860)), path="/mcp")

requirements.txt

@@ -0,0 +1,10 @@
+alphagenome==0.2.0
+anndata==0.12.2
+fastmcp==2.12.2
+matplotlib==3.10.6
+numpy==2.3.2
+pandas==2.3.2
+plotnine==0.15.0
+tqdm==4.67.1
+fastapi
+starlette==0.47.3

tools/batch_variant_scoring.py

@@ -0,0 +1,232 @@
+"""
+Batch variant scoring tutorial demonstrating how to score multiple genetic variants using AlphaGenome.
+
+This MCP Server provides 2 tools:
+1. score_variants_batch: Score multiple genetic variants in batch using configurable variant scorers
+2. filter_variant_scores: Filter variant scores by ontology criteria (e.g., cell types)
+
+All tools extracted from `/batch_variant_scoring.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+from io import StringIO
+
+# AlphaGenome imports
+from alphagenome import colab_utils
+from alphagenome.data import genome
+from alphagenome.models import dna_client, variant_scorers
+from tqdm import tqdm
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+INPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# Fetch your secret
+ALPHAGENOME_API_KEY = os.environ["ALPHAGENOME_API_KEY"]
+
+# MCP server instance
+batch_variant_scoring_mcp = FastMCP(name="batch_variant_scoring")
+
+@batch_variant_scoring_mcp.tool
+def score_variants_batch(
+    # Primary data inputs
+    vcf_path: Annotated[str | None, "Path to VCF file with extension .vcf or .tsv. The header of the file should include the following columns: variant_id, CHROM, POS, REF, ALT"] = None,
+    # Analysis parameters with tutorial defaults
+    api_key: Annotated[str, "AlphaGenome API key for authentication"] = ALPHAGENOME_API_KEY,
+    organism: Annotated[Literal["human", "mouse"], "Organism for variant scoring"] = "human",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Length of sequence around variants to predict"] = "1MB",
+    score_rna_seq: Annotated[bool, "Score RNA-seq effects"] = True,
+    score_cage: Annotated[bool, "Score CAGE effects"] = True,
+    score_procap: Annotated[bool, "Score ProCAP effects"] = True,
+    score_atac: Annotated[bool, "Score ATAC-seq effects"] = True,
+    score_dnase: Annotated[bool, "Score DNase effects"] = True,
+    score_chip_histone: Annotated[bool, "Score ChIP histone effects"] = True,
+    score_chip_tf: Annotated[bool, "Score ChIP transcription factor effects"] = True,
+    score_polyadenylation: Annotated[bool, "Score polyadenylation effects"] = True,
+    score_splice_sites: Annotated[bool, "Score splice sites effects"] = True,
+    score_splice_site_usage: Annotated[bool, "Score splice site usage effects"] = True,
+    score_splice_junctions: Annotated[bool, "Score splice junctions effects"] = True,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Score multiple genetic variants in batch using AlphaGenome with configurable variant scorers.
+    Input is VCF file with variant information and output is comprehensive variant scores table.
+    """
+    # Validate exactly one input
+    if vcf_path is None:
+        raise ValueError("Path to VCF file must be provided")
+    
+    # Set output prefix
+    if out_prefix is None:
+        out_prefix = f"batch_variant_scores_{timestamp}"
+    
+    # Load VCF file containing variants
+    vcf = pd.read_csv(vcf_path, sep='\t')
+    
+    # Validate required columns
+    required_columns = ['variant_id', 'CHROM', 'POS', 'REF', 'ALT']
+    for column in required_columns:
+        if column not in vcf.columns:
+            raise ValueError(f'VCF file is missing required column: {column}.')
+    
+    # Load the model
+    dna_model = dna_client.create(api_key)
+    
+    # Parse organism specification
+    organism_map = {
+        'human': dna_client.Organism.HOMO_SAPIENS,
+        'mouse': dna_client.Organism.MUS_MUSCULUS,
+    }
+    organism_enum = organism_map[organism]
+    
+    # Parse sequence length
+    sequence_length_value = dna_client.SUPPORTED_SEQUENCE_LENGTHS[
+        f'SEQUENCE_LENGTH_{sequence_length}'
+    ]
+    
+    # Parse scorer specification
+    scorer_selections = {
+        'rna_seq': score_rna_seq,
+        'cage': score_cage,
+        'procap': score_procap,
+        'atac': score_atac,
+        'dnase': score_dnase,
+        'chip_histone': score_chip_histone,
+        'chip_tf': score_chip_tf,
+        'polyadenylation': score_polyadenylation,
+        'splice_sites': score_splice_sites,
+        'splice_site_usage': score_splice_site_usage,
+        'splice_junctions': score_splice_junctions,
+    }
+    
+    all_scorers = variant_scorers.RECOMMENDED_VARIANT_SCORERS
+    selected_scorers = [
+        all_scorers[key]
+        for key in all_scorers
+        if scorer_selections.get(key.lower(), False)
+    ]
+    
+    # Remove any scorers or output types that are not supported for the chosen organism
+    unsupported_scorers = [
+        scorer
+        for scorer in selected_scorers
+        if (
+            organism_enum.value
+            not in variant_scorers.SUPPORTED_ORGANISMS[scorer.base_variant_scorer]
+        )
+        | (
+            (scorer.requested_output == dna_client.OutputType.PROCAP)
+            & (organism_enum == dna_client.Organism.MUS_MUSCULUS)
+        )
+    ]
+    if len(unsupported_scorers) > 0:
+        print(
+            f'Excluding {unsupported_scorers} scorers as they are not supported for'
+            f' {organism_enum}.'
+        )
+        for unsupported_scorer in unsupported_scorers:
+            selected_scorers.remove(unsupported_scorer)
+    
+    # Score variants in the VCF file
+    results = []
+    
+    for i, vcf_row in tqdm(vcf.iterrows(), total=len(vcf)):
+        variant = genome.Variant(
+            chromosome=str(vcf_row.CHROM),
+            position=int(vcf_row.POS),
+            reference_bases=vcf_row.REF,
+            alternate_bases=vcf_row.ALT,
+            name=vcf_row.variant_id,
+        )
+        interval = variant.reference_interval.resize(sequence_length_value)
+        
+        variant_scores = dna_model.score_variant(
+            interval=interval,
+            variant=variant,
+            variant_scorers=selected_scorers,
+            organism=organism_enum,
+        )
+        results.append(variant_scores)
+    
+    df_scores = variant_scorers.tidy_scores(results)
+    
+    # Save results
+    output_file = OUTPUT_DIR / f"{out_prefix}.csv"
+    df_scores.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Batch variant scoring completed for {len(vcf)} variants with {len(selected_scorers)} scorers",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/batch_variant_scoring.ipynb",
+        "artifacts": [
+            {
+                "description": "Batch variant scores results",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@batch_variant_scoring_mcp.tool
+def filter_variant_scores(
+    # Primary data inputs
+    scores_path: Annotated[str | None, "Path to variant scores CSV file from batch scoring"] = None,
+    # Analysis parameters with tutorial defaults
+    ontology_curie: Annotated[str, "Ontology CURIE for filtering (e.g., 'CL:0000084' for T-cells)"] = "CL:0000084",
+    exclude_ontology_column: Annotated[bool, "Whether to exclude ontology_curie column from output"] = True,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Filter variant scores by ontology criteria to examine effects on specific cell types or tissues.
+    Input is variant scores CSV file and output is filtered scores table.
+    """
+    # Validate exactly one input
+    if scores_path is None:
+        raise ValueError("Path to variant scores CSV file must be provided")
+    
+    # Set output prefix
+    if out_prefix is None:
+        out_prefix = f"filtered_variant_scores_{timestamp}"
+    
+    # Load variant scores
+    df_scores = pd.read_csv(scores_path)
+    
+    # Filter by ontology criteria
+    filtered_df = df_scores[df_scores['ontology_curie'] == ontology_curie]
+    
+    # Optionally exclude ontology column
+    if exclude_ontology_column:
+        columns = [c for c in filtered_df.columns if c != 'ontology_curie']
+        filtered_df = filtered_df[columns]
+    
+    # Save filtered results
+    output_file = OUTPUT_DIR / f"{out_prefix}.csv"
+    filtered_df.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Filtered {len(filtered_df)} variant scores for ontology {ontology_curie}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/batch_variant_scoring.ipynb",
+        "artifacts": [
+            {
+                "description": "Filtered variant scores",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }

tools/essential_commands.py

@@ -0,0 +1,590 @@
+"""
+Essential commands for AlphaGenome API interaction covering data structures and operations.
+
+This MCP Server provides 8 tools:
+1. create_genomic_interval: Create genomic intervals for DNA regions
+2. create_genomic_variant: Create genomic variants for genetic changes  
+3. create_track_data: Create TrackData objects from arrays and metadata
+4. create_variant_scores: Create AnnData objects for variant scoring results
+5. genomic_interval_operations: Perform operations on genomic intervals
+6. variant_interval_operations: Check variant overlaps with intervals  
+7. track_data_operations: Filter, resize, slice and transform TrackData
+8. track_data_resolution_conversion: Convert between track data resolutions
+
+All tools extracted from `https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+
+# AlphaGenome imports
+from alphagenome.data import genome, track_data
+from alphagenome.models import dna_client
+import anndata
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+INPUT_DIR = Path(os.environ.get("ESSENTIAL_COMMANDS_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("ESSENTIAL_COMMANDS_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# MCP server instance
+essential_commands_mcp = FastMCP(name="essential_commands")
+
+@essential_commands_mcp.tool
+def create_genomic_interval(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr1', 'chr2')"] = "chr1",
+    start: Annotated[int, "Start position (0-based)"] = 1000,
+    end: Annotated[int, "End position (0-based, exclusive)"] = 1010,
+    strand: Annotated[Literal["+", "-", "."], "DNA strand"] = ".",
+    name: Annotated[str, "Interval name"] = "",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Create genomic intervals for DNA regions with basic properties and operations.
+    Input is genomic coordinates and output is interval object with properties and operations results.
+    """
+    
+    # Create genomic interval
+    interval = genome.Interval(chromosome=chromosome, start=start, end=end, strand=strand, name=name)
+    
+    # Calculate basic properties
+    results = {
+        "interval": {
+            "chromosome": interval.chromosome,
+            "start": interval.start,
+            "end": interval.end,
+            "strand": interval.strand,
+            "name": interval.name,
+            "center": interval.center(),
+            "width": interval.width,
+        },
+        "operations": {
+            "resize_100bp": str(interval.resize(100)),
+            "resize_1MB": str(interval.resize(dna_client.SEQUENCE_LENGTH_1MB)),
+        }
+    }
+    
+    # Save results
+    prefix = out_prefix or f"genomic_interval_{timestamp}"
+    output_file = OUTPUT_DIR / f"{prefix}.csv"
+    
+    # Flatten results for CSV
+    rows = []
+    for category, data in results.items():
+        for key, value in data.items():
+            rows.append({"category": category, "property": key, "value": str(value)})
+    
+    df = pd.DataFrame(rows)
+    df.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Genomic interval created: {interval.chromosome}:{interval.start}-{interval.end}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": "Genomic interval properties",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def create_genomic_variant(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr3')"] = "chr3",
+    position: Annotated[int, "1-based position"] = 10000,
+    reference_bases: Annotated[str, "Reference sequence (e.g., 'A')"] = "A",
+    alternate_bases: Annotated[str, "Alternate sequence (e.g., 'C')"] = "C",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Create genomic variants for genetic changes with reference interval operations.
+    Input is variant coordinates and sequences and output is variant properties and intervals.
+    """
+    
+    # Create genomic variant
+    variant = genome.Variant(
+        chromosome=chromosome,
+        position=position,
+        reference_bases=reference_bases,
+        alternate_bases=alternate_bases
+    )
+    
+    # Get reference interval and properties
+    ref_interval = variant.reference_interval
+    input_interval = ref_interval.resize(dna_client.SEQUENCE_LENGTH_1MB)
+    
+    # Create test interval for overlap testing
+    test_interval = genome.Interval(chromosome=chromosome, start=position+5, end=position+10)
+    
+    results = {
+        "variant": {
+            "chromosome": variant.chromosome,
+            "position": variant.position,
+            "reference_bases": variant.reference_bases,
+            "alternate_bases": variant.alternate_bases,
+            "reference_interval": str(ref_interval),
+            "input_interval_width": input_interval.width,
+        },
+        "overlap_tests": {
+            "reference_overlaps_test": variant.reference_overlaps(test_interval),
+            "alternate_overlaps_test": variant.alternate_overlaps(test_interval),
+        }
+    }
+    
+    # Save results
+    prefix = out_prefix or f"genomic_variant_{timestamp}"
+    output_file = OUTPUT_DIR / f"{prefix}.csv"
+    
+    # Flatten results for CSV
+    rows = []
+    for category, data in results.items():
+        for key, value in data.items():
+            rows.append({"category": category, "property": key, "value": str(value)})
+    
+    df = pd.DataFrame(rows)
+    df.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Genomic variant created: {variant.chromosome}:{variant.position} {variant.reference_bases}>{variant.alternate_bases}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": "Genomic variant properties",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def create_track_data(
+    values_array: Annotated[str | None, "Path to CSV file with values array (shape: sequence_length x num_tracks)"] = None,
+    track_names: Annotated[list[str], "List of track names"] = ["track1", "track1", "track2"],
+    track_strands: Annotated[list[str], "List of track strands (+, -, .)"] = ["+", "-", "."],
+    chromosome: Annotated[str, "Chromosome for interval"] = "chr1",
+    start: Annotated[int, "Start position"] = 1000,
+    end: Annotated[int, "End position"] = 1004,
+    resolution: Annotated[int, "Base pair resolution"] = 1,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Create TrackData objects from user arrays and metadata with validation.
+    Input is values array and track metadata and output is TrackData object properties.
+    """
+    
+    if values_array is None:
+        # Use tutorial example data if no input provided
+        values = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]).astype(np.float32)
+    else:
+        # Load user data
+        values = np.loadtxt(values_array, delimiter=',').astype(np.float32)
+    
+    # Create metadata
+    metadata = pd.DataFrame({
+        'name': track_names,
+        'strand': track_strands,
+    })
+    
+    # Create genomic interval 
+    interval = genome.Interval(chromosome=chromosome, start=start, end=end)
+    
+    # Create TrackData object
+    tdata = track_data.TrackData(
+        values=values, 
+        metadata=metadata, 
+        resolution=resolution, 
+        interval=interval
+    )
+    
+    # Save results
+    prefix = out_prefix or f"track_data_{timestamp}"
+    values_file = OUTPUT_DIR / f"{prefix}_values.csv"
+    metadata_file = OUTPUT_DIR / f"{prefix}_metadata.csv"
+    
+    # Save values and metadata
+    np.savetxt(values_file, tdata.values, delimiter=',')
+    tdata.metadata.to_csv(metadata_file, index=False)
+    
+    results = {
+        "shape": tdata.values.shape,
+        "resolution": tdata.resolution,
+        "interval": str(tdata.interval) if tdata.interval else "None",
+        "num_tracks": len(tdata.metadata),
+        "track_names": tdata.metadata.name.tolist(),
+        "track_strands": tdata.metadata.strand.tolist(),
+    }
+    
+    return {
+        "message": f"TrackData created with shape {tdata.values.shape} and {len(tdata.metadata)} tracks",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": "Track data values",
+                "path": str(values_file.resolve())
+            },
+            {
+                "description": "Track metadata",
+                "path": str(metadata_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def create_variant_scores(
+    scores_array: Annotated[str | None, "Path to CSV file with scores array (shape: num_genes x num_tracks)"] = None,
+    gene_ids: Annotated[list[str], "List of gene IDs"] = ["ENSG0001", "ENSG0002", "ENSG0003"],
+    track_names: Annotated[list[str], "List of track names"] = ["track1", "track2"],
+    track_strands: Annotated[list[str], "List of track strands"] = ["+", "-"],
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Create AnnData objects for variant scoring results with gene and track metadata.
+    Input is scores array and metadata and output is AnnData object structure.
+    """
+    
+    if scores_array is None:
+        # Use tutorial example data if no input provided
+        scores = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6]])
+    else:
+        # Load user data
+        scores = np.loadtxt(scores_array, delimiter=',')
+    
+    # Create metadata
+    gene_metadata = pd.DataFrame({'gene_id': gene_ids})
+    track_metadata = pd.DataFrame({
+        'name': track_names,
+        'strand': track_strands
+    })
+    
+    # Create AnnData object
+    variant_scores = anndata.AnnData(
+        X=scores, 
+        obs=gene_metadata, 
+        var=track_metadata
+    )
+    
+    # Save results
+    prefix = out_prefix or f"variant_scores_{timestamp}"
+    scores_file = OUTPUT_DIR / f"{prefix}_scores.csv"
+    gene_metadata_file = OUTPUT_DIR / f"{prefix}_gene_metadata.csv"
+    track_metadata_file = OUTPUT_DIR / f"{prefix}_track_metadata.csv"
+    
+    # Save components
+    np.savetxt(scores_file, variant_scores.X, delimiter=',')
+    variant_scores.obs.to_csv(gene_metadata_file, index=False)
+    variant_scores.var.to_csv(track_metadata_file, index=False)
+    
+    results = {
+        "scores_shape": variant_scores.X.shape,
+        "num_genes": variant_scores.n_obs,
+        "num_tracks": variant_scores.n_vars,
+        "gene_ids": variant_scores.obs.gene_id.tolist(),
+        "track_names": variant_scores.var.name.tolist(),
+    }
+    
+    return {
+        "message": f"Variant scores AnnData created with {variant_scores.n_obs} genes and {variant_scores.n_vars} tracks",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant scores matrix",
+                "path": str(scores_file.resolve())
+            },
+            {
+                "description": "Gene metadata",
+                "path": str(gene_metadata_file.resolve())
+            },
+            {
+                "description": "Track metadata",
+                "path": str(track_metadata_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def genomic_interval_operations(
+    interval1_chromosome: Annotated[str, "First interval chromosome"] = "chr1",
+    interval1_start: Annotated[int, "First interval start"] = 1000,
+    interval1_end: Annotated[int, "First interval end"] = 1010,
+    interval2_chromosome: Annotated[str, "Second interval chromosome"] = "chr1", 
+    interval2_start: Annotated[int, "Second interval start"] = 1005,
+    interval2_end: Annotated[int, "Second interval end"] = 1015,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Perform operations on genomic intervals including overlaps, intersections and comparisons.
+    Input is two genomic intervals and output is comparison operations results.
+    """
+    
+    # Create intervals
+    interval1 = genome.Interval(chromosome=interval1_chromosome, start=interval1_start, end=interval1_end)
+    interval2 = genome.Interval(chromosome=interval2_chromosome, start=interval2_start, end=interval2_end)
+    
+    # Perform operations
+    operations = {
+        "interval1": str(interval1),
+        "interval2": str(interval2),
+        "interval1_center": interval1.center(),
+        "interval1_width": interval1.width,
+        "interval2_center": interval2.center(), 
+        "interval2_width": interval2.width,
+        "overlaps": interval1.overlaps(interval2),
+        "contains": interval1.contains(interval2),
+        "intersect": str(interval1.intersect(interval2)) if interval1.overlaps(interval2) else "No overlap",
+        "interval1_resized_100": str(interval1.resize(100)),
+        "interval2_resized_100": str(interval2.resize(100)),
+    }
+    
+    # Save results
+    prefix = out_prefix or f"genomic_interval_operations_{timestamp}"
+    output_file = OUTPUT_DIR / f"{prefix}.csv"
+    
+    # Convert to DataFrame
+    df = pd.DataFrame([
+        {"operation": key, "result": str(value)} 
+        for key, value in operations.items()
+    ])
+    df.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Genomic interval operations completed for {interval1} and {interval2}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb", 
+        "artifacts": [
+            {
+                "description": "Interval operations results",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def variant_interval_operations(
+    variant_chromosome: Annotated[str, "Variant chromosome"] = "chr3",
+    variant_position: Annotated[int, "Variant position (1-based)"] = 10000,
+    variant_ref: Annotated[str, "Reference bases"] = "T",
+    variant_alt: Annotated[str, "Alternate bases"] = "CGTCAAT",
+    interval_chromosome: Annotated[str, "Test interval chromosome"] = "chr3",
+    interval_start: Annotated[int, "Test interval start"] = 10005,
+    interval_end: Annotated[int, "Test interval end"] = 10010,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Check variant overlaps with genomic intervals for reference and alternate alleles.
+    Input is variant and interval coordinates and output is overlap test results.
+    """
+    
+    # Create variant and interval
+    variant = genome.Variant(
+        chromosome=variant_chromosome,
+        position=variant_position,
+        reference_bases=variant_ref,
+        alternate_bases=variant_alt,
+    )
+    
+    interval = genome.Interval(
+        chromosome=interval_chromosome, 
+        start=interval_start, 
+        end=interval_end
+    )
+    
+    # Perform overlap tests
+    results = {
+        "variant": f"{variant.chromosome}:{variant.position} {variant.reference_bases}>{variant.alternate_bases}",
+        "interval": str(interval),
+        "reference_interval": str(variant.reference_interval),
+        "reference_overlaps": variant.reference_overlaps(interval),
+        "alternate_overlaps": variant.alternate_overlaps(interval),
+        "variant_ref_length": len(variant.reference_bases),
+        "variant_alt_length": len(variant.alternate_bases),
+    }
+    
+    # Save results
+    prefix = out_prefix or f"variant_interval_operations_{timestamp}"
+    output_file = OUTPUT_DIR / f"{prefix}.csv"
+    
+    # Convert to DataFrame
+    df = pd.DataFrame([
+        {"property": key, "value": str(value)} 
+        for key, value in results.items()
+    ])
+    df.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Variant interval operations completed: ref_overlaps={results['reference_overlaps']}, alt_overlaps={results['alternate_overlaps']}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant interval operations results", 
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool
+def track_data_operations(
+    values_array: Annotated[str | None, "Path to CSV file with values array"] = None,
+    track_names: Annotated[list[str], "List of track names"] = ["track1", "track1", "track2"],
+    track_strands: Annotated[list[str], "List of track strands"] = ["+", "-", "."],
+    operation: Annotated[Literal["filter", "resize", "slice", "subset", "reverse_complement"], "Operation to perform"] = "filter",
+    filter_strand: Annotated[Literal["+", "-", "."], "Strand to filter to"] = "+",
+    resize_width: Annotated[int, "Width to resize to"] = 8,
+    slice_start: Annotated[int, "Slice start position"] = 2,
+    slice_end: Annotated[int, "Slice end position"] = 4,
+    subset_names: Annotated[list[str], "Track names to subset to"] = ["track1"],
+    chromosome: Annotated[str, "Chromosome"] = "chr1",
+    start: Annotated[int, "Start position"] = 1000,
+    end: Annotated[int, "End position"] = 1004,
+    strand: Annotated[Literal["+", "-", "."], "Interval strand"] = "+",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Filter, resize, slice and transform TrackData objects with strand-aware operations.
+    Input is TrackData and operation parameters and output is transformed TrackData.
+    """
+    
+    if values_array is None:
+        # Use tutorial example data
+        values = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]).astype(np.float32)
+    else:
+        values = np.loadtxt(values_array, delimiter=',').astype(np.float32)
+    
+    # Create metadata and interval
+    metadata = pd.DataFrame({
+        'name': track_names,
+        'strand': track_strands,
+    })
+    
+    interval = genome.Interval(chromosome=chromosome, start=start, end=end, strand=strand)
+    tdata = track_data.TrackData(values=values, metadata=metadata, resolution=1, interval=interval)
+    
+    # Perform operation
+    if operation == "filter":
+        if filter_strand == "+":
+            result_tdata = tdata.filter_to_positive_strand()
+        elif filter_strand == "-":
+            result_tdata = tdata.filter_to_negative_strand()
+        else:
+            result_tdata = tdata.filter_to_unstranded()
+        operation_info = f"filtered to {filter_strand} strand"
+    elif operation == "resize":
+        result_tdata = tdata.resize(width=resize_width)
+        operation_info = f"resized to width {resize_width}"
+    elif operation == "slice":
+        result_tdata = tdata.slice_by_positions(start=slice_start, end=slice_end)
+        operation_info = f"sliced from {slice_start} to {slice_end}"
+    elif operation == "subset":
+        result_tdata = tdata.select_tracks_by_name(names=subset_names)
+        operation_info = f"subset to tracks {subset_names}"
+    elif operation == "reverse_complement":
+        result_tdata = tdata.reverse_complement()
+        operation_info = "reverse complemented"
+    
+    # Save results
+    prefix = out_prefix or f"track_data_{operation}_{timestamp}"
+    values_file = OUTPUT_DIR / f"{prefix}_values.csv"
+    metadata_file = OUTPUT_DIR / f"{prefix}_metadata.csv"
+    
+    # Save values and metadata
+    np.savetxt(values_file, result_tdata.values, delimiter=',')
+    result_tdata.metadata.to_csv(metadata_file, index=False)
+    
+    return {
+        "message": f"TrackData {operation_info}: shape {result_tdata.values.shape}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": f"Track data values after {operation}",
+                "path": str(values_file.resolve())
+            },
+            {
+                "description": f"Track metadata after {operation}",
+                "path": str(metadata_file.resolve())
+            }
+        ]
+    }
+
+@essential_commands_mcp.tool  
+def track_data_resolution_conversion(
+    values_array: Annotated[str | None, "Path to CSV file with values array"] = None,
+    track_names: Annotated[list[str], "List of track names"] = ["track1", "track1", "track2"],
+    track_strands: Annotated[list[str], "List of track strands"] = ["+", "-", "."],
+    original_resolution: Annotated[int, "Original resolution in bp"] = 1,
+    target_resolution: Annotated[int, "Target resolution in bp"] = 2,
+    chromosome: Annotated[str, "Chromosome"] = "chr1",
+    start: Annotated[int, "Start position"] = 1000,
+    end: Annotated[int, "End position"] = 1004,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Convert between different resolutions by upsampling or downsampling TrackData.
+    Input is TrackData and resolution parameters and output is resolution-converted data.
+    """
+    
+    if values_array is None:
+        # Use tutorial example data
+        values = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]).astype(np.float32)
+    else:
+        values = np.loadtxt(values_array, delimiter=',').astype(np.float32)
+    
+    # Create metadata and interval
+    metadata = pd.DataFrame({
+        'name': track_names,
+        'strand': track_strands,
+    })
+    
+    interval = genome.Interval(chromosome=chromosome, start=start, end=end)
+    tdata = track_data.TrackData(
+        values=values, 
+        metadata=metadata, 
+        resolution=original_resolution, 
+        interval=interval
+    )
+    
+    # Change resolution
+    converted_tdata = tdata.change_resolution(resolution=target_resolution)
+    
+    # Save results
+    prefix = out_prefix or f"track_data_resolution_{original_resolution}_to_{target_resolution}_{timestamp}"
+    original_file = OUTPUT_DIR / f"{prefix}_original.csv"
+    converted_file = OUTPUT_DIR / f"{prefix}_converted.csv"
+    metadata_file = OUTPUT_DIR / f"{prefix}_metadata.csv"
+    
+    # Save original, converted values, and metadata
+    np.savetxt(original_file, tdata.values, delimiter=',')
+    np.savetxt(converted_file, converted_tdata.values, delimiter=',')
+    converted_tdata.metadata.to_csv(metadata_file, index=False)
+    
+    return {
+        "message": f"Resolution converted from {original_resolution}bp to {target_resolution}bp: {tdata.values.shape} -> {converted_tdata.values.shape}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/essential_commands.ipynb",
+        "artifacts": [
+            {
+                "description": f"Original values at {original_resolution}bp resolution",
+                "path": str(original_file.resolve())
+            },
+            {
+                "description": f"Converted values at {target_resolution}bp resolution", 
+                "path": str(converted_file.resolve())
+            },
+            {
+                "description": "Track metadata",
+                "path": str(metadata_file.resolve())
+            }
+        ]
+    }

tools/quick_start.py

@@ -0,0 +1,664 @@
+"""
+AlphaGenome Quick Start tutorial tools for DNA sequence analysis and prediction.
+
+This MCP Server provides 6 tools:
+1. predict_dna_sequence: Predict genomic tracks from DNA sequence
+2. predict_genome_interval: Predict genomic tracks for reference genome intervals  
+3. predict_variant_effects: Predict and visualize genetic variant effects
+4. score_variant_effect: Score genetic variant effects using variant scorers
+5. ism_analysis: Perform in silico mutagenesis analysis with sequence logos
+6. mouse_predictions: Make predictions for mouse sequences and intervals
+
+All tools extracted from `https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+
+# AlphaGenome imports
+from alphagenome import colab_utils
+from alphagenome.data import gene_annotation
+from alphagenome.data import genome
+from alphagenome.data import transcript as transcript_utils
+from alphagenome.interpretation import ism
+from alphagenome.models import dna_client
+from alphagenome.models import variant_scorers
+from alphagenome.visualization import plot_components
+import matplotlib.pyplot as plt
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+INPUT_DIR = Path(os.environ.get("QUICK_START_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("QUICK_START_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# MCP server instance
+quick_start_mcp = FastMCP(name="quick_start")
+
+@quick_start_mcp.tool
+def predict_dna_sequence(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    sequence: Annotated[str, "DNA sequence to analyze (will be center-padded to valid length)"] = 'GATTACA',
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "2KB",
+    output_types: Annotated[list[str], "List of output types to predict (e.g. ['DNASE', 'CAGE', 'RNA_SEQ'])"] = ["DNASE"],
+    ontology_terms: Annotated[list[str], "List of ontology terms for tissues/cell types (e.g. ['UBERON:0002048'])"] = ["UBERON:0002048"],
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Predict genomic tracks from a DNA sequence using AlphaGenome model.
+    Input is DNA sequence string and output is track predictions with metadata tables.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"predict_dna_sequence_{timestamp}"
+    
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Convert sequence length to client constant
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB, 
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    target_length = length_map[sequence_length]
+    
+    # Pad sequence to valid length
+    padded_sequence = sequence.center(target_length, 'N')
+    
+    # Convert output types to client enums
+    output_enums = []
+    for output_type in output_types:
+        output_enums.append(getattr(dna_client.OutputType, output_type))
+    
+    # Make prediction
+    output = dna_model.predict_sequence(
+        sequence=padded_sequence,
+        requested_outputs=output_enums,
+        ontology_terms=ontology_terms,
+    )
+    
+    artifacts = []
+    
+    # Save track data and metadata for each output type
+    for output_type in output_types:
+        track_data = getattr(output, output_type.lower())
+        
+        # Save values
+        values_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_values.csv"
+        pd.DataFrame(track_data.values).to_csv(values_file, index=False)
+        artifacts.append({
+            "description": f"{output_type} prediction values",
+            "path": str(values_file.resolve())
+        })
+        
+        # Save metadata
+        metadata_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_metadata.csv"
+        track_data.metadata.to_csv(metadata_file, index=False)
+        artifacts.append({
+            "description": f"{output_type} track metadata", 
+            "path": str(metadata_file.resolve())
+        })
+    
+    return {
+        "message": f"DNA sequence predictions completed for {len(output_types)} output types",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb",
+        "artifacts": artifacts
+    }
+
+@quick_start_mcp.tool
+def predict_genome_interval(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    chromosome: Annotated[str, "Chromosome name (e.g. 'chr19')"] = "chr19",
+    start_position: Annotated[int, "Start position on chromosome"] = 40991281,
+    end_position: Annotated[int, "End position on chromosome"] = 41018398,
+    strand: Annotated[Literal["+", "-", "."], "Strand orientation"] = "+",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "1MB",
+    output_types: Annotated[list[str], "List of output types to predict (e.g. ['RNA_SEQ'])"] = ["RNA_SEQ"],
+    ontology_terms: Annotated[list[str], "List of ontology terms for tissues/cell types"] = ["UBERON:0001114"],
+    gene_symbol: Annotated[str | None, "Gene symbol to center interval on (overrides coordinates)"] = "CYP2B6",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Predict genomic tracks for a reference genome interval with transcript visualization.
+    Input is genomic coordinates or gene symbol and output is prediction plot and metadata.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"predict_genome_interval_{timestamp}"
+        
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Load GTF file for gene annotation
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    
+    # Set up transcript extractors
+    gtf_transcripts = gene_annotation.filter_protein_coding(gtf)
+    gtf_transcripts = gene_annotation.filter_to_longest_transcript(gtf_transcripts)
+    transcript_extractor = transcript_utils.TranscriptExtractor(gtf_transcripts)
+    
+    # Create interval - use gene symbol if provided, otherwise coordinates
+    if gene_symbol:
+        interval = gene_annotation.get_gene_interval(gtf, gene_symbol=gene_symbol)
+    else:
+        interval = genome.Interval(chromosome, start_position, end_position, strand)
+    
+    # Resize to model-compatible length
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB,
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    interval = interval.resize(length_map[sequence_length])
+    
+    # Convert output types to client enums
+    output_enums = []
+    for output_type in output_types:
+        output_enums.append(getattr(dna_client.OutputType, output_type))
+    
+    # Make prediction
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs=output_enums,
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts for visualization
+    longest_transcripts = transcript_extractor.extract(interval)
+    
+    artifacts = []
+    
+    # Save metadata for each output type
+    for output_type in output_types:
+        track_data = getattr(output, output_type.lower())
+        
+        # Save metadata
+        metadata_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_metadata.csv"
+        track_data.metadata.to_csv(metadata_file, index=False)
+        artifacts.append({
+            "description": f"{output_type} track metadata",
+            "path": str(metadata_file.resolve())
+        })
+    
+    # Create visualization - full interval
+    plt.figure(figsize=(15, 8))
+    track_data = getattr(output, output_types[0].lower())
+    plot_components.plot(
+        components=[
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(track_data),
+        ],
+        interval=track_data.interval,
+    )
+    
+    plot_file = OUTPUT_DIR / f"{out_prefix}_{output_types[0].lower()}_plot.png"
+    plt.savefig(plot_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    artifacts.append({
+        "description": f"{output_types[0]} prediction plot",
+        "path": str(plot_file.resolve())
+    })
+    
+    # Create zoomed visualization
+    plt.figure(figsize=(15, 8))
+    plot_components.plot(
+        components=[
+            plot_components.TranscriptAnnotation(longest_transcripts, fig_height=0.1),
+            plot_components.Tracks(track_data),
+        ],
+        interval=track_data.interval.resize(2**15),
+    )
+    
+    plot_zoomed_file = OUTPUT_DIR / f"{out_prefix}_{output_types[0].lower()}_plot_zoomed.png"
+    plt.savefig(plot_zoomed_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    artifacts.append({
+        "description": f"{output_types[0]} prediction plot (zoomed)",
+        "path": str(plot_zoomed_file.resolve())
+    })
+    
+    return {
+        "message": f"Genome interval predictions completed with {len(longest_transcripts)} transcripts",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb", 
+        "artifacts": artifacts
+    }
+
+
+def predict_variant_effects(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    chromosome: Annotated[str, "Chromosome name (e.g. 'chr22')"] = "chr22",
+    position: Annotated[int, "Variant position"] = 36201698,
+    reference_bases: Annotated[str, "Reference allele"] = "A", 
+    alternate_bases: Annotated[str, "Alternative allele"] = "C",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "1MB",
+    output_types: Annotated[list[str], "List of output types to predict"] = ["RNA_SEQ"],
+    ontology_terms: Annotated[list[str], "List of ontology terms for tissues/cell types"] = ["UBERON:0001157"],
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Predict and visualize genetic variant effects comparing REF vs ALT predictions.
+    Input is variant coordinates and output is overlaid REF/ALT visualization plot.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"predict_variant_effects_{timestamp}"
+        
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Create variant object
+    variant = genome.Variant(
+        chromosome=chromosome,
+        position=position,
+        reference_bases=reference_bases,
+        alternate_bases=alternate_bases,
+    )
+    
+    # Create interval from variant
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB,
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    interval = variant.reference_interval.resize(length_map[sequence_length])
+    
+    # Convert output types to client enums
+    output_enums = []
+    for output_type in output_types:
+        output_enums.append(getattr(dna_client.OutputType, output_type))
+    
+    # Make variant prediction
+    variant_output = dna_model.predict_variant(
+        interval=interval,
+        variant=variant,
+        requested_outputs=output_enums,
+        ontology_terms=ontology_terms,
+    )
+    
+    # Load GTF for transcript annotation
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcripts = gene_annotation.filter_protein_coding(gtf)
+    gtf_transcripts = gene_annotation.filter_to_longest_transcript(gtf_transcripts)
+    transcript_extractor = transcript_utils.TranscriptExtractor(gtf_transcripts)
+    longest_transcripts = transcript_extractor.extract(interval)
+    
+    artifacts = []
+    
+    # Create overlaid REF vs ALT visualization
+    plt.figure(figsize=(15, 8))
+    ref_track_data = getattr(variant_output.reference, output_types[0].lower())
+    alt_track_data = getattr(variant_output.alternate, output_types[0].lower())
+    
+    plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': ref_track_data,
+                    'ALT': alt_track_data,
+                },
+                colors={'REF': 'dimgrey', 'ALT': 'red'},
+            ),
+        ],
+        interval=ref_track_data.interval.resize(2**15),
+        # Annotate the location of the variant as a vertical line
+        annotations=[plot_components.VariantAnnotation([variant], alpha=0.8)],
+    )
+    
+    plot_file = OUTPUT_DIR / f"{out_prefix}_{output_types[0].lower()}_variant_plot.png"
+    plt.savefig(plot_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    artifacts.append({
+        "description": f"{output_types[0]} REF vs ALT comparison plot",
+        "path": str(plot_file.resolve())
+    })
+    
+    return {
+        "message": f"Variant effect predictions completed for {chromosome}:{position}:{reference_bases}>{alternate_bases}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb",
+        "artifacts": artifacts
+    }
+
+
+def score_variant_effect(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    chromosome: Annotated[str, "Chromosome name (e.g. 'chr22')"] = "chr22",
+    position: Annotated[int, "Variant position"] = 36201698,
+    reference_bases: Annotated[str, "Reference allele"] = "A",
+    alternate_bases: Annotated[str, "Alternative allele"] = "C", 
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "1MB",
+    scorer_type: Annotated[Literal["RNA_SEQ", "DNASE", "CAGE", "ATAC"], "Variant scorer type to use"] = "RNA_SEQ",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Score genetic variant effects using recommended variant scorers and produce tidy scores.
+    Input is variant coordinates and output is variant scores table with genes and tracks.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"score_variant_effect_{timestamp}"
+        
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Create variant object
+    variant = genome.Variant(
+        chromosome=chromosome,
+        position=position,
+        reference_bases=reference_bases,
+        alternate_bases=alternate_bases,
+    )
+    
+    # Create interval from variant
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB,
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    interval = variant.reference_interval.resize(length_map[sequence_length])
+    
+    # Get recommended variant scorer
+    variant_scorer = variant_scorers.RECOMMENDED_VARIANT_SCORERS[scorer_type]
+    
+    # Score variant
+    variant_scores = dna_model.score_variant(
+        interval=interval,
+        variant=variant, 
+        variant_scorers=[variant_scorer]
+    )
+    
+    artifacts = []
+    
+    # Extract first scorer results
+    scores_adata = variant_scores[0]
+    
+    # Save gene metadata (obs)
+    genes_file = OUTPUT_DIR / f"{out_prefix}_{scorer_type}_genes.csv"
+    scores_adata.obs.to_csv(genes_file, index=True)
+    artifacts.append({
+        "description": f"{scorer_type} gene metadata",
+        "path": str(genes_file.resolve())
+    })
+    
+    # Save track metadata (var)
+    tracks_file = OUTPUT_DIR / f"{out_prefix}_{scorer_type}_tracks.csv" 
+    scores_adata.var.to_csv(tracks_file, index=True)
+    artifacts.append({
+        "description": f"{scorer_type} track metadata",
+        "path": str(tracks_file.resolve())
+    })
+    
+    # Save raw scores matrix
+    raw_scores_file = OUTPUT_DIR / f"{out_prefix}_{scorer_type}_raw_scores.csv"
+    pd.DataFrame(scores_adata.X, 
+                 index=scores_adata.obs.index, 
+                 columns=scores_adata.var.index).to_csv(raw_scores_file, index=True)
+    artifacts.append({
+        "description": f"{scorer_type} raw scores matrix",
+        "path": str(raw_scores_file.resolve())
+    })
+    
+    # Create tidy scores dataframe
+    tidy_scores_df = variant_scorers.tidy_scores([scores_adata], match_gene_strand=True)
+    
+    # Save tidy scores
+    tidy_file = OUTPUT_DIR / f"{out_prefix}_{scorer_type}_tidy_scores.csv"
+    tidy_scores_df.to_csv(tidy_file, index=False)
+    artifacts.append({
+        "description": f"{scorer_type} tidy scores table",
+        "path": str(tidy_file.resolve())
+    })
+    
+    return {
+        "message": f"Variant scoring completed: {scores_adata.X.shape[0]} genes × {scores_adata.X.shape[1]} tracks",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb",
+        "artifacts": artifacts
+    }
+
+@quick_start_mcp.tool
+def ism_analysis(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    chromosome: Annotated[str, "Chromosome for ISM analysis"] = "chr20",
+    start_position: Annotated[int, "Start position for sequence context"] = 3753000,
+    end_position: Annotated[int, "End position for sequence context"] = 3753400,
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "2KB",
+    ism_width: Annotated[int, "Width of region to mutate systematically"] = 256,
+    output_type: Annotated[Literal["DNASE", "RNA_SEQ", "CAGE", "ATAC"], "Output type for scoring variants"] = "DNASE",
+    mask_width: Annotated[int, "Width of center mask for scoring"] = 501,
+    target_cell_line: Annotated[str, "Ontology term for specific cell line/tissue"] = "EFO:0002067",
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Perform in silico mutagenesis analysis with sequence logo visualization of important regions.
+    Input is genomic coordinates and output is ISM matrix and sequence logo plot.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"ism_analysis_{timestamp}"
+        
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Create sequence interval
+    sequence_interval = genome.Interval(chromosome, start_position, end_position)
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB,
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    sequence_interval = sequence_interval.resize(length_map[sequence_length])
+    
+    # Create ISM interval (region to mutate)
+    ism_interval = sequence_interval.resize(ism_width)
+    
+    # Create variant scorer
+    output_enum = getattr(dna_client.OutputType, output_type)
+    variant_scorer = variant_scorers.CenterMaskScorer(
+        requested_output=output_enum,
+        width=mask_width,
+        aggregation_type=variant_scorers.AggregationType.DIFF_MEAN,
+    )
+    
+    # Score all ISM variants
+    variant_scores = dna_model.score_ism_variants(
+        interval=sequence_interval,
+        ism_interval=ism_interval,
+        variant_scorers=[variant_scorer],
+    )
+    
+    # Extract scores for target cell line/tissue
+    def extract_target_scores(adata):
+        values = adata.X[:, adata.var['ontology_curie'] == target_cell_line]
+        if values.size == 0:
+            # If target not found, use first available track
+            values = adata.X[:, 0:1]
+        assert values.size >= 1
+        return values.flatten()[0]
+    
+    # Create ISM matrix
+    ism_result = ism.ism_matrix(
+        [extract_target_scores(x[0]) for x in variant_scores],
+        variants=[v[0].uns['variant'] for v in variant_scores],
+    )
+    
+    artifacts = []
+    
+    # Save ISM matrix
+    ism_matrix_file = OUTPUT_DIR / f"{out_prefix}_ism_matrix.csv"
+    pd.DataFrame(ism_result).to_csv(ism_matrix_file, index=False)
+    artifacts.append({
+        "description": "ISM contribution matrix",
+        "path": str(ism_matrix_file.resolve())
+    })
+    
+    # Create sequence logo plot
+    plt.figure(figsize=(35, 6))
+    plot_components.plot(
+        [
+            plot_components.SeqLogo(
+                scores=ism_result,
+                scores_interval=ism_interval,
+                ylabel=f'ISM {target_cell_line} {output_type}',
+            )
+        ],
+        interval=ism_interval,
+        fig_width=35,
+    )
+    
+    logo_file = OUTPUT_DIR / f"{out_prefix}_sequence_logo.png"
+    plt.savefig(logo_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    artifacts.append({
+        "description": "ISM sequence logo plot",
+        "path": str(logo_file.resolve())
+    })
+    
+    return {
+        "message": f"ISM analysis completed: {len(variant_scores)} variants scored ({ism_width} positions)",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb",
+        "artifacts": artifacts
+    }
+
+
+def mouse_predictions(
+    api_key: Annotated[str, "AlphaGenome API key for authentication"],
+    sequence: Annotated[str | None, "DNA sequence for sequence prediction"] = 'GATTACA',
+    chromosome: Annotated[str | None, "Mouse chromosome for interval prediction"] = "chr1", 
+    start_position: Annotated[int | None, "Start position for interval prediction"] = 3000000,
+    end_position: Annotated[int | None, "End position for interval prediction"] = 3000001,
+    prediction_type: Annotated[Literal["sequence", "interval"], "Type of prediction to perform"] = "sequence",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Model input sequence length"] = "2KB",
+    output_types: Annotated[list[str], "List of output types to predict"] = ["DNASE"],
+    ontology_terms: Annotated[list[str], "List of ontology terms for mouse tissues"] = ["UBERON:0002048"],
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Make predictions for mouse sequences and genomic intervals using MUS_MUSCULUS organism.
+    Input is mouse DNA sequence or coordinates and output is prediction metadata tables.
+    """
+    # Set up output prefix
+    if out_prefix is None:
+        out_prefix = f"mouse_predictions_{timestamp}"
+        
+    # Create DNA model
+    dna_model = dna_client.create(api_key)
+    
+    # Convert sequence length to client constant
+    length_map = {
+        "2KB": dna_client.SEQUENCE_LENGTH_2KB,
+        "16KB": dna_client.SEQUENCE_LENGTH_16KB,
+        "100KB": dna_client.SEQUENCE_LENGTH_100KB,
+        "500KB": dna_client.SEQUENCE_LENGTH_500KB,
+        "1MB": dna_client.SEQUENCE_LENGTH_1MB
+    }
+    target_length = length_map[sequence_length]
+    
+    # Convert output types to client enums
+    output_enums = []
+    for output_type in output_types:
+        output_enums.append(getattr(dna_client.OutputType, output_type))
+    
+    artifacts = []
+    
+    if prediction_type == "sequence":
+        # Sequence prediction for mouse
+        if sequence is None:
+            raise ValueError("sequence must be provided for sequence prediction")
+            
+        # Pad sequence to valid length
+        padded_sequence = sequence.center(target_length, 'N')
+        
+        # Make mouse sequence prediction
+        output = dna_model.predict_sequence(
+            sequence=padded_sequence,
+            organism=dna_client.Organism.MUS_MUSCULUS,
+            requested_outputs=output_enums,
+            ontology_terms=ontology_terms,
+        )
+        
+        # Save results for each output type
+        for output_type in output_types:
+            track_data = getattr(output, output_type.lower())
+            
+            # Save values
+            values_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_values.csv"
+            pd.DataFrame(track_data.values).to_csv(values_file, index=False)
+            artifacts.append({
+                "description": f"Mouse {output_type} prediction values",
+                "path": str(values_file.resolve())
+            })
+            
+            # Save metadata
+            metadata_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_metadata.csv"
+            track_data.metadata.to_csv(metadata_file, index=False)
+            artifacts.append({
+                "description": f"Mouse {output_type} track metadata",
+                "path": str(metadata_file.resolve())
+            })
+    
+    elif prediction_type == "interval":
+        # Interval prediction for mouse
+        if chromosome is None or start_position is None or end_position is None:
+            raise ValueError("chromosome, start_position, and end_position must be provided for interval prediction")
+            
+        # Create mouse interval
+        interval = genome.Interval(chromosome, start_position, end_position).resize(target_length)
+        
+        # Make mouse interval prediction
+        output = dna_model.predict_interval(
+            interval=interval,
+            organism=dna_client.Organism.MUS_MUSCULUS,
+            requested_outputs=output_enums,
+            ontology_terms=ontology_terms,
+        )
+        
+        # Save results for each output type
+        for output_type in output_types:
+            track_data = getattr(output, output_type.lower())
+            
+            # Save metadata
+            metadata_file = OUTPUT_DIR / f"{out_prefix}_{output_type.lower()}_metadata.csv"
+            track_data.metadata.to_csv(metadata_file, index=False)
+            artifacts.append({
+                "description": f"Mouse {output_type} interval metadata",
+                "path": str(metadata_file.resolve())
+            })
+    
+    return {
+        "message": f"Mouse {prediction_type} predictions completed for {len(output_types)} output types",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/quick_start.ipynb",
+        "artifacts": artifacts
+    }

tools/tissue_ontology_mapping.py

@@ -0,0 +1,148 @@
+"""
+Tissue ontology mapping tutorial for navigating biological data ontologies in AlphaGenome.
+
+This MCP Server provides 2 tools:
+1. explore_output_metadata: Explore and filter output metadata for specific organisms and search terms
+2. count_tracks_by_output_type: Count tracks by output type for human and mouse organisms
+
+All tools extracted from `https://github.com/google-deepmind/alphagenome/tree/main/colabs/tissue_ontology_mapping.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+
+INPUT_DIR = Path(os.environ.get("TISSUE_ONTOLOGY_MAPPING_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("TISSUE_ONTOLOGY_MAPPING_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+ALPHAGENOME_API_KEY = os.environ["ALPHAGENOME_API_KEY"]
+
+# MCP server instance
+tissue_ontology_mapping_mcp = FastMCP(name="tissue_ontology_mapping")
+
+@tissue_ontology_mapping_mcp.tool
+def explore_output_metadata(
+    # Analysis parameters with tutorial defaults
+    organism: Annotated[Literal["HOMO_SAPIENS", "MUS_MUSCULUS"], "Target organism for metadata exploration"] = "HOMO_SAPIENS",
+    api_key: Annotated[str, "AlphaGenome API key for accessing the DNA model"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Explore output metadata for specific organisms to find ontology terms and tissue types.
+    Input is organism selection and API key and output is metadata table for interactive exploration.
+    """
+    # Import required modules
+    from alphagenome.models import dna_client
+    
+    if not api_key:
+        raise ValueError("API key must be provided")
+    
+    # Create DNA model client
+    dna_model = dna_client.create(api_key)
+    
+    # Get organism enum
+    org_enum = getattr(dna_client.Organism, organism)
+    
+    # Get output metadata
+    output_metadata = dna_model.output_metadata(org_enum).concatenate()
+    
+    # Set output filename
+    if out_prefix is None:
+        out_prefix = f"output_metadata_{organism.lower()}"
+    
+    output_file = OUTPUT_DIR / f"{out_prefix}_{timestamp}.csv"
+    
+    # Save metadata as CSV
+    output_metadata.to_csv(output_file, index=False)
+    
+    # Return standardized format
+    return {
+        "message": f"Output metadata exploration completed for {organism}",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/tissue_ontology_mapping.ipynb", 
+        "artifacts": [
+            {
+                "description": f"Output metadata for {organism}",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@tissue_ontology_mapping_mcp.tool
+def count_tracks_by_output_type(
+    # Analysis parameters with tutorial defaults
+    api_key: Annotated[str, "AlphaGenome API key for accessing the DNA model"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Count tracks by output type for both human and mouse organisms to understand data availability.
+    Input is API key and output is track counts table comparing human vs mouse availability.
+    """
+    # Import required modules
+    from alphagenome.models import dna_client
+    
+    if not api_key:
+        raise ValueError("API key must be provided")
+    
+    # Create DNA model client
+    dna_model = dna_client.create(api_key)
+    
+    # Count human tracks
+    human_tracks = (
+        dna_model.output_metadata(dna_client.Organism.HOMO_SAPIENS)
+        .concatenate()
+        .groupby('output_type')
+        .size()
+        .rename('# Human tracks')
+    )
+    
+    # Count mouse tracks
+    mouse_tracks = (
+        dna_model.output_metadata(dna_client.Organism.MUS_MUSCULUS)
+        .concatenate()
+        .groupby('output_type')
+        .size()
+        .rename('# Mouse tracks')
+    )
+    
+    # Combine the results
+    track_counts = pd.concat([human_tracks, mouse_tracks], axis=1).astype(pd.Int64Dtype())
+    
+    # Set output filename
+    if out_prefix is None:
+        out_prefix = "track_counts"
+    
+    output_file = OUTPUT_DIR / f"{out_prefix}_{timestamp}.csv"
+    
+    # Save track counts as CSV
+    track_counts.to_csv(output_file)
+    
+    # Return standardized format
+    return {
+        "message": "Track counting by output type completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/tissue_ontology_mapping.ipynb",
+        "artifacts": [
+            {
+                "description": "Track counts by output type",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }

tools/variant_scoring_ui.py

@@ -0,0 +1,389 @@
+"""
+Interactive tutorial for scoring and visualizing single variants with comprehensive modality options.
+
+This MCP Server provides 2 tools:
+1. score_variant: Score a single variant with multiple variant scorers and save results
+2. visualize_variant_effects: Generate comprehensive variant effect visualization across multiple modalities
+
+All tools extracted from `https://github.com/google-deepmind/alphagenome/tree/main/colabs/variant_scoring_ui.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+INPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# Fetch your secret
+ALPHAGENOME_API_KEY = os.environ["ALPHAGENOME_API_KEY"]
+
+# MCP server instance
+variant_scoring_ui_mcp = FastMCP(name="variant_scoring_ui")
+
+
+def score_variant(
+    # Primary data inputs - variant specification
+    variant_chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"] = "chr22",
+    variant_position: Annotated[int, "Genomic position"] = 36201698,
+    variant_reference_bases: Annotated[str, "Reference allele"] = "A",
+    variant_alternate_bases: Annotated[str, "Alternate allele"] = "C",
+    # Analysis parameters with tutorial defaults
+    organism: Annotated[Literal["human", "mouse"], "Organism to analyze"] = "human",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Length of sequence around variant to predict"] = "1MB",
+    api_key: Annotated[str | None, "API key for AlphaGenome model"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Score a single variant using multiple variant scorers with comprehensive analysis.
+    Input is variant coordinates and parameters, output is variant scores table and downloadable CSV file.
+    """
+    from alphagenome import colab_utils
+    from alphagenome.data import genome
+    from alphagenome.models import dna_client, variant_scorers
+    
+    # Use provided API key or get from environment/colab
+    if api_key:
+        dna_model = dna_client.create(api_key)
+    else:
+        dna_model = dna_client.create(colab_utils.get_api_key())
+    
+    # Map organism string to enum
+    organism_map = {
+        'human': dna_client.Organism.HOMO_SAPIENS,
+        'mouse': dna_client.Organism.MUS_MUSCULUS,
+    }
+    organism_enum = organism_map[organism]
+    
+    # Create variant object
+    variant = genome.Variant(
+        chromosome=variant_chromosome,
+        position=variant_position,
+        reference_bases=variant_reference_bases,
+        alternate_bases=variant_alternate_bases,
+    )
+    
+    # Get sequence length
+    sequence_length_value = dna_client.SUPPORTED_SEQUENCE_LENGTHS[
+        f'SEQUENCE_LENGTH_{sequence_length}'
+    ]
+    
+    # The input interval is derived from the variant (centered on it)
+    interval = variant.reference_interval.resize(sequence_length_value)
+    
+    # Score variant
+    variant_scores = dna_model.score_variant(
+        interval=interval,
+        variant=variant,
+        variant_scorers=list(variant_scorers.RECOMMENDED_VARIANT_SCORERS.values()),
+    )
+    
+    # Convert to tidy format
+    df_scores = variant_scorers.tidy_scores(variant_scores)
+    
+    # Save results
+    if out_prefix is None:
+        out_prefix = f"variant_{variant_chromosome}_{variant_position}_{variant_reference_bases}_{variant_alternate_bases}"
+    
+    output_file = OUTPUT_DIR / f"{out_prefix}_scores_{timestamp}.csv"
+    
+    # Filter columns for display (remove internal columns)
+    columns = [
+        c for c in df_scores.columns if c not in ['variant_id', 'scored_interval']
+    ]
+    df_display = df_scores[columns]
+    
+    # Save full results
+    df_scores.to_csv(output_file, index=False)
+    
+    return {
+        "message": f"Variant scoring completed with {len(df_scores)} scores across modalities",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/variant_scoring_ui.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant scores CSV",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@variant_scoring_ui_mcp.tool
+def visualize_variant_effects(
+    # Primary data inputs - variant specification
+    variant_chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"] = "chr22",
+    variant_position: Annotated[int, "Genomic position"] = 36201698,
+    variant_reference_bases: Annotated[str, "Reference allele"] = "A",
+    variant_alternate_bases: Annotated[str, "Alternate allele"] = "C",
+    # Analysis parameters with tutorial defaults
+    organism: Annotated[Literal["human", "mouse"], "Organism to analyze"] = "human",
+    sequence_length: Annotated[Literal["2KB", "16KB", "100KB", "500KB", "1MB"], "Length of sequence around variant to predict"] = "1MB",
+    ontology_terms: Annotated[list[str], "List of cell and tissue ontology terms"] = None,
+    # Gene annotation options
+    plot_gene_annotation: Annotated[bool, "Include gene annotation in plot"] = True,
+    plot_longest_transcript_only: Annotated[bool, "Show only longest transcript per gene"] = True,
+    # Output types to plot
+    plot_rna_seq: Annotated[bool, "Plot RNA-seq tracks"] = True,
+    plot_cage: Annotated[bool, "Plot CAGE tracks"] = True,
+    plot_atac: Annotated[bool, "Plot ATAC-seq tracks"] = False,
+    plot_dnase: Annotated[bool, "Plot DNase tracks"] = False,
+    plot_chip_histone: Annotated[bool, "Plot ChIP-seq histone tracks"] = False,
+    plot_chip_tf: Annotated[bool, "Plot ChIP-seq transcription factor tracks"] = False,
+    plot_splice_sites: Annotated[bool, "Plot splice sites"] = True,
+    plot_splice_site_usage: Annotated[bool, "Plot splice site usage"] = False,
+    plot_contact_maps: Annotated[bool, "Plot contact maps"] = False,
+    plot_splice_junctions: Annotated[bool, "Plot splice junctions"] = False,
+    # DNA strand filtering
+    filter_to_positive_strand: Annotated[bool, "Filter tracks to positive strand only"] = False,
+    filter_to_negative_strand: Annotated[bool, "Filter tracks to negative strand only"] = False,
+    # Visualization options
+    ref_color: Annotated[str, "Color for reference allele"] = "dimgrey",
+    alt_color: Annotated[str, "Color for alternate allele"] = "red",
+    plot_interval_width: Annotated[int, "Width of plot interval in base pairs"] = 43008,
+    plot_interval_shift: Annotated[int, "Shift of plot interval from variant center"] = 0,
+    api_key: Annotated[str | None, "API key for AlphaGenome model"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Generate comprehensive variant effect visualization across multiple genomic modalities.
+    Input is variant coordinates and visualization parameters, output is variant effect plots showing REF vs ALT predictions.
+    """
+    from alphagenome import colab_utils
+    from alphagenome.data import gene_annotation, genome, transcript
+    from alphagenome.models import dna_client
+    from alphagenome.visualization import plot_components
+    import matplotlib.pyplot as plt
+    
+    # Validate strand filtering parameters
+    if filter_to_positive_strand and filter_to_negative_strand:
+        raise ValueError(
+            'Cannot specify both filter_to_positive_strand and '
+            'filter_to_negative_strand.'
+        )
+    
+    # Use provided API key or get from environment/colab
+    if api_key:
+        dna_model = dna_client.create(api_key)
+    else:
+        dna_model = dna_client.create(colab_utils.get_api_key())
+    
+    # Default ontology terms from tutorial
+    if ontology_terms is None:
+        ontology_terms = ['EFO:0001187', 'EFO:0002067', 'EFO:0002784']
+    
+    # Map organism string to enum
+    organism_map = {
+        'human': dna_client.Organism.HOMO_SAPIENS,
+        'mouse': dna_client.Organism.MUS_MUSCULUS,
+    }
+    organism_enum = organism_map[organism]
+    
+    # Reference paths for gene annotation
+    HG38_GTF_FEATHER = (
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    MM10_GTF_FEATHER = (
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'mm10/gencode.vM23.annotation.gtf.gz.feather'
+    )
+    
+    # Create variant object
+    variant = genome.Variant(
+        chromosome=variant_chromosome,
+        position=variant_position,
+        reference_bases=variant_reference_bases,
+        alternate_bases=variant_alternate_bases,
+    )
+    
+    # Get sequence length
+    sequence_length_value = dna_client.SUPPORTED_SEQUENCE_LENGTHS[
+        f'SEQUENCE_LENGTH_{sequence_length}'
+    ]
+    
+    # The input interval is derived from the variant (centered on it)
+    interval = variant.reference_interval.resize(sequence_length_value)
+    
+    # Load gene annotation
+    match organism_enum:
+        case dna_client.Organism.HOMO_SAPIENS:
+            gtf_path = HG38_GTF_FEATHER
+        case dna_client.Organism.MUS_MUSCULUS:
+            gtf_path = MM10_GTF_FEATHER
+        case _:
+            raise ValueError(f'Unsupported organism: {organism_enum}')
+
+    import pandas as pd
+    gtf = pd.read_feather(gtf_path)
+
+    # Filter to protein-coding genes and highly supported transcripts
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+
+    # Extractor for identifying transcripts in a region
+    transcript_extractor = transcript.TranscriptExtractor(gtf_transcript)
+
+    # Also define an extractor that fetches only the longest transcript per gene
+    gtf_longest_transcript = gene_annotation.filter_to_longest_transcript(
+        gtf_transcript
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gtf_longest_transcript
+    )
+    
+    # Predict variant effects
+    output = dna_model.predict_variant(
+        interval=interval,
+        variant=variant,
+        organism=organism_enum,
+        requested_outputs=[*dna_client.OutputType],
+        ontology_terms=ontology_terms,
+    )
+    
+    # Filter to DNA strand if requested
+    ref, alt = output.reference, output.alternate
+
+    if filter_to_positive_strand:
+        ref = ref.filter_to_strand(strand='+')
+        alt = alt.filter_to_strand(strand='+')
+    elif filter_to_negative_strand:
+        ref = ref.filter_to_strand(strand='-')
+        alt = alt.filter_to_strand(strand='-')
+    
+    # Build plot components
+    components = []
+    ref_alt_colors = {'REF': ref_color, 'ALT': alt_color}
+
+    # Gene and transcript annotation
+    if plot_gene_annotation:
+        if plot_longest_transcript_only:
+            transcripts = longest_transcript_extractor.extract(interval)
+        else:
+            transcripts = transcript_extractor.extract(interval)
+        components.append(plot_components.TranscriptAnnotation(transcripts))
+
+    # Individual output type plots
+    plot_map = {
+        'plot_atac': (ref.atac, alt.atac, 'ATAC'),
+        'plot_cage': (ref.cage, alt.cage, 'CAGE'),
+        'plot_chip_histone': (ref.chip_histone, alt.chip_histone, 'CHIP_HISTONE'),
+        'plot_chip_tf': (ref.chip_tf, alt.chip_tf, 'CHIP_TF'),
+        'plot_contact_maps': (ref.contact_maps, alt.contact_maps, 'CONTACT_MAPS'),
+        'plot_dnase': (ref.dnase, alt.dnase, 'DNASE'),
+        'plot_rna_seq': (ref.rna_seq, alt.rna_seq, 'RNA_SEQ'),
+        'plot_splice_junctions': (
+            ref.splice_junctions,
+            alt.splice_junctions,
+            'SPLICE_JUNCTIONS',
+        ),
+        'plot_splice_sites': (ref.splice_sites, alt.splice_sites, 'SPLICE_SITES'),
+        'plot_splice_site_usage': (
+            ref.splice_site_usage,
+            alt.splice_site_usage,
+            'SPLICE_SITE_USAGE',
+        ),
+    }
+
+    for key, (ref_data, alt_data, output_type) in plot_map.items():
+        if eval(key) and ref_data is not None and ref_data.values.shape[-1] == 0:
+            print(
+                f'Requested plot for output {output_type} but no tracks exist in'
+                ' output. This is likely because this output does not exist for your'
+                ' ontologies or requested DNA strand.'
+            )
+        if eval(key) and ref_data and alt_data:
+            match output_type:
+                case 'CHIP_HISTONE':
+                    ylabel_template = (
+                        f'{output_type}: {{biosample_name}} ({{strand}})\n{{histone_mark}}'
+                    )
+                case 'CHIP_TF':
+                    ylabel_template = (
+                        f'{output_type}: {{biosample_name}}'
+                        ' ({strand})\n{transcription_factor}'
+                    )
+                case 'CONTACT_MAPS':
+                    ylabel_template = f'{output_type}: {{biosample_name}} ({{strand}})'
+                case 'SPLICE_SITES':
+                    ylabel_template = f'{output_type}: {{name}} ({{strand}})'
+                case _:
+                    ylabel_template = (
+                        f'{output_type}: {{biosample_name}} ({{strand}})\n{{name}}'
+                    )
+
+            if output_type == 'CONTACT_MAPS':
+                component = plot_components.ContactMapsDiff(
+                    tdata=alt_data - ref_data,
+                    ylabel_template=ylabel_template,
+                )
+                components.append(component)
+            elif output_type == 'SPLICE_JUNCTIONS':
+                ref_plot = plot_components.Sashimi(
+                    ref_data,
+                    ylabel_template='REF: ' + ylabel_template,
+                )
+                alt_plot = plot_components.Sashimi(
+                    alt_data,
+                    ylabel_template='ALT: ' + ylabel_template,
+                )
+                components.extend([ref_plot, alt_plot])
+            else:
+                component = plot_components.OverlaidTracks(
+                    tdata={'REF': ref_data, 'ALT': alt_data},
+                    colors=ref_alt_colors,
+                    ylabel_template=ylabel_template,
+                )
+                components.append(component)
+
+    # Validate plot interval width
+    if plot_interval_width > interval.width:
+        raise ValueError(
+            f'plot_interval_width ({plot_interval_width}) must be less than '
+            f'interval.width ({interval.width}).'
+        )
+
+    # Generate plot
+    plot = plot_components.plot(
+        components=components,
+        interval=interval.shift(plot_interval_shift).resize(plot_interval_width),
+        annotations=[
+            plot_components.VariantAnnotation([variant]),
+        ],
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"variant_{variant_chromosome}_{variant_position}_{variant_reference_bases}_{variant_alternate_bases}"
+    
+    output_file = OUTPUT_DIR / f"{out_prefix}_effects_{timestamp}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": f"Variant visualization completed with {len(components)} plot components",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/variant_scoring_ui.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant effects plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }

tools/visualization_modality_tour.py

@@ -0,0 +1,1053 @@
+"""
+AlphaGenome visualization modality tour for different genomic data types.
+
+This MCP Server provides 9 tools:
+1. visualize_gene_expression: Visualize RNA_SEQ and CAGE gene expression predictions
+2. visualize_variant_expression_effects: Show REF vs ALT variant effects on gene expression
+3. visualize_custom_annotations: Plot custom annotations like polyadenylation sites
+4. visualize_chromatin_accessibility: Visualize DNASE and ATAC chromatin accessibility
+5. visualize_splicing_effects: Visualize splicing predictions with SPLICE_SITES, SPLICE_SITE_USAGE, SPLICE_JUNCTIONS
+6. visualize_variant_splicing_effects: Show REF vs ALT variant effects on splicing with sashimi plots
+7. visualize_histone_modifications: Visualize CHIP_HISTONE predictions with custom colors
+8. visualize_tf_binding: Visualize CHIP_TF transcription factor binding predictions
+9. visualize_contact_maps: Visualize CONTACT_MAPS DNA-DNA contact predictions
+
+All tools extracted from `https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb`.
+"""
+
+# Standard imports
+from typing import Annotated, Literal, Any
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import os
+from fastmcp import FastMCP
+from datetime import datetime
+import matplotlib.pyplot as plt
+
+# AlphaGenome imports
+from alphagenome import colab_utils
+from alphagenome.data import gene_annotation, genome, track_data, transcript
+from alphagenome.models import dna_client
+from alphagenome.visualization import plot_components
+
+# Base persistent directory (HF Spaces guarantees /data is writable & persistent)
+BASE_DIR = Path("/data")
+
+DEFAULT_INPUT_DIR = BASE_DIR / "tmp_inputs"
+DEFAULT_OUTPUT_DIR = BASE_DIR / "tmp_outputs"
+
+INPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_INPUT_DIR", DEFAULT_INPUT_DIR))
+OUTPUT_DIR = Path(os.environ.get("BATCH_VARIANT_SCORING_OUTPUT_DIR", DEFAULT_OUTPUT_DIR))
+
+# Ensure directories exist
+INPUT_DIR.mkdir(parents=True, exist_ok=True)
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Fetch your secret
+ALPHAGENOME_API_KEY = os.environ["ALPHAGENOME_API_KEY"]
+
+# Timestamp for unique outputs
+timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+# MCP server instance
+visualization_modality_tour_mcp = FastMCP(name="visualization_modality_tour")
+
+@visualization_modality_tour_mcp.tool
+def visualize_gene_expression(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001159', 'UBERON:0001155'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize RNA_SEQ and CAGE gene expression predictions for a genomic interval.
+    Input is genomic coordinates and ontology terms and output is gene expression visualization plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval and resize to supported length
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={
+            dna_client.OutputType.RNA_SEQ,
+            dna_client.OutputType.CAGE,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(
+                tdata=output.rna_seq,
+                ylabel_template='RNA_SEQ: {biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.Tracks(
+                tdata=output.cage,
+                ylabel_template='CAGE: {biosample_name} ({strand})\n{name}',
+            ),
+        ],
+        interval=interval,
+        title='Predicted RNA Expression (RNA_SEQ, CAGE) for colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"gene_expression_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Gene expression visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Gene expression visualization plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+
+def visualize_variant_expression_effects(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    position: Annotated[int, "Variant genomic position"],
+    reference_bases: Annotated[str, "Reference allele sequence"],
+    alternate_bases: Annotated[str, "Alternate allele sequence"],
+    interval_start: Annotated[int, "Start position for prediction interval"],
+    interval_end: Annotated[int, "End position for prediction interval"],
+    gene_symbol: Annotated[str | None, "Gene symbol to zoom in on"] = None,
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001159', 'UBERON:0001155'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize REF vs ALT variant effects on gene expression with overlaid tracks.
+    Input is variant coordinates and interval and output is variant effect visualization plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create variant and interval
+    variant = genome.Variant(chromosome, position, reference_bases, alternate_bases)
+    interval = genome.Interval(chromosome, interval_start, interval_end).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make variant predictions
+    output = dna_model.predict_variant(
+        interval=interval,
+        variant=variant,
+        requested_outputs={
+            dna_client.OutputType.RNA_SEQ,
+            dna_client.OutputType.CAGE,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Determine plot interval
+    if gene_symbol is not None:
+        plot_interval = gene_annotation.get_gene_interval(gtf, gene_symbol=gene_symbol)
+        plot_interval.resize_inplace(plot_interval.width + 1000)
+    else:
+        plot_interval = interval
+    
+    # Define colors for REF and ALT
+    ref_alt_colors = {'REF': 'dimgrey', 'ALT': 'red'}
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': output.reference.rna_seq.filter_to_nonpositive_strand(),
+                    'ALT': output.alternate.rna_seq.filter_to_nonpositive_strand(),
+                },
+                colors=ref_alt_colors,
+                ylabel_template='{biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': output.reference.cage.filter_to_nonpositive_strand(),
+                    'ALT': output.alternate.cage.filter_to_nonpositive_strand(),
+                },
+                colors=ref_alt_colors,
+                ylabel_template='{biosample_name} ({strand})\n{name}',
+            ),
+        ],
+        annotations=[plot_components.VariantAnnotation([variant])],
+        interval=plot_interval,
+        title='Effect of variant on predicted RNA Expression in colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"variant_expression_effects_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Variant expression effects visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant expression effects plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+
+def visualize_custom_annotations(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    annotation_intervals: Annotated[list, "List of annotation intervals as [chr, start, end, strand, label] tuples"],
+    plot_start: Annotated[int, "Start position for plotting window"],
+    plot_end: Annotated[int, "End position for plotting window"],
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001159', 'UBERON:0002048'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize RNA predictions with custom interval annotations like polyadenylation sites.
+    Input is genomic coordinates and custom annotations and output is annotated RNA visualization plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={
+            dna_client.OutputType.RNA_SEQ,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Create custom annotation intervals
+    custom_intervals = []
+    labels = []
+    for ann in annotation_intervals:
+        if len(ann) >= 5:
+            chr_name, start, end, strand, label = ann[:5]
+            custom_intervals.append(genome.Interval(chr_name, start, end, strand))
+            labels.append(label)
+    
+    # Define plotting interval
+    plot_interval = genome.Interval(chromosome, plot_start, plot_end, '-')
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(
+                tdata=output.rna_seq.filter_to_negative_strand(),
+                ylabel_template='RNA_SEQ: {biosample_name} ({strand})\n{name}',
+                shared_y_scale=True,
+            )
+        ],
+        annotations=[
+            plot_components.IntervalAnnotation(
+                custom_intervals,
+                alpha=1,
+                labels=labels,
+                label_angle=90
+            )
+        ],
+        interval=plot_interval,
+        title='Custom annotations with RNA expression',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"custom_annotations_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Custom annotations visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Custom annotations plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@visualization_modality_tour_mcp.tool
+def visualize_chromatin_accessibility(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    variant_position: Annotated[int | None, "Variant position to highlight"] = None,
+    variant_ref: Annotated[str | None, "Variant reference allele"] = None,
+    variant_alt: Annotated[str | None, "Variant alternate allele"] = None,
+    promoter_intervals: Annotated[list | None, "List of promoter intervals as [chr, start, end, name] tuples"] = None,
+    window_size: Annotated[int, "Size of plotting window around variant"] = 8000,
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0000317', 'UBERON:0001155', 'UBERON:0001157', 'UBERON:0001159', 'UBERON:0004992', 'UBERON:0008971'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize DNASE and ATAC chromatin accessibility predictions for intestinal tissues.
+    Input is genomic coordinates and optional variant information and output is chromatin accessibility plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval,
+        requested_outputs={
+            dna_client.OutputType.DNASE,
+            dna_client.OutputType.ATAC,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Prepare annotations
+    annotations = []
+    
+    # Add variant annotation if provided
+    if variant_position is not None and variant_ref is not None and variant_alt is not None:
+        variant = genome.Variant(chromosome, variant_position, variant_ref, variant_alt)
+        annotations.append(plot_components.VariantAnnotation([variant]))
+        plot_interval = variant.reference_interval.resize(window_size)
+    else:
+        plot_interval = interval
+    
+    # Add promoter annotations if provided
+    if promoter_intervals is not None:
+        promoter_objs = []
+        for prom in promoter_intervals:
+            if len(prom) >= 4:
+                chr_name, start, end, name = prom[:4]
+                promoter_objs.append(genome.Interval(chr_name, start, end, name=name))
+        if promoter_objs:
+            annotations.append(plot_components.IntervalAnnotation(promoter_objs))
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(
+                tdata=output.dnase,
+                ylabel_template='DNASE: {biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.Tracks(
+                tdata=output.atac,
+                ylabel_template='ATAC: {biosample_name} ({strand})\n{name}',
+            ),
+        ],
+        interval=plot_interval,
+        annotations=annotations,
+        title='Predicted chromatin accessibility (DNASE, ATAC) for colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"chromatin_accessibility_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Chromatin accessibility visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Chromatin accessibility plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@visualization_modality_tour_mcp.tool
+def visualize_splicing_effects(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    gene_symbol: Annotated[str | None, "Gene symbol to focus on"] = None,
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001157', 'UBERON:0001159'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize splicing predictions including SPLICE_SITES, SPLICE_SITE_USAGE, and SPLICE_JUNCTIONS.
+    Input is genomic coordinates and optional gene symbol and output is splicing effects plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={
+            dna_client.OutputType.RNA_SEQ,
+            dna_client.OutputType.SPLICE_SITES,
+            dna_client.OutputType.SPLICE_SITE_USAGE,
+            dna_client.OutputType.SPLICE_JUNCTIONS,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Determine plot interval
+    if gene_symbol is not None:
+        plot_interval = gene_annotation.get_gene_interval(gtf, gene_symbol=gene_symbol)
+        plot_interval.resize_inplace(plot_interval.width + 1000)
+    else:
+        plot_interval = interval
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(
+                tdata=output.splice_sites.filter_to_negative_strand(),
+                ylabel_template='SPLICE SITES: {name} ({strand})',
+            ),
+        ],
+        interval=plot_interval,
+        title='Predicted splicing effects for colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"splicing_effects_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Splicing effects visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Splicing effects plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+
+def visualize_variant_splicing_effects(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    variant_position: Annotated[int, "Variant genomic position"],
+    variant_ref: Annotated[str, "Variant reference allele"],
+    variant_alt: Annotated[str, "Variant alternate allele"],
+    interval_start: Annotated[int, "Start position for prediction interval"],
+    interval_end: Annotated[int, "End position for prediction interval"],
+    gene_symbol: Annotated[str | None, "Gene symbol to focus on"] = None,
+    tissue_filter: Annotated[str, "Specific tissue to filter for sashimi plots"] = "Colon_Transverse",
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001157', 'UBERON:0001159'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize REF vs ALT variant effects on splicing with sashimi plots and overlaid tracks.
+    Input is variant coordinates and interval and output is variant splicing effects plot with sashimi arcs.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create variant and interval
+    variant = genome.Variant(chromosome, variant_position, variant_ref, variant_alt)
+    interval = genome.Interval(chromosome, interval_start, interval_end).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    transcript_extractor = transcript.TranscriptExtractor(gtf_transcript)
+    
+    # Make variant predictions
+    output = dna_model.predict_variant(
+        interval=interval,
+        variant=variant,
+        requested_outputs={
+            dna_client.OutputType.RNA_SEQ,
+            dna_client.OutputType.SPLICE_SITES,
+            dna_client.OutputType.SPLICE_SITE_USAGE,
+            dna_client.OutputType.SPLICE_JUNCTIONS,
+        },
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract all transcripts
+    transcripts = transcript_extractor.extract(interval)
+    
+    # Determine plot interval
+    if gene_symbol is not None:
+        plot_interval = gene_annotation.get_gene_interval(gtf, gene_symbol=gene_symbol)
+        plot_interval.resize_inplace(plot_interval.width + 1000)
+    else:
+        plot_interval = interval
+    
+    ref_output = output.reference
+    alt_output = output.alternate
+    
+    # Define colors for REF and ALT
+    ref_alt_colors = {'REF': 'dimgrey', 'ALT': 'red'}
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(transcripts),
+            plot_components.Sashimi(
+                ref_output.splice_junctions
+                .filter_to_strand('-')
+                .filter_by_tissue(tissue_filter),
+                ylabel_template='Reference {biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.Sashimi(
+                alt_output.splice_junctions
+                .filter_to_strand('-')
+                .filter_by_tissue(tissue_filter),
+                ylabel_template='Alternate {biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': ref_output.rna_seq.filter_to_nonpositive_strand(),
+                    'ALT': alt_output.rna_seq.filter_to_nonpositive_strand(),
+                },
+                colors=ref_alt_colors,
+                ylabel_template='RNA_SEQ: {biosample_name} ({strand})\n{name}',
+            ),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': ref_output.splice_sites.filter_to_nonpositive_strand(),
+                    'ALT': alt_output.splice_sites.filter_to_nonpositive_strand(),
+                },
+                colors=ref_alt_colors,
+                ylabel_template='SPLICE SITES: {name} ({strand})',
+            ),
+            plot_components.OverlaidTracks(
+                tdata={
+                    'REF': (
+                        ref_output.splice_site_usage.filter_to_nonpositive_strand()
+                    ),
+                    'ALT': (
+                        alt_output.splice_site_usage.filter_to_nonpositive_strand()
+                    ),
+                },
+                colors=ref_alt_colors,
+                ylabel_template=(
+                    'SPLICE SITE USAGE: {biosample_name} ({strand})\n{name}'
+                ),
+            ),
+        ],
+        interval=plot_interval,
+        annotations=[plot_components.VariantAnnotation([variant])],
+        title='Predicted REF vs. ALT effects of variant in colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"variant_splicing_effects_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Variant splicing effects visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Variant splicing effects plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@visualization_modality_tour_mcp.tool
+def visualize_histone_modifications(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    include_tss_annotations: Annotated[bool, "Whether to include transcription start site annotations"] = True,
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0000317', 'UBERON:0001155', 'UBERON:0001157', 'UBERON:0001159'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize CHIP_HISTONE predictions with custom colors grouped by histone mark.
+    Input is genomic coordinates and output is histone modifications plot with colored tracks.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    gtf_longest_transcript = gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    longest_transcript_extractor = transcript.TranscriptExtractor(gtf_longest_transcript)
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={dna_client.OutputType.CHIP_HISTONE},
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Reorder tracks by histone mark and apply colors
+    reordered_chip_histone = output.chip_histone.select_tracks_by_index(
+        output.chip_histone.metadata.sort_values('histone_mark').index
+    )
+    
+    histone_to_color = {
+        'H3K27AC': '#e41a1c',
+        'H3K36ME3': '#ff7f00',
+        'H3K4ME1': '#377eb8',
+        'H3K4ME3': '#984ea3',
+        'H3K9AC': '#4daf4a',
+        'H3K27ME3': '#ffc0cb',
+    }
+    
+    track_colors = (
+        reordered_chip_histone.metadata['histone_mark']
+        .map(lambda x: histone_to_color.get(x.upper(), '#000000'))
+        .values
+    )
+    
+    # Prepare annotations
+    annotations = []
+    if include_tss_annotations:
+        # Extract TSS annotations
+        gtf_tss = gene_annotation.extract_tss(gtf_longest_transcript)
+        tss_as_intervals = [
+            genome.Interval(
+                chromosome=row.Chromosome,
+                start=row.Start,
+                end=row.End + 1000,  # Add extra 1Kb so the TSSs are visible
+                name=row.gene_name,
+            )
+            for _, row in gtf_tss.iterrows()
+        ]
+        annotations.append(
+            plot_components.IntervalAnnotation(
+                tss_as_intervals, alpha=0.5, colors='blue'
+            )
+        )
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.Tracks(
+                tdata=reordered_chip_histone,
+                ylabel_template=(
+                    'CHIP HISTONE: {biosample_name} ({strand})\n{histone_mark}'
+                ),
+                filled=True,
+                track_colors=track_colors,
+            ),
+        ],
+        interval=interval,
+        annotations=annotations,
+        despine_keep_bottom=True,
+        title='Predicted histone modification markers in colon tissue',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"histone_modifications_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Histone modifications visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Histone modifications plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@visualization_modality_tour_mcp.tool
+def visualize_tf_binding(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    transcription_factor: Annotated[str | None, "Specific transcription factor to visualize (e.g., 'CTCF')"] = None,
+    min_max_prediction: Annotated[float, "Minimum maximum prediction value to include tracks"] = 8000.0,
+    gene_symbol: Annotated[str | None, "Gene symbol to focus analysis on"] = None,
+    include_tss_annotations: Annotated[bool, "Whether to include transcription start site annotations"] = True,
+    ontology_terms: Annotated[list, "List of ontology terms for tissues/cell types"] = ['UBERON:0001159', 'UBERON:0001157', 'EFO:0002067', 'EFO:0001187'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize CHIP_TF transcription factor binding predictions with filtering and averaging options.
+    Input is genomic coordinates and filtering parameters and output is TF binding visualization plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    gtf_longest_transcript = gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    longest_transcript_extractor = transcript.TranscriptExtractor(gtf_longest_transcript)
+    transcript_extractor = transcript.TranscriptExtractor(gtf_transcript)
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={dna_client.OutputType.CHIP_TF},
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    all_transcripts = transcript_extractor.extract(interval)
+    
+    # Determine plot interval and filtering logic
+    if gene_symbol is not None:
+        gene_interval = gene_annotation.get_gene_interval(gtf, gene_symbol=gene_symbol)
+        gene_interval.resize_inplace(gene_interval.width + 1000)
+        
+        # Filter based on gene interval
+        max_predictions = output.chip_tf.slice_by_interval(
+            gene_interval, match_resolution=True
+        ).values.max(axis=0)
+        
+        # Get top 10 tracks for gene-specific analysis
+        output_filtered = output.chip_tf.filter_tracks(
+            (max_predictions >= np.sort(max_predictions)[-10])
+        )
+        plot_interval = gene_interval
+        transcripts_to_use = all_transcripts
+    else:
+        # Filter by minimum max prediction globally
+        output_filtered = output.chip_tf.filter_tracks(
+            output.chip_tf.values.max(axis=0) > min_max_prediction
+        )
+        plot_interval = interval
+        transcripts_to_use = longest_transcripts
+    
+    # Handle specific transcription factor averaging
+    if transcription_factor is not None:
+        # Filter to specific TF and create mean track
+        tf_mask = output_filtered.metadata['transcription_factor'] == transcription_factor
+        if tf_mask.any():
+            mean_tf_values = output_filtered.values[:, tf_mask].mean(axis=1)
+            
+            # Create new TrackData object
+            tdata_mean_tf = track_data.TrackData(
+                values=mean_tf_values[:, None],
+                metadata=pd.DataFrame({
+                    'transcription_factor': [transcription_factor],
+                    'name': ['mean'],
+                    'strand': ['.']
+                }),
+                interval=output_filtered.interval,
+                resolution=output_filtered.resolution,
+            )
+            
+            track_data_to_plot = tdata_mean_tf
+            ylabel_template = '{name} {transcription_factor}'
+            plot_title = f'Predicted {transcription_factor} binding (mean across cell types)'
+        else:
+            raise ValueError(f"No tracks found for transcription factor: {transcription_factor}")
+    else:
+        track_data_to_plot = output_filtered
+        ylabel_template = 'CHIP TF: {biosample_name} ({strand})\n{transcription_factor}'
+        plot_title = 'Predicted TF-binding in K562, HepG2, and sigmoid colon.'
+    
+    # Prepare annotations
+    annotations = []
+    if include_tss_annotations:
+        # Extract TSS annotations
+        gtf_tss = gene_annotation.extract_tss(gtf_longest_transcript)
+        tss_as_intervals = [
+            genome.Interval(
+                chromosome=row.Chromosome,
+                start=row.Start,
+                end=row.End + 1000,  # Add extra 1Kb so the TSSs are visible
+                name=row.gene_name,
+            )
+            for _, row in gtf_tss.iterrows()
+        ]
+        annotations.append(
+            plot_components.IntervalAnnotation(
+                tss_as_intervals, alpha=0.3, colors='blue'
+            )
+        )
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(transcripts_to_use),
+            plot_components.Tracks(
+                tdata=track_data_to_plot,
+                ylabel_template=ylabel_template,
+                filled=True,
+            ),
+        ],
+        interval=plot_interval,
+        annotations=annotations,
+        despine_keep_bottom=True,
+        title=plot_title,
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        tf_suffix = f"_{transcription_factor}" if transcription_factor else ""
+        out_prefix = f"tf_binding{tf_suffix}_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "TF binding visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "TF binding plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }
+
+@visualization_modality_tour_mcp.tool
+def visualize_contact_maps(
+    chromosome: Annotated[str, "Chromosome name (e.g., 'chr22')"],
+    start_position: Annotated[int, "Start genomic position"],
+    end_position: Annotated[int, "End genomic position"],
+    colormap: Annotated[str, "Matplotlib colormap for contact map"] = 'autumn_r',
+    vmax: Annotated[float, "Maximum value for colormap scaling"] = 1.0,
+    ontology_terms: Annotated[list, "List of ontology terms for cell lines"] = ['EFO:0002824'],
+    api_key: Annotated[str | None, "AlphaGenome API key"] = ALPHAGENOME_API_KEY,
+    out_prefix: Annotated[str | None, "Output file prefix"] = None,
+) -> dict:
+    """
+    Visualize CONTACT_MAPS DNA-DNA contact predictions showing topologically-associated domains.
+    Input is genomic coordinates and colormap parameters and output is contact maps visualization plot.
+    """
+    if api_key is None:
+        raise ValueError("API key must be provided")
+    
+    # Create interval
+    interval = genome.Interval(chromosome, start_position, end_position).resize(
+        dna_client.SEQUENCE_LENGTH_1MB
+    )
+    
+    # Create model client
+    dna_model = dna_client.create(api_key)
+    
+    # Load gene annotations
+    gtf = pd.read_feather(
+        'https://storage.googleapis.com/alphagenome/reference/gencode/'
+        'hg38/gencode.v46.annotation.gtf.gz.feather'
+    )
+    gtf_transcript = gene_annotation.filter_transcript_support_level(
+        gene_annotation.filter_protein_coding(gtf), ['1']
+    )
+    longest_transcript_extractor = transcript.TranscriptExtractor(
+        gene_annotation.filter_to_longest_transcript(gtf_transcript)
+    )
+    
+    # Make predictions
+    output = dna_model.predict_interval(
+        interval=interval,
+        requested_outputs={dna_client.OutputType.CONTACT_MAPS},
+        ontology_terms=ontology_terms,
+    )
+    
+    # Extract transcripts
+    longest_transcripts = longest_transcript_extractor.extract(interval)
+    
+    # Build plot
+    plot = plot_components.plot(
+        [
+            plot_components.TranscriptAnnotation(longest_transcripts),
+            plot_components.ContactMaps(
+                tdata=output.contact_maps,
+                ylabel_template='{biosample_name}\n{name}',
+                cmap=colormap,
+                vmax=vmax,
+            ),
+        ],
+        interval=interval,
+        title='Predicted contact maps',
+    )
+    
+    # Save plot
+    if out_prefix is None:
+        out_prefix = f"contact_maps_{timestamp}"
+    output_file = OUTPUT_DIR / f"{out_prefix}.png"
+    plt.savefig(output_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    return {
+        "message": "Contact maps visualization completed successfully",
+        "reference": "https://github.com/google-deepmind/alphagenome/tree/main/colabs/visualization_modality_tour.ipynb",
+        "artifacts": [
+            {
+                "description": "Contact maps plot",
+                "path": str(output_file.resolve())
+            }
+        ]
+    }