Text Summarizer: Intelligent Content Compression with Dynamic Ratios

Code Example:

async function summarizeArticle() {
  const article = `
    Artificial intelligence has transformed software development...
    [1,200 words of content]
  `;

  const response = await fetch('https://apphighway.com/api/v1/text-summarizer', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      text: article,
      compression_ratio: 0.25, // 25% of original length
      extract_key_phrases: true,
      key_phrase_count: 10,
      include_quality_scores: true
    }),
  });
  const result = await response.json();

  console.log('Summary:', result.summary);
  console.log('Original length:', article.split(' ').length, 'words');
  console.log('Summary length:', result.summary.split(' ').length, 'words');
  console.log('\nKey Phrases:');
  result.key_phrases.forEach((phrase, i) => {
    console.log(`${i + 1}. ${phrase.phrase} (score: ${phrase.score})`);
  });
  console.log('\nQuality Scores:');
  console.log('- Coherence:', result.quality.coherence);
  console.log('- Coverage:', result.quality.coverage);
  console.log('- Conciseness:', result.quality.conciseness);
  console.log('- Overall:', result.quality.overall);
}

summarizeArticle();

Code Example:

async function summarizeNewsArticles() {
  const articles = [
    {
      id: 'article-1',
      title: 'Tech Company Announces New AI Model',
      content: '...', // 800 words
      source: 'TechNews',
      published_at: '2025-01-07'
    },
    {
      id: 'article-2',
      title: 'Industry Experts React to AI Breakthrough',
      content: '...', // 650 words
      source: 'AIDaily',
      published_at: '2025-01-07'
    },
    // ... 8 more articles
  ];

  const response = await fetch('https://apphighway.com/api/v1/text-summarizer/multi', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      documents: articles.map(a => ({
        id: a.id,
        text: a.content,
        metadata: {
          title: a.title,
          source: a.source,
          date: a.published_at
        }
      })),
      compression_ratio: 0.25,
      enable_cross_document_analysis: true,
      identify_contradictions: true,
      extract_common_themes: true
    }),
  });
  const result = await response.json();

  console.log('Unified Summary:', result.unified_summary);
  console.log('\nCommon Themes:');
  result.themes.forEach(theme => {
    console.log(`- ${theme.name}: ${theme.description}`);
    console.log(`  Mentioned in: ${theme.document_ids.join(', ')}`);
  });
  console.log('\nAgreements:');
  result.agreements.forEach(agreement => {
    console.log(`- ${agreement.statement}`);
    console.log(`  Sources: ${agreement.document_ids.join(', ')}`);
  });
  console.log('\nContradictions:');
  result.contradictions.forEach(contradiction => {
    console.log(`- Topic: ${contradiction.topic}`);
    console.log(`  View A: ${contradiction.view_a.statement}`);
    console.log(`    (${contradiction.view_a.document_ids.join(', ')})`);
    console.log(`  View B: ${contradiction.view_b.statement}`);
    console.log(`    (${contradiction.view_b.document_ids.join(', ')})`);
  });

  // Optional: Get individual summaries for each document
  if (result.individual_summaries) {
    console.log('\nIndividual Summaries:');
    result.individual_summaries.forEach(summary => {
      console.log(`\n${summary.metadata.title}:`);
      console.log(summary.summary);
    });
  }
}

Code Example:

async function summarizeWithQualityGuarantee() {
  const document = await fetchLongDocument(); // 5,000 words

  const response = await fetch('https://apphighway.com/api/v1/text-summarizer', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      text: document,
      target_word_count: 500, // Instead of ratio, specify exact length
      auto_optimize: true, // Enable automatic quality adjustment
      min_quality_score: 85, // Minimum acceptable overall quality
      preserve_transitions: true, // Better coherence
      multi_topic_mode: true, // Better coverage for complex docs
      max_iterations: 3, // Maximum optimization attempts
      include_quality_scores: true
    }),
  });
  const result = await response.json();

  const actualLength = result.summary.split(' ').length;
  
  console.log('Target length: 500 words');
  console.log('Actual length:', actualLength, 'words');
  console.log('Quality score:', result.quality.overall);
  
  if (actualLength > 500) {
    console.log(`\nNote: Summary is ${actualLength - 500} words longer than target`);
    console.log('to maintain quality score above', result.min_quality_score);
  }

  // Check if quality meets requirements
  if (result.quality.overall < 85) {
    console.warn('Warning: Could not achieve target quality!');
    console.warn('Consider reducing compression or adjusting min_quality_score');
    
    // Analyze which dimension is weakest
    const scores = result.quality;
    const weakest = Object.entries(scores)
      .filter(([key]) => key !== 'overall')
      .sort((a, b) => a[1] - b[1])[0];
    
    console.warn(`Weakest dimension: ${weakest[0]} (${weakest[1]})`);
  }
}

Code Example:

async function batchSummarizeWithTracking() {
  const documents = await fetchDocumentBatch(); // 100 documents
  const batchSize = 10; // Process 10 at a time
  const results: any[] = [];
  const errors: any[] = [];

  async function summarizeText(text, options = {}) {
    const response = await fetch('https://apphighway.com/api/v1/text-summarizer', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.APPHIGHWAY_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ text, ...options }),
    });
    return response.json();
  }

  console.log(`Processing ${documents.length} documents in batches of ${batchSize}...`);

  for (let i = 0; i < documents.length; i += batchSize) {
    const batch = documents.slice(i, i + batchSize);
    const batchNum = Math.floor(i / batchSize) + 1;
    const totalBatches = Math.ceil(documents.length / batchSize);

    console.log(`\nProcessing batch ${batchNum}/${totalBatches}...`);

    try {
      const promises = batch.map(async (doc, idx) => {
        try {
          const result = await summarizeText(doc.content, {
            compression_ratio: 0.25,
            extract_key_phrases: true,
            key_phrase_count: 5,
            include_quality_scores: true
          });

          return {
            id: doc.id,
            success: true,
            summary: result.summary,
            key_phrases: result.key_phrases,
            quality: result.quality.overall,
            original_length: doc.content.split(' ').length,
            summary_length: result.summary.split(' ').length
          };
        } catch (error: any) {
          return {
            id: doc.id,
            success: false,
            error: error.message
          };
        }
      });

      const batchResults = await Promise.all(promises);
      
      // Separate successes and failures
      batchResults.forEach(result => {
        if (result.success) {
          results.push(result);
        } else {
          errors.push(result);
        }
      });

      const progress = ((i + batch.length) / documents.length * 100).toFixed(1);
      console.log(`Progress: ${progress}% (${results.length} succeeded, ${errors.length} failed)`);

      // Rate limiting: wait 1 second between batches
      if (i + batchSize < documents.length) {
        await new Promise(resolve => setTimeout(resolve, 1000));
      }
    } catch (error: any) {
      console.error(`Batch ${batchNum} failed:`, error.message);
      // Continue with next batch
    }
  }

  // Generate summary report
  console.log('\n=== Summary Report ===');
  console.log(`Total processed: ${documents.length}`);
  console.log(`Successful: ${results.length}`);
  console.log(`Failed: ${errors.length}`);
  
  if (results.length > 0) {
    const avgQuality = results.reduce((sum, r) => sum + r.quality, 0) / results.length;
    const avgCompression = results.reduce((sum, r) => 
      sum + (r.summary_length / r.original_length), 0) / results.length;
    
    console.log(`\nAverage quality score: ${avgQuality.toFixed(1)}`);
    console.log(`Average compression ratio: ${(avgCompression * 100).toFixed(1)}%`);
    
    // Identify low-quality summaries
    const lowQuality = results.filter(r => r.quality < 80);
    if (lowQuality.length > 0) {
      console.log(`\nLow quality summaries (< 80): ${lowQuality.length}`);
      lowQuality.forEach(r => {
        console.log(`- Document ${r.id}: quality ${r.quality}`);
      });
    }
  }

  if (errors.length > 0) {
    console.log('\nFailed documents:');
    errors.forEach(e => {
      console.log(`- Document ${e.id}: ${e.error}`);
    });
  }

  return { results, errors };
}