Angelica AI — Every movie brings you closer to the perfect next one.

Angelica AI is a personalized movie recommendation agent that learns from everything a person watches and continuously predicts what they are most likely to enjoy next.

Instead of offering generic “popular now” suggestions, Angelica builds a dynamic understanding of each user’s viewing behavior. It analyzes movies watched, genres, actors, directors, themes, languages, completion rates, rewatches, skips, ratings, search history, watch time, and even the time or mood in which content is consumed.

Every interaction improves Angelica’s recommendations.

Core Product Concept

Angelica acts as a personal movie concierge. After a user watches a movie, the agent updates their preference profile and recommends the next best titles based on both long-term taste and current viewing context.

Rotten Tomatoes Score Integration

Angelica also considers Rotten Tomatoes ratings as an external quality signal when ranking movie recommendations. It can evaluate both the Tomatometer score, which reflects professional critic reviews, and the Audience Score, which represents viewer sentiment. These ratings do not replace the user’s personal viewing preferences; instead, they act as supporting features within the ranking model. For example, when two movies are equally aligned with a user’s taste, Angelica may prioritize the movie with stronger critic and audience reception. The system can also personalize how much weight these scores receive, since some users may prefer critically acclaimed films while others are more influenced by general audience reactions.

For example, Angelica may recognize that a user:

• Watches comforting comedies on weekday evenings

• Prefers psychological thrillers on weekends

• Frequently finishes historical dramas

• Skips movies longer than two hours

• Enjoys movies featuring certain actors or directors

• Likes foreign-language films but prefers slower pacing only occasionally

The recommendations then adapt automatically.

How Angelica Works

1. Viewing Behavior Collection

Angelica gathers signals such as:

• Movies watched

• Watch duration

• Completion percentage

• Pauses and rewinds

• Movies abandoned early

• Rewatched titles

• Search activity

• Ratings and likes

• Watchlist additions

• Genre preferences

• Preferred actors and directors

• Viewing time and device

• Household or individual profile behavior

These signals are more useful than ratings alone because they reflect what the person actually does.

2. Personal Taste Profile

Angelica creates a continuously updated taste profile for every user.

The profile may include:

• Favorite genres

• Preferred subgenres

• Mood preferences

• Story themes

• Preferred pacing

• Tolerance for violence or suspense

• Preferred movie length

• Language preferences

• Familiar versus adventurous viewing behavior

• Favorite actors, directors, and franchises

• Recency preferences

• Comfort-viewing patterns

The profile is not static. It changes as the user’s taste evolves.

3. Candidate Generation

Angelica first creates a broad pool of movies that the user may like.

Candidates can come from:

Angelica generates recommendations from multiple sources, including movies enjoyed by similar users, titles that resemble content the person previously watched, and films that match their preferred genres, actors, and directors. It also considers trending content, newly released titles, movies related to the user’s watchlist, lesser-known titles hidden deeper in the catalog, curated editorial collections, seasonal recommendations, and movies currently popular within the user’s region.

This stage may reduce a catalog of millions of titles to several hundred relevant candidates.

4. Ranking Model

The ranking model scores every candidate and predicts how likely the user is to:

• Click the movie

• Start watching

• Finish watching

• Rate it positively

• Add it to a watchlist

• Recommend it

• Rewatch it later

Each title receives a personalized score.

A simplified ranking formula could include:

Recommendation Score =

• 25% genre compatibility

• 20% similarity to previously completed movies

• 15% current mood fit

• 10% actor or director affinity

• 10% predicted completion probability

• 8% freshness

• 7% popularity among similar viewers

• 5% diversity value

The weights can change for each user.

5. Context-Aware Recommendations

Angelica considers the user’s current situation, not only their historical preferences.

Examples include:

• “You usually watch light comedies on Sunday evenings.”

• “You have 90 minutes available, so these shorter movies may fit.”

• “You recently watched three crime dramas, so here are similar titles.”

• “You have been watching intense movies lately, so here are some lighter options.”

• “You are watching with family, so these suggestions avoid mature content.”

6. Continuous Learning

Every user action becomes feedback.

Positive signals may include:

• Watching the full movie

• Rewatching

• Rating highly

• Adding similar titles to a watchlist

• Searching for the same actor or director

Negative signals may include:

• Skipping the recommendation

• Abandoning the movie early

• Selecting “not interested”

• Repeatedly ignoring similar titles

Angelica updates the user profile after every interaction.

Key Features

Angelica For You

A personalized home feed that ranks movies specifically for the individual user.

Angelica Tonight

A conversational recommendation experience where users can ask:

• “What should I watch tonight?”

• “Give me a comforting movie.”

• “I want something like Gone Girl.”

• “Find me a good Iranian comedy.”

• “I only have 90 minutes.”

• “Suggest something my family will enjoy.”

Angelica Mood Match

Users can choose a mood such as:

• Comforting

• Romantic

• Suspenseful

• Inspiring

• Funny

• Nostalgic

• Emotional

• Thought-provoking

• Relaxing

• Adventurous

Angelica combines the selected mood with historical viewing behavior.

Angelica Next

After a movie ends, the agent immediately recommends the most relevant next title.

Example:

“Because you finished this movie and previously enjoyed character-driven mysteries, your best next choice is…”

Angelica Hidden Gems

The agent identifies lesser-known movies that closely match the user’s taste but may not appear in mainstream recommendations.

Angelica Taste Map

A visual dashboard showing:

• Favorite genres

• Recent taste changes

• Most-watched themes

• Preferred actors

• Completion patterns

• Mood trends

• Recommendations outside the user’s usual comfort zone

Angelica Group Mode

The agent combines the preferences of multiple viewers and recommends movies everyone is likely to enjoy.

It can balance:

• Shared preferences

• Age restrictions

• Genre conflicts

• Previously watched titles

• Movie length

• Individual dislikes

Angelica Explain

Each recommendation includes a clear reason.

Examples:

• “Recommended because you finished three similar historical dramas.”

• “You frequently watch movies starring this actor.”

• “This matches your preference for slow-burn psychological thrillers.”

• “You usually prefer movies under two hours on weekday nights.”

AI and Data Architecture

Angelica can be built using:

• Event streaming for real-time watch behavior

• A user profile store

• A movie metadata catalog

• A feature store

• Embedding models

• Collaborative filtering

• Content-based recommendation models

• Candidate-generation models

• Ranking models

• Vector databases

• Real-time inference services

• Feedback and experimentation systems

• Model monitoring and drift detection

Business Applications

Angelica can be sold to:

• Streaming platforms

• Smart television providers

• Cinema applications

• Hotel entertainment systems

• Airlines

• Telecom companies

• Media subscription platforms

• Movie discovery applications

Business Value

Angelica can help entertainment companies improve:

• Watch time

• Content discovery

• Completion rate

• Subscription retention

• Customer satisfaction

• Catalog utilization

• Click-through rate

• Watchlist activity

• User engagement

• Discovery of long-tail content

Example User Experience

A user finishes a psychological thriller.

Angelica responds:

“You tend to complete suspenseful movies with strong female leads and unexpected endings. Based on your recent viewing history, here are your three strongest next choices.”

The user selects one recommendation.

Angelica then records the selection, observes whether the user finishes the movie, and adjusts future rankings.

Product Positioning

Angelica is a continuously learning entertainment companion that understands what a person watches, why they may enjoy it, and what they are most likely to want next.

How to Implement Angelica AI

Angelica should be built as a two-stage recommendation system that learns from every movie a person watches:

User behavior
     ↓
Event collection
     ↓
User and movie features
     ↓
Candidate generation
     ↓
Ranking model
     ↓
Personalized recommendations
     ↓
User watches, skips, or rates
     ↓
Feedback updates the system

1. Define the recommendation objective

Angelica should not optimize only for clicks. A click can happen even when the user dislikes the movie.

The primary goals should be:

• Probability the user starts the movie

• Probability the user watches at least 20–30 minutes

• Probability the user completes it

• Probability the user rates it positively

• Probability the user returns to the platform

• Overall satisfaction and recommendation diversity

A useful combined objective could be:

Angelica Score =
0.20 × click probability
+ 0.25 × start probability
+ 0.30 × completion probability
+ 0.15 × positive-rating probability
+ 0.10 × diversity value

These weights should eventually be learned through experimentation rather than permanently hard-coded.

2. Collect viewing behavior

Every meaningful action should generate an event.

Important user events

movie_impression
movie_clicked
movie_started
movie_paused
movie_resumed
movie_completed
movie_abandoned
movie_rewatched
movie_liked
movie_disliked
movie_rated
movie_searched
watchlist_added
watchlist_removed
not_interested

Each event should contain context such as:

{
  "user_id": "U123",
  "movie_id": "M456",
  "event_type": "movie_completed",
  "timestamp": "2026-07-11T21:15:00Z",
  "watch_percentage": 0.96,
  "device_type": "smart_tv",
  "session_id": "S789",
  "time_of_day": "evening",
  "day_of_week": "Saturday",
  "profile_type": "individual"
}

Technology options

For an MVP:

• Application API

• PostgreSQL

• Python batch jobs

• Scheduled workflows

For production scale:

• Kafka, Kinesis, or Pub/Sub for event streaming

• S3, Azure Data Lake, or Google Cloud Storage for historical data

• Snowflake, BigQuery, Databricks, or Redshift for analytics

• Spark or Flink for large-scale transformation

3. Build the movie catalog

Angelica needs rich information about every movie.

Movie metadata

Include:

• Title

• Genre and subgenre

• Actors

• Director

• Release year

• Language

• Country

• Runtime

• Age rating

• Plot summary

• Themes

• Mood

• Pace

• Violence level

• Humor level

• Emotional intensity

• Popularity

• Average rating

• Availability by region

For example:

{
  "movie_id": "M456",
  "title": "Example Movie",
  "genres": ["Drama", "Mystery"],
  "themes": ["Family", "Identity", "Secrets"],
  "mood": ["Emotional", "Suspenseful"],
  "pace": "Slow",
  "runtime_minutes": 112,
  "language": "English"
}

Angelica can use a language model to extract additional attributes from plot summaries and reviews, such as:

• “Slow-burn”

• “Comforting”

• “Dark comedy”

• “Strong female lead”

• “Unexpected ending”

• “Family-friendly”

• “Emotionally intense”

These attributes improve content-based recommendations.

4. Create user profiles

Angelica should maintain two user profiles.

Long-term taste profile

This represents stable preferences, such as:

• Favorite genres

• Preferred actors

• Preferred directors

• Typical movie length

• Language preferences

• Preferred pacing

• Historical completion patterns

• Sensitivity to violence or mature content

Short-term session profile

This represents what the user currently wants.

For example, the person may normally like thrillers but currently be watching holiday comedies.

Short-term signals include:

• Last five movies watched

• Current search terms

• Current mood request

• Current device

• Time available

• Day and time

• Whether they are watching alone or with others

The recommendation model should balance both:

Final preference =
70% long-term taste
+ 30% current-session interest

The exact balance can become dynamic. When a user performs several similar actions within one session, short-term intent should receive more weight.

5. Build a feature store

A feature store holds the calculated variables used by the recommendation models.

It ensures that training and live recommendations use the same definitions.

User features

Examples:

favorite_genre
thriller_completion_rate
average_runtime_watched
foreign_language_affinity
weekend_comedy_affinity
preferred_release_decade
average_movies_per_week
rewatch_rate
recent_genre_distribution

Movie features

Examples:

genre_embedding
plot_embedding
popularity_score
completion_rate
average_rating
runtime
release_recency
regional_popularity

User–movie interaction features

Examples:

genre_match_score
actor_affinity_score
director_affinity_score
runtime_match
language_match
similarity_to_last_movie
number_of_similar_movies_completed
movie_already_seen

Feature-store technologies may include:

• Feast

• Databricks Feature Store

• SageMaker Feature Store

• Tecton

• Redis combined with warehouse tables

For a small MVP, PostgreSQL tables are enough.

6. Generate movie embeddings

Embeddings convert users and movies into numerical vectors.

Movies with similar stories, moods, genres, actors, or viewing patterns will be positioned close together.

A movie vector might represent:

[comedy, romance, suspense, pacing, emotional intensity, era, language...]

Movie embeddings can be created from:

• Plot summaries

• Genres

• Cast and directors

• User viewing patterns

• Reviews and descriptions

Possible model approaches:

• Sentence Transformers for plot embeddings

• Matrix factorization for behavioral embeddings

• Two-tower neural networks

• Multimodal models using posters, trailers, and text

The embeddings can be stored in:

• Pinecone

• Weaviate

• Milvus

• OpenSearch

• Elasticsearch

• pgvector

• FAISS

For an MVP, pgvector or FAISS is usually sufficient.

7. Candidate generation

Candidate generation narrows the full catalog down to approximately 200–1,000 potentially relevant movies.

Angelica should use several candidate generators rather than relying on one model.

A. Collaborative filtering

This recommends movies enjoyed by users with similar behavior.

Example:

Users who completed Movie A and Movie B
also frequently completed Movie C.

Methods include:

• Matrix factorization

• Alternating least squares

• Neural collaborative filtering

• Implicit-feedback models

This is strong when there is substantial viewing history.

B. Content-based recommendations

This identifies movies similar to those the user previously enjoyed.

It uses:

• Genre

• Themes

• Plot embeddings

• Actors

• Directors

• Mood

• Runtime

• Language

This works well for new or less popular movies.

C. User-to-movie vector retrieval

A user embedding is compared with movie embeddings using approximate nearest-neighbor search.

This produces movies whose vectors are closest to the user’s taste vector.

D. Trending and popular candidates

Angelica should include:

• Regionally popular movies

• Recently released movies

• Seasonal movies

• Movies trending among similar users

E. Exploration candidates

The system should occasionally recommend something outside the user’s normal preferences.

Otherwise, it creates a filter bubble and repeats the same content.

A candidate pool might look like:

100 collaborative-filtering candidates
100 content-similarity candidates
100 embedding-based candidates
50 trending candidates
25 exploration candidates

Duplicates are removed before ranking.

8. Train the ranking model

The ranking model evaluates every candidate and predicts the user’s response.

It can use:

• User features

• Movie features

• Context features

• User–movie interaction features

Good first ranking models

Start with:

• Logistic regression

• Random forest

• XGBoost

• LightGBM

For most initial implementations, LightGBM or XGBoost performs very well and is easier to operate than deep learning.

Later, Angelica can use:

• Deep neural ranking models

• Wide-and-deep models

• DeepFM

• Transformer-based sequential recommendation

• Multi-task learning models

Example ranking features

genre_match
plot_similarity
actor_affinity
director_affinity
movie_popularity
movie_freshness
predicted_completion_rate
runtime_fit
time_of_day_fit
recent_genre_similarity
user_has_seen_movie
number_of similar movies skipped

The ranking model may output:

P(click)
P(start)
P(complete)
P(like)
P(rewatch)

Then Angelica combines these predictions into a final score.

9. Add business and experience rules

Machine-learning scores should not be the final step.

The system also needs rules.

Filtering rules

Remove:

• Already watched movies, unless rewatches are allowed

• Content unavailable in the user’s region

• Age-inappropriate movies

• Content marked “not interested”

• Movies outside subscription access

• Blocked languages or themes

Diversity rules

Avoid returning ten nearly identical movies.

Angelica should diversify across:

• Genre

• Actor

• Director

• Release year

• Language

• Mood

• Popularity

A re-ranking formula could be:

Final score =
0.80 × predicted relevance
+ 0.10 × diversity
+ 0.05 × novelty
+ 0.05 × freshness

A method such as Maximal Marginal Relevance can balance relevance and variety.

10. Build real-time recommendation serving

When the user opens Angelica, the recommendation service should respond within a few hundred milliseconds.

Online request flow

User opens app
      ↓
Recommendation API receives user ID and context
      ↓
Fetch real-time user features
      ↓
Retrieve candidate movies
      ↓
Score candidates with ranking model
      ↓
Apply filters and diversity rules
      ↓
Return top recommendations

Example API request

{
  "user_id": "U123",
  "context": {
    "device": "smart_tv",
    "time_available": 100,
    "mood": "comforting",
    "watching_with": "family"
  }
}

Example API response

{
  "recommendations": [
    {
      "movie_id": "M901",
      "score": 0.93,
      "reason": "You often complete warm family comedies on weekend evenings."
    },
    {
      "movie_id": "M332",
      "score": 0.89,
      "reason": "Similar to two movies you recently rated highly."
    }
  ]
}

Recommended serving technologies:

• FastAPI, Flask, Node.js, or Java Spring

• Docker

• Kubernetes, ECS, Cloud Run, or Azure Container Apps

• Redis for low-latency features and caching

• MLflow or SageMaker for model deployment

11. Update recommendations after every watch

Angelica should react to important behavior immediately.

When the user completes a movie:

1. The completion event enters the event stream.

2. The user’s recent-watch history is updated.

3. Short-term genre and mood preferences are recalculated.

4. The user embedding is refreshed.

5. Candidate recommendations are regenerated.

6. The next recommendation is returned.

Not every model needs to be retrained after each event.

There are three separate update speeds:

Real-time updates

Within seconds:

• Recent history

• Session preferences

• Already-watched filter

• Current mood

• User embedding adjustments

Daily batch updates

Once per day:

• Genre affinity

• Actor affinity

• Completion rates

• User clusters

• Movie popularity

Periodic model retraining

Weekly or monthly:

• Candidate model

• Ranking model

• Embedding model

12. Explain every recommendation

Angelica should not expose raw technical scoring.

Instead, it should translate the strongest features into human explanations.

Examples:

• “Because you completed three character-driven mysteries.”

• “This shares a director with two movies you rated highly.”

• “You usually prefer movies under two hours on weekday evenings.”

• “This is popular with viewers who share your taste.”

• “You asked for something comforting and family-friendly.”

An explanation service can receive:

Top ranking feature:
genre_match = high

Supporting feature:
weekend_completion_rate = high

And convert those signals into a natural sentence.

13. Handle the cold-start problem

New users and new movies have little behavioral data.

New user

Angelica can ask a short onboarding questionnaire:

• Select five movies you liked

• Select preferred genres

• Select disliked genres

• Choose favorite actors or directors

• Choose language preferences

• Choose typical movie duration

It can also begin with:

• Popular regional movies

• Editorial collections

• Session-based recommendations

• Content-based similarity

New movie

Use metadata rather than viewing history:

• Plot embedding

• Genre

• Actors

• Director

• Mood

• Language

• Runtime

As people begin watching it, collaborative signals become available.

14. Train the models correctly

Historical recommendation data can contain bias.

For example, a movie may have few clicks because it was rarely shown, not because users disliked it.

Training data should include:

• Recommendations presented

• Recommendation position

• Whether the recommendation was visible

• User action

• Watch duration

• Completion

• Rating

• Context

A training row could look like:

user_id
movie_id
impression_time
position
genre_match
actor_affinity
runtime_match
clicked
started
completed
liked

Negative examples should include movies the user saw but did not select, not random movies they may never have encountered.

15. Evaluate Angelica

Offline metrics

Before deployment, measure:

• Precision@K

• Recall@K

• NDCG@K

• Mean Average Precision

• Hit Rate

• Coverage

• Diversity

• Novelty

Recall@10

Of all the movies the user eventually enjoyed, how many appeared in Angelica’s top ten?

Precision@10

Of the ten movies recommended, how many were actually relevant?

NDCG@10

Did Angelica place the strongest recommendations near the top?

Online metrics

Use A/B testing to measure:

• Recommendation click-through rate

• Movie-start rate

• Completion rate

• Minutes watched

• Time to first play

• Session length

• Return rate

• Subscription retention

• “Not interested” rate

• User satisfaction

Do not optimize only for watch time. Constantly recommending addictive or extreme content may increase minutes watched while reducing trust and satisfaction.

16. Monitor the production system

Angelica needs monitoring for both technology and model performance.

System monitoring

Track:

• API latency

• Error rate

• Recommendation availability

• Event-processing delay

• Feature freshness

• Cache performance

Model monitoring

Track:

• Recommendation click rate

• Completion prediction accuracy

• Feature drift

• User preference drift

• Catalog coverage

• Diversity

• Popularity bias

• Performance by user segment

Alerts should trigger when:

• Recommendations become repetitive

• New releases never surface

• One genre dominates

• Feature data becomes stale

• Model performance drops

• Certain user groups receive poorer recommendations

17. Privacy and user control

Viewing behavior can reveal sensitive preferences.

Angelica should include:

• Clear consent

• Ability to delete watch history

• Ability to reset recommendations

• Separate household profiles

• Data encryption

• Role-based access controls

• Minimal collection of personal data

• Audit logging

• Retention policies

Users should be able to tell Angelica:

• “Do not use this movie for future recommendations.”

• “This was watched by someone else.”

• “Show me fewer horror movies.”

• “Reset my taste profile.”

18. Recommended production architecture

Streaming App / Smart TV / Mobile App
                |
                v
          API Gateway
                |
        -----------------
        |               |
        v               v
 Recommendation API   Event Collector
        |               |
        |               v
        |          Kafka / Kinesis
        |               |
        |        -----------------
        |        |               |
        |        v               v
        |   Stream Processing   Data Lake
        |        |               |
        |        v               v
        |   Online Features   Data Warehouse
        |        |               |
        |        |          Model Training
        |        |               |
        v        v               v
 Candidate Retrieval        Model Registry
        |
        v
 Ranking Service
        |
        v
 Filtering and Re-ranking
        |
        v
 Recommendation Results

19. Practical technology stack

A realistic cloud-neutral stack could be:

20. MVP implementation

Angelica does not need deep learning on day one.

Phase 1: Basic MVP

Build:

• User registration

• Movie catalog

• Watch-history collection

• Likes and dislikes

• Content-based recommendations

• “Because you watched…” explanations

• Basic recommendation API

Technology:

• Python

• FastAPI

• PostgreSQL

• Sentence Transformers

• pgvector

• React

Phase 2: Behavioral intelligence

Add:

• Collaborative filtering

• Completion-based learning

• User embeddings

• Real-time event collection

• Candidate-generation service

• XGBoost or LightGBM ranking

Phase 3: Advanced personalization

Add:

• Short-term session modeling

• Mood-aware recommendations

• Group recommendations

• Exploration strategy

• Multi-objective ranking

• A/B experimentation

• Sequence models

Phase 4: Enterprise product

Add:

• Multi-tenant architecture

• Streaming-platform integrations

• Recommendation APIs and SDKs

• Administration dashboard

• Model monitoring

• Privacy and governance

• Regional catalogs

• Customer-specific model configuration

21. Simple MVP recommendation logic

A first version can calculate:

Recommendation Score =
35% plot similarity
+ 25% genre similarity
+ 15% actor affinity
+ 10% director affinity
+ 10% popularity
+ 5% freshness

Example Python-style logic:

score = (
    0.35 * plot_similarity
    + 0.25 * genre_similarity
    + 0.15 * actor_affinity
    + 0.10 * director_affinity
    + 0.10 * popularity_score
    + 0.05 * freshness_score
)

After enough user behavior is collected, replace fixed weights with a learned ranking model.

Final Angelica workflow

1. User watches a movie.
2. Angelica records watch behavior.
3. User features and recent interests are updated.
4. Several models generate candidate movies.
5. The ranking model predicts engagement and satisfaction.
6. Rules remove inappropriate or repetitive results.
7. A diversity layer creates a balanced list.
8. Angelica explains why each movie was selected.
9. The user watches, skips, likes, or dislikes.
10. That response becomes new training feedback.

The most important design principle is that Angelica should learn from actual viewing behavior, not only ratings. Finishing, abandoning, rewatching, searching, and ignoring recommendations often reveal more about a person’s taste than a five-star score.