TranscriptionTools MCP Server

Instructions

Implementation Reference

• src/tools/summary.ts:19-167 (handler)

  The primary handler function for the 'summary_text' tool. It processes input text (direct or from file), applies configurable constraints (time, chars, words), and generates a summary using simulated ACE cognitive methodology: priming, comprehension, context clarification, expansion, and recursive refinement stages. Uses sentence importance scoring and selection to meet target lengths.
  export async function summaryText(params: SummaryTextParams): Promise<{ summary: string }> { try { const { input_text, is_file_path = false, constraint_type = null, constraint_value = null } = params; // Resolve content (either direct text or from file) const textContent = await FileHandler.resolveTextContent(input_text, is_file_path); // Create a session ID and logger const logger = new Logger(); const sessionId = logger.getSessionId(); // In a real implementation, this would be a sophisticated NLP pipeline // using deep learning models for summarization. Here we'll simulate the process. // ACE-Driven Processing // Step 1: Priming Stage const contentLength = textContent.length; const wordCount = textContent.split(/\s+/).length; // Determine target length based on constraint let targetLength: number; if (constraint_type === 'time') { // Base rate: 150 words/minute const baseRate = 150; targetLength = constraint_value ? constraint_value * baseRate / 60 : wordCount * 0.3; } else if (constraint_type === 'chars') { targetLength = constraint_value ? constraint_value : contentLength * 0.3; } else if (constraint_type === 'words') { targetLength = constraint_value ? constraint_value : wordCount * 0.3; } else { // Default constraint: 30% of original targetLength = wordCount * 0.3; } // Simulate domain context identification const primingFactors = [ 'Document length analysis', 'Content type recognition', 'Terminological evaluation', 'Priority patterns identified' ]; // Step 2: Comprehension Stage const paragraphs = textContent.split(/\n\n+/); // Simulate comprehension metrics const comprehensionMetrics = { coreThemeCount: Math.min(5, paragraphs.length), relationshipNodes: paragraphs.length * 2, causalChains: Math.floor(paragraphs.length / 2), hierarchyLevels: 3 }; // Step 3: Context Clarification Stage const sentences = textContent.match(/[^.!?]+[.!?]+/g) || []; // Map importance scores to sentences (simulated) const sentenceScores = sentences.map((sentence, index) => { // In a real implementation, this would use NLP models to score importance // Here we'll use position and length as proxies for importance const positionScore = 1 - (index / sentences.length); // Early sentences get higher scores const lengthScore = Math.min(1, sentence.length / 100); // Longer sentences (up to a point) get higher scores return { sentence, score: (positionScore * 0.7) + (lengthScore * 0.3) }; }); // Sort by importance score sentenceScores.sort((a, b) => b.score - a.score); // Simulated context maps const contextMaps = { semanticUnits: sentences.length, densityEvaluation: 'Completed', dependencyGraph: 'Generated', narrativeThreads: 'Mapped' }; // Step 4: Expanding Stage // Select top sentences based on constraint let selectedSentences: string[] = []; let currentLength = 0; const targetMetric = constraint_type === 'chars' ? 'chars' : 'words'; // Keep adding sentences until we hit the target length for (const item of sentenceScores) { const sentenceLength = targetMetric === 'chars' ? item.sentence.length : item.sentence.split(/\s+/).length; if (currentLength + sentenceLength <= targetLength) { selectedSentences.push(item.sentence); currentLength += sentenceLength; } else if (selectedSentences.length === 0) { // Always include at least one sentence selectedSentences.push(item.sentence); break; } else { break; } } // Step 5: Recursive Stage // In a real implementation, this would iteratively refine the summary // For simulation, we'll just reorder the sentences to follow the original text flow // Get original order of selected sentences const sentenceIndexes = selectedSentences.map(sentence => { return sentences.findIndex(s => s === sentence); }); // Sort by original position const sortedIndexes = [...sentenceIndexes].sort((a, b) => a - b); selectedSentences = sortedIndexes.map(index => { return sentences[index]; }); // Join the selected sentences to form the summary let summary = selectedSentences.join(' ').trim(); // Simulate refinement const expansionIterations = 3; const recursiveOptimizations = 2; // Log the summary process const constraintDetails = { type: constraint_type, target: constraint_value, achieved: currentLength }; const processStats = { primingFactors, comprehensionMetrics, contextMaps, expansionIterations, recursiveOptimizations }; await logger.logSummaryProcess(constraintDetails, processStats); return { summary }; } catch (error) { throw new Error(`Summary process failed: ${error instanceof Error ? error.message : String(error)}`); } }
• src/tools/summary.ts:7-12 (schema)

  TypeScript interface defining the input parameters for the summaryText handler.
  export interface SummaryTextParams { input_text: string; is_file_path?: boolean; constraint_type?: 'time' | 'chars' | 'words' | null; constraint_value?: number | null; }
• src/index.ts:117-144 (registration)

  Tool registration in the ListToolsRequestSchema handler, defining name, description, and JSON inputSchema matching SummaryTextParams.
  { name: 'summary_text', description: 'Generates intelligent summaries using ACE cognitive methodology', inputSchema: { type: 'object', properties: { input_text: { type: 'string', description: 'Text to summarize or path to file' }, is_file_path: { type: 'boolean', description: 'Whether input_text is a file path', default: false }, constraint_type: { type: 'string', enum: ['time', 'chars', 'words', null], description: 'Type of constraint to apply' }, constraint_value: { type: 'number', description: 'Value for the specified constraint' } }, required: ['input_text'] } }
• src/index.ts:200-213 (registration)

  Dispatch case in the CallToolRequestSchema handler that validates arguments and invokes the summaryText handler, returning the summary as MCP content.
  case 'summary_text': // Validate required parameters if (!args || typeof args.input_text !== 'string') { throw new McpError(ErrorCode.InvalidParams, 'Missing required parameter: input_text'); } const summaryResult = await summaryText(args as unknown as SummaryTextParams); return { content: [ { type: 'text', text: summaryResult.summary } ] };
• src/index.ts:120-143 (schema)

  JSON schema for input validation in the tool registration, mirroring the SummaryTextParams interface.
  inputSchema: { type: 'object', properties: { input_text: { type: 'string', description: 'Text to summarize or path to file' }, is_file_path: { type: 'boolean', description: 'Whether input_text is a file path', default: false }, constraint_type: { type: 'string', enum: ['time', 'chars', 'words', null], description: 'Type of constraint to apply' }, constraint_value: { type: 'number', description: 'Value for the specified constraint' } }, required: ['input_text'] }