Tag: code

The Switch: Why I Dumped ChatGPT Plus for Gemini

For a long time, I was a loyal subscriber to ChatGPT Plus. I happily paid the €23.99/month to access the best AI models. But recently, my focus shifted. I’m currently optimizing my finances to invest more in index ETFs and aim for early retirement (FIRE). Every Euro counts.

That’s when I stumbled upon a massive opportunity: Gemini Advanced.

I managed to snag a promotional deal for Gemini Advanced at just €8.99/month. That is nearly 65% cheaper than ChatGPT Plus for a comparable, and in some ways superior, feature set. Multimodal capabilities, huge context windows, and deep Google integration for the price of a sandwich? That is an immediate win for my portfolio.

(Not using AI obviously is not an option anymore in 2026, sorry not sorry)

The Developer Nightmare: Scraping ChatGPT

As a developer, I love automating tasks. With ChatGPT, I built my own “API” to bypass the expensive official token costs. I wrote a script to automate the web interface, but it was a maintenance nightmare.

The ChatGPT website and app seemed to change weekly. Every time they tweaked a div class or a button ID, my script broke. I spent more time fixing my “money-saving” tool than actually using it. It was painful, annoying, and unreliable.

The Python Upgrade: Unlocking Gemini

When I switched to Gemini, I looked for a similar solution and found an open-source gem: Gemini-API by HanaokaYuzu.

This developer has built an incredible, stable Python wrapper for the Gemini Web interface. It pairs perfectly with my new subscription, allowing me to interact with Gemini Advanced programmatically through Python.

I am now paying significantly less money for a cutting-edge AI model that integrates seamlessly into my Python workflows. If you are looking to cut subscriptions without cutting capabilities, it’s time to look at Gemini.

The Setup Guide

How to Set Up Your Python Wrapper

If you want to use the HanaokaYuzu wrapper to mimic the web interface, you will need to grab your session cookies. This effectively “logs in” the script as you.

⚠️ Important Note: This method relies on your browser cookies. If you log out of Google or if the cookies expire, you will need to repeat these steps. For a permanent solution, use the official Gemini API and Google Cloud.

Step 1: Get Your Credentials 

You don’t need a complex API key for this wrapper; you just need to prove you are a human. Here is how to find your __Secure-1PSID and __Secure-1PSIDTS tokens: Copy the long string of characters from the Value column for both.

• Open your browser (Chrome, Firefox, or Edge) and navigate to gemini.google.com.
• Ensure you are logged into the Google account you want to use.
• Open the Developer Tools:
  • Windows/Linux: Press F12 or Ctrl + Shift + I.
  • Mac: Press Cmd + Option + I.
• Navigate to the Application tab (in Chrome/Edge) or the Storage tab (in Firefox).
• Ensure you are logged into the Google account you want to use.

On the left sidebar, expand the Cookies dropdown and select https://gemini.google.com.

Look for the following two rows in the list:

• __Secure-1PSID
• __Secure-1PSIDTS

Step 2: Save the Cookies

Add a .env to your coding workspace:

# Gemini API cookies
SECURE_1PSID=g.a00
SECURE_1PSIDTS=sidts-CjE

Examples

Automating Image Generation

We have our cookies, we have our wrapper, and now we are going to build with Nano Banana. This script will hit the Gemini API, request a specific image, and save it locally, all without opening a browser tab.

Here is the optimized, async-ready Python script:

import asyncio
import os
import sys
from pathlib import Path

# Third-party imports
from dotenv import load_dotenv
from gemini_webapi import GeminiClient, set_log_level
from gemini_webapi.constants import Model

# Load environment variables
load_dotenv()
Secure_1PSID = os.getenv("SECURE_1PSID")
Secure_1PSIDTS = os.getenv("SECURE_1PSIDTS")

# Enable logging for debugging
set_log_level("INFO")

def get_client():
    """Initialize the client with our cookies."""
    return GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)

async def gen_and_edit():
    # Setup paths
    temp_dir = Path("temp")
    temp_dir.mkdir(exist_ok=True)
    
    # Import our local watermark remover (see next section)
    # We add '.' to sys.path to ensure Python finds the file
    sys.path.append('.')
    try:
        from watermark_remover import remove_watermark
    except ImportError:
        print("Warning: Watermark remover module not found. Skipping cleanup.")
        remove_watermark = None

    client = get_client()
    await client.init()

    prompt = "Generate a photorealistic picture of a ragdoll cat dressed as a baker inside of a bakery shop"
    print(f"🎨 Sending prompt: {prompt}")

    response = await client.generate_content(prompt)

    for i, image in enumerate(response.images):
        filename = f"cat_{i}.png"
        img_path = temp_dir / filename
        
        # Save the raw image from Gemini
        await image.save(path="temp/", filename=filename, verbose=True)
        
        # If we have the remover script, clean the image immediately
        if remove_watermark:
            print(f"✨ Polishing image: {img_path}")
            cleaned = remove_watermark(img_path)
            cleaned.save(img_path)
            print(f"✅ Done! Saved to: {img_path}")

if __name__ == "__main__":
    asyncio.run(gen_and_edit())

If you have ever tried running a high-quality image generator (like Flux or SDXL) on your own laptop, you know the pain. You need massive amounts of VRAM, a beefy GPU, and patience. Using Gemini offloads that heavy lifting to Google’s supercomputers, saving your hardware.

But there is a “tax” for this free cloud compute: The Watermark.

Gemini stamps a semi-transparent logo on the bottom right of every image. While Google also uses SynthID (an invisible watermark for AI detection), the visible logo ruins the aesthetic for professional use.

The Fix: Mathematical Cleaning

You might think you need another AI to “paint over” the watermark, but that is overkill. Since the watermark is always the same logo applied with the same transparency, we can use Reverse Alpha Blending.

I found an excellent Python implementation by journey-ad (ported to Python here) that subtracts the known watermark values from the pixels to reveal the original colors underneath.

⚠️ Important Requirement: To run the script below, you must download the alpha map files (bg_48.png and bg_96.png) from the original repository and place them in the same folder as your script.

Here is the cleaning module:

#!/usr/bin/env python3
"""
Gemini Watermark Remover - Python Implementation
Ported from journey-ad/gemini-watermark-remover
"""
import sys
from pathlib import Path
from PIL import Image
import numpy as np
from io import BytesIO

# Ensure bg_48.png and bg_96.png are in this folder!
ASSETS_DIR = Path(__file__).parent

def load_alpha_map(size):
    """Load and calculate alpha map from the background assets."""
    bg_path = ASSETS_DIR / f"bg_{size}.png"
    if not bg_path.exists():
        raise FileNotFoundError(f"Missing asset: {bg_path} - Please download from repo.")
    
    bg_img = Image.open(bg_path).convert('RGB')
    bg_array = np.array(bg_img, dtype=np.float32)
    # Normalize to [0, 1]
    return np.max(bg_array, axis=2) / 255.0

# Cache the maps so we don't reload them every time
_ALPHA_MAPS = {}

def get_alpha_map(size):
    if size not in _ALPHA_MAPS:
        _ALPHA_MAPS[size] = load_alpha_map(size)
    return _ALPHA_MAPS[size]

def detect_watermark_config(width, height):
    """
    Gemini uses a 96px logo for images > 1024px, 
    and a 48px logo for everything else.
    """
    if width > 1024 and height > 1024:
        return {"logo_size": 96, "margin": 64}
    else:
        return {"logo_size": 48, "margin": 32}

def remove_watermark(image, verbose=False):
    """
    The Magic: Reverses the blending formula:
    original = (watermarked - alpha * logo) / (1 - alpha)
    """
    # Load image and convert to RGB
    if isinstance(image, (str, Path)):
        img = Image.open(image).convert('RGB')
    elif isinstance(image, bytes):
        img = Image.open(BytesIO(image)).convert('RGB')
    else:
        img = image.convert('RGB')

    width, height = img.size
    config = detect_watermark_config(width, height)
    logo_size = config["logo_size"]
    margin = config["margin"]
    
    # Calculate position (Bottom Right)
    x = width - margin - logo_size
    y = height - margin - logo_size

    if x < 0 or y < 0:
        return img # Image too small

    # Get the math ready
    alpha_map = get_alpha_map(logo_size)
    img_array = np.array(img, dtype=np.float32)
    
    LOGO_VALUE = 255.0  # The watermark is white
    MAX_ALPHA = 0.99    # Prevent division by zero

    # Process only the watermark area
    for row in range(logo_size):
        for col in range(logo_size):
            alpha = alpha_map[row, col]
            
            # Skip noise
            if alpha < 0.002: continue
            
            alpha = min(alpha, MAX_ALPHA)
            
            # Apply the reverse blend to R, G, B channels
            for c in range(3):
                pixel_val = img_array[y + row, x + col, c]
                restored = (pixel_val - alpha * LOGO_VALUE) / (1.0 - alpha)
                img_array[y + row, x + col, c] = max(0, min(255, round(restored)))

    return Image.fromarray(img_array.astype(np.uint8), 'RGB')

# Main block for CLI usage
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python remover.py <image_path>")
        sys.exit(1)
    
    img_path = Path(sys.argv[1])
    result = remove_watermark(img_path, verbose=True)
    output = img_path.parent / f"{img_path.stem}_clean{img_path.suffix}"
    result.save(output)
    print(f"Saved cleaned image to: {output}")

You could now build som etching with FastAPI on top of this and have your own image API! Yay.

The “LinkedIn Auto-Pilot” (With Memory)

⚠️ The Danger Zone (Read This First)

Before we look at the code, we need to address the elephant in the room. What we are doing here is technically against the Terms of Service.

When you use a wrapper to automate your personal Google account:

1. Session Conflicts: You cannot easily use the Gemini web interface and this Python script simultaneously. They fight for the session state.
2. Chat History: This script will flood your Gemini sidebar with hundreds of “New Chat” entries.
3. Risk: There is always a non-zero risk of Google flagging the account. Do not use your primary Google account for this.

Now that we are all adults here… let’s build something cool.

The Architecture: Why “Human-in-the-Loop” Matters

I’ve tried fully automating social media before. It always ends badly. AI hallucinates, it gets the tone wrong, or it sounds like a robot.

That is why I built a Staging Environment. My script doesn’t post to LinkedIn. It posts to Flatnotes (my self-hosted note-taking app).

The Workflow:

1. Python Script wakes up.
2. Loads Memory: Checks memory.json to see what we talked about last week (so we don’t repeat topics).
3. Generates Content: Uses a heavy-duty system prompt to create a viral post.
4. Staging: Pushes the draft to Flatnotes via API.
5. Human Review: I wake up, read the note, tweak one sentence, and hit “Post.”

The Code: The “Viral Generator”

This script uses asyncio to handle the network requests and maintains a local JSON database of past topics.

Key Features:

• JSON Enforcement: It forces Gemini to output structured data, making it easy to parse.
• Topic Avoidance: It reads previous entries to ensure fresh content.
• Psychological Prompting: The prompt explicitly asks for “Fear & Gap” and “Thumb-Stoppers” marketing psychology baked into the code.

from random import randint
import time
import aiohttp
import datetime
import json
import os
import asyncio
from gemini_webapi import GeminiClient, set_log_level
from dotenv import load_dotenv

load_dotenv()

# Set log level for debugging
set_log_level("INFO")

MEMORY_PATH = os.path.join(os.path.dirname(__file__), "memory.json")
HISTORY_PATH = os.path.join(os.path.dirname(__file__), "history.json")
FLATNOTES_API_URL = "https://flatnotes.notarealdomain.de/api/notes/LinkedIn"
FLATNOTES_USERNAME = os.getenv("FLATNOTES_USERNAME")
FLATNOTES_PASSWORD = os.getenv("FLATNOTES_PASSWORD")
Secure_1PSID = os.getenv("SECURE_1PSID")
Secure_1PSIDTS = os.getenv("SECURE_1PSIDTS")


async def post_to_flatnotes(new_post):
    """
    Fetches the current note, prepends the new post, and updates the note using Flatnotes API with basic auth.
    """
    if not FLATNOTES_USERNAME or not FLATNOTES_PASSWORD:
        print(
            "[ERROR] FLATNOTES_USERNAME or FLATNOTES_PASSWORD is not set in .env. Skipping Flatnotes update."
        )
        return
    token_url = "https://notes.karlcloud.de/api/token"
    async with aiohttp.ClientSession() as session:
    
        # 1. Get bearer token
        token_payload = {"username": FLATNOTES_USERNAME, "password": FLATNOTES_PASSWORD}
        async with session.post(token_url, json=token_payload) as token_resp:
            if token_resp.status != 200:
                print(f"[ERROR] Failed to get token: {token_resp.status}")
                return
            token_data = await token_resp.json()
            access_token = token_data.get("access_token")
            if not access_token:
                print("[ERROR] No access_token in token response.")
                return
        headers = {"Authorization": f"Bearer {access_token}"}
        
        # 2. Get current note content
        async with session.get(FLATNOTES_API_URL, headers=headers) as resp:
            if resp.status == 200:
                try:
                    data = await resp.json()
                    current_content = data.get("content", "")
                except aiohttp.ContentTypeError:
                    # Fallback: treat as plain text
                    current_content = await resp.text()
            else:
                current_content = ""
                
        # Prepend new post
        updated_content = f"{new_post}\n\n---\n\n" + current_content
        patch_payload = {"newContent": updated_content}
        async with session.patch(
            FLATNOTES_API_URL, json=patch_payload, headers=headers
        ) as resp:
            if resp.status not in (200, 204):
                print(f"[ERROR] Failed to update Flatnotes: {resp.status}")
            else:
                print("[INFO] Flatnotes updated successfully.")


def save_history(new_json):
    arr = []
    if os.path.exists(HISTORY_PATH):
        try:
            with open(HISTORY_PATH, "r", encoding="utf-8") as f:
                arr = json.load(f)
                if not isinstance(arr, list):
                    arr = []
        except Exception:
            arr = []
    arr.append(new_json)
    with open(HISTORY_PATH, "w", encoding="utf-8") as f:
        json.dump(arr, f, ensure_ascii=False, indent=2)
    return arr


def load_memory():
    if not os.path.exists(MEMORY_PATH):
        return []
    try:
        with open(MEMORY_PATH, "r", encoding="utf-8") as f:
            data = json.load(f)
            if isinstance(data, list):
                return data
            return []
    except Exception:
        return []


def save_memory(new_json):
    arr = load_memory()
    arr.append(new_json)
    arr = arr[-3:]  # Keep only last 3
    with open(MEMORY_PATH, "w", encoding="utf-8") as f:
        json.dump(arr, f, ensure_ascii=False, indent=2)
    return arr


def get_client():
    return GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)


def get_current_date():
    return datetime.datetime.now().strftime("%d. %B %Y")


async def example_generate_content():
    client = get_client()
    await client.init()
    chat = client.start_chat(model="gemini-3.0-pro")

    memory_entries = load_memory()
    memory_str = ""
    if memory_entries:
        memory_str = "\n\n---\nVergangene LinkedIn-Posts (letzte 3):\n" + "\n".join(
            [
                json.dumps(entry, ensure_ascii=False, indent=2)
                for entry in memory_entries
            ]
        )

    prompt = (
        """
        **Role:** Du bist ein weltklasse LinkedIn-Strategist (Top 1% Creator) und Verhaltenspsychologe.
        **Mission:** Erstelle einen viralen LinkedIn-Post, kurz knapp auf den punkt, denn leute lesen nur wenig und kurz, der mich als die unangefochtene Autorität für Cybersecurity & AI Governance in der DACH-Region etabliert.
        **Ziel:** Maximale Reichweite (100k Follower Strategie) + direkte Lead-Generierung für "https://karlcom.de" (High-Ticket Consulting).
        **Output Format:** Ausschließlich valides JSON.
        **Datum:** Heute ist der """
        + str(get_current_date())
        + """ nutze nur brand aktuelle Themen.

        **PHASE 1: Deep Intelligence (Google Search)**
        Nutze Google Search. Suche nach "Trending News Cybersecurity AI Cloud EU Sovereignty last 24h".
        Finde den "Elephant in the room" – das Thema, das C-Level Manager (CISO, CTO, CEO) gerade nachts wach hält, über das aber noch keiner Tacheles redet.
        * *Fokus:* Große Schwachstellen, Hackerangriffe, Datenleaks, AI, Cybersecurity, NIS2-Versäumnisse, Shadow-AI Datenlecks, Cloud-Exit-Szenarien.
        * *Anforderung:* Es muss ein Thema mit finanziellem oder strafrechtlichem Risiko sein.

        **PHASE 2: Die "Viral Architecture" (Konstruktion)**
        Schreibe den Post auf DEUTSCH. Befolge strikt diese 5-Stufen-Matrix für Viralität:

        **1. The "Thumb-Stopper" (Der Hook - Zeile 1-2):**
        * Keine Fragen ("Wussten Sie...?").
        * Keine Nachrichten ("Heute wurde Gesetz X verabschiedet").
        * **SONDERN:** Ein harter Kontrarian-Standpunkt oder eine unbequeme Wahrheit.
        * *Stil:* "Ihr aktueller Sicherheitsplan ist nicht nur falsch. Er ist fahrlässig."
        * *Ziel:* Der Leser spürt einen körperlichen Impuls, weiterzulesen.

        **2. The "Fear & Gap" (Die Agitation):**
        * Erkläre die Konsequenz der News aus Phase 1.
        * Nutze "Loss Aversion": Zeige auf, was sie verlieren (Geld, Reputation, Job), wenn sie das ignorieren.
        * Nutze kurze, rhythmische Sätze (Staccato-Stil). Das erhöht die Lesegeschwindigkeit massiv.

        **3. The "Authority Bridge" (Die Wende):**
        * Wechsle von Panik zu Kompetenz.
        * Zeige auf, dass blinder Aktionismus jetzt falsch ist. Man braucht Strategie.
        * Hier etablierst du deinen Status: Du bist der Fels in der Brandung.

        **4. The "Soft Pitch" (Die Lösung):**
        * Biete **Karlcom.de** als exklusive Lösung an. Nicht betteln ("Wir bieten an..."), sondern feststellen:
        * *Wording:* "Das ist der Standard, den wir bei Karlcom.de implementieren." oder "Deshalb rufen uns Vorstände an, wenn es brennt."

        **5. The "Engagement Trap" (Der Schluss):**
        * Stelle eine Frage, die man nicht mit "Ja/Nein" beantworten kann, sondern die eine Meinung provoziert. (Treibt den Algorithmus).
        * Beende mit einem imperativen CTA wie zum Beispiel: "Sichern wir Ihre Assets."

        **PHASE 3: Anti-AI & Status Checks**
        * **Verbotene Wörter (Sofortiges Disqualifikations-Kriterium):** "entfesseln", "tauchen wir ein", "nahtlos", "Gamechanger", "In der heutigen Welt", "Synergie", "Leuchtturm".
        * **Verbotene Formatierung:** Keine **fetten** Sätze (wirkt werblich). Keine Hashtag-Blöcke > 3 Tags.
        * **Emojis:** Maximal 2. Nur "Status-Emojis" (📉, 🛑, 🔒, ⚠️). KEINE Raketen 🚀.

        **PHASE 4: JSON Output**
        Erstelle das JSON. Der `post` String muss `\n` für Zeilenumbrüche nutzen.

        **Output Schema:**
        ```json
        {
        "analyse": "Kurze Erklärung, warum dieses Thema heute viral gehen wird (Psychologischer Hintergrund).",
        "thema": "Titel des Themas",
        "source": "Quelle",
        "post": "Zeile 1 (Thumb-Stopper)\n\nZeile 2 (Gap)\n\nAbsatz (Agitation)...\n\n(Authority Bridge)...\n\n(Pitch Karlcom.de)...\n\n(Engagement Trap)"
        }

        **Context für vergangene Posts, diese Themen solltest du erstmal vermeiden:**\n\n"""
        + memory_str
    )

    response = await chat.send_message(prompt.strip())
    previous_session = chat.metadata

    max_attempts = 3
    newest_post_str = None
    def format_flatnotes_post(json_obj):
        heading = f"# {json_obj.get('thema', '').strip()}\n"
        analyse = json_obj.get('analyse', '').strip()
        analyse_block = f"\n```psychology\n{analyse}\n```\n" if analyse else ""
        post = json_obj.get('post', '').strip()
        source = json_obj.get('source', '').strip()
        source_block = f"\nQuelle: {source}" if source else ""
        return f"{heading}{analyse_block}\n{post}{source_block}"
    for attempt in range(max_attempts):
        try:
            text = response.text.strip()
            if text.startswith("```json"):
                text = text[7:].lstrip()
            if text.endswith("```"):
                text = text[:-3].rstrip()
            json_obj = json.loads(text)
            save_memory(json_obj)
            save_history(json_obj)
            newest_post_str = format_flatnotes_post(json_obj)
            break
        except Exception:
            print(response.text)
            print("- output was not valid json, retrying...")
            if attempt < max_attempts - 1:
                previous_chat = client.start_chat(metadata=previous_session)
                response = await previous_chat.send_message(
                    f"ENSURE PROPER JSON OUTPUT!\n\n{prompt}"
                )
            else:
                print("[ERROR] Failed to get valid JSON response after 3 attempts.")

    # Post to Flatnotes if we have a valid post
    if newest_post_str:
        await post_to_flatnotes(newest_post_str)


async def main():
    await example_generate_content()


if __name__ == "__main__":
    for i in range(50):
        asyncio.run(main())
        time.sleep(randint(60, 300))  # Wait between 1 to 5 minutes before next run

The Result (Case Study)

Real-World Example: The “Ethics & Liability” Angle

To prove this isn’t just generating generic corporate fluff, let’s look at a raw output from a simulation run.

I set the internal date to January 31, 2026 (a future scenario regarding EU regulations) and asked the AI to find the “Elephant in the room” regarding Cybersecurity.

The AI didn’t choose a technical topic like “Firewalls.” It chose Personal Liability. It identified that C-Level executives are terrified of going to jail or losing personal assets due to negligence.

Here is the raw JSON output from the script. Pay attention to the analyse field, this is the AI “thinking” before it writes.

{
  "analyse": "Psychologischer Hebel: 'Personal Accountability' & 'Optimism Bias'. C-Level-Führungskräfte leben oft in der Illusion, Cyber-Risiken durch die Einstellung eines CISO vollständig an diesen delegiert zu haben (Moral Hazard). Der 'Elephant in the room' am 31.01.2026 ist das Ende der Schonfrist für die NIS2-Umsetzung...",
  "thema": "Der CISO-Irrtum: Warum Delegation Sie jetzt ins Gefängnis bringt",
  "source": "EU NIS2 Enforcement Reports Q1 2026 / Handelsblatt",
  "post": "Ihr CISO ist nicht Ihre Versicherung.\nEr ist Ihr potenzieller Belastungszeuge.\n\nDer Irrglaube vieler Vorstände hat im Januar 2026 ein jähes Ende gefunden.\n\nDie erste Welle der NIS2-Prüfungen rollt durch die DACH-Region.\nUnd die Aufsichtsbehörden suchen nicht nach technischen Fehlern.\nSie suchen nach 'Organisationsverschulden'.\n\nDas Szenario:\nEin Ransomware-Angriff legt die Produktion lahm.\nDer CEO sagt: 'Ich habe doch einen Top-CISO eingestellt. Das war sein Job.'\n\nDer Richter sagt: 'Nein. Die Überwachungspflicht ist nicht delegierbar.'\n\nWenn Sie Cyber-Resilienz als reine IT-Aufgabe behandeln, handeln Sie grob fahrlässig.\nDer CISO liefert die Technik.\nAber *Sie* liefern die Governance.\n\nWenn Sie das Risikoprofil Ihrer eigenen Supply Chain nicht ohne PowerPoint erklären können, haften Sie.\nNicht die GmbH.\nSie persönlich.\nMit Ihrem Privatvermögen.\n\n[...]\n\nSichern wir Ihre Assets. ⚖️"
}

Why This Post Works (The Anatomy)

This output demonstrates exactly why we use the “Human-in-the-Loop” architecture with Flatnotes. The AI followed the 5-step viral matrix perfectly:

1. The Hook:“Ihr CISO ist nicht Ihre Versicherung. Er ist Ihr potenzieller Belastungszeuge.”
   • It attacks a common belief immediately. It’s controversial and scary.
2. The Agitation: It creates a specific scenario (Courtroom, Judge vs. CEO). It uses the psychological trigger of Loss Aversion (“Mit Ihrem Privatvermögen” / “With your private assets”).
3. The Authority Bridge: It stops the panic by introducing a clear concept: “Executive-Shield Standard.”
4. The Tone: It avoids typical AI words like “Synergy” or “Landscape.” It is short, punchy, and uses a staccato rhythm.

Summary

By combining Gemini’s 2M Context Window (to read news) with Python Automation (to handle the logic) and Flatnotes (for human review), we have built a content engine that doesn’t just “write posts”—it thinks strategically.

It costs me pennies in electricity, saves me hours of brainstorming, and produces content that is arguably better than 90% of the generic posts on LinkedIn today.

The Verdict

From Consumer to Commander

We started this journey with a simple goal: Save €15 a month by cancelling ChatGPT Plus. But we ended up with something much more valuable.

By switching to Gemini Advanced and wrapping it in Python, we moved from being passive consumers of AI to active commanders.

• We built a Nano Banana Image Generator that bypasses the browser and cleans up its own mess (watermarks).
• We engineered a LinkedIn Strategist that remembers our past posts, researches the news, and writes with psychological depth, all while we sleep.

Is This Setup for You?

This workflow is not for everyone. It is “hacky.” It relies on browser cookies that expire. It dances on the edge of Terms of Service.

• Stick to ChatGPT Plus if: …can’t think of a reason, it is sub-par in every way
• Switch to Gemini & Python if: You are a builder. You want to save money and you want to build custom workflows that no off-the-shelf product can offer (for free 😉).

The Final Word on “Human-in-the-Loop”

The most important lesson from our LinkedIn experiment wasn’t the code, it was the workflow. The AI generates the draft, but the Human (you) makes the decision.

Whether you are removing watermarks from a cat picture or approving a post about Cyber-Liability, the magic happens when you use AI to do the heavy lifting, leaving you free to do the creative directing.

Ready to build your own agent? 

Happy coding! 🚀

The journey to bringing you this guide was paved with rage and hardship. Before we go any further, let me be clear: local AI is nowhere near as good as ChatGPT or similar online tools. Without solid prompt engineering, you’ll mostly get weird, useless responses.

That said, DeepSeek-R1 (32B) is hands down the best local model I’ve ever used—but even then, it’s nowhere near the level of ChatGPT-4o in the cloud. To match that, you’d need the DeepSeek-R1 671B model, which is a mind-blowing 404GB. Running that locally? Yeah, that would be absolute madness.

Disclaimer: This post has some strong opinions about Linux distributions and hardware that some people may find disturbing or hurtful. Please don’t take it too serious.

Rant about AMD

Skip it, or read my raw unfiltered anger.

The image of this post perfectly reflects my mood.

A while ago, I decided to build an AI server at home to run models locally. My plan was to get an NVIDIA 4090, which at the time cost around 2000€. But then, my friend—who runs Arch as his daily driver (I should’ve seen the red flag)—was using an AMD RX 7900 XTX, which was only 900€ at the time. He hyped it up, saying, “Oh yeah, get this one! Same VRAM, super easy to set up, everything works flawlessly!”

I was intrigued.

As fate would have it, another friend echoed the same thing, insisting that for 24GB of VRAM, I wouldn’t find anything cheaper. And, well, that was actually true.

However, everything I read online told me that AMD GPUs lag far behind NVIDIA in every way, and worst of all, you’d always have to hack things together just to make them work. Still, on Black Friday, I caved and bought the AMD GPU.

I regret it every single day since putting it in. I hate it. It absolutely sucks.

So far, it has worked on Windows 11—but even there, it was a pain. And seriously, how do you even mess up Windows 11 support??

Then I switched to Ubuntu as my main OS (☹️). After two days of struggle (and reinstalling the entire OS three times), I somehow got it to work. I still don’t know what I did. Every guide on the internet gives different commands, different settings, and different advice. Most are for older AMD GPUs, almost none work for the newer models, and—just for fun—most of the essential tools don’t support the “new” AMD cards either.

I hate it. I hate it so much.

I will never buy an AMD GPU ever again. Even if they came with 100GB of VRAM and cost just 5€, I do not care.

Looking back, I would rather pay 2000€ for a GPU that just works than spend endless hours hacking together the most basic functionality. The sheer frustration of dealing with this mess infuriates me beyond words.

This post serves as both a rant and a personal reminder: Never. Ever. Ever. Buy. AMD. Hardware. Again.

To be honest, I’m just as disappointed in AMD CPUs. Their hardware transcoding is absolute trash.

From now on, it’s Intel and NVIDIA, forever and always.

Prerequisite

• 32GB RAM (with ComfyUI, bump that up to 40GB)
• 250GB SSD Storage
• Debian 12 LXC

If you are more curious about my exact setup you’ll find a detailed list where you can check if yours is similar here: My Home Server: “PrettyLittleKitten” – A Personal Tech Haven. At the very least, your GPU should match (AMD RX 7900 XTX) to follow the tutorial step by step. If it doesn’t, chances are it’ll fail.

You need to install the kernel drivers on the host for passthrough to an LXC:

apt update
apt install pve-headers dkms
apt install amdgpu-dkms

You need to reboot Proxmox after that.

reboot

Setting up LXC

It’s important to note that the LXC must be privileged. I know there are guides for setting up an unprivileged one, but literally none of them worked—which only fueled my rage to unbearable levels.

So yeah… I just went with privileged.

Easy mode Proxmox VE Helper-Scripts:

bash -c "$(wget -qLO - https://github.com/community-scripts/ProxmoxVE/raw/main/ct/debian.sh)"

Or, just manually add a Debian 12 LXC in the Proxmox GUI. Make sure to enable nesting=1, as this is required for Docker to work later.

I did try to get this working on Ubuntu 24 for hours… and failed miserably. Don’t ask me why—I have no idea.

Now, let’s install some dependencies that we’ll need later—or at the very least, ones that will make our lives easier:

apt update && apt upgrade -y
apt install sudo curl jq -y
cd /tmp
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh ./get-docker.sh 

You are free to install docker without using the convenience script.

GPU Passthrough

This heavily depends on your hardware and software.

If, like me, you have an AMD RX 7900 XTX and Proxmox 8.3.3, then you can just follow along. Otherwise—based on my own painful experience—you’ll likely need to find another guide.

Inside the LXC, run:

cat /etc/group | grep -w 'render\|\video'

This will display the GIDs you need for passthrough in a second—so make sure to note them down:

video:x:44:root # <- /dev/kfd
render:x:993:root # <- /dev/dri/render*

The 44 will be used for “video” and the 993 for “render”. Yours will, of course, be different.

On the Proxmox host run the following command:

lspci | grep VGA
ls -l /sys/class/drm/renderD*/device

The output should be something like this:

lspci | grep VGA
03:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Navi 31 [Radeon RX 7900 XT/7900 XTX] (rev c8)
11:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Raphael (rev cb)

ls -l /sys/class/drm/renderD*/device
lrwxrwxrwx 1 root root 0 Feb  2 13:33 /sys/class/drm/renderD128/device -> ../../../0000:03:00.0
lrwxrwxrwx 1 root root 0 Feb  2 13:33 /sys/class/drm/renderD129/device -> ../../../0000:11:00.0

In my case, “renderD128” is the part I need. To find yours, match the ID from the first command (e.g., 03:00.0) with the ID from the second command (e.g., 0000:03:00.0). Once they match, you’ll know which renderD* device corresponds to your GPU (the other one is the iGPU of the CPU, don’t use that).

 In the Proxmox GUI, go to your LXC container’s “Resources” tab and click “Add” → “Device Passthrough“. Now, add the “video” and “render” devices using the GIDs you noted earlier:

• Render device: Use the path for your graphics card and the GID from the LXC output.
• Video device: Use /dev/kfd and the GID for “video” from the LXC output.

This is what your settings should look like (you may need to restart the LXC first).

After a restart of the container check to see if permission are correct:

ls -lah /dev/kfd /dev/dri/renderD128 # <- edit the ID

The output should look like this:

crw-rw---- 1 root render 226, 128 Feb  2 18:01 /dev/dri/renderD128
crw-rw---- 1 root video  236,   0 Feb  2 18:01 /dev/kfd

Make sure that “root render” is the GPU and “root video” the Kernel Fusion Driver (kfd).

Kernel Fusion Driver

If you want to run ROCm-based GPU compute workloads, such as machine learning, OpenCL, or scientific computing, on your AMD GPU within Proxmox. It acts as the interface between the AMD GPU driver and user-space applications, enabling GPU acceleration for parallel computing tasks.

– ChatGPT-4o

Install AMD Software

We need to install some tools inside of our Debian LXC:

apt update && apt upgrade -y
cd /tmp
wget https://repo.radeon.com/amdgpu-install/6.2.4/ubuntu/noble/amdgpu-install_6.2.60204-1_all.deb
sudo apt install ./amdgpu-install_6.2.60204-1_all.deb
amdgpu-install --usecase=rocm --no-dkms

You can also refer to the official guide: Quick Start Installation Guide – ROCm (at the very least, check if the links are still valid by the time you’re reading this).

The download might take a while. Since I have a new AMD RX 7900 XTX, I need to use:

export HSA_OVERRIDE_GFX_VERSION=11.0.0
echo 'export HSA_OVERRIDE_GFX_VERSION=11.0.0' >> ~/.bashrc
source ~/.bashrc

The next step is to test if everything is working. We’ll use amdgpu_top for this (you can skip this, but I wouldn’t):

sudo apt install libdrm-dev
cd /tmp
wget https://github.com/Umio-Yasuno/amdgpu_top/releases/download/v0.10.1/amdgpu-top_without_gui_0.10.1-1_amd64.deb
dpkg -i amdgpu-top_without_gui_0.10.1-1_amd64.deb 
amdgpu_top

You should see the name of your GPU and see some values below.

Run this command inside of the LXC to see if everything worked correctly:

/opt/rocm/bin/rocminfo

Somewhere in that “rocminfo” output you should see your GPU (and a bunch of other nerd stuff):

  Marketing Name:          Radeon RX 7900 XTX
  Vendor Name:             AMD

🤩 Sweet!

Installing Ollama

This will also take a while. Just follow the guide on the Ollama website —here’s all you need to do:

apt install curl 
cd /tmp
curl -fsSL https://ollama.com/install.sh | sh

Since curl is not installed by default in the Debian LXC we’re using, we’ll need to install it first (if you filled this guide, you have it already). Then, we’ll run the install script from the Ollama website. Be patient—the download takes a while since it pulls about 30GB of data.

By the way, I love the Ollama website. The simple black-and-white design with rounded borders? 🤌 I’m a sucker for minimalistic aesthetics. (I hope you like my blog’s design too! 🕺)

Next Step: Testing with a Smaller Model

Before downloading the DeepSeek 32B model, we’ll first test with a smaller DeepSeek version. If your GPU matches mine, the larger model should work fine.

You can check the available models on the Ollama Models website.

Now, run this command—it’s going to download a 1.5GB file, so the wait time depends on your internet speed:

ollama pull deepseek-r1:1.5b

You can then test:

curl -X POST http://localhost:11434/api/generate -d '{
  "model": "deepseek-r1:1.5b",
  "prompt": "Tell me a funny story about my best friend Karl. 300 characters maximum.",
  "stream": false
}' | jq .

Once upon a time, in the quiet town of Pawsley, there was Karl, a beloved kind cat who adored his three feline friends: Sam, Max, and Lily. Karl always had a warm smile and a habit of aiding others, often finding humor in unexpected places.

One crisp autumn afternoon, Karl spotted a bag of marbles on the park’s bench. Curious, he decided to play with them. To everyone’s surprise, a man walked by, holding a jar full of coins instead of marbles. “Hey, it’s you!” Karl exclaimed. The man, initially unimpressed, asked for his change. Karl suggested taking one marble in exchange and gave him the coins.

“Thank you,” the man thanked. Karl offered him a glass of water, knowing the jar was empty. “That’ll keep me happy,” he said. But as the water filled the glass, a strange ripple appeared on the floor. The man ran over to check but found nothing—no coins, just a tiny, pink spot.

“Wait, is it my pet?!” Karl pointed. The man laughed, looking suspiciously at Karl. “You saw that marble in there.” He handed Karl a piece of paper and said,”I need your help.”

Karl rolled on his back and rolled into the street. From behind him, he saw Sam, Max, and Lily with their usual spotlights on. Karl placed a paw on Sam’s paw, suggesting they might be related.

“Hey!” Max excitedly exclaimed. “My little sister is getting sick! Can you help me find her?”

Karl hesitated but followed Max to the neighbor’s yard. His friend found Lily, who was hiding somewhere. Karl helped Lily bring her back home, while Sam and Max watched in laughter. Karl’s kind words were met with cheers.

In the end, Karl became a beloved companion among Pawsley’s residents, not just for his love of marbles but also for his warmth and kindness.

Never interrupt an AI artist in the middle of their masterpiece. 🎨🤖 But yeah, the 300-Character-Limit was ignored.

Cleanup

Let’s get rid of the old files. But first, double-check before running these commands—they’ll wipe out all .sh and .deb files in /tmp.

ls -lh /tmp/*.sh /tmp/*.deb

The command above shows you what the command below will delete. Proceed if the displayed files are trash. The deleted files are irreversibly gone after this command:

rm -f /tmp/*.sh /tmp/*.deb
apt autoremove

Testing OpenWebUI with DeepSeek-R1 32B

The prompt I gave DeepSeek was “Give me a 10 word super short story about a cat named Paul.” – which is the name of my actual cat.

Well, not quite 10 words, but close enough. This was a cold start, meaning the model wasn’t loaded into VRAM yet—so yeah, it took a bit longer.

DeepSeek really put in some serious effort here, like it was deep in thought, sweating over every word. 😂 Considering all that, the result is absolutely hilarious:

Okay, so I need to come up with a 10-word super short story about a cat named Paul. Hmm, let’s see… The user gave an example: “Paul the cat climbed the fence, chasing a bird, then napped in the sun.” That’s pretty straightforward but conveys a little action and a bit of character.

I should think about what elements make a good 10-word story. It needs to have a clear subject (Paul), some action or activity, maybe an obstacle or goal, and perhaps a resolution or consequence. Since it’s so short, each word counts, so I need to be concise but still vivid.

Let me brainstorm some ideas about Paul the cat. Maybe he’s curious, playful, adventurous, or lazy. The example has him chasing a bird and then napping. Perhaps another activity? Maybe exploring somewhere, finding something, or having an interaction with another animal or person.

I should think of a simple structure: subject (Paul), action verb, some context, maybe an obstacle or additional detail, and a resolution. For example, “Paul pounced on the mouse but it escaped.” That’s 8 words. Maybe add more details to make it 10.

Or perhaps something like “Paul sat by the window watching birds chirp.” That’s also 8 words. Maybe include movement: “Paul raced through the garden chasing a butterfly.”

Wait, the user provided an example that starts with Paul doing an action (climbed), then another action (chasing), and ends with resting (napped). So perhaps following a similar structure would work well.

Let me try: “Paul explored the attic, found a toy, and took a nap.” That’s 9 words. Maybe add more detail or action. Or “Paul climbed the tree, met another cat, then curled up to sleep.”

Wait, that’s 10 words. Hmm, but it feels a bit flat. Maybe make the interaction more engaging: “Paul chased a squirrel around the yard and finally rested.” That’s 9 words. Could add something like “in the shade” at the end for 10.

Alternatively, maybe include some emotion or consequence: “Paul pounced on the ball, rolled over, and fell asleep.”

Wait, let me check word count. Each idea needs to be exactly 10 words. Let’s see:

• Paul the cat climbed the fence, chasing a bird, then napped in the sun. (10 words)

So that’s the example given. I can try something similar but different.

Maybe focus on a different activity: “Paul discovered a sunny spot, curled up, and purred softly.” That’s 9 words. Maybe add more action or detail to make it 10.

Alternatively: “Paul leaped onto the counter, knocked over a bowl, then ate the leftovers.” That’s 10 words but maybe a bit long in description.

Another angle: “Paul wandered through the park, met a dog, and they played together.” That’s 9 words. Add something like “all day” at the end for 10.

Wait, perhaps include some obstacle or challenge: “Paul tried to catch a fish in the pond but got wet.” That’s 10 words. It includes an attempt, action, consequence.

Or maybe something more peaceful: “Paul stretched lazily on the rug, yawned, and drifted off.” 9 words. Add “to sleep” for 10.

I think I need to ensure each word adds value without being redundant. Let me try another approach:

• Paul chased a butterfly in the garden until it flew away. (That’s 8 words. Maybe add “then rested” at the end: 10 words.)

Wait, but that might be too similar to the example.

Alternatively, focus on something unique about Paul: “Paul, the curious cat, explored every nook and cranny.” That’s 9 words. Maybe add “all day long” for 12; that’s too many.

Perhaps include an interaction with another animal or a person: “Paul meowed at the door, demanding attention, then curled up.” 9 words. Add “by the fire” for 10.

Wait, perhaps combine actions and consequences more effectively. Let me think of a scenario where Paul does something that leads to a natural conclusion in just 10 words.

How about: “Paul sneaked into the kitchen, stole a treat, then hid under the bed.” That’s 9 words. Maybe add “to digest” for 10.

Or maybe something more adventurous: “Paul climbed a tall tree, got stuck, and miaowed for help.” That’s 9 words. Add “from his owner” for 11; that’s too many.

Alternatively: “Paul caught a moth in the dark, played with it, then slept soundly.” 9 words. Maybe add “through the night” for 10.

I think I’m overcomplicating it. Let me go back to the example and see if I can structure something similar but different. The example has two actions (climbed, chasing) followed by a rest. So maybe another set of actions leading to a consequence or resolution.

Perhaps: “Paul chased his tail in circles until he panted.” That’s 8 words. Maybe add “then stopped to rest” for 10.

Alternatively: “Paul jumped on the sofa, knocked over a lamp, then slept.” But that’s 9 words; maybe add “peacefully” at the end for 10.

Wait, perhaps focus on Paul’s interaction with an object or another animal. Let me think of something unique but still within the 10-word limit.

Another idea: “Paul found a cozy spot under the stairs and napped.” That’s 8 words. Maybe add “after exploring all day” for 10.

Wait, that would be “Paul found a cozy spot under the stairs after exploring all day.” That’s 9 words. Hmm.

Alternatively: “Paul purred contentedly while basking in sunlight.” 7 words. Add some activity before that to make it 10.

I think I need to stick to a structure where Paul does something, then another action or consequence, and maybe ends with a state or rest.

Let me try again: “Paul climbed the fence, chased a butterfly, then napped in shade.” That’s 9 words. Maybe change “then” to “and” for flow: “climbed, chased, and napped” but that might not add up correctly.

Wait, let’s count the example given: “Paul the cat climbed the fence, chasing a bird, then napped in the sun.” That’s 10 words. So it includes his name, his action (climbed), context (the fence), another action (chasing), and the consequence (napped in the sun). I need to mirror that structure but with different actions.

So maybe: “Paul the cat explored the garden, found a mouse, then relaxed by the pond.” That’s 10 words. It follows a similar flow—action, context, additional action, consequence.

Alternatively: “Paul the cat pounced on a toy, rolled around, and fell asleep.” 9 words. Add “on the rug” for 10.

Wait, maybe make it more dynamic: “Paul the cat raced through the park, met a friend, then rested under a tree.” That’s 10 words. It shows activity, interaction, and rest.

I think that’s a good structure—action, context, another action or interaction, consequence. So putting it all together, I can create a concise story within the word limit.

– DeepSeek-R1:32B thoughts

Here you can see the electricity usage—a solid 450W for two minutes until things calmed down. Usually the server “idles” at around 50-53W, since I have a local SIEM and this website (along with a lot of other stuff) runs on it, it is never really really idle.

Both hardware and software went all in, pushing their limits… all for my short, 10-word cat story:

This does not prove that DeepSeek-R1 is a waste of electricity and ends up with a subpar result, rather that you probably do not need an advanced thinking model for such a super simple task.

Check out dolphin-mistral, also on a cold start only taking 4 seconds. The second message did not even take a second:

Bonus: ComfyUI

The Official Installation Guide: How to Install ComfyUI on Linux Alright, OpenWebUI now supports ComfyUI for image generation (still in beta at the time of writing). Here is the super quick start for ComfyUI, run these commands in your LXC:

apt update && apt upgrade -y && apt install git apt install python3.11-venv -y
mkdir ~/comfy && cd ~/comfy
git clone https://github.com/comfyanonymous/ComfyUI.git
cd ~/comfy/ComfyUI
python3 -m venv venv
source venv/bin/activate
pip install --upgrade pip
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0
pip install -r requirements.txt

Make sure to double-check the versions and links against your system and the official guide I linked at the top.

Once everything is set up, give it a test run to confirm it’s working as expected:

python main.py

If your output confirms that everything is running smoothly, go ahead and turn it into a system service:

nano /etc/systemd/system/comfyui.service

Paste the following into the service file:

[Unit]
Description=ComfyUI Service
After=network.target

[Service]
User=root
Group=root
WorkingDirectory=/root/comfy/ComfyUI
ExecStart=/root/comfy/ComfyUI/venv/bin/python /root/comfy/ComfyUI/main.py --listen 0.0.0.0
Restart=always

[Install]
WantedBy=multi-user.target

Now reload and start the comfyui.service:

sudo systemctl daemon-reload
sudo systemctl enable comfyui.service
sudo systemctl start comfyui.service
sudo systemctl status comfyui.service

ComfyUI Manager

ComfyUI Manager is the ultimate quality-of-life add-on for ComfyUI, making model and plugin installation a breeze. Just get it—you’ll thank me later:

cd ~/comfy/ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager comfyui-manager
sudo systemctl restart comfyui.service

Restart takes a little while since it downloads some dependencies, but no worries—give it a minute or two, and everything should run smoothly.

Conclusion

You should now have a working Debian LXC for local AI tasks, equipped with:

• Ollama
• OpenWebUI
• ComfyUI (optional)

Setting this up, especially with newer AMD GPUs, used to be a bit of a headache. I’m honestly glad I waited a bit—getting this to work wasn’t exactly painless, and I had to do a lot of digging through forums. But hey, it’s running now!

Next up, get some models from the Ollama page. If you have an AMD RX 7900 XTX, you should be able to run the 32B version of DeepSeek-R1 effortlessly. Technically, you can load models larger than your VRAM, but be warned—it’ll slow things down.

Also, don’t forget to secure your AI server and add valid SSL certificates, check out my post about it:

I set up firewall rules centrally on my Dream Machine, so my AI server can only communicate with the reverse proxy.

If your setup is different, you might want to handle this locally using UFW.

These Goodbye Message are Brought to you by AI

Aww, yaaaay! I totally loooove all your amazing readers <3 Wishing you guys the biiiggest luck with everything you dooove, okay? Dayyyyyybeeee~ 💕✨

– qwen2.5:32b

Love y’all, keep slaying in everything you do <3 Can’t wait to see what awesome things you have coming up. Bye for now! 👋🏼😉

– dolphin-mistral

EDIT 1 (04.02.2024)

I have downloaded and tested almost all popular models now and the only actually usable one for daily business like rewriting German emails or asking for expertise in German is qwen2.5 so far.

The uncensored Dolphin models are a lot of fun, but also kind of stink with German, which is of course because their underlying models aren’t good at German either.