DEV Community: Purva Bangad

Gemma 4: AI Masala Engine

Purva Bangad — Tue, 26 May 2026 15:11:00 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

I built the AI Masala Engine, a "Cine-Intelligence" platform designed to solve the chronic problem of "infinite scrolling" through movie catalogs. Instead of generic genres, this app maps a user's specific emotional state—like "Nostalgic but Edgy"—to a combination of current cinematic culture (vibes/memes) and personalized film recommendations.
It acts as a hybrid bridge between deep movie reasoning and the fast-paced world of social cinema trends.

Demo

Live Demo Link

How I Used Gemma 4

The AI Masala Engine utilizes a Hybrid Multi-Model Architecture to ensure that each part of the user experience is powered by the right tool for the job. We didn't just use one model; we matched the competition guidelines by being intentional with model selection:

Gemma 4 31B Dense (Core Reasoning):
Why: We used the 31B Dense model for the complex Reason field in our recommendations. Connecting an abstract user preference like "Cyberpunk Noir with a hint of hope" to a specific classic film requires deep world knowledge and superior reasoning capabilities that only a server-grade dense model can provide.
Gemma 4 26B Mixture-of-Experts (High-Throughput Extraction):
Why: For the "Trending Vibes" and "Cinematic Memes" section, we utilized the MoE architecture. Identifying cultural micro-trends across YouTube, blogs, and social media requires high throughput and the ability to process diverse, switching contexts rapidly. MoE allowed us to extract these vibes without sacrificing inference speed.
Gemma 4 4B Small (Edge-Optimized Copy):
Why: We offloaded the generation of "Punchy Taglines" to the 4B model. These are concise, micro-copy elements where speed is prioritized over deep reasoning, simulating a workflow where this model could eventually run locally on a user's device for instant UI feedback.

The most compelling aspect of this project is the Inference Log visible in the app's footer, which shows the system "choosing" the path (Dense vs. MoE) based on the complexity of the user's movie prompt.

Code Highlight: Prompt Engineering for Model Rationale

// From src/services/geminiService.ts
const prompt = `
  REASONING ARCHITECTURE (Gemma 4 31B Dense + 4B Small Hybrid):
  - Use the 31B Dense reasoning path for the 'reason' field to provide deep cinematic links.
  - Use the 4B Small path for 'tagline' to ensure punchy, micro-copy style output.
  - Include a 'modelRationale' explaining how the Dense model connected this movie to the user's mood.
`;

Why "Mood" Relevancy Matters
The "Mood" relevancy is the heart of why this stands out.

Beyond Metadata: Traditional search looks for "Action" or "1990s." Gemma 4 allows us to search for vibe. It understands that a "Neon-Noir Cyberpunk" mood isn't just about the setting—it's about the pacing, the color palette, and the philosophical undertones.

The Model Rationale: By surfacing the modelRationale in the UI (e.g., "System Rationale: Gemma 4 31B Dense connected your 'melancholy optimism' to this film's use of natural light and non-linear storytelling"), I give the user insight into the AI's "thought process," turning a black-box recommendation into a collaborative discovery.

Cultural Context: Integrating memes and vibes alongside movie picks makes the app feel "alive." It treats cinema as a living cultural conversation rather than a static database.

Core Feature Breakdown

Craft Your Scene (Mood Recommender) Uses Gemma 4 31B Dense to perform deep-link reasoning, connecting complex emotional prompts to obscure cinematic parallels.

// System instruction for Dense Reasoning
REASONING ARCHITECTURE (Gemma 4 31B Dense):
- Use the 31B Dense reasoning path for the 'reason' field to provide deep cinematic links.
- Use the 4B Small (Edge-optimized) path for the 'tagline' to ensure punchy, micro-copy style output.

Trend Intelligence (Vibe Analysis) Utilizes Gemma 4 26B MoE to process massive amounts of cultural data and identify shifting "Filmy Vibes" on social platforms.

// System instruction for MoE Throughput
INTELLIGENCE LAYER (Gemma 4 MoE 26B Optimized): 
- Since you are performing high-throughput cultural extraction, utilize the Mixture-of-Experts reasoning path. 
- Explain why a high-throughput social model was needed to catch this specific trend.

Trending Memes (Cultural Extraction) Extracts the "current humor" of the film industry, turning critique into content by identifying micro-trends in cinematic discourse.

// Task: Identify 4 trending movie-related "Memes" // that define the current cinematic humor or critique style.

Code Highlight: Multi-Model Prompting
This snippet from geminiService.ts shows how I orchestrate the different models within a single user flow to provide a "system rationale" for every recommendation:

// src/services/geminiService.ts
const prompt = `
  REASONING ARCHITECTURE (Gemma 4 31B Dense + 4B Small Hybrid):
  - Use the 31B Dense reasoning path for the 'reason' field to provide deep cinematic links.
  - Include a 'modelRationale' for EACH recommendation explaining how the Dense model 
    connected this specific movie to the user's complex mood.
`;

Build an AI Job Tracker With Gmail + Claude published: Auto-extracts applications, statuses, and interview dates from your inbox.

Purva Bangad — Mon, 04 May 2026 18:08:15 +0000

I applied to 40 jobs. I tracked exactly 3 of them. The other 37 lived rent-free in a spreadsheet I stopped opening after week two.

So I did what any reasonable engineer would do: spent a weekend building a robot to do it for me.

The result: an open-source Flask app that reads your Gmail, uses Claude AI to figure out what happened in each email, and builds you a full job search dashboard. Zero manual entry. Here's how it works.

The problem with every existing tool

Huntr, Teal — beautiful Kanban boards. You still move the cards yourself. That's just a prettier spreadsheet.

Simplify — great Chrome extension for autofilling applications. Does nothing after you hit submit. The moment you need it most: silence.

LazyApply, LoopCV — auto-applies to hundreds of jobs for you. Congratulations, you've been rejected at scale.

G-Track — actually syncs Gmail! But uses keyword/domain heuristics. It doesn't understand your emails, it pattern-matches them.

None of them read "We'd love to move forward with your application" and know that means in_process. That's where an LLM earns its keep.

The whole system in one diagram

Gmail API → raw emails → Claude (tool use) → structured data → SQLite → dashboard

That's it. The AI part is one function call.

The core trick: give Claude one tool and let it decide

Instead of asking Claude to "return JSON," you give it a function to call — and tell it to only call it for job-related emails. Claude classifies, extracts, and structures all in one pass. Non-job emails? It just... doesn't call the tool. Beautiful.

_SAVE_APPLICATION_TOOL = {
    'name': 'save_job_application',
    'description': 'Save a job application. Only call this for actual job emails, not newsletters.',
    'input_schema': {
        'type': 'object',
        'properties': {
            'company':   {'type': 'string'},
            'role':      {'type': 'string'},
            'status': {
                'type': 'string',
                'enum': ['applied', 'in_process', 'interview_scheduled', 'rejected', 'offer'],
            },
            'applied_date':   {'type': 'string', 'description': 'YYYY-MM-DD'},
            'interview_date': {'type': 'string', 'description': 'YYYY-MM-DD if scheduled'},
            'skills': {
                'type': 'array',
                'items': {'type': 'string'},
                'description': 'Tech skills mentioned. Max 8.',
            },
        },
        'required': ['gmail_message_id', 'company', 'status'],
    },
}

The status enum is load-bearing — Claude cannot invent a value outside those five. Schema as guardrails.

Now batch up to 50 emails and fire:

message = client.messages.create(
    model='claude-haiku-4-5-20251001',
    max_tokens=4096,
    tools=[_SAVE_APPLICATION_TOOL],
    messages=[{'role': 'user', 'content': prompt}],
)

# Each tool_use block = one detected job application
results = [b.input for b in message.content if b.type == 'tool_use']

One API call. 50 emails in, structured records out.

The one data model rule that saves everything

Status only moves forward. Always.

STATUS_RANK = {'applied': 1, 'in_process': 2, 'interview_scheduled': 3, 'offer': 4, 'rejected': 5}
TERMINAL_STATUSES = {'rejected', 'offer'}  # once here, you're done (sadly or happily)

if existing.status not in TERMINAL_STATUSES:
    if STATUS_RANK.get(new_status, 0) > STATUS_RANK.get(existing.status, 0):
        existing.status = new_status

Without this, your daily scan would see an old "application received" email and cheerfully overwrite the interview you scheduled last Tuesday. Don't let it.

A UniqueConstraint on (user_id, gmail_message_id) means the same email can never create two records. Idempotent scans, no drama.

The bonus features (the fun stuff)

Auto follow-ups — application sitting in applied for 14+ days? Claude writes you a polite "just checking in" email. You decide whether to send it.

Interview prep — status flips to interview_scheduled? Claude immediately generates 5 likely questions, 4 things to research, 3 talking points, and 1 tip. Stored on the record, shown on the dashboard.

Daily scheduler — three background jobs, staggered 5 minutes apart so each one has fresh data:

CronTrigger(hour=8, minute=0)   # scan Gmail
CronTrigger(hour=8, minute=5)   # generate follow-ups
CronTrigger(hour=8, minute=10)  # generate interview prep

Wake up at 8am. Everything's already done.

Running it

git clone https://github.com/your-repo/job-tracker
cd job-tracker
pip install -r requirements.txt
cp .env.example .env  # add your Anthropic + Google keys
python app.py

No Google keys? Set GOOGLE_CLIENT_ID= to blank. The app loads 8 demo applications so you can click around immediately.

Cost: Claude Haiku at ~$0.25/million tokens. Scanning 50 emails costs less than 0.01 cents. You spend more on the tab you accidentally left open.

Why not just ask Claude for JSON?

Three reasons tool use wins:

One bad email doesn't kill the batch. Tool use is per-item. A JSON array fails all-or-nothing.
"Skip non-job emails" is natural. Claude just... doesn't call the tool. No null entries, no filtering logic.
The enum is enforced at the API level. Claude cannot return "ghosted" as a status, no matter how accurate that would be.

That's it

Under 300 lines of Python for the core pipeline. Runs on your laptop. Your data stays local. Claude Haiku keeps costs laughably low.

Full write-up with architecture deep-dive → Medium article

Repo → https://github.com/bangadpurva/job-tracker

Go forth and be rejected in an organized fashion. 🚀