这是参加Redis AI 挑战赛：实时 AI 创新者的参赛作品。
NewsHub是一个智能新闻聚合平台，它彻底改变了用户发现和消费新闻内容的方式。NewsHub 以 Redis 8 作为核心实时数据层，结合了人工智能的强大功能和 Redis 的先进特性，提供个性化、情境相关的新闻体验。
这是我第一次使用 Redis，学习曲线虽然陡峭，但收获颇丰。我发现 Redis 远不止是一个缓存——它是一个功能强大的多模型平台，能够处理复杂的 AI 工作负载。构建 NewsHub 让我明白了 Redis 如何集主数据库、向量搜索引擎和实时分析平台于一体。
人工智能驱动的内容智能
高级搜索与发现
智能个性化
实时分析与洞察
性能与可扩展性
NewsHub 采用现代微服务架构，以 Redis 8 作为核心智能层。该系统旨在实现高性能、可扩展性和实时 AI 处理。
Varshithvhegde /新闻中心
NewsHub是一个现代化的全栈新闻聚合和摘要平台，采用React、TypeScript、Node.js和Redis构建。它利用Google Gemini AI和Redis向量搜索，为用户提供AI驱动的新闻摘要、个性化信息流和高级搜索功能。
主仪表盘包含人工智能精选新闻，并附有情感指标、互动指标和个性化推荐。
强大的搜索功能，可按主题和情感进行实时筛选
提供文章详情视图，包括人工智能生成的摘要、情感分析和相似文章推荐。
由人工智能精心策划的个性化新闻推送，可根据用户偏好和阅读行为自动调整。
基于向量的语义相似度引擎，使用 Redis 向量搜索显示上下文相关的文章。
Redis 8 是 NewsHub 智能功能的主要实时数据层。我之前主要使用传统数据库，学习 Redis 让我大开眼界。我发现 Redis 能够在处理复杂的 AI 工作负载的同时，保持卓越的性能。
这是我使用 Redis 过程中最具挑战性的部分。如何实现向量搜索和语义相似度对我来说完全是全新的领域，但结果却令人惊艳。
// redisService.js - Vector Search Implementation
class RedisService {
async createVectorIndex() {
try {
// Create vector search index for semantic similarity
await this.client.ft.create('news:vector_index', {
'$.title': 'TEXT',
'$.content': 'TEXT',
'$.embedding': 'VECTOR',
'$.sentiment': 'TAG',
'$.topic': 'TAG',
'$.source': 'TAG',
'$.publishedAt': 'NUMERIC'
}, {
ON: 'JSON',
PREFIX: 'news:articles:',
FILTER: '@publishedAt:[0 +inf]',
SCHEMA: {
'$.title': { type: 'TEXT', WEIGHT: 2.0 },
'$.content': { type: 'TEXT', WEIGHT: 1.0 },
'$.embedding': {
type: 'VECTOR',
DIM: 768,
DISTANCE_METRIC: 'COSINE',
TYPE: 'FLOAT32'
},
'$.sentiment': { type: 'TAG' },
'$.topic': { type: 'TAG' },
'$.source': { type: 'TAG' },
'$.publishedAt': { type: 'NUMERIC' }
}
});
console.log('✅ Vector search index created successfully');
} catch (error) {
console.log('Vector index already exists or error:', error.message);
}
}
async findSimilarArticles(articleId, limit = 10) {
try {
// Get article embedding
const article = await this.client.json.get(`news:articles:${articleId}`);
if (!article || !article.embedding) {
throw new Error('Article or embedding not found');
}
// Vector similarity search
const query = `*=>[KNN $k @embedding $embedding AS score]`;
const params = {
k: limit,
embedding: article.embedding
};
const results = await this.client.ft.search('news:vector_index', query, {
PARAMS: params,
RETURN: ['$.title', '$.content', '$.sentiment', '$.topic', 'score'],
SORTBY: 'score',
DIALECT: 2
});
return results.documents.map(doc => ({
id: doc.id.replace('news:articles:', ''),
title: doc.value['$.title'],
content: doc.value['$.content'],
sentiment: doc.value['$.sentiment'],
topic: doc.value['$.topic'],
similarity: doc.value.score
}));
} catch (error) {
console.error('Error finding similar articles:', error);
throw error;
}
}
}
学习使用 Redis 作为主数据库是一次范式转变。它能够存储复杂的 JSON 文档，同时还能保持全文搜索功能，这简直太棒了。
// redisService.js - JSON Storage Implementation
class RedisService {
async storeArticle(article) {
try {
const articleId = `news:articles:${article.id}`;
// Store article as JSON with full-text search capabilities
await this.client.json.set(articleId, '$', {
id: article.id,
title: article.title,
content: article.content,
summary: article.summary,
sentiment: article.sentiment,
topic: article.topic,
source: article.source,
url: article.url,
publishedAt: article.publishedAt,
embedding: article.embedding,
keywords: article.keywords,
metadata: {
wordCount: article.wordCount,
readingTime: article.readingTime,
language: article.language
}
});
// Create search index for full-text search
await this.createSearchIndex();
console.log(`✅ Article stored: ${articleId}`);
return article.id;
} catch (error) {
console.error('Error storing article:', error);
throw error;
}
}
async searchArticles(query, filters = {}) {
try {
let searchQuery = `(@title:${query} | @content:${query} | @summary:${query})`;
// Add filters
if (filters.sentiment) {
searchQuery += ` @sentiment:{${filters.sentiment}}`;
}
if (filters.topic) {
searchQuery += ` @topic:{${filters.topic}}`;
}
if (filters.source) {
searchQuery += ` @source:{${filters.source}}`;
}
if (filters.dateRange) {
searchQuery += ` @publishedAt:[${filters.dateRange.start} ${filters.dateRange.end}]`;
}
const results = await this.client.ft.search('news:search_index', searchQuery, {
RETURN: ['$.title', '$.content', '$.sentiment', '$.topic', '$.source'],
SORTBY: '@publishedAt',
LIMIT: { from: 0, size: 50 }
});
return results.documents.map(doc => ({
id: doc.id.replace('news:articles:', ''),
title: doc.value['$.title'],
content: doc.value['$.content'],
sentiment: doc.value['$.sentiment'],
topic: doc.value['$.topic'],
source: doc.value['$.source']
}));
} catch (error) {
console.error('Error searching articles:', error);
throw error;
}
}
}
理解 Redis 缓存模式对提升性能至关重要。我实现了一种复杂的多层缓存机制，显著提高了响应速度。
// cacheClearService.js - Multi-layer Caching Implementation
class CacheClearService {
constructor(redisClient) {
this.client = redisClient;
this.cacheLayers = {
REQUEST: 'cache:requests:',
QUERY: 'cache:queries:',
RESULT: 'cache:results:',
SIMILARITY: 'cache:similarity:',
USER: 'cache:user:'
};
}
async setCacheWithTTL(key, data, ttl = 3600) {
try {
const cacheKey = `cache:results:${key}`;
await this.client.json.set(cacheKey, '$', {
data: data,
timestamp: Date.now(),
ttl: ttl
});
await this.client.expire(cacheKey, ttl);
console.log(`✅ Cache set: ${cacheKey}`);
} catch (error) {
console.error('Error setting cache:', error);
}
}
async getCache(key) {
try {
const cacheKey = `cache:results:${key}`;
const cached = await this.client.json.get(cacheKey);
if (cached && cached.data) {
console.log(`✅ Cache hit: ${cacheKey}`);
return cached.data;
}
console.log(`❌ Cache miss: ${cacheKey}`);
return null;
} catch (error) {
console.error('Error getting cache:', error);
return null;
}
}
}
正是在个性化系统中，我学习到了 Redis 的高级数据结构。实现从个性化订阅源中自动删除文章的功能，是一次非常宝贵的学习经历。
// redisService.js - User Preferences Implementation
class RedisService {
async storeUserPreferences(userId, preferences) {
try {
const userKey = `user:preferences:${userId}`;
await this.client.hset(userKey, {
topics: JSON.stringify(preferences.topics),
sources: JSON.stringify(preferences.sources),
sentiment: preferences.sentiment,
language: preferences.language,
updatedAt: Date.now()
});
// Set expiration for user preferences (30 days)
await this.client.expire(userKey, 30 * 24 * 60 * 60);
console.log(`✅ User preferences stored: ${userKey}`);
return true;
} catch (error) {
console.error('Error storing user preferences:', error);
throw error;
}
}
async getPersonalizedNews(userId, limit = 20) {
try {
const preferences = await this.getUserPreferences(userId);
if (!preferences) {
return await this.getTrendingArticles(limit);
}
// Build personalized search query
let searchQuery = '*';
const filters = [];
if (preferences.topics.length > 0) {
filters.push(`@topic:{${preferences.topics.join('|')}}`);
}
if (preferences.sources.length > 0) {
filters.push(`@source:{${preferences.sources.join('|')}}`);
}
if (preferences.sentiment) {
filters.push(`@sentiment:{${preferences.sentiment}}`);
}
if (filters.length > 0) {
searchQuery = filters.join(' ');
}
const results = await this.client.ft.search('news:search_index', searchQuery, {
RETURN: ['$.title', '$.content', '$.sentiment', '$.topic', '$.source'],
SORTBY: '@publishedAt',
LIMIT: { from: 0, size: limit }
});
return results.documents.map(doc => ({
id: doc.id.replace('news:articles:', ''),
title: doc.value['$.title'],
content: doc.value['$.content'],
sentiment: doc.value['$.sentiment'],
topic: doc.value['$.topic'],
source: doc.value['$.source']
}));
} catch (error) {
console.error('Error getting personalized news:', error);
throw error;
}
}
// Auto-remove viewed articles from personalized feed
async trackArticleView(userId, articleId) {
try {
// Add to viewed articles set
await this.client.sadd(`user:viewed:${userId}`, articleId);
// Remove from personalized feed
await this.client.srem(`user:personalized:${userId}`, articleId);
// Track engagement metrics
await this.trackEngagement(articleId, 'view');
console.log(`✅ Article view tracked and removed from personalized feed: ${articleId}`);
} catch (error) {
console.error('Error tracking article view:', error);
}
}
}
学习使用 Redis 有序集合来实现热门算法真是太棒了。能够直接在 Redis 中实现时间衰减算法，简直是颠覆性的突破。
// redisService.js - Trending Articles Implementation
class RedisService {
async updateTrendingArticles() {
try {
// Get all articles with engagement metrics
const articles = await this.client.ft.search('news:search_index', '*', {
RETURN: ['$.title', '$.source', '$.publishedAt'],
SORTBY: '@publishedAt',
LIMIT: { from: 0, size: 1000 }
});
const trendingScores = {};
for (const doc of articles.documents) {
const articleId = doc.id.replace('news:articles:', '');
const publishedAt = parseInt(doc.value['$.publishedAt']);
const now = Date.now();
// Calculate trending score based on recency and engagement
const timeDecay = Math.exp(-(now - publishedAt) / (24 * 60 * 60 * 1000)); // 24 hours
const engagementScore = await this.getEngagementScore(articleId);
trendingScores[articleId] = timeDecay * engagementScore;
}
// Store trending articles in sorted set
const trendingKey = 'trending:articles';
await this.client.del(trendingKey); // Clear existing
for (const [articleId, score] of Object.entries(trendingScores)) {
await this.client.zadd(trendingKey, score, articleId);
}
console.log(`✅ Updated trending articles: ${Object.keys(trendingScores).length} articles`);
} catch (error) {
console.error('Error updating trending articles:', error);
throw error;
}
}
async trackEngagement(articleId, action = 'view') {
try {
const engagementKey = `metrics:engagement:${articleId}`;
const actionKey = `${action}:count`;
await this.client.hincrby(engagementKey, actionKey, 1);
await this.client.hset(engagementKey, 'last_updated', Date.now());
// Set expiration for engagement metrics (7 days)
await this.client.expire(engagementKey, 7 * 24 * 60 * 60);
console.log(`✅ Tracked engagement: ${action} for article ${articleId}`);
} catch (error) {
console.error('Error tracking engagement:', error);
}
}
}
在学习 Redis 的过程中，我取得了令人瞩目的性能指标：
缓存性能
向量搜索性能
可扩展性指标
这个项目让我第一次接触到 Redis，它彻底改变了我对数据存储和缓存的看法。我了解到 Redis 不仅仅是一个缓存——它是一个完整的数据平台，能够：
学习曲线非常陡峭，尤其是理解向量搜索和 Redis 的查询语法，但我所取得的性能和能力让我觉得所有的挑战都是值得的。构建 NewsHub 让我明白了 Redis 如何加速 AI 应用，并处理通常需要多个专用系统才能完成的复杂实时工作负载。
NewsHub 展示了 Redis 8 如何为下一代 AI 应用提供强大支持，使其成为一个完整的实时智能平台。向量搜索、JSON 存储、多层缓存和实时分析的结合，打造出无缝、智能的用户体验，能够实时适应用户行为和偏好。
技术栈：React、TypeScript、Node.js、Express、Redis 8、Google Gemini AI、Tailwind CSS
文章来源：https://dev.to/varshithvhegde/newshub-ai-powered-news-aggregation-platform-5c11