Como construir um aplicativo de leitura de feed RSS de Scratch usando IA

npx create-turbo@latest rss-ai-reader
cd rss-ai-reader
# Install core dependencies
pnpm add rss-parser zod @tanstack/react-query
pnpm add -D typescript @types/node

import { z } from 'zod';

const envSchema = z.object({
  OPENAI_API_KEY: z.string().min(1),
  DATABASE_URL: z.string().url(),
  REDIS_URL: z.string().url().optional(),
  NEXT_PUBLIC_APP_URL: z.string().url(),
});

export const env = envSchema.parse(process.env);

import Parser from 'rss-parser';
import { cache } from 'react';

const parser = new Parser({
  customFields: { item: ['media:content', 'content:encoded'] },
});

export const fetchFeed = cache(async (feedUrl: string) => {
  const controller = new AbortController();
  const timeout = setTimeout(() => controller.abort(), 10000);

  try {
    const feed = await parser.parseURL(feedUrl, {
      headers: { 'User-Agent': 'RSS-AI-Reader/1.0' },
      signal: controller.signal,
    });
    return { success: true, data: feed };
  } catch (error) {
    return { success: false, error: error.message };
  } finally {
    clearTimeout(timeout);
  }
});

export interface RawFeedItem {
  id: string;
  title: string;
  link: string;
  pubDate: string;
  content: string;
  feedSource: string;
}

export interface AIEnrichedItem extends RawFeedItem {
  summary?: string;
  tags: string[];
  sentiment?: 'positive' | 'neutral' | 'negative';
  readingTimeMinutes: number;
  duplicateOf?: string;
  relevanceScore?: number; // Personalized ranking
}

import OpenAI from 'openai';

const openai = new OpenAI({ apiKey: env.OPENAI_API_KEY });

export async function generateSummary(content: string, maxLength = 280) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages: [{
      role: 'system',
      content: `You summarize news articles concisely. Output JSON with:
        - summary: ${maxLength}-char max
        - keyPoints: array of 3 bullet strings
        - entities: array of mentioned people/orgs`
    }, {
      role: 'user',
      content: content.slice(0, 8000) // Stay within token limits
    }],
    response_format: { type: 'json_object' },
  });

  return JSON.parse(response.choices[0].message.content);
}

import { embed } from 'ai';
import { cosineSimilarity } from 'ml-distance';

const CATEGORY_EMBEDDINGS = {
  technology: await embed('tech, software, AI, startup...'),
  finance: await embed('markets, investing, crypto...'),
  // ... pre-compute category vectors
};

export async function autoTag(content: string) {
  const contentEmbedding = await embed(content.slice(0, 2000));

  return Object.entries(CATEGORY_EMBEDDINGS)
    .map(([category, vec]) => ({
      category,
      score: cosineSimilarity(contentEmbedding, vec)
    }))
    .filter(({ score }) => score > 0.65)
    .sort((a, b) => b.score - a.score)
    .slice(0, 3)
    .map(({ category }) => category);
}

export function FeedItem({ item }: { item: AIEnrichedItem }) {
  const [expanded, setExpanded] = useState(false);

  return (
    <article className="border rounded-lg p-4 hover:bg-secondary/20">
      <h3 className="font-semibold">{item.title}</h3>
      <div className="flex gap-2 mt-2">
        {item.tags.map(tag => (
          <Badge key={tag} variant="secondary">{tag}</Badge>
        ))}
      </div>

      {item.summary && (
        <p className="text-sm text-muted-foreground mt-2">
          {expanded ? item.content : item.summary}
          <button onClick={() => setExpanded(!expanded)} className="text-primary ml-1">
            {expanded ? 'Show less' : 'Read more'}
          </button>
        </p>
      )}

      <div className="flex items-center gap-3 mt-3 text-xs text-muted-foreground">
        <span>{formatDate(item.pubDate)}</span>
        {item.sentiment && (
          <span className={`sentiment-${item.sentiment}`}>
            {item.sentiment}
          </span>
        )}
      </div>
    </article>
  );
}

export async function updateRelevanceScore(
  userId: string,
  itemId: string,
  feedback: 'up' | 'down'
) {
  // Store feedback in database
  await db.userFeedback.create({ data: { userId, itemId, feedback } });

  // Retrain lightweight ranking model (or trigger batch job)
  // For MVP: adjust scores heuristically
  const multiplier = feedback === 'up' ? 1.2 : 0.8;

  await db.feedItem.update({
    where: { id: itemId },
    data: {
      relevanceScore: {
        multiply: multiplier
      }
    }
  });
}