-MadData_2026-MadNote

MadNote is an AI-Powered recommendation platform designed to transform how you find and read papers. important features: Discover-For-You, AI Summaries & Paper Chat, Global Knowledge Graph.

Comment

Inspiration

MadNote started from a simple frustration: research discovery is noisy, overwhelming, and often disconnected from personal intent. Traditional feeds surface volume, not relevance. We wanted to build a paper exploration experience that feels curated, interactive, and adaptive from the first click.

The idea was to combine:

  • A social-style paper card interface for fast scanning.
  • A guided “bubble onboarding” to capture user interests.
  • A recommendation layer that is explainable (topic + keyword based), not a black box.
  • A paper-level assistant (“Ask Paper”) to turn reading into dialogue.

What it does

MadNote is an AI-powered research discovery platform with a backend-driven data flow.

Core capabilities:

  • Dynamic feed from backend APIs (no front-end JSON/CSV loading in runtime).
  • Category chips and search both powered by backend endpoints.
  • “Discover For You” mode:
    • Multi-round bubble selection (topic -> seed keywords -> expanded keywords).
    • Personalized ranking using weighted scoring.
    • Focused result view (top matches only) with highlight styling.
  • Paper detail modal:
    • AI breakdown + original abstract tabs.
    • Read PDF jump.
    • Knowledge graph modal for similarity navigation.
    • Ask Paper chat connected to backend.
  • Auth + interactions:
    • Sign up / sign in / session restore.
    • Like/save/comment APIs.
    • Profile page with liked/saved views.

How we built it

Frontend:

  • React + Vite + Context architecture:
    • AuthContext for session/auth state.
    • PostsContext for feed/search/category/recommendation state.
    • ThemeContext for visual mode.
  • Major UI modules:
    • Header navigation with category and Discover For You controls.
    • Intro overlay for bubble-based onboarding.
    • Masonry/row layouts for feed and recommendation focus.
    • Post modal with comments, graph, and chat panel.

Backend:

  • FastAPI service with modular data loading:
    • Unified data source through backend/database.py.
    • Merged metadata: abstracts, categories, keywords, URLs, interactions.
  • Recommendation APIs:
    • /api/v1/recommend/for-you
    • /api/v1/recommend/keywords
    • /api/v1/recommend/keywords/expand
  • Weighted ranking:
    • score = 0.45 * topic_match + 0.35 * keyword_overlap + 0.15 * freshness + 0.05 * popularity
  • Auth/session with cookie + token handling.
  • Chat API:
    • /api/v1/papers/{paper_id}/chat
    • chatbox.py refactored from CLI into reusable service logic.

Deployment:

  • Vercel (frontend) + Render (backend).
  • Environment-based API URL and CORS/cookie settings for cross-origin auth.

Challenges we ran into

  • Data alignment drift between frontend fields and backend schema after merges/pulls.
  • Cross-origin login issues in deployment:
    • Missing VITE_API_URL.
    • CORS origin mismatch across changing Vercel URLs.
    • Cookie SameSite/Secure behavior in cross-site contexts.
  • Runtime dependency fragility:
    • Optional sklearn import initially blocked backend startup.
  • UI behavior consistency:
    • Overlay/bubble reopening rules.
    • Graph initial zoom too aggressive.
    • Profile-route navigation chips not redirecting to feed.
  • Incremental refactors with active code changes from multiple contributors.

Accomplishments that we're proud of

  • Achieved backend-first data pipeline across feed, search, category, interactions, and recommendation.
  • Built a multi-round intent-capture flow (bubble onboarding) tied to real keyword signals.
  • Delivered a distinct “Discover For You” experience instead of just another filtered feed.
  • Implemented paper chat API integration with robust fallback/error handling.
  • Stabilized deployment behavior for local + cloud environments without breaking developer workflow.
  • Iteratively improved UI coherence while preserving existing product functionality.

What we learned

  • Recommendation quality depends as much on input capture UX as on ranking math.
  • “Small” deployment details (CORS, cookie policy, env injection) can dominate user-perceived reliability.
  • Optional dependencies should never block core service boot.
  • For collaborative projects, defensive integration patterns (fallback fields, resilient imports, clear API contracts) are essential.
  • UI polish and state management bugs often reveal deeper architecture assumptions.

What's next for -MadData_2026-MadNote

  • Move from heuristic recommendation to hybrid retrieval + learning-to-rank.
  • Persist user preference vectors server-side (instead of session-only onboarding state).
  • Add explanation cards per recommendation (“why this paper” with score breakdown).
  • Improve graph performance and progressive loading for large node sets.
  • Add chat memory persistence per user + paper.
  • Expand evaluation:
    • Offline ranking metrics (NDCG/Recall@K).
    • Online UX metrics (time-to-first-relevant-paper, save/like lift).
  • Harden production:
    • Automated env/config checks.
    • Health and observability dashboards.
    • End-to-end CI tests for auth/search/recommend/chat flows.
Share this project:

Updates