generate_dna_sequence

Instructions

Implementation Reference

• src/tools/generateDNA.ts:44-117 (handler)

  Main handler function that executes the generate_dna_sequence tool logic. Accepts parameters for length, GC content, count, seed, model (random/markov/codon-biased), and output format (fasta/plain). Uses SequenceGenerator utility and supports three different generation models.

  async handler({ 
    length, 
    gcContent = 0.5, 
    count = 1, 
    seed, 
    model = "random",
    outputFormat = "fasta"
  }: { 
    length: number; 
    gcContent?: number; 
    count?: number; 
    seed?: number;
    model?: string;
    outputFormat?: string;
  }) {
    const generator = new SequenceGenerator(seed);
    const sequences = [];
  
    for (let i = 0; i < count; i++) {
      let sequence: string;
      
      switch (model) {
        case "random":
          sequence = generator.generateRandomDNA(length, gcContent);
          break;
        case "markov":
          sequence = generateMarkovDNA(length, gcContent, generator);
          break;
        case "codon-biased":
          sequence = generateCodonBiasedDNA(length, generator);
          break;
        default:
          sequence = generator.generateRandomDNA(length, gcContent);
      }
  
      const actualGC = (sequence.match(/[GC]/g) || []).length / sequence.length;
      
      sequences.push({
        id: `sim_dna_${i + 1}`,
        sequence,
        length: sequence.length,
        gcContent: Math.round(actualGC * 10000) / 100,
        model
      });
    }
  
    let output = '';
    if (outputFormat === 'fasta') {
      output = sequences.map(seq => 
        `>${seq.id} length=${seq.length} gc=${seq.gcContent}% model=${seq.model}\n${seq.sequence}`
      ).join('\n\n');
    } else {
      output = sequences.map(seq => seq.sequence).join('\n');
    }
  
    const stats = {
      totalSequences: sequences.length,
      averageLength: Math.round(sequences.reduce((sum, seq) => sum + seq.length, 0) / sequences.length),
      averageGC: Math.round(sequences.reduce((sum, seq) => sum + seq.gcContent, 0) / sequences.length * 100) / 100,
      model,
      seed: seed || "random"
    };
  
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          statistics: stats,
          sequences: outputFormat === 'fasta' ? output : sequences,
          rawOutput: outputFormat === 'plain' ? output : undefined
        }, null, 2)
      }]
    };
  }

• src/tools/generateDNA.ts:4-43 (schema)

  Tool definition and input schema for generate_dna_sequence. Defines the tool name, description, and JSON Schema validation for all input parameters including length (required), gcContent, count, seed, model, and outputFormat.

  export const generateDNA = {
    definition: {
      name: "generate_dna_sequence",
      description: "Generate random DNA sequences with specified parameters",
      inputSchema: {
        type: "object",
        properties: {
          length: {
            type: "number",
            description: "Length of the DNA sequence to generate"
          },
          gcContent: {
            type: "number",
            description: "GC content (0-1), default is 0.5",
            minimum: 0,
            maximum: 1
          },
          count: {
            type: "number",
            description: "Number of sequences to generate, default is 1",
            minimum: 1
          },
          seed: {
            type: "number",
            description: "Random seed for reproducible results (optional)"
          },
          model: {
            type: "string",
            description: "Generation model: 'random', 'markov', or 'codon-biased'",
            enum: ["random", "markov", "codon-biased"]
          },
          outputFormat: {
            type: "string",
            description: "Output format: 'fasta' or 'plain'",
            enum: ["fasta", "plain"]
          }
        },
        required: ["length"]
      },
    },

• src/server.ts:47-55 (registration)

  Registration of the generate_dna_sequence tool handler in the MCP server's CallToolRequestSchema request handler. Maps the tool name to the generateDNA.handler function with proper TypeScript type annotations.

  case "generate_dna_sequence":
    return await generateDNA.handler(args as {
      length: number;
      gcContent?: number;
      count?: number;
      seed?: number;
      model?: string;
      outputFormat?: string;
    });

• src/utils/sequenceUtils.ts:48-81 (helper)

  SequenceGenerator utility class with seedable RNG and the generateRandomDNA method used by the handler. Supports generating random DNA sequences with specified GC content bias.

  export class SequenceGenerator {
    public rng: () => number;
  
    constructor(seed?: number) {
      if (seed !== undefined) {
        let s = seed;
        this.rng = () => {
          s = Math.sin(s) * 10000;
          return s - Math.floor(s);
        };
      } else {
        this.rng = Math.random;
      }
    }
  
    generateRandomDNA(length: number, gcContent: number = 0.5): string {
      const gcProb = gcContent / 2;
      const atProb = (1 - gcContent) / 2;
      
      let sequence = '';
      for (let i = 0; i < length; i++) {
        const rand = this.rng();
        if (rand < atProb) {
          sequence += 'A';
        } else if (rand < atProb * 2) {
          sequence += 'T';
        } else if (rand < atProb * 2 + gcProb) {
          sequence += 'G';
        } else {
          sequence += 'C';
        }
      }
      return sequence;
    }

• src/tools/generateDNA.ts:120-172 (helper)

  Helper functions for alternative DNA generation models: generateMarkovDNA (uses Markov chain transitions) and generateCodonBiasedDNA (uses codon usage tables). These are called by the main handler when model parameter is set to 'markov' or 'codon-biased'.

  function generateMarkovDNA(length: number, gcContent: number, generator: SequenceGenerator): string {
    const transitions = {
      'A': { 'A': 0.3, 'T': 0.3, 'G': 0.2, 'C': 0.2 },
      'T': { 'A': 0.3, 'T': 0.3, 'G': 0.2, 'C': 0.2 },
      'G': { 'A': 0.2, 'T': 0.2, 'G': 0.3, 'C': 0.3 },
      'C': { 'A': 0.2, 'T': 0.2, 'G': 0.3, 'C': 0.3 }
    };
  
    let sequence = generator.generateRandomDNA(1, gcContent);
    
    for (let i = 1; i < length; i++) {
      const lastBase = sequence[i - 1] as keyof typeof transitions;
      const probs = transitions[lastBase];
      const rand = Math.random();
      
      let cumProb = 0;
      for (const [base, prob] of Object.entries(probs)) {
        cumProb += prob;
        if (rand < cumProb) {
          sequence += base;
          break;
        }
      }
    }
    
    return sequence;
  }
  
  function generateCodonBiasedDNA(length: number, generator: SequenceGenerator): string {
    const codonUsage = {
      'F': ['TTT', 'TTC'], 'L': ['TTA', 'TTG', 'CTT', 'CTC', 'CTA', 'CTG'],
      'S': ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC'], 'Y': ['TAT', 'TAC'],
      'C': ['TGT', 'TGC'], 'W': ['TGG'], 'P': ['CCT', 'CCC', 'CCA', 'CCG'],
      'H': ['CAT', 'CAC'], 'Q': ['CAA', 'CAG'], 'R': ['CGT', 'CGC', 'CGA', 'CGG', 'AGA', 'AGG'],
      'I': ['ATT', 'ATC', 'ATA'], 'M': ['ATG'], 'T': ['ACT', 'ACC', 'ACA', 'ACG'],
      'N': ['AAT', 'AAC'], 'K': ['AAA', 'AAG'], 'V': ['GTT', 'GTC', 'GTA', 'GTG'],
      'A': ['GCT', 'GCC', 'GCA', 'GCG'], 'D': ['GAT', 'GAC'], 'E': ['GAA', 'GAG'],
      'G': ['GGT', 'GGC', 'GGA', 'GGG'], '*': ['TAA', 'TAG', 'TGA']
    };
  
    const aminoAcids = Object.keys(codonUsage).filter(aa => aa !== '*');
    let sequence = '';
    
    const targetCodons = Math.floor(length / 3);
    for (let i = 0; i < targetCodons; i++) {
      const aa = aminoAcids[Math.floor(Math.random() * aminoAcids.length)];
      const codons = codonUsage[aa as keyof typeof codonUsage];
      const codon = codons[Math.floor(Math.random() * codons.length)];
      sequence += codon;
    }
    
    return sequence.substring(0, length);
  }