SceneMate

Find a movie everyone can agree on. SceneMate uses explainable, constraint-aware recommendations and real MCP tool calls to help households choose their next movie night together.

Comment

Inspiration

Movie night should be the easy part of spending time together. Choosing what to watch often isn't. One person wants comedy, another prefers sci-fi, and everyone has different limits on runtime, age suitability, and accessibility.

I wanted to explore a simple question: Can a recommendation system help a group reach a fair compromise instead of simply picking the highest-scoring title?

That idea became SceneMate, a household movie-night assistant built around Harmony, a deterministic recommendation engine designed to balance individual preferences while respecting shared constraints.

What it does

SceneMate helps a household find a movie that works for everyone.

  • Personalized recommendations: Combines household preferences and individual viewer tastes to rank candidate titles.
  • Hard constraints first: Excludes titles that violate the configured runtime limit, age-rating requirements, or required accessibility features.
  • Explainable ranking: Shows the factors behind a recommendation, including individual genre fit and trade-offs between viewers.
  • Balanced decisions: Gives extra weight to the least-satisfied participant, so one person's strong match doesn't automatically make a title the best household choice.
  • Head-to-head comparison: Lets users compare promising titles under the same household preferences and constraints.
  • Persistent watchlist: Allows users to save and remove choices, with changes retained across reloads.
  • Real MCP integration: Connects the browser interface to a Model Context Protocol (MCP) server over Streamable HTTP, making actual tool calls rather than simulating them in the UI.

The catalog is fictional, so the project demonstrates the recommendation and decision-making experience rather than claiming real-world streaming availability.

How I built it

I built SceneMate as a full-stack application with a React and Vite frontend and a Node.js MCP server written in TypeScript.

The browser communicates with the server through a Vite proxy. The MCP client flow includes initialization, tool discovery, and tool execution over Streamable HTTP. The server exposes tools for catalog search, recommendations, household preferences, watchlist management, and preference updates.

I kept the recommendation logic in a shared package so the scoring rules can be tested independently of the interface. Harmony first applies hard eligibility constraints, then ranks eligible titles using preference-fit signals and household balance. The interface presents the result alongside structured explanations, allowing users to inspect the reasoning rather than treating the recommendation as a black box.

I also implemented persistent storage with a local file-backed option and an optional S3 adapter. The local workflow was tested; the S3 adapter was mock-tested but has not been verified against live AWS.

Challenges I faced

Balancing individual preferences fairly. A simple average can hide the fact that one person is poorly served by a recommendation. I designed Harmony to give additional weight to the weakest participant's fit, making compromise a deliberate part of the ranking logic.

Separating requirements from preferences. A title that violates a hard requirement should not become eligible just because it scores highly elsewhere. I separated eligibility checks from ranking and made exclusions visible so users can understand why a title did not qualify.

Making MCP integration real and inspectable. Connecting a UI to an MCP server is more meaningful when the interaction is observable. I implemented the actual initialization, tool-listing, and tool-call flow over Streamable HTTP and surfaced activity so the request and response can be inspected.

Making state changes reliable. Saving and removing watchlist entries needed to work beyond a temporary UI update. I added persistence and tests around storage behavior, including failure handling, so the interface only reflects a change when the operation succeeds.

What I learned

This project reinforced that a useful recommendation system is not just about producing a score. It is about defining what must never be violated, deciding how to balance competing preferences, and making the trade-offs understandable to the people affected by the decision.

I also learned to treat protocol integration, persistence, and failure behavior as first-class parts of the product—not just implementation details behind a polished interface. Deterministic scoring and automated tests made the system easier to reason about and verify.

What's next

The next steps are to evaluate Harmony with more diverse household scenarios, improve how soft preferences such as mood are represented, and validate the optional S3 storage path against a real AWS environment. The current demo uses a fictional catalog and transparent, rule-based scoring rather than claiming to predict personal enjoyment.

SceneMate is an experiment in making shared decisions clearer, fairer, and easier to explain. Less arguing. Better movie nights.

Built With

Share this project:

Updates

Submission history