For the past few months or so, I've started tracking my movie watching with Letterboxd. I'm not doing a lot of reviews, mostly just logging, but I find it neat to look back and remind myself of what I've watched recently. You can see my profile if you're curious, or check out my "Now" page as well. I thought it might be interesting to see if I could use my Letterboxd data along with Google Gemini as a way to suggest the next movie I should watch. I was able to build a quick workflow using the incredible Pipedream in a few minutes. Let me share with you how I did that.

What does it do?

At a high level, my workflow does the following:

• It runs, automatically, once a week on Sunday. That was a bit arbitrary but felt like a good day to pick.
• Look at my Letterboxd profile and pluck out the most recent film I logged.
• From that, generate a prompt and ask Gemini what it would suggest.
• Take those suggestions and email them to me.

Now let's take a look at that workflow in detail.

Step One - The Schedule

This will be the quickest step as it was one of Pipedream's built-in triggers - a CRON/schedule. All I had to was set it to weekly on Sunday.

Step Two - Getting My Letterboxd Data

While Letterboxd has an API, they also have RSS feeds for people's logs. You can find mine here: https://letterboxd.com/raymondcamden/rss/. In Pipedream, I added a built-in step that parses RSS feeds. I selected the "Merge" one even though I only had one feed and I'm not sure if there's an action I missed specifically for one feed, but it worked easily enough - I simply gave it the RSS url.

As a quick aside, and as a reminder of why I love Pipedream, I've now got a serverless workflow with a custom schedule parsing RSS and I haven't written one line of code.

Step Three - Generate My Prompt

Now I actually do need to write code. I'm going to get the first item from the RSS feed, which looks like so in raw XML:

<item>
	<title>Late Night with the Devil, 2023 - ★★★</title>
	<link>https://letterboxd.com/raymondcamden/film/late-night-with-the-devil/</link>
	<guid isPermaLink="false">letterboxd-watch-578751912</guid>
	<pubDate>Sun, 21 Apr 2024 14:43:16 +1200</pubDate>
	<letterboxd:watchedDate>2024-04-20</letterboxd:watchedDate>
	<letterboxd:rewatch>No</letterboxd:rewatch>
	<letterboxd:filmTitle>Late Night with the Devil</letterboxd:filmTitle>
	<letterboxd:filmYear>2023</letterboxd:filmYear>
	<letterboxd:memberRating>3.0</letterboxd:memberRating>
	<tmdb:movieId>938614</tmdb:movieId>
	<description><![CDATA[ <p><img src="https://a.ltrbxd.com/resized/film-poster/8/4/3/4/1/5/843415-late-night-with-the-devil-0-600-0-900-crop.jpg?v=b6c384f7c5"/></p> <p>Watched on Saturday April 20, 2024.</p> ]]></description>
	<dc:creator>Raymond Camden</dc:creator>
</item>

I wanted the title, but not the title in <title> as it has extra info, but rather, the value in <letterboxed:filmTitle>. I grab that value, and generate my prompt:

export default defineComponent({
  async run({ steps, $ }) {
    let lastMovie = steps.get_films.$return_value[0];
    let title = lastMovie['letterboxd:filmtitle']['#'];
    
    $.export('title', title);
    
    return `
The last movie I watched is "${title}". What would you suggest I watch next?
    `;
  },
})

Note how I both return the prompt and export the title. I need the title later in the workflow, but I wanted the main return to be the prompt. I've not returned multiple values from a Pipedream step before and I appreciate how easy it is. At the end of this step, I'll be able to reference title from the step as well as $return_value.

Step Four - Talking to Gemini

At this point (if you read my blog), you've seen me demonstrate the Gemini API multiple times. In general, it's trivial code, with the truly important bits being the prompt. A few days back, I blogged about how to get JSON results from your prompt using the response type setting and system instructions. I followed the same format for my code here:

import { GoogleGenerativeAI, HarmCategory, HarmBlockThreshold } from '@google/generative-ai';

async function callGemini(text,model) {

	const generationConfig = {
		temperature: 0.9,
		topK: 1,
		topP: 1,
		maxOutputTokens: 2048,
		response_mime_type:'application/json'
	};

	const safetySettings = [
		{ category: HarmCategory.HARM_CATEGORY_HARASSMENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,	threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
		{ category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT, threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE, },
	];

	const parts = [
    	{text},
  	];

	const result = await model.generateContent({
		contents: [{ role: "user", parts }],
		generationConfig,
		safetySettings,
	});


	try {

		if(result.response.promptFeedback && result.response.promptFeedback.blockReason) {

			return { error: `Blocked for ${result.response.promptFeedback.blockReason}` };
		}
		const response = result.response;
		return JSON.parse(response.candidates[0].content.parts[0].text);
	} catch(e) {

		return {
			error:e.message
		}
	}
	
}

export default defineComponent({
  async run({ steps, $ }) {
    
    const MODEL_NAME = "gemini-1.5-pro-latest";
    const API_KEY = process.env.GOOGLE_API_KEY;

    const si = `
You are an expert at movies and can make recommendations for a movie a person should watch based on their last film. 

Your response should be a JSON object containing an array of recommendations in this form:

* title: The title of the movie.
* year: The year it was released.
* reason: A one sentence explanation for why the film was recommended.
    `;
    
    const genAI = new GoogleGenerativeAI(API_KEY);
    const model = genAI.getGenerativeModel({ model: MODEL_NAME,
    	systemInstruction: {
    		parts: [{ text:si }],
    		role:"model"
    	} } , { apiVersion:'v1beta' });

    return await callGemini(steps.generatePrompt.$return_value,model);
    
  },
})

That's a big block of code, but the important portion really is the system instructions I set up in the si string. I describe how Gemini should act and how it should return its results. The net result is an array that looks like so:

{
	"$return_value": [
		{
			"title": "Talk to Me",
			"year": 2023,
			"reason": "If you enjoyed the blend of horror and humor in \"Late Night with the Devil\", \"Talk to Me\" offers a similar tone with its exploration of a group of friends who discover how to conjure spirits using an embalmed hand."
		},
		{
			"title": "The Blackening",
			"year": 2023,
			"reason": "For those who appreciated the satirical elements of \"Late Night with the Devil\", \"The Blackening\" provides a comedic horror experience that cleverly critiques horror movie tropes through a group of Black friends facing a killer."
		},
		{
			"title": "Evil Dead Rise",
			"year": 2023,
			"reason": "If the demonic presence in \"Late Night with the Devil\" intrigued you, \"Evil Dead Rise\" delivers a thrilling continuation of the Evil Dead franchise, showcasing a fresh take on the iconic Deadites and their malevolent influence."
		}
	]
}

Step Five - Generate Email

As I plan on using HTML for my email, I created another code step for the sole purpose of creating an HTML string:

export default defineComponent({
  async run({ steps, $ }) {
    let html = `
<h2>Movie Recommendations</h2>

<p>
The last movie you watched was "${steps.generatePrompt.title}". I asked Google Gemini what you should watch next
and this is what it recommended:
</p>
    `;

    for(let film of steps.generateResponse.$return_value) {
      html += `
 <h3>${film.title} (${film.year})</h3>

 ${film.reason}
      `;
    }

    return html;
  },
})

Basically, here's what you watched last, and here's what to watch next. I spent maybe one minute making it look decent, but I could have done much more of course.

Step Six - Email

The final step is trivial. Pipedream includes an "email you" type step where you provide a subject and content to email, and it emails the account holder, in this, case. You absolutely can use email services and they've got built-in actions for those, but I'm fine with the basic one.

The Results

The last movie I watched was "Late Night with the Devil", and here's what Gemini recommended:

Of those, I've seen two of them, and honestly, the recommendations feel spot on. While testing I got a few different recommendations including "Antlers", "The Blackening", and "Evil Dead Rise". Again, these feel like great recommendations.

I do think it might be interesting to grab the last two movies instead of one, and that way you would get a bit more variety in responses (assuming you watched different genres), but I figure this by itself is good enough. You can find the complete Pipedream source here: https://github.com/cfjedimaster/General-Pipedream-Stuff/tree/production/suggest-next-movie-p_ZJCRzAD. Let me know what you think!