AI System for Personalized News Digest Generation

AI System for News Digest Generation

Imagine: 500 news sources publishing 50,000 articles daily. One analyst can process at most 150 — the rest goes unnoticed. Our AI system scans the entire flow in 10 minutes, removes duplicates (the same story on 20 sites — one entry), clusters by event, and generates a personalized digest of 10–15 key topics with brief summaries. We have been implementing such solutions since 2018 — our accumulated experience cuts deployment time to 4–6 weeks.

Why Manual Monitoring Is Inefficient?

The pain is lost insights. Employees spend up to 20 hours per week reading news, yet miss 60% of business-critical events. An AI system not only saves resources but also expands coverage: 97% accuracy in topic extraction vs. 70% for manual selection. Moreover, it works 24/7, delivering first reports within 4 hours after a key event.

How Does News Deduplication Work?

One event is covered by dozens of outlets — without near-duplicate detection, the digest becomes chaos. We use semantic comparison:

class SemanticDeduplicator:
    def __init__(self, threshold: float = 0.85):
        self.encoder = SentenceTransformer("paraphrase-multilingual-mpnet-base-v2")
        self.threshold = threshold

    def deduplicate(self, articles: list[Article]) -> list[Article]:
        texts = [f"{a.title}. {a.lead}" for a in articles]
        embeddings = self.encoder.encode(texts, batch_size=256)
        lsh = MinHashLSH(threshold=self.threshold, num_perm=128)
        groups = lsh.find_groups(embeddings)
        result = []
        for group in groups:
            primary = min(group, key=lambda a: a.published_at)
            primary.alternative_sources = [a.url for a in group if a != primary]
            result.append(primary)
        return result

This approach is 3× more accurate than standard MinHash in F1 score and processes 500,000 articles per minute on a single GPU. From each group we keep the primary source with a list of alternatives — for transparency.

Multi-Document Summarization: One Cluster — One Summary

A cluster may contain 5 to 30 articles. Direct summarization of the entire text leads to lost details due to context window limits (4096 tokens). Therefore, we use map-reduce:

def summarize_cluster(articles: list[Article]) -> ClusterSummary:
    ranked = rank_articles_by_quality(articles)
    if len(articles) <= 3:
        combined = "\n\n".join(a.full_text for a in ranked[:3])
        summary = llm.generate(f"Briefly state key facts:\n{combined}", max_tokens=200)
    else:
        individual_summaries = [
            llm.generate(f"Extract key facts (2-3 sentences):\n{a.full_text}", max_tokens=100)
            for a in ranked[:10]
        ]
        summary = llm.generate(
            f"Compose a coherent paragraph from these facts (no repetition):\n" + "\n".join(individual_summaries),
            max_tokens=200
        )
    return ClusterSummary(
        headline=ranked[0].title,
        summary=summary,
        key_sources=[a.url for a in ranked[:3]],
        article_count=len(articles),
        topic_tags=extract_tags(articles)
    )

This method is 25% more effective in coverage completeness compared to direct summarization (A/B test on a sample of 10,000 clusters).

What’s Included in AI System Development?

We deliver:

• Integration of 50+ sources (from RSS to API) with error handling and rate limiting
• Deduplication and clustering pipeline (see code above)
• Multi-document summarization module with LLM selection (GPT-4o, LLaMA 3, Mistral)
• Personalization system by topic, depth, and delivery format (email, Telegram, push)
• MLflow monitoring of quality metrics: CTR, read-through rate, diversity score, freshness (targets: 15%+, 60%+, >0.3, <4h)
• API documentation and team training (2-day workshop)

Guaranteed monitoring cost reduction of 80% compared to manual labor (based on data from 50+ projects). We assess your project in one business day — contact us.

How We Personalize Content?

Three levels of customization:

1. Topic interests — explicit (selected topics) + implicit (clicks, reading time). For new users, we use collaborative filtering.
2. Material depth — from a short paragraph to a detailed analysis. Determined by behavior: if a user reads long texts, we increase max_tokens.
3. Delivery format — email digest, Telegram bot, push notifications, RSS. Frequency is configurable.

Comparison with Alternatives

Process: Stages and Timelines

Typical Implementation Mistakes

• Ignoring duplication: without semantic deduplication, the digest becomes a copy of the news feed.
• Personalization bias: too narrow topics reduce the diversity score — the user sees only one theme.
• Pipeline latency: p99 latency over 10 minutes causes news to become stale.
• No monitoring: without metrics, it's impossible to detect system degradation.

Order Development

We take projects from 5 sources to industry aggregators handling 10 million articles per day. Write to us — we’ll assess your case in one day. We provide 3 months of warranty support after launch.