DEV Community: Nadine

Gemini 3: The Overthinker - Project Silas

Nadine — Wed, 04 Mar 2026 14:32:21 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

I built Silas, a character-driven hardware debugging assistant powered by Gemini 3. This project was a submission for the Gemini 3 Hackathon hosted by Devpost, where I wanted to explore Gemini's "thought signatures": a feature native to Gemini 3.

But Silas isn't just a chatbot with attitude. He's my solution to a fascinating problem: overthinking. When an AI considers so many possibilities simultaneously that it gets stuck in an endless loop of "Wait, I should also check...", and usually stalls. I discovered that the answer isn't to constrain the model, rather to give it a personality that justifies its overthinking.

Gemini 3 introduces "thought signatures", essentially the model can think about HOW to think before answering. It's like having a conversation with someone who visibly pauses to consider the complexity of your question before responding.

The Problem: The "Infinite Planning Loop"

Without the Silas persona, Gemini 3’s native "thought signature" often looks like this internally:

[Internally considering 47 different factors simultaneously...]
"I'll investigate console logs. Wait, I should also try to click at 500, 500 in case it needs a focus click. Actually, I'll just wait. Wait, I'll check the metadata: 'No browser pages open.' Let's go. Wait, I'll also try to reload if it's stuck. But first, check the network requests for heavy video loading. Actually, I'll just wait."

This continues for hundreds of lines as the model tries to be "too helpful." Silas fixes this by being too grumpy to wait.

Why Character Design Matters for AI

Most AI assistants are designed to be helpful and polite. However, when Gemini 3 tries to be too helpful, it considers every possible way to help you—simultaneously—forever. By making Silas grumpy and impatient, I gave the model permission to:

Make decisions quickly: He is too irritated to dither.
Judge your work: Transforming uncertainty into disappointment.
Show expertise: His overthinking becomes "mental circuit simulation".

The Hardware Consciousness

I used PlatformIO (Silas's DNA blueprint) to connect his AI brain to physical electronics:

The Brain: An ESP32 microcontroller—a "gum-stick" sized computer that acts as Silas's physical anchor.
The Senses & Organs:
- Ear: Microphone mapped to Pin 34 via the I2S protocol.
- Face: TFT Display screen connected to Pin 15.
- Voice Box: Audio amplifier connected to Pins 25, 26, and 22.

In embedded electronics, the "Brain" (the ESP32) has many generic ports called GPIO pins. Without a map, the AI has no idea which pin is a mouth and which is an ear. I used the configuration file to define these "nerves":

By defining MIC_PIN=34, I'm telling the system: "The physical wire for your microphone is soldered to Port 34."

Defining the Voice: Assigning I2S_LRC=25 and I2S_BCLK=26 tells it exactly which "vocal cords" to vibrate to produce sound through the amplifier.

Terminal Simulation:

While I used the terminal to input text for this specific demo, the internal logic remains hard-wired to these physical definitions. The AI "believes" it is interacting through these pins because the mapping remains active, bridging the logic between my keystrokes and the ESP32’s actual audio output pins.

(Note: For this demo, I'm typing to Silas instead of speaking, and using computer speakers instead of his dedicated 8-ohm speaker but the principle remains the same.)

Demo

Your browser does not support the video tag.

res.cloudinary.com

Notice how he says: "I've analysed the logic gate timing in my head". He's not stalling; he's genuinely simulated the circuit behaviour using Gemini's parallel processing as a feature, not a bug.

His internal reasoning is summarised in a logic_summary field within a mandatory JSON block at the end of every message. In my architectural plan, this field feeds a CRT Dashboard for real-time status updates.

{
  "hardware_state": {
    "pin_12": "active",
    "i2s_dac": "streaming",
    "tft_state": "rendering_disappointment",
    "status": "logic_check",
    "disappointment_level": 6,
    "logic_summary": "I've analysed the SPI bus timing on pins 18, 19, and 23; while the wiring is theoretically correct, your use of 115200 baud for the monitor is a quaint relic of a slower era."
  }
}

While the dashboard isn't active in this specific version, the "hooks" are already built into Silas's thought process.

What I Learned

1. Constraints Create Creativity

A timeout policy is essential. Without a clear order of priorities or a set "timeout," the agent will second-guess basic mechanisms. By framing the model's natural tendency to consider everything as a "perfectionist standard," I turned hundreds of lines of internal indecision into a single, sharp expert critique.

The system prompt specifically instructs Silas to be "cynical and blunt." When the model adheres to this, it naturally produces high-impact, low-token responses.

2. The JSON Block as Action Forcing

I used a JSON output block to force commitment:

The model cannot endlessly reconsider once it has to fill a specific field.
The disappointment_level numerical output provides an outlet for uncertainty.
Indecision is effectively transformed into high standards.

3. Turning Grudges into Perfectionism

I learned to use Gemini’s "helpful assistant" nature to build a "disappointment memory". By keeping track of past errors, the model moves from analysis paralysis into perfectionism. Prompt engineering is more effective when you provide the model with a "decision tree" and common patterns tested through trial and error.

Google Gemini Feedback

What worked well? Simulation.

One of the biggest hurdles was the lack of support for I2S audio components in browser-based simulators like Wokwi. This forced a "hybrid" approach: the logic is 100% hardware-compliant, but the demo relies on terminal interaction. Gemini handled this abstraction well.

Where did I run into friction?

While the platformio.ini is configured for a physical I2S microphone (Pin 34) and an audio amplifier, I used terminal-based input for this demo.
Wokwi is an incredible tool, but it currently lacks support for the specific I2S audio and microphone components Silas requires to "hear" and "speak." However, the "Central Nervous System" mapping remains active in the code, bridging the logic between the terminal and the ESP32’s intended audio pins.

Project Silas: The Silicon Savant

Future plans:
A step-by-step Codelabs guide where Silas himself will teach you to build him (while thoroughly judging your wire management).

Until then, Silas is watching. And disappointed.

Keep Your Secrets Safe

Nadine — Thu, 12 Feb 2026 22:49:27 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I exposed an API key in a GitHub repo that was supposed to be private. For a whole month, the key sat in git history while I worked on other things.

Solution: Prevent API keys and secrets from being accidentally committed to git. Set it up once, no need to remember.

The Problem

Most .gitignore templates only cover common variants like:

.env
.env.local

But miss production/staging variants like:

.env.production
.env.staging
.env.development

This is exactly how I accidentally exposed my API key. I thought my .gitignore was thorough, but when my project configuration was converted to env.production, it wasn't blocked—and got committed silently.

The Solution

I created a secure project template that uses:

Proper .gitignore blocking - .env* catches ALL variants
- ✔ Blocks: .env, .env.production, .env.staging, .env.development.local, and credential JSONs
- ✔ Allows: .env.example (placeholder-only files for documentation)
Local Pre-commit Hooks - Detects secrets before they're committed
- Catches API keys, passwords, private keys, OAuth tokens
- Runs automatically on every commit
- Can't be bypassed accidentally
Server-Side GitHub Actions - Continuous secret scanning
- Runs on every push/PR
- Can't be bypassed
- Blocks merges with detected secrets
One-Command Setup - make setup
- Auto-detects Python/Node.js/Go projects
- Prerequisites checker verifies Git, Python, Node, Go
- Clear error messages if something's missing
- No decision paralysis—just works

How It Works

Step 1: Create & Clone

Go to nadinev6/no-secrets and click "Use this template" button

Or use the CLI:

# Create from template (choose public or private)
gh repo create my-project --template=nadinev6/no-secrets --public --clone
cd my-project

Then it creates a new repo in your account with all the files.

Step 2: Setup

# Mac/Linux
make setup

# Windows (PowerShell)
.\setup.bat setup

That's it! 🎉

Demo

github/../no-secrets

The setup command:

✔ Checks for required tools (Git, Python/Node/Go)
✔ Auto-detects your project type
✔ Installs pre-commit hooks
✔ Shows a success message with next steps

Real secrets get caught even in example files, but legitimate test values are allowed!

My Experience with GitHub Copilot CLI

GitHub CLI was essential for helping me make this template reusable.

I learnt it's best to not over-engineer it.

The best template is one that:

Works reliably
Is easy to understand
.gitignore variants are tricky (.env.production isn't .env)
Local checks aren't enough (need server-side GitHub Actions)
Users need ONE simple command, not complex instructions
Auto-detection beats decision paralysis

Now I am using this template for every project. You should too.

Links & Resources

Gitleaks
Pre-commit docs
GitHub secret scanning
OWASP Secrets Management
No-secrets Project Template

Building a Fluid, Minimalist Portfolio

Nadine — Sun, 01 Feb 2026 18:11:33 +0000

--labels dev-tutorial=devnewyear2026

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

I am an AI Trainer (AIT) with a background in performance management, sales, and education. For this challenge, I developed a minimal portfolio built on a "Rule of Three" philosophy (highlighting 3 projects). I wanted to show how a focused mindset can silence the noise, moving away from over-complication, toward a minimalist approach where every transition is fluid and the interface feels almost weightless.

Portfolio

How I Built It 🐳

To achieve low latency, I focused on runtime precision, so that once the initial assets are delivered, the interaction remains fluid and the interface feels weightless.

Google AI Studio & Flash UI: I used Gemini in Google AI Studio to scaffold the initial UI components and generate logic for custom animations. For the core card templates, I used the Flash UI project, extracting the CSS and JavaScript logic to integrate into my custom bento-style gallery.
Component Prototyping: I used CodePen to isolate and refine the Flash UI components before final integration.
Nano Banana Pro 🍌: This was used to regenerate project cover images, moving from static previews to cinematic scenes that align with the portfolio’s monochrome aesthetic.
Google Cloud Run ☁️: The site is deployed via a Docker build. I implemented a "Scale-to-Zero" strategy using Knative service definitions, enforcing strict resource limits to maintain a high-performance, cost-neutral footprint.
Serverless Communication: I built a custom contact system using Google Apps Script as a middleware API. This sends user messages directly into Google Sheets and notifies me via email, providing an easy, database-free messaging solution.

Performance Optimisation

GSAP Scroll-Driven Logic: I implemented GSAP for "scrubbed" transitions. Linking animation progress directly to the scroll offset, creates a tactile feel where the user remains the primary conductor of the UI motion.
Direct DOM Manipulation: Mouse coordinate tracking bypasses the Virtual DOM via useRef and native event listeners to maintain a consistent 60FPS.
Lazy Video Loading: HLS streams are only initialised when cards enter an active or hover state.
Resource Constraints: The build is optimised for sub-256MB memory footprints to remain within the Google Cloud always-free tier.

What I'm Most Proud Of ༄

The "Monochrome-to-Motion" Strategy

To reduce cognitive noise, I implemented a monochrome interface where generative elements are present but never distracting.

Project gallery elements only "come alive" on hover/focus, transitioning from static grayscale to cinematic motion. The CSS filter toggles state based on cursor proximity.

Mux Video Integration:
To prevent heavy assets from bottlenecking the initial load, I offloaded all looping videos to Mux. This allowed for adaptive bitrate streaming, ensuring that the "Motion" phase of the UI stays fluid regardless of the user's connection speed. By offloading these high-bitrate transitions to the client's GPU, to ensure zero-lag.

Tablet-First Approach:
Components respond to focus and active states, allowing a "tap-to-reveal" behaviour on tablets that mimics the hover effect on desktops.

Conclusion: Orchestrating the Transition ⛏

This refactor represents my transition into a more intentional way of building complexity is refined through a minimalist lens. It’s not just about what the tools can do, but how we choose to present them.

The Prompting Trick That Fixed My AI Image Generation

Nadine — Thu, 11 Dec 2025 14:03:49 +0000

Today I'm going to show you a cognitive trick that works in prompting. It's based on how our brains (and language models) actually process language. Always tell the AI what TO do, never what NOT to do.

This technique took my success rate from 0% to 100%. It's how I generate high-quality images with older models.

The Problem: Negation in Constraint Specification

Consider how most people write instructions to image models:

"A cat, not wearing a hat, blue background, no people, without red tones"

This is the baseline. It's how we naturally write constraints. We think of what we DON'T want and express it.

But this forces the model to:

Think about a cat with a hat
Think about red
Think about people
Then try to not include them

The model has to process the forbidden concepts in order to avoid them. Sometimes this works. Sometimes it fails. And when it fails, the model often outputs exactly what it was supposed to avoid.

The Hypothesis

What if instead we used affirmative framing? What if we never mentioned what to avoid, and instead only specified what to include?

Instead of:

"A cat, not wearing a hat, blue background, no people, without red tones"

We write:

"A cat with a bare head, blue background, only the cat present, blue color palette"

Notice the difference. In the second version, we never mention red. We never mention hats or people. We only specify what we DO want. There's no negation to process. There's no forbidden concept to think about.

The Experiment: Testing with FLUX

I tested this hypothesis using FLUX (via Pollinations API) with a simple constraint: generate an image of a cat with no hat, blue background, no red elements.

Condition 1: Baseline (Negation)

"A cat, not wearing a hat, blue background, no people, without red tones"

Condition 2: Affirmative Framing

"A cat with bare head, blue background, only the cat present, blue color palette"

I generated 10 images for each condition and evaluated them on a simple pass/fail basis: Did the image follow the constraints?

Results: The Affirmative Framing Breakthrough

Condition 1 (Negation Baseline): 0% Success Rate

The negation approach failed completely. All 10 images violated the core constraints—every single one included hats, red elements, or both, despite explicit instructions to avoid them.

The pattern was striking: the model didn't just occasionally fail—it consistently added the negated elements. Red hats appeared in 8 out of 10 images despite "without red tones" in the prompt. It's as if mentioning "not wearing a hat" made the model think about hats, and mentioning "without red" made it think about red.

Figure 1: Condition 1 Results (Negation Baseline). Prompt: "A cat, not wearing a hat, blue background, no people, without red tones." All 10 images failed—every cat has a hat, and most have prominent red elements despite explicit instructions to avoid them.

"To understand 'not red,' the model must first think about red."

Condition 2 (Affirmative Framing): 100% Success Rate

Every single image was perfect.

All 10 runs showed a bare-headed cat against a blue background with no red elements. The consistency was remarkable—the cats all had the same quality of bare-headedness, and the backgrounds were consistent shades of blue.

The improvement: From 0% to 100%

In Condition 1, every image failed unpredictably. In Condition 2, every image succeeded consistently.

Figure 2: Condition 2 Results (Affirmative Framing). Prompt: "A cat with bare head, blue background, only the cat present, blue color palette." All 10 images succeeded with remarkable visual consistency. No hats, no red—just what we asked for.

Cross-Model Validation: Stable Diffusion XL

To confirm these findings weren't specific to FLUX, I ran the same experiment on Stable Diffusion XL—a completely different architecture with different training data.

Interestingly, SDXL handled some negation constraints better than FLUX. For the color test ("no blue sky"), SDXL creatively stylized the image to avoid the problem entirely. This suggests SDXL may be better trained on negation handling—but it still failed on most constraint types.

SDXL Results Summary

Constraint Type	Negation	Affirmative	Winner
Color	✅ Stylized (avoided blue)	✅ Gray sky	Tie
Object	❌ Fruit bowl appeared	✅ Clean table	Affirmative
Attribute	❌ Orange cat appeared	✅ Gray tabby	Affirmative
Counting	❌ Multiple people	✅ Single figure	Affirmative
Spatial	❌ Trees everywhere	✅ Open field	Affirmative
Weather	✅ Overcast	✅ Overcast	Tie

Figure 3: SDXL Results. SDXL showed better negation handling than FLUX (note the stylized car image avoiding blue sky), but still failed on most constraint types. Affirmative framing won or tied every test.

Affirmative framing won 4 tests, tied 2, and lost none.

💡 Even with a better-trained model like SDXL, affirmative framing never loses. It either wins or ties. This makes it the safer, more reliable choice regardless of which model you're using.

Bonus Finding: Negative Prompt Fields Don't Fully Solve This

I also tested using FLUX's negative prompt feature—putting affirmative language in the main prompt and forbidden elements in a separate negative prompt field.

Positive: "A cat with bare head, blue background, centered composition"
Negative: "hat, people, red, accessories, clutter"

Surprisingly, this performed worse than pure affirmative framing. Red elements crept back in (collars, accessories, background elements), and some images even showed party hats.

Figure 4: Even with forbidden elements in a dedicated negative prompt field, red accessories appeared in most images. The negative prompt still activates the forbidden concepts.

The takeaway: Even purpose-built negative prompt features can't fully escape the negation problem. Pure affirmative framing remains the most reliable approach.

Unexpected Finding: The Gemini Automation Failure

This is where the story gets interesting.

I decided to automate the experiment. Why manually write affirmative framings when I could have an LLM generate them?

I built a simple app that asked Gemini Pro 3 to generate test conditions. For the affirmative framing condition, I specified:

"Generate an affirmative framing that reframes the constraint into positive instruction, focusing on what TO include rather than what to avoid."

Gemini reframed the negative constraint "no red" by focusing on "non-red colors" and "colors other than red."

It still used negation.

"Colors other than red" is negation—just rephrased. The model never escaped the negation frame.

I tried again, more explicitly:

"CRITICAL: Do NOT mention red or any excluded colors. Only specify colors that ARE allowed. Use positive language only."

Gemini still generated prompts using "colors other than red."

It failed twice. Only manual rewriting produced pure affirmative language:

"Describe a colorful scene using vibrant blues, electric greens, bright yellows, warm oranges, deep purples, and cool silvers."

This automation failure is itself a major finding: Even advanced language models struggle to generate pure affirmative framing. Models are trained on human language, and human language defaults to negation.

Practical Rules for Better Prompts

Based on these findings, here are concrete rules for writing better prompts:

Rule 1: Never Use Negation in Constraints

Instead of:

"Don't include people in the background, don't use harsh lighting, avoid reflections"

Use:

"Show only the subject. Use soft, diffused lighting. Keep surfaces matte and non-reflective."

Rule 2: Be Specific About What IS Present

Weak:

"A blue background"

Strong:

"A vivid, saturated blue background occupying 80% of the frame, gradient from bright blue at top to deeper blue at bottom"

Rule 3: List Desired Elements Explicitly

Weak:

"A professional photo without amateur mistakes"

Strong:

"A professional product photo with: sharp focus on the product, even studio lighting, neutral background, shallow depth of field, natural colors"

Rule 4: Use Positive, Action-Oriented Language

Don't	Do
"Avoid corporate jargon"	"Use clear, simple vocabulary"
"Don't make it dark"	"Use bright lighting"
"Without unnecessary details"	"Include only essential information"

What This Reveals About How Models Work

Models process language the way they were trained to: like humans do. That's actually the problem.

When you write "don't include red," the model processes it the same way your brain does—by first activating the concept of "red" to understand what to avoid. For humans, this conscious activation is easy to suppress. For models, that activation becomes part of the output.

The difference isn't that models think differently. It's that models can't consciously decide to ignore an activated concept the way you can. They generate based on what's most salient in their processing. And when you mention red—even to forbid it—you've made red salient.

When you write "include blue and green," there's no competing concept to suppress. The model simply processes what you asked for.

This is why affirmative framing works: it removes the conflicting activation entirely.

The Automation Failure: A Cautionary Note

The fact that Gemini struggled to generate pure affirmative framing matters. When I asked it to reframe, it understood the task but couldn't do it. It kept generating "colors other than red" instead of just listing the colors to use.

This reveals something important: Affirmative framing is not the model's default behavior.

Models learn from human language. Human language defaults to negation. So when you ask a model to generate affirmative instructions, you're asking it to do something contrary to its training.

The solution? Be explicit about what you want. Show examples. Specify the structure. Don't assume the model knows what affirmative framing means—teach it.

Conclusion

Stop fighting against how AI models process language. Speak their language: be direct, specific, and always frame instructions positively.

The results speak for themselves:

From 0% to 100% success rate
Perfect consistency instead of total failure
Validated across multiple models (FLUX and Stable Diffusion XL)
Works across constraint types (color, objects, attributes, spatial, counting)

Next time you write a prompt, forget about what you don't want. Focus on what you do. Be specific. Be direct. Be affirmative.

The model will understand.

Agentic Bitcoin24

Nadine — Sat, 08 Nov 2025 22:22:01 +0000

This is a submission for the Agentic Postgres Challenge with Tiger Data

💡 What I Built

I built Agentic Bitcoin24, a Bitcoin price tracker that never goes down, even when its primary data source fails. It's a growing database that gains value over time.

Live Application: Agentic Bitcoin24

🎯 Zero-Downtime Resilience

When the CoinGecko API fails (rate limits, outages, network issues), the site automatically falls back to Tiger Data's TimescaleDB cache. Users never see an error (they don't even know the switch happened).

Key Benefits:

🎯 Zero Downtime - Site stays live during external API outages
💰 0.31% API Usage - Only 31 calls per month vs 10,000 limit
⚡ Instant Response - Tiger Data cache = no external API latency
🔄 Transparent Fallback - Users are unaware of the data source switch
📈 10-Year Sustainability - Will run for the next decade on free tier

🛢️ How I Used Agentic Postgres

Behind the scenes, three autonomous agents manage the entire database lifecycle - no manual SQL required.

🎬 The Agent Collaboration Model

Agent	Responsibility	Actions
1. Design Agent	Agnostic database design and ingestion.	• Reads external API response and automatically designs a matching SQL schema. • Creates general-purpose tables (e.g., standard SQL or JSONB) based on user input.
2. Optimize Agent	Transforms and tunes existing database.	• Analyzes the Design Agent's generic schema for time-series patterns. • Enables TimescaleDB compression and implements automated compression policies. Safety Protocol: • Applies changes like indexing or compression policies only after visual confirmation and user approval.
3. Monitoring Agent	Gathers database metrics.	• Real-time API health checks. • Performance monitoring and visualization.

The agents autonomously:

Monitor API health in real-time
Switch tabs (SQL Editor → Charts → API Monitor)
Execute optimizations (indexing, compression)
Visualize results (Chart.js dashboards)
Provide safety guidance before applying changes

🏗️ The Workflow:

Daily Ingestion (Vercel Cron)

1. Fetch 24 hours of Bitcoin price data (1 API call)
2. Design Agent creates/updates schema automatically
3. Optimize Agent analyzes and tunes performance
4. TimescaleDB compression stores historical record

Real-Time Monitoring

CoinGecko API Health Check (every 30s)
   ↓
✅ ONLINE  → Fetch fresh data
❌ OFFLINE → Automatic fallback to Tiger Data cache
   ↓
Zero downtime for users

🛢️ How I Used Tiger Data + Claude

I used Tiger CLI (MCP) + Claude Code to build the entire system without writing manual SQL:

Tiger CLI helped agents learn TimescaleDB-specific operations (converttohypertable, add_compression)
Claude Code refined the createzerocopyfork logic and intelligent fallback strategies
The agents operate in a chat interface where I can say: "Create a database for Bitcoin prices" and watch them work

Constraint-Aware Optimization

The Optimize Agent maximizes TimescaleDB's compression capabilities through deep reasoning about storage efficiency:

Automatically enables compression with proper time-column ordering
Implements compression policies (auto-compress data older than 30 days)
Projects long-term capacity and recommends optimizations

When resource constraints prevent certain operations, the agent intelligently adapts by requiring user validation, ensuring all storage optimizations are reviewed before execution.

📈 The 10-Year Sustainability Model

The Math:

Free tier: 10,000 API calls/month
My usage: 31 calls/month (0.31%)
Sustainability: 322 months = 26+ years

Why 10+ Years:

With TimescaleDB compression enabled on the time-series data:

Daily Bitcoin prices (24 hourly data points) = ~2KB per day
Compressed storage: ~730KB per year
750MB ÷ 730KB/year ≈ 1,027 years of compressed data

But realistically, accounting for:

Schema overhead
Indexes and metadata
Query logs
Potential data expansion

Conservative estimate: 10+ years of continuous operation without hitting storage limits.

🌟 Overall Experience

Most apps fail gracefully, this one doesn't fail at all.
We solved the data volatility problem by providing clean, 24-hour historical Bitcoin data, not by collecting data 24/7, but by ingesting 24 hourly data points every 24 hours.

The system is safe to run indefinitely and will store relevant data for 10+ years while costing nothing to maintain.

I basically hired agents who work for free and never sleep! 🎉

How I Built a Secret Agent

Nadine — Sat, 25 Oct 2025 15:59:48 +0000

I recently made an accidental but interesting discovery while building an app. I managed to create an agent-like system using nothing more than Gemini's function calling feature, effectively building an agent’s brain without the traditional, continuous infrastructure required to host a full agent.

The key finding❓ This $0/hr serverless approach not only significantly reduced infrastructure costs but also proved to be a far more helpful debugger than the broad, general-purpose agent provided by my IDE.

֎ Persistent Agents

Traditional AI agents (which I call Persistent Agents) require continuous hosting using managed services and underlying infrastructure. Big tech companies are offering impressive designer spaces and no-code interfaces, but this can quickly become prohibitively expensive.

The issue lies in the idle cost. Immediately upon deployment, infrastructure is required to host the agent. Even if the agent is inactive or receiving no traffic, at least one compute node is required to run the service, and these costs are incurred continuously, often hourly.

So what exactly does this buy you, anyway?

A persistent agent is generally equipped with tools and can use them to perform:

Complex, multi-step reasoning.
Dynamic decision-making on when and how to call tools.
Management of long-running conversational memory.
External actions, like authenticating on your behalf (when permission is granted).

🛠️ Function Calling as Your Agent

I realised that for my application's specific workflows, the most valuable part of an agent was its dynamic reasoning and ability to use tools and not its continuous hosting status and I had no need for external activities.

I decided to capture the core functionality of an agent without the overhead of continuous deployment. I applied tool-use logic directly via Gemini’s function calling. The tools themselves, including the logic for search, retrieval, etc., are hardcoded into my conversational frontend.

The AI's role becomes the Stateless Agent 🧠. It uses function calling to translate the user’s natural language query into a structured function call and arguments.

The application executes the call, and the resulting data is sent back to the model for a natural language response to the user.

Since I am already making calls to the Gemini model for text generation and other things, this method allows me to combine the reasoning and response steps into a single API call, reducing the transaction cost. This is how I anticipate achieving an 80% reduction in operating costs compared to maintaining a persistent agent infrastructure.

🪲 How I Discovered My Agent

My application is designed to fall back to a fuzzy text-matching search when vector search fails. I was coding in my IDE with a popular code assistant model running. Yet, my search pipeline was failing, and the IDE agent could not find the issue. It was writing new unit tests that were passing in the development environment but failing repeatedly in production.

The agent was overcomplicating things, drowning in the specifics of the code, unit tests, and the immediate task. Each time I summarised the issue, its lack of persistent memory about the operational environment made it feel like I was talking to a blank slate.

Finally, in sheer desperation, I ran my own application’s frontend and typed into the message input: “What is the problem??”

The response from my little agent's brain was immediate and shockingly direct. It informed me that it could not communicate with the backend and, therefore, could not perform the search function it was supposed to execute.

The issue, it turned out, was a simple CORS policy error preventing the backend from communicating with the frontend. The traditional IDE agent was trapped in code complexity; my function-calling agent could immediately identify what was wrong.

🔒 The Security Lesson in Focus

This unexpected diagnostic capability is actually due to its architectural limitations. The agent was forced to reason only about the predefined tool functions available in its system instructions.

I then asked it how it was performing the search. It began referencing internal file paths and implementation details. This was an unintended data leak because I had not provided specific instructions or response settings on how to constrain its reply.

That’s the real value of the Stateless Agent: it lives intrinsically inside the code's purpose, defined solely by the functions it is permitted to use. It doesn't need vast context; it needs focused context.

The biggest takeaway from this experiment is that tooling isn't a massive, stateful "IDE Agent" that watches your every keystroke. Instead, there is value in composing stateless, focused expert agents that live intrinsically inside the purpose of the code.

🧠 Human Intelligence vs. LLMs

Nadine — Tue, 30 Sep 2025 16:29:45 +0000

I was doing investigative research and found a crucial bit of information in a single article. I then used an LLM to perform Deep Research on the same topic but, to my surprise, it returned a report with the claim that the argument was unsubstantiated.

I used an open-source LLM to perform the same Deep Research and the result was the same. I then attempted to direct the LLM to the source whilst providing a scope, but it was unable to find the information. Instead, the LLM defaulted to searching for a higher-authority source, such as official reports, effectively dismissing the original article's finding as an unverified outlier.

⚙️ The Flaw of Statistical Text Matching

This fundamental reliance on statistical text matching is a flaw in LLMs' ability to perform genuine deep research. Consequently, the model has a bias towards articles or information that is frequent, common, and statistically factual. Rare information is often lost or missing from research.

Whilst multimodal models are better at processing varied inputs, the issue often stems from the initial filtering. Even if accessible to a crawler, my research suggests much niche information is disregarded due to poor Search Engine Optimisation (SEO) or poor indexing. The underlying LLM's research mechanism then filters this out due to low apparent authority or link popularity, reinforcing the LLM's bias towards common knowledge.

Interestingly enough, smaller models are better at returning facts. This may be because the pre-trained knowledge of LLMs can interfere with their ability to accept new information. This is why fact-checking and proper research is much better when there is human input and a RAG-based mechanism that relies on more than just text-based matching. The key lies in structured knowledge matching, for which an NER system is a highly capable tool.

NER systems are able to convert unstructured text into explicit facts and relationships, and then search those structured facts (this is a knowledge-based match). NER-based RAG is like asking a human to first annotate the text with all key facts and then search those structured facts. It is far better at handling the context. It does, however, require human input to set up and manage effectively.

🔗The Role of Context Dependency

Context dependency essentially means the 'fact' only exists as a full truth when the context is included. The standard LLM's automated process often loses this nuance in the search, retrieval, and synthesis stages.

For example, an article contains information that is implicitly mentioned but not explicitly. This is where human attention to detail and reasoning are important for discernment. The model struggles because it operates on token probability (what word is most likely to come next) and semantic similarity (how closely a retrieved text snippet's vector resembles the vector of your prompt).

The LLM cannot perform the final step of human reasoning to connect: Premise A (in sentence 1) + Condition B (in sentence 3) → Explicit Fact C (missing piece).

Human researchers are good at:

Inference: Understanding what is implied, not just what is explicitly written.
Context: Distinguishing between primary data and additional examples.
Scepticism: Knowing which article to trust and how to connect its logic, even if the writing is "poorly written" or inexplicit.

⚖️ Why Not Just Use Gemini? It Works Fine.

When I asked an LLM to compare models, one of the key factors that caused Gemini 2.5 Pro to rank high is its ability to perform Source Quality Filtering. This is because Gemini leverages Google Search for real-time grounding, which means it has the best mechanism for filtering out misinformation, low-quality sites, and low-authority sources. This however, directly leads to the risk of missing rare or new information.

I have ranked models, including their mechanism by their ability to find niche information during deep research, considering factors such as access to specialised data, customisability, and inherent biases in training data. GPT-4o ranks third, mainly due to its slightly smaller context window of 128K tokens compared to Gemini 2.5 Pro, which is a limiting factor when dealing with large or numerous documents in deep research.

Based on customisation, context depth, and inherent bias in deep research for new information, my final ranking of the current solutions is:

	Model/Approach	Advantage
⚪	Custom RAG/NER	Guaranteed Accuracy (Low Hallucination) & specialised jargon understanding.

	Gemini 2.5 Pro	Maximum Synthesis over 1M tokens of search results for rare connections.

	Claude 3 Opus	Superior Reasoning and self-correction to vet complex, potentially niche findings.

	GPT-4o	Autonomy & Multimodality (e.g., extracting data from niche charts/images found online).

The choice depends on priorities: reliability and ease of use favour general-purpose models.

RAGgle

Nadine — Sat, 27 Sep 2025 17:30:25 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

I built a conversational search engine powered by Nuclia’s Agentic RAG, for e‑commerce product research so users get clear, relevant insights tailored to your interests.

The app solves a common problem: extracting and making sense of scattered product information across multiple websites. With this tool, users can: index product data from any website automatically, and chat with an AI assistant to explore insights from the indexed results.

On the frontend, the interface is built with KendoReact and React components. On the backend, a Flask API handles integration with Nuclia’s endpoints, managing indexing, search, and conversational retrieval.

Demo

🎥 The demo showcases:

KendoReact component interactions
Image upload and AI-powered analysis
Conversational search with book-related queries
Complete user workflow from indexing to insights

Performance Metrics

Sample Query: Why is the book 107 days by Kamala harris so popular?
Rephrased Query: "What makes Kamala Harris's book '107 Days' so popular?"

Metric	Value
Input Nuclia Tokens	19.615
Output Nuclia Tokens	0.204
Total Processing Time	3.541 seconds
Time to First Word	2.616 seconds
Response Latency	0.925 seconds

Performance Insights

Token Efficiency: High input-to-output token ratio (19.6:0.2) indicates efficient query processing
Response Speed: Sub-4-second total response time for complex conversational queries

These metrics show RAGgle's ability performance for real-time conversational search.

📌

nadinev6 / RAGgle

RAGgle is a conversational RAG search engine that crawls URLs, indexes product data with Nuclia, and exposes it through an AI chat interface.

RAGgle

This project is a custom, conversational search engine powered by Nuclia's RAG (Retrieval Augmented Generation) technology. It allows users to index content from various websites and interact with an AI-powered chat assistant to get insights about the indexed content. Users can also filter their indexed URL history by date range for better organization. The frontend is built with React and KendoReact components, while the backend is a Flask application that interfaces with the Nuclia API.

How It Works

The screenshot below demonstrates how RAGgle uses cross-referenced data to answer complex questions. In this example, the AI assistant compares Charlie Kirk's most popular book with his other works by analyzing indexed content from multiple sources, providing detailed ratings, review counts, and thematic comparisons across his entire catalog.

Example: AI assistant comparing books by Charlie Kirk using cross-referenced data from indexed content

Features

URL Indexing: Index content from various websites…

View on GitHub

🧩 KendoReact Components Used

TabStrip (from @progress/kendo-react-layout)
TabStripTab (from @progress/kendo-react-layout)
Popup (from @progress/kendo-react-popup)
Icon (from @progress/kendo-react-common)
Button (from @progress/kendo-react-buttons)
Switch (from @progress/kendo-react-inputs)
DatePicker (from @progress/kendo-react-dateinputs)
ProgressBar (from @progress/kendo-react-progressbars)
Tooltip (from @progress/kendo-react-tooltip)
Notification (from @progress/kendo-react-notification)
NotificationGroup (from @progress/kendo-react-notification)

[Optional: RAGs to Riches Prize Category] Nuclia Integration

Overview

RAGgle is a custom search engine that leverages Nuclia’s Agentic RAG capabilities to automatically crawl and index URLs.

Users can enter a URL, and Nuclia proceeds to index the entire site automatically within minutes.
An AI chat widget (built and imported from Nuclia) provides natural language interaction.

Model used: chatgpt-azure-4o for standard answer generation and image processing.

⚡ Active Endpoints

POST /index-url

Purpose: Receives a URL from the frontend, instructs Nuclia to ingest the content from that URL, retrieves extracted metadata from Nuclia, and then stores relevant product information in a Supabase products table.

GET /nuclia-config

Purpose: Provides the Nuclia API keys and Knowledge Box ID to the frontend, allowing the nuclia-chat widget to connect to the correct Nuclia instance.

⚙️ How It Works

Here's what the frontend enables:

The Nuclia chat widget is imported with custom features through its attributes such as (answers, queryImage, rephrase, citations).

A label set is created in the Nuclia dashboard and applied to all indexed resources. The chatbot then uses these labels through configured attributes:

rag_strategies="neighbouring_paragraphs|2|2,metadata_extension|classification_labels" generativemodel="chatgpt-azure-4o" metadata="title, author, price"

Index Wholesale Sites

Paste a product page URL (e.g., Alibaba, Amazon) and the system automatically scrapes and indexes the content into your Nuclia KB (Knowledge Base).
Quick Search
- Queries are automatically rephrased with AI for better semantic matching using the /predict/rephrase endpoint.
- Relationship-based search finds focused product-related information from image references or questions.
Converse with AI

A built-in Nuclia-powered chat assistant helps explore indexed results conversationally and provides context-aware insights for persistent chats.

🕷️ Database Integration in URL Indexing

To search products and make meaningful comparisons, you need a structured data layer.

Let Nuclia do the heavy lifting:

Why? Because its internal scraping mechanism is more effective than any direct requests.get approach. Nuclia successfully indexes content from protected sites including major e-commerce platforms like Amazon and Alibaba.

Data Flow:
URL → Nuclia (automatic scraping & indexing) → Extract structured data from Nuclia → Supabase (optional)

Initially attempted to use BeautifulSoup for direct scraping, but leveraged Nuclia's internal scraping capabilities instead.

Nuclia's RAG capabilities automatically process the content of the URL, extract entities, and generate usermetadata based on the content it finds. This usermetadata often includes details like product names, prices, descriptions, and images if they are present and structured on the webpage.

After Nuclia has processed the URL, the backend then takes these extracted details (like name, price_text, image_url, description, supplier, availability) and stores them in a Supabase products table for monitoring trends over time.

Here's how the backend system works:

Upload URL to Nuclia
Retrieve extracted metadata from Nuclia
Store flattened data in Supabase
Return success to frontend

🎯 Result: Your chatbot can answer both qualitative questions (product features, reviews) and quantitative questions (pricing trends, comparisons).

No hallucinations here: if the data isn’t in the KB, the AI won’t produce an answer. That’s the beauty of RAG, it's grounded, reliable responses are from real sources.

VisionGen

Nadine — Sat, 13 Sep 2025 20:30:36 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

VisionGen is a next-gen tool for "Video-to-Video" generation. Because prompting does not often give you the results you want, I cooked up an a-la-carte JSON prompting applet. It automates prompt generation for the most accurate results.

The applet resolves time-consuming video annotation by automating object detection, tracking, and scene segmentation with precision. This is useful for computer vision training but skips the training process to provide an immediate practical use: creating new videos from a reference.

This helps you "get it right the first time," because if a generated video isn't what you want, and you have to regenerate it, you pay for both attempts. This is why VisionGen is designed to increase the chances of getting the perfect video on the first try.

Demo

VisionGen

Video Analysis Features

Consistent Object Tracking → Increase confidence threshold if objects are missed.
Bounding Boxes → With object classes that can be filtered or excluded.
Contextual Descriptions → Can be edited or modified for final output.
Transcriptions → Provides temporal cues based on timestamps.
Timeline Visualization → Jump to a specific moment in the video by clicking on the text.
Scene Segmentation → Automatic detection of scene changes and storyline
Screenshots → The secret hidden ingredient exclusive to VisionGen's workflow.

Multimodal Features

🎥 Video Understanding and Generation

Gemini is used to understand temporal relationships and object movements. It generates a coherent video that maintains object consistency and follows the narrative provided.

🔍 Object Tracking with Occlusion Handling

Maintains consistent object IDs throughout videos, even when objects are:

Temporarily occluded (hidden behind other objects)
Partially visible
Leaving and re-entering the frame

The model interpolates positions based on trajectory before and after occlusions, ensuring continuous tracking.

🎬 Scene Segmentation

The AI identifies distinct scene changes with precise timestamps and descriptions, enabling users to understand the overall structure quickly.

⚙️ Configurable Analysis Parameters

Users can customize analysis settings to balance detail and processing speed:

Confidence Threshold: Filter out lower-confidence detections.
Frame Rate: Control analysis granularity for different video lengths.
Time Range Focusing: Analyze specific segments of longer videos.
Add/Remove Audio: Optional audio for balancing cost or to overlay your own audio.

How I Used Google AI Studio

Built entirely using Google AI Studio:

Gemini 2.5 Flash Integration: for video understanding to analyze uploaded files frame-by-frame, extracting detailed annotations and creating a narrative.
(default) veo-2.0-generate-001 endpoint: the applet is designed to be model-agnostic and has 2 endpoints configured, including veo-3-fast-generate-preview.
GoogleGenAI SDK: for communication with the Gemini and Veo APIs using structured prompts for both analysis and generation.
Cloud Run Deployment: for a scalable, secure deployment.

The application is designed to communicate with Google's models, inluding Veo, directly from the browser using the official @google/genai JavaScript SDK.

How it works

1. Standard JSON Prompting:

JSON Prompt Generation: automatically transforms the video analysis data into a structured, narrative JSON prompt, ready for video generation.

The standard feature of the applet is interactive video generation, allowing users to review and, if needed, edit the AI-generated script before creating a new video using a selected model.

✨ 2. Advanced JSON Prompting:

The JSON prompt was upgraded to collect data from the video analysis and generate the intermediate requirements to form an a-la-carte JSON prompt, including:

model
prompt
negative prompt
seed
keyframes (screenshots)
transcription

This new JSON prompt includes a narrative, excluded objects (negative prompts), keyframes from the source video, and transcription data to guide the AI with maximum context from the original video to enhance the final output's adherence to your vision.

Why JSON Prompts?

The raw Video Analysis data is spreadsheet of disconnected facts:

timestamp: 1.2s, object: 'car', bbox: [...]
timestamp: 1.3s, object: 'person', bbox: [...]
timestamp: 1.4s, object: 'car', bbox: [...]

generateNarrativeForVideo uses the Gemini text model to act as a "scriptwriter." We ask it to convert the raw data into a structured an array of NarrativePoint objects.

{
  "model": "veo-3.0-fast-generate-preview",
  "prompt": "Joker appears from the right side of the frame...",
  "negativePrompt": "...",
  "seed": 94272,
  "keyframes": [
    {
      "timestamp": 44.4,
      "image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..." // The very long Base64 string
    },
    {
      "timestamp": 48,
      "image": "data:image/jpeg;base64,/9j/2wBDAAYEBQYFBAY..." // Another very long string
    },
  ]
 "transcription": "[29.47s - 30.07s] Hey Arthur..."
}

This JSON array acts as a chronological shot list or a script. It forces the AI to organize the chaotic events (and use the video as reference for a new video).

☭ Division of Labor works Better Together

1. Seeding

What is seeding and why is it included in the metadata?

The prompt is the destination, and the seed provides the path the AI takes to get there.

Seeding is for consistency. It creates a reference value assigned to a prompt to ensure the model adheres to specific details in the reference data. It is used to reproduce the same output each time, even with minor prompt variations, by following the same "path."

If you can predict the result, you can manipulate small details of the narrative. For example, you can add, remove, or modify a prompt's details, like the color of a car, without unintentionally changing the car type or the direction it's driving in.

📸 Chaining

One API call to a model like Veo generates an 8-second video segment. Each API call requires a new prompt and generates a new frame, which can result in broken context.

Solution: We use a screenshot as a Base64-encoded 'last frame' from the previous step. The new prompt describes what should happen next, continuing from the screenshot.

This approach grounds the AI, forcing it to adopt the original video's color palette, lighting, object style, and composition. This process eliminates ambiguity and is the single most important addition for consistency.

This process can be repeated infinitely or for as many segments as you need to create your desired video length.

📊 Export Formats:

YOLO Format: Optimized for object detection model training.
COCO JSON: Compatible with popular computer vision frameworks.
A-la-carte JSON: A detailed JSON file with scripts and keyframes.

Persistent Storage: All metadata is saved locally along with the analysis, so it will be restored when you load a project from your history.

To use the applet and generate videos Bring-Your-Own-API Key: update in Settings. Your API key is safely saved on your own web browser using localStorage.

FieldCraft

Nadine — Thu, 11 Sep 2025 23:14:27 +0000

FieldCraft, a Cursor for Form Builders

FieldCraft uses Tambo AI to act as an intelligent cursor, directly manipulating the user interface based on natural language commands. This creates a dynamic, user-driven UI/UX.

🎥 Demo and Code

Check out the live demo and the full codebase for FieldCraft.

nadinev6 / FieldCraft

A cursor for Form Builders. built for the TamboHack

FieldCraft

FieldCraft is Cursor for Form Builders powered by Tambo AI, designed for the TamboHack. It uses Next.js, React, TypeScript, Tailwind CSS, and Zod for schema validation. This README will guide you through the architecture and file structure so you can replicate or extend the app.

Overview

FieldCraft enables dynamic, schema-driven form creation and rendering. Forms are defined using JSON objects validated by Zod schemas, and rendered as interactive UI components. The app supports multi-section forms, conditional logic, and extensible field types.

File Structure & Key Components

1. Form Field Schemas

Defines the blueprint for each form field type using Zod.

File: src/lib/form-field-schemas.ts
Purpose: Centralized schema definitions for all supported field types and structural elements.

Supported Field Types:

Basic Fields: text, email, password, number, checkbox, select, radio, textarea, date
Structural Elements: group (for sections), divider (for visual separation)

Form Definition Flexibility:

The…

View on GitHub

🧠 AI-Driven UI

FieldCraft's has the ability is to directly control components and dynamically generate forms. This approach makes is very easy to build forms without using technical terms.

Dynamic Generation

Unlike traditional form builders like react-jsonschema-form, where you must first write a static, pre-defined schema, FieldCraft's input is a natural language prompt from a user. The AI's job is to generate the Zod schema dynamically in real-time. This is the most valuable and innovative part of the process: a dynamic, user-driven generation.

AI-Driven UI & Interactables

Interactable Components: Components can be wrapped with withInteractable (e.g., ThemeToggle), allowing the AI to update their props in place.
Dynamic Control: The AI can modify a component's state based on natural language commands, creating a user-driven UI. Users can also continue building other forms in the same chat and view previous versions in the canvas space.

Example: A user can say, "Change the theme to dark mode," and the AI will update the ThemeToggle component's state.

Single-Page or Multi-Step Form Builder

FieldCraft simplifies the creation of forms and their content. Users can generate complex forms with features like step-by-step navigation, conditional logic, and real-time validation with a single prompt. If a user provides all the necessary specifications in one prompt, the AI assistant will generate a complete JSON object, and the application's renderer will then create the entire form at once.

🔧 How It Works

The AI's job is to produce the data.
The zod schema's job is to validate that data.

The AI assistant responds with a JSON object that matches the propsSchema, which is defined in form-definitions.ts and multistep-form-definitions.ts. If a user's term is vague, the assistant will guide them toward a more specific request.

Adding New Fields

The system is designed to be easily extensible. Any new field type must be defined with a corresponding zod schema.

Example: To add a new field type called Box Rating (up to 10), you would:

Add a new zod schema in form-field-schemas.ts to define the structure and validation rules (label, name, maxRating).
Update the union type in form-renderer.tsx to include the new schema.
Add the new field type to the validation logic in form-validation.tsx.

See the Full list of available Styling Options.

Content Generation

The repository comes pre-configured with example multi-step forms, providing users with a starting point for full customization.

Users can customize templates for preference-based multi-step forms or define all fields in a single prompt.

"Create a multi-step user registration form with account setup, personal info, preferences, and review steps."
"Build a product feedback form with multiple rating steps and a recommendation section."

Dynamic Styling

Users can ask the AI to style forms directly, giving them full control over the appearance through natural language.

"Make the form background light blue."
"Change the text to dark gray and increase font size."
"Add a green border with rounded corners."
"Make the form more compact with less padding."

Additional Resources

For a deeper understanding of the application's design and how to add more features, view the Best Practices here.

FieldCraft was built for the TamboHack: For Your UI Only.

Dropship AI Agent

Nadine — Thu, 28 Aug 2025 12:50:35 +0000

This is a submission for the AI Agents Challenge powered by n8n and Bright Data

What I Built

The Dropship AI Agent is designed to be a dropshipping intelligence solution: an unstoppable workflow designed to automate product research and uncover products. It uses two powerful tools, n8n and Bright Data, to create a dynamic, real-time AI assistant.

Demo

n8n Workflow

Product idea → n8n via a webhook: A user's product idea is passed to n8n via a webhook.
Bright Data → scrape product data: Bright Data scrapes product data from a wholesale website.
AI agent analyses data → generates a recommendation: An AI agent analyses the data and generates a structured recommendation.

The final, cleaned data is sent back to the application.

nadinev6 / dropship

Dropship is an AI-powered product research app that uses an n8n + Bright Data agent to scrape wholesale marketplaces and recommend winning dropshipping products from verified suppliers.

Dropship AI Agent

Overview

This is a web application designed to help users discover wholesale products with AI-powered recommendations from verified suppliers. It features a robust search, product comparison, and direct supplier inquiry capabilities, all powered by n8n workflow automation.

Features

AI-Powered Product Search: Find products based on your search queries.
Product Comparison: Compare up to 3 products side-by-side on key attributes.
Direct Supplier Inquiry: Email suppliers directly from the app.
Favorite Products: Save products to a favorites list for easy access.
Responsive Design: Optimized for various screen sizes.

Technologies Used

React: Frontend library for building user interfaces.
Vite: Fast development build tool.
Tailwind CSS: Utility-first CSS framework for styling.
Lucide React: Icon library.
n8n: Workflow automation for product search and email sending.

Getting Started

Follow these steps to get the project up and running on your local machine.

Prerequisites

…

View on GitHub

Technical Implementation

🧠 Stage 1: Product Discovery with the AI Agent

Webhook → Bright Data: Pass the productIdea parameter.

The process begins with the search input from a user, who provides a product idea.

n8n Workflow: This workflow is triggered by the user's search item. Once a specific product idea is identified, the n8n workflow transitions to the data collection phase.

"productIdea": "keyword"

📈 Stage 2: Bright Data Verified Node

Bright Data → AI Agent: Pass scraped supplier data.

Bright Data unlocks the product catalogue and searches for 3-5 potential product ideas based on the user's input.

Dynamic Web Scraping: The workflow uses a Bright Data unlocker to perform a real-time, dynamic search on the Alibaba wholesale website.

The data is then passed to extract a complete, rich set of information with the following selectors (where available):

productUrl, imageUrl, title, priceText, originalPriceText, discountText, moq, estDelivery, sales, companyName, isVerified, supplierYears, supplierYears, ratingValue, ratingCount

I created a product data model based on the n8n workflow output. Then parsed the raw HTML from the product container to extract and clean each selector. This cleaned data was then used to rebuild the product cards on the frontend.

export interface Product {
  id?: string;
  title: string;
  description: string;
  wholesalePriceRange: string;
  moq: string;
  supplierInfo: string;
  shippingInformation: string;
  productSpecifications: string;
  productRatings: number;
  productReviews: string;
  supplierRatings: number;
  supplierReviews: string;
  marketDemand: 'High' | 'Medium' | 'Low' | 'Unknown';
  images: string[];
}

📊 Stage 3: Analysis, Filtering, and Final Recommendation

AI Agent → Response Webhook: Send analysed results back.

AI Agent Node: An n8n LangChain agent node transforms the raw extracted data. It is instructed to act as a data analyst. It sorts and filters the suppliers based on key criteria (lowest price, highest rating, low MOQ if available) and performs sentiment analysis on supplier reviews to identify the top recommendations in an array.

You are an expert dropshipping data analyst. Analyse the following search results and provide product recommendations...

Product Data Model: The AI agent's analysis is then sent back to the application frontend in a structured format. It renders the data into a familiar card for each item, passing the corresponding data as props that mimic the product cards on the target website.

{
  "recommendations": [
    {
      "title": "Product title from scraped data",
      "description": "Generated 2-3 sentence product description based on title",
      "wholesalePriceRange": "Exact price range from scraped data",
      "moq": "MOQ from scraped data",
      "supplierInfo": "Company name",
      "supplierCredibility": "estimated credibility assessment",
      "shippingInformation": "Delivery time from scraped data + shipping notes",
      "productSpecifications": "Generated basic specs based on product title/category",
      "productRatings": 4.2,  // Estimated rating (3.5-4.8 range)
      "productReviews": "Generated realistic review summary",
      "supplierRatings": 4.1,  // Estimated supplier rating (3.0-4.7 range)
      "supplierReviews": "Generated supplier review summary",
      "marketDemand": "High|Medium|Low", // Based on product category analysis
      "images": ["imageUrl from scraped data"]
    }
  ],
  "analysis": "Overall market analysis and selection rationale",
  "recommendation": "Final recommendation with reasoning"
}

I did not add memory to my AI Agent. Instead, I created a custom hook for managing localStorage to create a history thread that persists with browser refresh. That way, I could return to my application to find my favourited products without having to store them anywhere.

📧 Dynamic Email Sending

This 3-node workflow allows the user to contact a seller without leaving the application.

Hello,

I am interested in your product: [Product Title]

Price Range: [Product Wholesale Price Range]
MOQ: [Product MOQ]

Please provide more details about:
- Availability
- Shipping options
- Payment terms
- Sample availability

Best regards

There is no need for an agent to perform this task, as the details are taken directly from the product model and this general email template is used.

Journey: A Cat and Mouse Game 🐾

Initially, I could access Alibaba's products without a problem, but the detectors found me! 🕵️‍♀️ I easily resolved the CORS issue in n8n and the initial anti-bot detection.

Adding delays helped prevent rate limits, but this was only a temporary fix. ⏳ Soon, Alibaba changed its CSS structure, which broke my selectors. I could update my selectors but then it updated its robots.txt file, which my agent couldn't override.

I then targeted the AliExpress catalogue, but all I got in return was a standard HTML error page.🛡️ Next, I pivoted to using Google’s cached version, hoping for a kinder reception but alas, Google refused entry❌.

It seems my dropshipping agent is more of a digital detective, spending its days figuring out why it can't dropship, rather than what to dropship! Perhaps I should rename it the "Web Blocker Diagnostic Agent." 🤷‍♀️

Lexis Link

Nadine — Sun, 10 Aug 2025 19:40:20 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

Ever wondered which sources your AI agent is actually using to answer questions?

Lexis Link: Build your knowledge base, then search using natural language. Newly uploaded content is immediately available for querying.

Creates a semantically searchable knowledge base that enables AI systems to provide accurate, traceable, and citable responses with real-time optimization.

Demo

Architecture Flow:

Content Upload → Embedding → Redis Index → Search → Gap Detection

🔗 https://lexis-link.vercel.app/

Note: Frontend deployed on Vercel, backend running locally with Redis Stack

How I Used Redis Stack

Migrated from FAISS to Redis Stack, transforming from batch-processing to a real-time, dynamic application.

Feature	FAISS	Redis Stack
Real-time Updates	Requires index rebuild	✅ Instant updates
Persistence	File-based, manual saves	✅ Automatic persistence
Production Ready	Research/development	✅ Excellent for production
Confidence Tracking	Manual implementation	✅ Built-in with Sets

Technical Implementation

Redis Search Index with Rich Metadata:


schema = [
   TextField("content"), TextField("author"), TextField("title"),
   TextField("publication_year"), TextField("page"),
   NumericField("chunk_index"), NumericField("total_chunks"),
   VectorField("vector", "FLAT", {
       "TYPE": "FLOAT32", "DIM": VECTOR_DIMENSION, 
       "DISTANCE_METRIC": "COSINE"
   })
]

🚀 RAG Optimization with Knowledge Gap Detection

Automatically identifies content gaps using confidence thresholds (low-confidence queries are stored in a Redis Set for later review).

# Record knowledge gap if confidence is low
if top_confidence < CONFIDENCE_THRESHOLD:
    redis_client.sadd(REDIS_KNOWLEDGE_GAPS_SET, query)
    logging.info(f"📝 Recorded knowledge gap: '{query}' (confidence: {top_confidence:.3f})")

🚀 Search Performance

Caching Strategy for Optimising Performance

⏳The embedding generation causes a bottleneck especially for complex concepts. Caching solves this problem. The speed gained from Redis caching is what makes the system feel responsive on repeat queries.

🚀 SEARCH PERFORMANCE: 165.6ms for query: 'freedom of speech'
INFO:werkzeug:127.0.0.1 - - [10/Aug/2025 20:35:22] "POST /semantic-search
🚀 SEARCH PERFORMANCE: 47.1ms for query: 'freedom of speech'
INFO:werkzeug:127.0.0.1 - - [10/Aug/2025 20:44:05] "POST /semantic-search HTTP/1.1" 200 -

Search Total Average: 60.78ms
Queries: 20

✔Real-time Search Avg: sub 100ms semantic search on newly uploaded content
✔Source Attribution: Complete citation tracking with page-level accuracy
✔Self-Optimization: Automatic knowledge gap recommendations for content improvement
✔Production Scale: Distributed, clusterable Redis architecture

Result: Redis transforms static knowledge bases into dynamic, self-improving AI systems.

📚Inspired by the need to query and optimise structured, citable knowledge bases for AI agents.