MCP Sequence Simulation Server

Instructions

Implementation Reference

• src/tools/generateProtein.ts:47-124 (handler)

  The main handler function that generates protein sequences. It supports multiple generation models (random, hydrophobic-bias, disorder-prone), custom amino acid composition, and output formats (fasta, plain). Returns sequence data with statistics including hydrophobic, charged, and aromatic ratios.
  async handler({ length, count = 1, seed, model = "random", composition, outputFormat = "fasta" }: { length: number; count?: number; seed?: number; model?: string; composition?: Record<string, number>; outputFormat?: string; }) { const generator = new SequenceGenerator(seed); const sequences = []; for (let i = 0; i < count; i++) { let sequence: string; switch (model) { case "random": if (composition) { sequence = generateCustomComposition(length, composition, generator); } else { sequence = generator.generateRandomProtein(length); } break; case "hydrophobic-bias": sequence = generateHydrophobicBiased(length, generator); break; case "disorder-prone": sequence = generateDisorderProne(length, generator); break; default: sequence = generator.generateRandomProtein(length); } const analysis = analyzeProtein(sequence); sequences.push({ id: `sim_protein_${i + 1}`, sequence, length: sequence.length, model, ...analysis }); } let output = ''; if (outputFormat === 'fasta') { output = sequences.map(seq => `>${seq.id} length=${seq.length} hydrophobic=${seq.hydrophobicRatio}% 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), averageHydrophobic: Math.round(sequences.reduce((sum, seq) => sum + seq.hydrophobicRatio, 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/generateProtein.ts:4-46 (schema)

  Tool definition with input schema specifying parameters: length (required), count, seed, model (random/hydrophobic-bias/disorder-prone), composition (custom amino acid frequencies), and outputFormat (fasta/plain).
  export const generateProtein = { definition: { name: "generate_protein_sequence", description: "Generate random protein sequences with specified parameters", inputSchema: { type: "object", properties: { length: { type: "number", description: "Length of the protein sequence to generate" }, 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', 'hydrophobic-bias', or 'disorder-prone'", enum: ["random", "hydrophobic-bias", "disorder-prone"] }, composition: { type: "object", description: "Custom amino acid composition (frequencies should sum to 1)", additionalProperties: { type: "number", minimum: 0, maximum: 1 } }, outputFormat: { type: "string", description: "Output format: 'fasta' or 'plain'", enum: ["fasta", "plain"] } }, required: ["length"] }, },
• src/server.ts:57-65 (registration)

  Registration of the generate_protein_sequence tool in the server's request handler. Routes tool calls to the generateProtein.handler function with type-safe argument casting.
  case "generate_protein_sequence": return await generateProtein.handler(args as { length: number; count?: number; seed?: number; model?: string; composition?: Record<string, number>; outputFormat?: string; });
• src/tools/generateProtein.ts:146-180 (helper)

  Helper functions generateHydrophobicBiased and generateDisorderProne that implement specialized protein generation models with biased amino acid selection.
  function generateHydrophobicBiased(length: number, generator: SequenceGenerator): string { const hydrophobic = ['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W']; const hydrophilic = ['R', 'N', 'D', 'C', 'Q', 'E', 'G', 'H', 'K', 'P', 'S', 'T']; let sequence = ''; for (let i = 0; i < length; i++) { if (Math.random() < 0.6) { sequence += hydrophobic[Math.floor(Math.random() * hydrophobic.length)]; } else { sequence += hydrophilic[Math.floor(Math.random() * hydrophilic.length)]; } } return sequence; } function generateDisorderProne(length: number, generator: SequenceGenerator): string { const disorderProne = ['A', 'R', 'G', 'Q', 'S', 'P', 'E', 'K']; const orderProne = ['V', 'I', 'Y', 'F', 'W', 'L']; const neutral = ['N', 'D', 'C', 'H', 'M', 'T']; let sequence = ''; for (let i = 0; i < length; i++) { const rand = Math.random(); if (rand < 0.5) { sequence += disorderProne[Math.floor(Math.random() * disorderProne.length)]; } else if (rand < 0.75) { sequence += neutral[Math.floor(Math.random() * neutral.length)]; } else { sequence += orderProne[Math.floor(Math.random() * orderProne.length)]; } } return sequence; }
• src/tools/generateProtein.ts:182-215 (helper)

  Helper function analyzeProtein that computes sequence statistics including hydrophobic ratio, charged ratio, aromatic ratio, and amino acid composition percentages.
  function analyzeProtein(sequence: string): { hydrophobicRatio: number; chargedRatio: number; aromaticRatio: number; composition: Record<string, number>; } { const hydrophobic = new Set(['A', 'V', 'I', 'L', 'M', 'F', 'Y', 'W']); const charged = new Set(['R', 'K', 'D', 'E']); const aromatic = new Set(['F', 'Y', 'W']); const composition: Record<string, number> = {}; let hydrophobicCount = 0; let chargedCount = 0; let aromaticCount = 0; for (const aa of sequence) { composition[aa] = (composition[aa] || 0) + 1; if (hydrophobic.has(aa)) hydrophobicCount++; if (charged.has(aa)) chargedCount++; if (aromatic.has(aa)) aromaticCount++; } return { hydrophobicRatio: Math.round((hydrophobicCount / sequence.length) * 10000) / 100, chargedRatio: Math.round((chargedCount / sequence.length) * 10000) / 100, aromaticRatio: Math.round((aromaticCount / sequence.length) * 10000) / 100, composition: Object.fromEntries( Object.entries(composition).map(([aa, count]) => [ aa, Math.round((count / sequence.length) * 10000) / 100 ]) ) }; }