TCHOUTZIFY: give meaning to every track and build your mood playlists

I was tidying up my room, Spotify playing in the background, when a sound hit me. A rising string section, a heavy bass, a voice that seemed to carry the weight of the entire world.

Power. Kanye West. My Beautiful Dark Twisted Fantasy.

I deeply loved what I was hearing. The flow, the energy, the sound construction. But the lyrics completely escaped me. I didn't understand what Kanye was saying, what he was living through, what he was conveying.

I'm someone who needs to understand what they're doing, and why. Not just feel it, but grasp it. That's the way I'm wired, and it naturally pushed me toward finding a solution. And with the Batch course I was taking at 6:30 in the morning, AI agents were already very much on my mind. The idea of building one came on its own.

Listening to music without understanding its message is like reading a book while only looking at the illustrations. The beauty is there, but the depth is missing.

The idea that changed everything

I thought: what if every time a new song started playing, someone told me its story? Not a cold translation. A real narrative. The context, the era, the artist, what they wanted to say, all delivered in seconds.

TuneZine AI was born from that frustration.

An agent that turns every listening session into learning. Every track becomes a story. Every song change becomes a lesson in culture, emotion, and humanity.

And the best part? 100% free to build.

Tchoutzify or TuneZine AI? Both, actually.

This project has two names, and it's not a coincidence.

After filtering through quite a few options, I kept TuneZine AI: iTunes fused with Tchoutzine. It's the name of the whole system: the architecture, what you deploy.

And Tchoutzify for the agent itself: Tchoutzine crossed with Spotify. It's the one that listens, analyzes, and talks to you.

TuneZine AI is the brain. Tchoutzify is the voice.

What TuneZine AI does

Here's what happens every time you change a song on Spotify:

1. An n8n workflow detects the change within 5 seconds
2. Google Gemini generates a cultural and musical narrative
3. Henri (a natural Microsoft Edge TTS male voice) pauses the music, reads the narration, resumes
4. The full message arrives on your Telegram bot

You can also send "analyse" to your bot for an on-demand analysis.

A concrete example

Imagine you're listening to Children by Robert Miles. Within seconds, Henri tells you:

"It's 1996, and Robert Miles, a 24-year-old Italian DJ, has just created something unusual in the techno world. Children isn't just a haunting melody: it's a direct response to the car accidents that happened after club nights, when people drove home exhausted after hours of intense music. The deep message of this track is as simple as it is moving: music can save lives."

That's TuneZine AI.

The mood playlist: the second superpower

Song analysis is great. But there's a second use case I use even more often.

You send your mood to the bot, one word is enough. "Tired", "Motivated", "Nostalgic", "Focus". Within seconds, Tchoutzify creates a custom playlist directly in Spotify and launches it.

One night at 5:22 AM, I send "Tired 😴". The bot generates a "Morning Soft" playlist with Weightless by Marconi Union, Clair de Lune by Debussy, River Flows in You by Yiruma... and it launches automatically in Spotify.

That's the kind of moment when you realize you've built something genuinely useful for yourself. And that's exactly where a project should come from.

The tech stack: all free, all structured

What surprised me most while building this is that you can create something this powerful without spending a single cent on AI tools.

*I first ran the project without Spotify Premium, and it works great. The free trial everyone can activate is more than enough to get started.

How I designed it

I started by defining the complete design before writing a single line of code. A detailed spec, a thought-out architecture, documented decisions.

Then I coded the Python server first: the local part that handles pause/TTS/resume. With unit tests for each component.

class TTSEngine:
    def __init__(self, voice: str = 'fr-FR-HenriNeural'):
        self.voice = voice          # Henri. Non-negotiable.
        pygame.mixer.init()         # Wake up the speakers

    def speak(self, text: str):
        tmp_path = tempfile.mktemp(suffix='.mp3')
        asyncio.run(self._generate(text, tmp_path))  # Gemini spoke, Henri follows
        pygame.mixer.music.load(tmp_path)
        pygame.mixer.music.play()
        while pygame.mixer.music.get_busy():
            pygame.time.wait(100)   # We wait for Henri, we don't rush him
        pygame.mixer.music.unload()
        os.unlink(tmp_path)         # Clean. No trace. Like a pro.

In short, all of Tchoutzify fits in one line:

tchoutzify = n8n + gemini + edge_tts + telegram + spotify  # free. for real.

And here's what Tchoutzify "sees" behind the scenes on every track change:

[05:21:03] 🎵 Track changed → "Power" by Kanye West
[05:21:04] 🧠 Sending to Gemini 2.5 Flash...
[05:21:06] ✅ Narration ready (312 tokens)
[05:21:06] 🔇 Spotify paused
[05:21:06] 🗣️  Henri speaking...
[05:21:41] ▶️  Spotify resumed
[05:21:41] 📩 Message sent to Telegram

Then the 4 n8n workflows, built node by node, tested live with Spotify.

spotify_watcher : detects every track change within 5 seconds

llm_narrator : sends the track title to Gemini, retrieves the narration

mood_engine : reads your mood on Telegram, generates and launches the playlist

tts_runner : triggers Henri, pauses Spotify, resumes after reading

The struggles (and what I learned)

This project taught me more than I expected. Not just about the technical side, but about perseverance.

Spotify and its restrictions. The Spotify API in developer mode blocks certain operations. I had to work around it using the Windows window title to detect tracks, and find alternative endpoints to create playlists.

Groq rate limits. Through testing, I burned through the free 100k daily tokens. I migrated to Gemini mid-project, and ultimately both coexist.

n8n and expressions. n8n's expression engine is powerful but demands precision. Every $('NodeName').first().json must match exactly the node name on the canvas.

Every blocker taught something. That's the real lesson.

For the community

If you want to build your own TuneZine AI, all the code is available on GitHub:

github.com/zoom-BT/Tchoutzify-Agent

The README contains all installation instructions. You'll need:

• Python 3.10+
• Node.js (for n8n)
• A Spotify Developer account (free)
• A Telegram bot (@BotFather)
• A Gemini API key (free at aistudio.google.com)

This project is a starting point. You can adapt it, improve it, add new languages, new notification channels, new music sources.

The code belongs to the community. Fork it, improve it, share it.

What I truly learned

Beyond the technical side, this project taught me something important:

The best ideas are born from personal frustration.

I wasn't trying to build "an AI agent". I was trying to solve my own problem: understanding the music I love. The agent came naturally.

If you have a recurring frustration in your life, something that holds you back, that's probably where your next project is hiding.

And you don't need a big budget. You don't need a team. You need curiosity, perseverance, and the right tools.

The tools are there. Free. Powerful. Accessible.

"Music can change the world because it can change people." Bono

TuneZine AI doesn't change the world. But it changes the way I experience music, and maybe it will change yours too.

The source code is available on GitHub. Feel free to open an issue, suggest an improvement, or just let me know what you think.

Live demo