DEV Community: Prema Ananda

The Warrior's Planner

Prema Ananda — Sat, 04 Apr 2026 09:56:18 +0000

This is a submission for the DEV April Fools Challenge

What I Built

The Warrior's Planner — the planner that offers an alternative perspective on your day

...and that's exactly why you should try it.

Admit it. You've done this.

Sunday. 10:47 PM. You open Notion. Or Todoist. Or Google Calendar.

You arrange tasks by time. Balance work and exercise. Squeeze in "30 minutes of reading" between a Zoom call and lunch. Add "meditation" — even though the last time you actually meditated was somewhere between your second vaccine shot and the start of a new Netflix season.

You look at the resulting schedule with quiet pride. This is it. Control. Order. I'm finally going to live the right way.

And then Monday arrives.

By 10:17 AM, the plan is dead. You're on your third coffee. The meeting ran long. "30 minutes of reading" turned into 30 minutes of scrolling Reddit — that's basically the same thing, right?

Sound familiar?

Don Juan saw the world differently

In Carlos Castaneda's books, an old Indian named Don Juan Matus gave his apprentice a lot of completely useless advice. For example, he suggested talking to plants before picking them.

What does that even mean? Who knows. But when you spend hours building the perfect plan instead of just starting to do things — Don Juan is laughing somewhere out there. Along with the desert wind.

The same idea, by the way, was picked up by the film "Peaceful Warrior." The coach tells the protagonist: "The journey is what brings us happiness, not the destination." And the guy at the beginning of the movie also really loved planning and controlling everything. How that worked out for him — watch it yourself.

How it works

You build your day. Drag tasks from the Task Bank onto the timeline. Or type your own from scratch. Everything looks beautiful. Drag & drop. Animations. The "Plan Seriousness" progress bar creeps upward.
You feel satisfaction. 67%... 81%... 94%... The perfect day is almost ready. You've practically become the person you've always wanted to be.
100%. You press the button.
And then...

No, I won't tell you what happens. This is the Warrior's Path — and a Warrior doesn't ask for spoilers.

I'll only say that the AI (Gemini) takes your carefully crafted plan and... transforms it. Into what? Into something you definitely didn't plan for. Every task turns into an unexpected, absurd, and slightly zen action. Complete with a Don Juan quote on top.

Is this useless?

From a productivity standpoint — absolutely, hopelessly, gloriously useless.

But if you're something more than a line in Jira...

If somewhere inside you there's something tired of optimization and just wants to be...

If you've ever caught yourself thinking that all this obsessive planning is just a way to avoid actually living...

Then maybe this "useless" thing is the most useful thing you'll discover.

Demo

Ai-Studio

Build a plan. Press the button. See what happens.

Disclaimer: no actual plans were harmed in the making of this app. Your Jira tickets are safe. Probably.

Code

Spontaneously created in Google AI Studio — in a single flow of inspiration, as if Don Juan whispered in my ear: "Do it now, or you never will."

premananda108 / The-Warrior-s-Planner

This is a submission for the [DEV April Fools Challenge](https://dev.to/challenges/aprilfools-2026)

The Warrior's Planner

A modern, drag-and-drop daily planner that transforms your mundane routine into an epic, slightly absurd "Warrior's Path." Built with React and powered by Gemini AI, this app takes your daily tasks and reimagines them with a humorous, zen-like twist inspired by the teachings of Don Juan Matus.

🌟 Features

Drag & Drop Interface: Easily drag tasks from the categorized Task Bank into your Daily Schedule using @dnd-kit.
Custom Tasks: Type your own specific tasks directly into the time slots.
AI-Powered Transformation: Once your schedule is full, the app uses Gemini AI to generate a "Warrior Plan," replacing your normal tasks with funny, unexpected, and absurd actions that break the routine.
Don Juan Quotes: Each generated plan includes a real, famous quote from Don Juan Matus (Carlos Castaneda's books) to guide your day.
Responsive Design: A fully responsive, side-by-side layout that works perfectly on both desktop and…

View on GitHub

How I Built It

Google AI Studio — the entire project was built right inside AI Studio. One moment of wild determination.
Gemini AI — transforms your boring schedule into the Warrior's Path
React + TypeScript — because even absurdity deserves strict typing
@dnd-kit — drag & drop that makes planning dangerously satisfying
Framer Motion + canvas-confetti — because when your plan undergoes a transformation, that calls for confetti 🎉

Prize Category

Community Favorite — because everyone who has ever built a perfect plan knows this feeling. And everyone could use hearing what Don Juan thinks about their Google Calendar.

Best Google AI Usage — the app was spontaneously created entirely in Google AI Studio, and Gemini AI is the beating heart of the application.

Built for the DEV April Fools Challenge 2026. Inspired by the books of Carlos Castaneda, the film "Peaceful Warrior," and the fact that you just built another perfect plan for Monday that won't survive Tuesday.

M2M API Integration Guide

Prema Ananda — Sat, 25 Oct 2025 10:18:50 +0000

Main article: Building a Pay-Per-Use AI Agent Marketplace with Auth0 + Web3

M2M API Integration Guide

This document describes how external systems can interact with the AgentBounty API to create and manage tasks on behalf of existing users.

Overview

The main idea of M2M (Machine-to-Machine) interaction is to allow automated systems (e.g., bots, scripts, other backends) to launch AI agents. All tasks are securely linked to a real user, and payment for paid results is made by the user themselves in a secure browser environment.

The process is divided into two parts:

Machine part: The M2M client creates and launches a task, then requests the result.
Human part: If the result is paid, the user receives an email notification and completes the payment in the web interface.

Prerequisites

To interact with the M2M API, you need two things:

Service Token (MCP_SERVICE_TOKEN):
- What it is: A shared secret key that allows M2M systems access to special endpoints.
- Where to get it: This token is located in the .env file of the main application. The administrator must securely provide it to the M2M client developer.
User ID (user_id):
- What it is: A unique user identifier from the Auth0 system, on whose behalf the task will be executed.
- Why it's needed: The system needs to know who the "owner" of the task is to verify their existence and send them a payment link via email.
- Where to get it: After logging into the AgentBounty web interface, the user_id is displayed in the site header under the username. It can be copied.

Step-by-Step M2M Interaction Process

Step 1: Creating a Task

The M2M client sends a POST request to a special endpoint to create a task.

Endpoint: POST /api/tasks/m2m/create
Headers:
- Authorization: Bearer <your_MCP_SERVICE_TOKEN>
- X-User-ID: <user_id>
- Content-Type: application/json
Request Body (JSON):

  {
      "agent_type": "factcheck",
      "input_data": {
          "text": "Does vitamin C cure the common cold?"
      }
  }

Example curl request:

  curl -X POST -H "Content-Type: application/json" \
  -H "Authorization: Bearer f44ac472df45f1691156ab189d3108673c7f3dbf37cc1f3cab58cb37ea0f5c8d" \
  -H "X-User-ID: google-oauth2|112852885226533594909" \
  -d '{
      "agent_type": "factcheck",
      "input_data": { "text": "Does vitamin C cure the common cold?" }
  }' \
  http://localhost:8000/api/tasks/m2m/create

Success Response (HTTP 201): The server will return a JSON object of the created task. Save the task id for the next steps.

  {
      "id": "fe1912d1-8412-4aaf-b0be-5d37ac4ea2a3",
      "user_id": "google-oauth2|112852885226533594909",
      "agent_type": "factcheck",
      "status": "pending",
      ...
  }

Step 2: Starting the Task

Immediately after creation, the task is in pending status. To start its execution, you need to send a POST request to the start endpoint.

Endpoint: POST /api/tasks/{task_id}/start
Headers:
- Authorization: Bearer <your_MCP_SERVICE_TOKEN>
- X-User-ID: <user_id>
Example curl request:

  curl -X POST \
  -H "Authorization: Bearer f44ac472df45f1691156ab189d3108673c7f3dbf37cc1f3cab58cb37ea0f5c8d" \
  -H "X-User-ID: google-oauth2|112852885226533594909" \
  http://localhost:8000/api/tasks/fe1912d1-8412-4aaf-b0be-5d37ac4ea2a3/start

The task will begin executing in the background.

Step 3: Status Checking (Polling)

The M2M client should periodically poll the task status to find out when it's completed.

Endpoint: GET /api/tasks/{task_id}
Headers:
- Authorization: Bearer <your_MCP_SERVICE_TOKEN>
- X-User-ID: <user_id>
Response (when task is completed): The status field will change to completed.

  {
      "id": "fe1912d1-8412-4aaf-b0be-5d37ac4ea2a3",
      "status": "completed",
      "actual_cost": 0.001,
      ...
  }

Step 4: Requesting Result and Transferring Control to User

When the task is completed, the M2M client requests the result.

Endpoint: GET /api/tasks/{task_id}/result
Headers:
- Authorization: Bearer <your_MCP_SERVICE_TOKEN>
- X-User-ID: <user_id>

Possible Responses:

If the result is free (actual_cost: 0): The server immediately returns the result.
If the result is paid: The server returns the following JSON. This means the M2M client has completed its work at this stage, and now it's the user's turn.

   {
       "status": "payment_link_sent",
       "message": "A link to complete the payment has been sent to the user's email.",
       "task_id": "fe1912d1-8412-4aaf-b0be-5d37ac4ea2a3",
       "amount": 0.001
   }

At this moment, a "magic link" is sent to the user's email.

Step 5: Payment by User

The user opens the email and clicks on the link like http://localhost:8000/?pay_task_id=....
The website opens in the browser, the page scrolls to the needed task, and a modal window appears to confirm the payment.
The user confirms the transaction in their crypto wallet (e.g., MetaMask).

Step 6: Retrieving the Paid Result

After the user has paid for the task, the M2M client (or any other client) can request the result again and this time receive it.

Endpoint: GET /api/tasks/{task_id}/result (same as in Step 4)
Headers: Same as before.
Success Response (HTTP 200): The server will return the full task result.

  {
      "task_id": "fe1912d1-8412-4aaf-b0be-5d37ac4ea2a3",
      "status": "completed",
      "result_type": "text",
      "content": "## Post Summary...",
      ...
  }

The Role of Auth0 in the M2M Process

Auth0 plays a key, though not always obvious, role in ensuring the security and coherence of this process:

User Existence Verification: When an M2M client sends a request with X-User-ID, our application doesn't blindly trust this ID. It immediately sends a request to the Auth0 Management API and asks: "Does a user with this ID exist?". If Auth0 responds "no", our server rejects the M2M request with a 404 Not Found error. This prevents the creation of "orphan tasks" on behalf of fictitious users.
Obtaining Email for Notification: After successful user verification, when it's time to send the payment link, our application again contacts Auth0 and requests the user profile by their user_id. From this profile, we extract the email to which the notification is sent.

Thus, Auth0 acts as the single source of truth about users, allowing the M2M system to securely initiate actions that ultimately require the participation of a real, verified person.

Main article: Building a Pay-Per-Use AI Agent Marketplace with Auth0 + Web3

🚀 AgentBounty User Guide

Prema Ananda — Sat, 25 Oct 2025 10:18:43 +0000

Main article: Building a Pay-Per-Use AI Agent Marketplace with Auth0 + Web3

Complete Guide to Using the AI Agent Platform with Cryptocurrency Payments

📖 Table of Contents

What is AgentBounty
Quick Start: Demo Mode
Registration and Login
Wallet Connection
Working with AI Agents
Payment and Receiving Results
Task History
Frequently Asked Questions
Troubleshooting

What is AgentBounty

AgentBounty is a decentralized AI agent marketplace where you only pay for completed tasks. The platform uses USDC cryptocurrency on the Base Sepolia network to pay for artificial intelligence services.

Key Features:

✅ Pay-per-use model — pay only for results
✅ Multiple AI agents — fact-checking, travel planning, and more
✅ Cryptocurrency payments — fast and secure with USDC
✅ Transparency — you know the cost before task execution begins
✅ Security — payment only occurs after receiving results

Available AI Agents:

🔍 FactCheck Agent — verifying information accuracy
✈️ Travel Planner Agent — trip planning and hotel selection

Quick Start: Demo Mode

Want to try the platform without registration and setup?

Demo mode allows you to:

Explore the platform interface
See examples of AI agents in action
Familiarize yourself with the payment process

How to launch demo mode:

Open your browser
Go to: https://agentbounty.premananda.site/?demo=true
The platform will automatically log in with a demo user
2 examples of completed tasks are available

💡 Tip: Demo mode is perfect for getting familiar with the platform. When you're ready to work with real agents, register.

Exiting demo mode:

Click the "Exit Demo" button in the yellow banner at the top of the page.

Registration and Login

Step 1: Open the platform

Go to the main page: https://agentbounty.premananda.site/

Step 2: Choose login method

Click the "Login" button in the upper right corner.

You'll have several login options available:

Email/Password — classic registration
GitHub — login through GitHub account
Google — login through Google account (in development)

Step 3: Create an account (for new users)

If it's your first time on the platform:

Select "Sign Up" on the login page
Enter your email and create a password
Confirm email (check your inbox)
Log in with the created credentials

Step 4: Successful login

After logging in, you'll see:

Your name in the upper right corner
"Connect Wallet" button to connect your wallet
Area for creating tasks

⚠️ Important: Without a connected wallet, you won't be able to pay for tasks, but you can create them and view their status.

Wallet Connection

To pay for tasks, you need a Web3 wallet with USDC on the Base Sepolia network.

Requirements:

MetaMask (or another Web3 wallet)
Connection to the Base Sepolia network (test network)
Some USDC in your balance

Step 1: Install MetaMask

If you don't have MetaMask yet:

Go to metamask.io
Download the extension for your browser
Create a new wallet or import an existing one

Step 2: Add Base Sepolia Testnet network

Open MetaMask
Click on network selection (at the top)
Select "Add Network" → "Add Manually"
Enter network parameters:

Network Name: Base Sepolia Testnet
RPC URL: https://sepolia.base.org
Chain ID: 84532
Currency Symbol: ETH
Block Explorer: https://sepolia.basescan.org

Click "Save"

Step 3: Get test USDC

To test the platform, you need USDC on Base Sepolia:

Get free ETH on Base Sepolia: https://demo.cdp.coinbase.com
Add USDC contract in MetaMask (Import Token):
- Address: 0x036CbD53842c5426634e7929541eC2318f3dCF7e
Swap ETH → USDC at https://pancakeswap.finance/swap?outputCurrency=0x036CbD53842c5426634e7929541eC2318f3dCF7e&chainId=8453&chain=baseSepolia&inputCurrency=ETH

💡 Tip: 1-2 USDC is enough for testing. Task costs are typically $0.001-$0.002.

Step 4: Connect wallet to AgentBounty

On the main page, click "Connect Wallet"
Select MetaMask in the popup window
Confirm connection in MetaMask
Sign the verification message (it's free, no gas required)

Step 5: Verify connection

After successful connection, you'll see:

Your wallet address (abbreviated)
USDC balance
"Disconnect" button to disconnect

Working with AI Agents

Now you're ready to create tasks for AI agents!

Creating a task

Step 1: Open the task creation form

Click the "➕ Create New Task" button in the center of the page.

Step 2: Select an agent

A modal window will open with agent selection. Available:

🔍 FactCheck Agent — $0.001 per task

Verifying information accuracy
Analyzing URLs or text
Finding sources
Issuing verdict: TRUE/FALSE/PARTIALLY TRUE

✈️ Travel Planner Agent — $0.002 per task

Flight search
Hotel selection
Price comparison
Route planning

Step 3: Fill out the task form

For FactCheck Agent:

URL Mode:

Select "Check URL"
Paste link to article/post
Example: https://www.linkedin.com/posts/anthropicresearch_...

Text Mode:

Select "Check Text"
Enter statement to verify
Example: "Artificial Intelligence will automate 50% of jobs by 2030"

For Travel Planner Agent:

Enter travel inquiry
Specify:
- From where and to where
- Travel dates
- Preferences (budget, hotel type)
Example: "I need to travel from New York to Miami on October 29, 2025."

Step 4: Create task

Verify entered data
Note the estimated cost at the bottom of the form
Click "Create Task"

Tracking execution

Task statuses:

⏳ Pending — task created, awaiting launch
▶️ Running — agent is working on the task
✅ Completed — task completed, result ready
❌ Failed — an error occurred

During execution:

You'll see a progress bar or message about the current stage
Tasks update automatically every 3 seconds
No need to refresh the page

Notifications:

When the task is complete, you'll see:

✅ Checkmark next to the task name
"View Result" button
Actual execution cost

Payment and Receiving Results

How the X402 payment system works

AgentBounty uses the innovative X402 Payment Protocol:

You create a task (payment NOT required)
Agent performs the work
Result is ready but hidden
You see a preview of the result
Decide whether it's worth paying
After payment, receive the full result

💡 Advantage: You pay only if satisfied with the quality!

Receiving results

Step 1: Open the result

When the task is completed, click "View Result".

Step 2: View preview

You'll see:

First few lines of the report
General structure of the answer
Execution quality

Step 3: Confirm payment (for tasks < $0.002)

For small amounts, payment happens immediately:

A "Payment Required" modal window will appear
Exact amount will be indicated (e.g., $0.001 USDC)
Click "Approve Payment"

Step 4: Sign transaction in MetaMask

MetaMask window will open
You'll see a signature request (NOT a transaction!)
Signature is free — no gas required
Click "Sign"

⚠️ Important: This is an EIP-712 signature, not a regular transaction. You don't pay gas fees!

Step 5: Receive result

After signing:

Payment will be processed instantly
Result will open automatically
You'll see the agent's full report

Payment with confirmation (for tasks ≥ $0.002)

For tasks costing $0.002 and above, additional confirmation via email is required:

Step 1: Request confirmation

After clicking "View Result," you'll see:

Message about the need for confirmation
Amount to be paid
Request expiration time (usually 10 minutes)

Step 2: Check email

Open your email (specified during registration)
Find the email from AgentBounty
- Subject: "Payment Approval Required"
Also check Spam folder

💡 Tip: Email may arrive with a 1-2 minute delay. Wait a bit.

Step 3: Confirm payment

In the email, click the "Approve Payment" button
Confirmation page will open
You'll see payment details
Click "Confirm Approval"

Step 4: Return to the platform

Return to the AgentBounty tab
The system will automatically detect the confirmation
Transaction signature window will appear
Sign in MetaMask
Receive the result!

Canceling payment

If you change your mind about paying:

Click "Cancel" in the payment window
Or simply close the modal window
Money will not be debited
Result will remain hidden

Task History

Viewing all tasks

All your tasks are displayed on the main page as a list.

Frequently Asked Questions

💰 Payment Questions

Q: How much does using agents cost?
A: Cost depends on agent type:

FactCheck Agent: $0.001 USDC
Travel Planner Agent: $0.002 USDC

Q: Do I need to pay gas fees?
A: No! We use EIP-712 signatures that don't require gas. The platform covers gas payments.

Q: What if I don't have enough USDC?
A: You can create a task, but won't be able to pay and receive the result. Top up your balance and return to the task.

Q: Can I cancel payment?
A: Before signing the transaction — yes. After signing — no, as blockchain transactions are irreversible.

Q: What if I'm not satisfied with the result?
A: You can see a preview before payment. If the result is clearly incorrect, don't pay.

🔐 Security Questions

Q: Is it safe to connect a wallet?
A: Yes. We use standard Web3 protocols. The platform doesn't have access to your private keys.

Q: Can the platform debit more money?
A: No. The EIP-712 signature contains the exact amount. Debiting more is technically impossible.

Q: Is my data saved?
A: Yes. Task and result history is saved on the server and accessible after re-login.

🤖 Agent Questions

Q: How long does a task take?
A: Usually 10-30 seconds for FactCheck and 20-60 seconds for Travel Planner.

Q: What if the agent gives an error?
A: The task will move to "Failed" status, payment won't be required. You can create a new task.

Q: Can I cancel a running task?
A: Not in the current version.

📧 Confirmation Questions

Q: Why is email confirmation needed for some tasks?
A: It's a security measure for payments of $0.002 and above to prevent accidental or fraudulent charges.

Q: Didn't receive confirmation email. What to do?
A:

Check "Spam" folder
Wait 2-3 minutes
Verify email correctness in your profile

Q: Can I disable email confirmations?
A: Currently no, but we're considering an option for experienced users.

Q: How long is the confirmation request valid?
A: Usually 10 minutes. After expiration, you need to create a new request.

Troubleshooting

Wallet Connection Issues

Problem: MetaMask doesn't open when clicking "Connect Wallet"

Solution:

Make sure MetaMask extension is installed and active
Refresh the page (F5)
Verify you're on the correct domain
Try another browser

Problem: "Wrong network" error

Solution:

Open MetaMask
Switch to Base Sepolia
If the network isn't in the list, add it (see "Wallet Connection" section)

Problem: USDC balance shows 0

Solution:

Verify you have USDC on Base Sepolia (not on another network!)
Add USDC token to MetaMask manually: 0x036CbD53842c5426634e7929541eC2318f3dCF7e
Wait 1-2 minutes for synchronization
Refresh the page

Task Creation Issues

Problem: "Create Task" button is inactive

Solution:

Verify all required fields are filled
Make sure you're logged in
Check browser console (F12) for errors
Try refreshing the page

Problem: Task stuck in "Pending" status

Solution:

Wait 1-2 minutes — tasks don't start instantly
Refresh the page
Check task status in a few minutes
If problem persists, contact support

Payment Issues

Problem: MetaMask doesn't open for signature

Solution:

Unlock MetaMask (enter password)
Verify extension isn't blocked by browser
Try closing and reopening payment window
Refresh page and try again

Problem: "Insufficient balance" error

Solution:

Check USDC balance in MetaMask
Top up wallet
Make sure you're on the correct network (Base Sepolia)
Try again after topping up

Problem: Result doesn't open after signing

Solution:

Wait 10-20 seconds — processing may take time
Check browser console (F12) for errors
Refresh page and click "View Result" again
If payment went through (check MetaMask history), result will be available

Problem: Didn't receive email for payment confirmation

Solution:

Check "Spam" folder
Wait 2-3 minutes
Verify correct email is specified in your profile
Try creating task again

Result Issues

Problem: Result doesn't display after payment

Solution:

Refresh page (F5)
Check payment status in task list
Click "View Result" again
Clear browser cache (Ctrl+Shift+Delete)

Main article: Building a Pay-Per-Use AI Agent Marketplace with Auth0 + Web3

Building a Pay-Per-Use AI Agent Marketplace with Auth0 + Web3

Prema Ananda — Sat, 25 Oct 2025 10:17:59 +0000

This is a submission for the Auth0 for AI Agents Challenge

What I Built

AgentBounty is a marketplace where AI agents authenticate via Auth0, execute tasks, and users pay per-use in USDC with gasless transactions.

Key Innovation: Auth0 (authentication) + X402 Protocol (payment gating) + EIP-712 (gasless signatures) = Perfect AI monetization stack.

The Problem

Building AI agent marketplaces requires solving multiple authentication and security challenges:

Challenge	Traditional Approach	Auth0 Approach
🔐 User Authentication	Build OAuth2 flows from scratch	Ready in minutes
🌐 Social Login	Integrate each provider separately	Toggle switches in dashboard
🔒 MFA/2FA	Custom implementation	Built-in feature
📊 User Metadata	Design database schema + API	Management API included
⚖️ GDPR Compliance	Legal review + implementation	Handled automatically
🛡️ Security Updates	Manual patching and monitoring	Automatic updates

Bottom Line: Auth0 let me skip building authentication infrastructure and focus on what makes my product unique: AI agent integration, Web3 payments, and user experience.

Tech Stack

Auth: Auth0 OAuth2 + Management API + Async Payment Approval
Backend: FastAPI (Python), SQLite
Frontend: Vanilla JS, Tailwind CSS
AI: Google Gemini API, Bright Data MCP Server
Payments: X402 Protocol, EIP-712, ERC-3009
Blockchain: Base Sepolia, USDC

🎬 Demo

📸 Screenshots

Auth0 Universal Login (works out of the box):

AI Agent Marketplace:

FactCheck Agent Results:

Gasless Payment via MetaMask:

Want to dive deeper? Check out these guides:

🚀 AgentBounty User Guide - Step-by-step instructions for end users covering account setup, wallet connection, and running AI agents
🔧 M2M API Integration Guide - Technical guide for developers integrating AgentBounty programmatically with code examples

Source Code:

GitHub: https://github.com/premananda108/AgentBounty

How I Used Auth0 for AI Agents

Auth0 isn't just "login"—it's the entire security and identity infrastructure. Here's how I used Auth0 to solve real problems:

Problem 1: User Authentication

Without Auth0, I would need to build:

# What a custom auth system requires:
- User registration endpoint
- Password hashing (bcrypt/argon2)
- Email verification system
- Password reset flow
- Session management
- CSRF protection
- Rate limiting
- Security headers
- Continuous security monitoring
...and many more security considerations

With Auth0:

# app/main.py - Complete auth setup
from authlib.integrations.starlette_client import OAuth

# OAuth client configuration
oauth = OAuth()
oauth.register(
    name='auth0',
    client_id=settings.AUTH0_CLIENT_ID,
    client_secret=settings.AUTH0_CLIENT_SECRET,
    server_metadata_url=f'https://{settings.AUTH0_DOMAIN}/.well-known/openid-configuration',
    client_kwargs={
        'scope': 'openid profile email offline_access'
    }
)

What I got included:

✅ OAuth2 + OIDC compliance
✅ PKCE for mobile security
✅ Automatic token refresh
✅ Secure session management
✅ Brute-force protection
✅ Breached password detection

Developer Benefit: I could focus on building product features instead of security infrastructure.

Problem 2: Social Login (GitHub, Google)

Traditional approach requires:

For each provider:
1. Register OAuth app on GitHub/Google/etc
2. Handle OAuth callback flow
3. Store OAuth tokens securely
4. Handle token refresh
5. Map provider user to local user
6. Handle edge cases (email changes, account linking)

With Auth0:

Auth0 handles:

✅ OAuth app credentials management
✅ Token storage and refresh
✅ User profile normalization
✅ Account linking (same email → same user)

Configuration in Auth0 Dashboard:

Go to Authentication → Social
Click "Google" → Enable
Click "GitHub" → Enable
Done!

Developer Benefit: Adding new social providers takes minutes instead of days of integration work.

Problem 3: Web3 Wallet Linking

Challenge: Users need to link their MetaMask wallet to their Auth0 account for crypto payments.

Traditional Approach:

Where to store wallet addresses?
- Design database schema
- Create API endpoints for CRUD
- Handle updates and validation
- Ensure persistence across sessions
- Maintain separate user data store

Auth0 Solution: User Metadata

Auth0 provides a flexible user_metadata field for storing custom user data:

# app/routers/wallet.py
@router.post("/connect")
async def connect_wallet(
    request: Request,
    data: ConnectWalletRequest,
    user: dict = Depends(require_auth)
):
    """
    Connect Web3 wallet to Auth0 account

    User must be logged in with Auth0 first.
    Verifies wallet ownership via signature.
    Saves wallet_address to Auth0 user_metadata.
    """

    auth0_user_id = user.get('sub')
    user_email = user.get('email', 'unknown')

    # Verify signature (proof of wallet ownership)
    w3 = Web3()
    message = encode_defunct(text=data.message)

Why this works:

No extra database: Wallet address stored with Auth0 user
Single source of truth: One user profile, multiple attributes
Persistence: Survives across sessions, devices
Security: Management API requires authentication
Flexibility: Can add more attributes anytime

Developer Benefit: No need to maintain separate user data storage. Auth0 becomes both authentication AND user database.

Problem 4: Async Payment Approval (2FA for Payments)

Challenge: High-value crypto payments need user confirmation before processing.

Requirements:

User initiates payment in browser
Backend holds transaction
User approves via separate channel (email/SMS)
Backend executes approved transaction
Must be secure and auditable

What Auth0 handles:

✅ Approval email/SMS delivery
✅ Secure approval links with expiration
✅ Callback to your backend
✅ Audit trail of all approvals
✅ Replay attack prevention

Security benefits:

Two-factor confirmation: User approves in separate channel
Time-limited: Approval expires after 5 minutes
Non-repudiation: Auth0 logs who approved what
Audit trail: Every payment tied to Auth0 user_id

Lessons Learned and Takeaways

✅ What Worked Brilliantly

1. Zero Upfront Investment

Auth0 Free Tier allowed me to:
- Build entire MVP
- Launch to early users
- Validate product idea
- All at no cost

Traditional approach:
- Significant development time upfront
- Long runway before first user
- Higher risk if product doesn't work out

2. Focus on Differentiation

With Auth0:
- Minimal time on authentication
- Maximum time on unique features (X402, AI agents, Web3)

Without Auth0:
- Significant time on authentication infrastructure
- Less time for product innovation

3. Enterprise Features from Day 1

Features I got immediately:
✅ Brute-force protection
✅ Breached password detection
✅ MFA/2FA
✅ GDPR compliance
✅ High availability

Building these manually would take considerable effort

4. Scalability Without Refactoring

Auth0 scales automatically:
- Small user base: Works perfectly
- Growing user base: Works perfectly
- Large user base: Still works perfectly

Custom auth system:
- Often needs refactoring as you scale
- Performance optimization required
- Infrastructure management overhead

5. Management API = Hidden Gem

# User metadata as a database
# This eliminated the need for:
- User settings system
- Preferences storage
- Wallet linking tables
- Custom attributes database

Just use Auth0:
await auth0_service.update_user_metadata(user_id, {
    'wallet_address': '0x...',
    'preferred_chain': 'base',
    'notifications': {'email': True},
    'mcp_usage_count': 42
})

Developer Insight: Auth0's Management API serves as user metadata storage. I built a complete user profile system without writing database migrations or CRUD APIs.

⚠️ Challenges & How I Solved Them

Rate Limits on Management API

# Problem: Hitting 429 Too Many Requests
# Solution: Aggressive caching

class Auth0Service:
    def __init__(self):
        self._token_cache = {}  # 23h TTL
        self._profile_cache = {}  # 5min TTL

    async def get_user_profile(self, user_id: str) -> dict:
        # Check cache first
        if user_id in self._profile_cache:
            profile, expires = self._profile_cache[user_id]
            if datetime.utcnow() < expires:
                return profile

        # Fetch from Auth0
        profile = await self._fetch_profile(user_id)

        # Cache for 5 minutes
        self._profile_cache[user_id] = (
            profile,
            datetime.utcnow() + timedelta(minutes=5)
        )

        return profile

# Result: Drastically reduced API calls

For AI Agent Platforms (like AgentBounty)

Advantages:

✅ User metadata perfect for agent preferences
✅ M2M authentication for automated systems
✅ Async Payment Approval for safe transactions
✅ Audit trail for compliance
✅ Scales with usage

Considerations:

⚠️ Need custom logic for wallet linking (straightforward to implement)
⚠️ Management API rate limits (solved with caching)

Verdict: Well-suited for this use case.

🔗 Try It Yourself

Live Demo: https://agentbounty.premananda.site
GitHub: https://github.com/premananda108/AgentBounty

🙏 Closing Thoughts

Building AgentBounty taught me that identity is infrastructure—just like databases, message queues, and cloud storage.

You don't build PostgreSQL from scratch. You don't build Kafka from scratch. You shouldn't build authentication from scratch.

Auth0 let me focus on what makes AgentBounty unique: X402 payments, AI agents, Web3 integration. The authentication layer was handled efficiently.

To other developers: If you're building anything that needs users, consider using Auth0. It's a practical choice that lets you focus on your product's unique value.

Documentation:

Auth0: https://auth0.com/docs
X402 Protocol: https://www.coinbase.com/developer-platform/products/x402
Bright Data MCP: https://docs.brightdata.com/mcp-server/overview#mcp-server-overview
EIP-712: https://eips.ethereum.org/EIPS/eip-712
ERC-3009: https://eips.ethereum.org/EIPS/eip-3009

Built with ❤️ for the Auth0 for AI Agents Challenge

Building a Hands-Free AI Fitness Applet with Gemini Live API

Prema Ananda — Sun, 14 Sep 2025 12:49:57 +0000

This is a submission for the Google AI Studio Multimodal Challenge

What I Built

AI Personal Trainer is an experimental fitness app with a "voice-first" approach that turns your smartphone into an interactive workout partner. The app is primarily controlled by voice commands, allowing you to focus on exercises rather than the screen.

The problem I'm exploring:

Distractions during workouts: The need to constantly interact with the phone screen
Lack of personalization: Most apps offer one-size-fits-all solutions
Passive interaction: Apps work as trackers rather than assistants

Implemented features:

🎤 Voice program creation: Dialog with AI to create personalized workout programs
🧠 Real-time audio interaction: Two-way voice communication during workouts
📊 Comprehensive database system: System for storing programs, sessions, and progress
📈 Analytics dashboard: Visual progress tracking and performance insights
📅 Google Calendar integration: Automatic addition of workouts to calendar
🎯 Hybrid architecture: Combining dialog speed with analysis accuracy

Demo

📱 View in AI Studio

💻 GitHub Repository:ai-personal-trainer

Thanks @aquascript-team for help with the video!

How I Used Google AI Studio

Development started directly in Google AI Studio, where I experimented with different approaches to multimodal interaction.

Development process:

Prototyping in Google AI Studio: Creating user interface and initial system setup
Export and development: Downloaded the project for local development
Extended development: Used Gemini CLI to integrate complex functions
Final deployment: Uploaded the finished project and used Deploy App

Two-model architecture:

Main model: Real-time dialog

// Connection to live audio dialog
sessionRef.current = await clientRef.current.live.connect({
  model: 'gemini-2.5-flash-preview-native-audio-dialog',
  callbacks: {
    onopen: () => setConnectionStatus('connected'),
    onmessage: async (message) => {
      // Processing user speech
      if (message.serverContent?.inputTranscription) {
        const userText = message.serverContent.inputTranscription.text;
        onTranscript(userText);
      }

      // Playing AI response  
      const audio = message.serverContent?.modelTurn?.parts[0]?.inlineData;
      if (audio && outputAudioContextRef.current) {
        await playAudioResponse(audio);
      }
    }
  },
  config: {
    systemInstruction: createDynamicPrompt(),
    responseModalities: [Modality.AUDIO],
    outputAudioTranscription: {}, // <--- Enable LLM transcription
    inputAudioTranscription: {}, // <--- Enable user transcription
    speechConfig: {
      voiceConfig: { prebuiltVoiceConfig: { voiceName: 'Orus' } }
    }
  }
});

Analytics model: Data extraction

// Precise interpretation of user commands
export const interpretWorkoutCommand = async (transcript: string): Promise<{ command: 'log_set' | 'get_form_tip' | 'chat_message', data: { reps?: number, weight?: number, text?: string } | null }> => {
    const prompt = `You are an AI assistant interpreting voice commands from a user during a workout. The user's voice transcript is: "${transcript}".

    Your task is to analyze the transcript and classify it into one of the following commands, extracting relevant data.

    POSSIBLE COMMANDS:
    1. 'log_set': The user is reporting the completion of a set. They might mention repetitions (reps) and/or weight.
       - Keywords: "done", "finished", "log it", "reps", "weight", "kilos", numbers.
       - Example Transcripts: "Okay, 12 reps at 50 kilos", "I'm done", "8 reps", "log 90 pounds".
    2. 'get_form_tip': The user is asking for advice on their exercise form.
       - Keywords: "form", "technique", "how do I do this", "am I doing it right".
       - Example Transcripts: "check my form", "what's the technique for this".
    3. 'chat_message': The user is saying something else, likely a question or comment for the AI coach. This is the default if no other command fits.
       - Example Transcripts: "how many sets left", "I'm feeling tired", "what's the next exercise".

    Respond in JSON format with "command" and optional "data".
    - For 'log_set', 'data' should be an object with optional 'reps' and 'weight' numbers.
    - For 'get_form_tip', 'data' should be null.
    - For 'chat_message', 'data' should be an object with the original transcript as 'text'.

    Return ONLY the JSON object.

    Example Responses:
    - Transcript: "10 reps at 80 kg" -> { "command": "log_set", "data": { "reps": 10, "weight": 80 } }
    - Transcript: "how do I do this right?" -> { "command": "get_form_tip", "data": null }
    - Transcript: "what's the next exercise?" -> { "command": "chat_message", "data": { "text": "what's the next exercise?" } }
    `;

    try {
        const result = await ai.models.generateContent({
            model: "gemini-2.5-flash",
            contents: prompt,
...

Multimodal Capabilities

1. Seamless audio interaction

Implemented: using client.live.connect from Gemini Live API SDK connection with continuous bidirectional streaming
Uniqueness: Works like a phone conversation — you can interrupt and get instant responses

2. Hybrid command processing

Architecture:

Dialog Model: Maintains natural conversation
Analysis Model: Extracts precise data from speech

Processing example:

User: "Did eight reps with sixty kilos, felt pretty easy"

Dialog Model → "Great! Logged 8 reps with 60 kg. Should we increase the weight?"
Analysis Model → 
  {
    "command": "log_set",
    "data": {
      "reps": 8,
      "weight": 60
    }
  }

3. Full-featured data system

Implemented architecture:

Workout programs (/programs/{programId}):

{
  "name": "Strength program, 12 weeks",
  "createdBy": "userId",
  "workouts": {
    "day1": {
      "dayName": "Chest and triceps",
      "exercises": [
        {
          "exerciseId": "bench_press",
          "name": "Barbell bench press",
          "sets": [{"reps": 8, "weight": 60}],
          "rest": 120
        }
      ]
    }
  }
}

Detailed training sessions (/sessions/{sessionId}):

{
  "userId": "user123",
  "date": "2024-01-15T10:00:00Z",
  "programId": "strength_program_001",
  "workoutId": "day1_chest",
  "duration": 5400, // seconds
  "voiceTranscript": "Complete log of conversation with AI...",
  "performedSets": {
    "set001": {
      "exerciseId": "bench_press",
      "setNumber": 1,
      "reps": 8,
      "weight": 62.5,
      "timestamp": "2024-01-15T10:15:30Z"
    }
  }
}

4. Automatic calendar integration

Implemented: Direct integration with Google Calendar API

export const scheduleWorkouts = async (workouts: Workout[], accessToken: string): Promise<void> => {
    if (!workouts || workouts.length === 0) {
        throw new Error("No workouts to schedule.");
    }

    const schedulePromises = workouts.map(workout => {
        const startTime = getNextWorkoutDate(workout.dayOfWeek);
        const endTime = new Date(startTime.getTime() + 60 * 60 * 1000); // Assume 1-hour duration

        const event = {
            'summary': `Workout: ${workout.dayName}`,
            'description': `Your scheduled workout session.\n\nExercises:\n- ${workout.exercises.map(e => e.name).join('\n- ')}`,
            'start': {
                'dateTime': startTime.toISOString(),
                'timeZone': Intl.DateTimeFormat().resolvedOptions().timeZone,
            },
            'end': {
                'dateTime': endTime.toISOString(),
                'timeZone': Intl.DateTimeFormat().resolvedOptions().timeZone,
            },
        };

        return fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${accessToken}`,
                'Content-Type': 'application/json',
            },
            body: JSON.stringify(event),
        });
    });

    await Promise.all(schedulePromises);
};

5. Contextual understanding of fitness terminology

AI understands specific vocabulary:

Recognition of data for set logging (log_set): AI searches user speech for numbers and keywords (such as "reps", "times", "weight", "pounds") to automatically fill in data about completed sets.
Processing requests and comments (get_form_tip, chat_message): Phrases that don't contain direct data for logging are processed as trainer requests or simple comments.

6. Comprehensive Analytics Dashboard

Implemented: A dedicated analytics section that provides detailed insights into workout performance and progress tracking.

Features include:

Visual progress charts and graphs
Historical workout data visualization
Performance metrics and trends analysis

Current MVP Limitations

Main challenges:

Speech recognition accuracy: AI doesn't always correctly interpret commands in live dialog, especially with background noise
Command execution: The model sometimes "forgets" to execute specific actions in the app after responding

Why Multimodality Matters for Fitness

Traditional fitness apps force you to choose: EITHER data tracking OR workout focus. The multimodal approach solves this dilemma:

Voice interface allows you to stay focused on exercises
Intelligent speech analysis structures data automatically
Real-time feedback creates the feeling of a personal trainer
Automatic workout scheduling integrates fitness into daily life

The result is a fitness companion that understands natural speech and adapts to each user's unique style.

Note: Despite my AI trainer being quite smart and motivating, we strongly recommend maintaining common sense, especially when it comes to health matters. 💪

Acknowledgments

I express deep gratitude to the organizers of the Google AI Studio Multimodal Challenge for the unique opportunity to experiment with cutting-edge artificial intelligence technologies.

Special thanks to:

The Google AI Studio team for the intuitive platform that makes complex technologies accessible
Gemini Live Audio API developers for the revolutionary real-time voice interaction technology
The Dev.to community for providing an inspiring platform for innovative projects

This project was made possible by an ecosystem of cutting-edge tools and the supportive developer community that Google AI creates.

MVP developed with React, TypeScript, Firebase, Google Calendar API and Google Gemini multimodal capabilities

Built with ❤️ by Premananda

My Summer 2025 Dev Journey: AI Challenges, Robot Adventures, and Community Growth 🌞

Prema Ananda — Sun, 31 Aug 2025 10:59:32 +0000

As August comes to an end, I can't help but reflect on what has been an absolutely incredible summer — full of programming, learning, and pushing the boundaries of what's possible with AI and web technologies. From building AI systems to literally "bringing a robot to life" — this summer has been a real adventure that I want to share with you.

Challenge Marathon 🏃‍♂️

This summer turned into a personal challenge marathon, and honestly, I enjoyed every minute of it:

Redis AI Challenge: Beyond Caching

The Redis AI Challenge became a real turning point for me. Instead of simply using Redis for caching, I dove deeper and transformed it into the forum's primary database. The result? A lightning-fast system that handles everything — from user data to AI-powered content recommendations. You can read the full description of this journey here.

Key Takeaway: The best solutions come from simple, well-thought-out architecture.

Algolia MCP Server: Learning Through Difficulties

The Algolia MCP Server Challenge taught me that sometimes documentation isn't enough — you need to roll up your sleeves and dig in yourself. Building a Python client from scratch was frustrating at times, but incredibly rewarding. Check out my battle scars and victories.

Lesson Learned: To study a technology, you need to fully immerse yourself in the project, learning all the nuances.

Postmark Challenge: Email Stories on Maps

Who would have thought that emails could tell geographical stories? The Postmark challenge led me to create MailMap — transforming mundane email data into interactive adventures on Google Maps. Read about simple email-based mapping approach.

n8n & BrightData Challenge: Multi-Agent Brand Monitoring

One of the most complex projects this summer was building BrandGuard AI - a comprehensive multi-agent brand monitoring system. Using n8n's visual programming and BrightData's reliable data streams, I created an intelligent platform that automatically tracks brand mentions across Twitter, Reddit, and LinkedIn, analyzes them with Google Gemini AI, and delivers insights through a Slack bot and web dashboard. Dive into the multi-agent architecture.

Technical Insight: This project showed me the power of no-code platforms for creating enterprise-level AI solutions with minimal time investment.

Robot Revolution 🤖

But the real highlight of my summer was giving the NAO robot the power of Google Gemini AI. Imagine: a humanoid robot that doesn't just move and dance, but actually thinks and responds intelligently. The full story of this AI-robot fusion is here.

This project taught me that the future isn't just about software, but about creating meaningful bridges between the digital and physical worlds.

Community Growth and Personal Wins 📈

Building Consistency

One of my main victories this summer was building stable community engagement. From a weekly streak to an 8-week Community Wellness streak — it's amazing how much you learn when you commit to showing up every day.

Technical Achievements 💻

Stack Evolution

My main stack this summer:

Backend: Python/Flask/FastAPI (still love this combination)
Cloud: Google Cloud (diving deeper into their AI services)
AI: Redis for vector search, Google Gemini for natural language processing
Databases: MongoDB
Cloudflare Tunnel: secure outbound tunnel from server to Cloudflare network
Deployment: Debian servers (reliable as always)
New Addition: n8n, BrightData and MCP (Model Context Protocol) for AI service integration

Problem-Solving Approach

This summer reinforced my belief in learning through building real solutions. Each challenge taught me something new:

Vector search for spam protection
Email parsing and geolocation mapping
Robot-AI integration
Custom MCP client development

Looking Forward 🚀

As we transition into fall, I'm looking forward to:

Deep AI Integration: Exploring new ways to combine traditional web development with AI capabilities
Robotics: Building simple physical robots
Community Contribution: Continuing to share learning experiences and help others navigate similar challenges

Summer Stats 📊

8 major projects completed
9 badges earned on dev.to
Multiple AI challenges conquered
1 virtual robot brought to life with AI
1 multi-agent monitoring system deployed
Countless hours of learning and programming
1 amazing community that supported every step

Final Thoughts 💭

This summer taught me that the best learning happens when you're slightly uncomfortable — when you're solving problems you've never solved before, and building bridges between different technologies.

To my fellow developers reading this: don't be afraid to take on challenges that seem above your current skill level. Some of my best work this summer came from projects where I had no idea how I'd solve them when I started.

We're living in an incredible time when a single developer can create systems that would have required entire teams just a few years ago.

What was your main technical victory this summer? I'd love to hear about your projects and challenges in the comments!

And if you're working on something interesting related to AI and robotics, feel free to connect — I'm always interested to learn what others are creating.

Building a Multi-Agent AI Brand Monitoring System with n8n and BrightData

Prema Ananda — Sat, 30 Aug 2025 07:15:56 +0000

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

What I Built

I created BrandGuard AI — a comprehensive multi-agent brand reputation monitoring system that fundamentally transforms how companies track and respond to online mentions. This isn't just another social media monitoring tool — it's an intelligent, fully automated platform that processes brand mentions through a sophisticated AI pipeline.

The system addresses a critically important problem: in today's hyper-connected digital world, brand mentions spread across countless platforms with such intensity that human teams physically cannot track them effectively. Traditional methods are too slow, too manual, and lack the depth to separate critical signals from noise.

BrandGuard AI solves this through:

Automatic collection of meaningful brand mentions from major social platforms (Twitter, Reddit, LinkedIn) using reliable BrightData data streams with simple mechanisms for adding new sources
Intelligent analysis of each significant mention through Google Gemini AI to extract sentiment, urgency level, business impact, and crisis indicators
Automated report generation with daily and weekly strategic summaries that typically require hours of analytical work
Instant access via a conversational Slack bot that understands natural queries like "Show me critical mentions for today" or "Show me what's up with Apple today"
Real-time insights delivery through a dynamic web dashboard with interactive visualizations

The system's uniqueness lies in its multi-agent architecture — each key function (data collection, analysis, reporting, user interface) is handled by a specialized, independent agent built as separate n8n workflows. This modular design ensures exceptional resilience, scalability, and maintainability.

GitHub Repository:

premananda108 / BrandGuardAI

Intelligent Brand Reputation Monitoring System Automated AI-powered brand monitoring with automated analysis, reporting, and a natural language Slack interface.

🛡️ BrandGuard AI

Intelligent Brand Reputation Monitoring System
Automated AI-powered brand monitoring with automated analysis, reporting, and a natural language Slack interface.

🎯 What is BrandGuard AI?

BrandGuard AI is a comprehensive, fully automated brand reputation monitoring system built on n8n. It is designed to:

🕷️ Collect brand mentions from major social platforms like Twitter, Reddit, and LinkedIn.
🧠 Analyze each mention for sentiment, urgency, and business impact using Google Gemini AI.
🗄️ Store enriched data in a structured MongoDB database.
📊 Generate automated daily and weekly analytical reports with strategic insights.
🖥️ Visualize data through a dynamic web dashboard.
💬 Interact with users via a smart Slack bot that understands natural language queries.
🚨 Alerts your team about critical mentions.

🗗️ System Architecture

The system is a collection of interconnected n8n workflows that create a full data processing pipeline, from collection to user-facing interfaces.

graph TD
    subgraph "Data Collection

…

View on GitHub

The system is fully functional and deployed in a production environment.
The complete source code includes all n8n workflows, Docker configurations and setup documentation.

n8n Workflow

The BrandGuard AI system is built on a modular architecture of interconnected n8n workflows. Each workflow performs a specialized function in the overall data processing pipeline.

Core Workflows:

1. Data Collection and Processing:

Brand Monitoring Step 1 - schedules data collection from BrightData and creates processing tasks
Brand Monitoring Step 2 - normalizes raw data into unified format through adapters

Brand Monitoring Step 3 - performs AI analysis through Google Gemini and saves to MongoDB

2. AI Reporting:

AI Daily Summary - generates daily analytical summaries
AI Weekly Summary - creates weekly strategic reports

3. User Interfaces:

BrandGuard AI - Dashboard - web dashboard with interactive analytics

BrandGuard AI bot - Slack bot with natural language support

Brand Mention Report - detailed mention viewing

Key Architectural Features:

Modularity: each agent is an independent workflow
Extensibility: adapter pattern for easy addition of data sources
Resilience: centralized error handling and state monitoring
Scalability: task management through MongoDB jobs collection

Complete workflow JSON files: available in the /workflows folder of the GitHub repository

Technical Implementation

AI Agent Configuration

The system uses Google Gemini as the primary AI model through the standard node in n8n. Each agent is configured with specialized system instructions for specific tasks:

Mention Analysis Agent:

System Instructions: "Analyze brand mentions and return structured JSON with fields: sentiment_score, confidence, urgency_level (1-10), key_topics, crisis_indicators, business_impact, severity, recommended_action"
Model: Google Gemini Flash and Pro for deep contextual understanding
Memory: Stateless - each mention is analyzed independently
Tools: JSON parser for structured output

Slack Bot Agent:

System Instructions: "You are an assistant for brand reputation analysis. Interpret user queries and translate them into MongoDB queries. Available functions: help, today, brand, search, critical, summary"
Model: Google Gemini Flash for natural language processing
Memory: Session context within a single request
Tools: MongoDB connector, Slack message formatting

Reporting Agents:

System Instructions: "Create executive summary based on brand mentions for specified period. Include trends, critical moments, recommendations"
Model: Google Gemini Pro for insight generation
Memory: Aggregated data for the period
Tools: MongoDB aggregation pipeline

Bright Data Verified Node

BrightData is the foundation of the entire data collection pipeline in BrandGuard AI. I used the official verified BrightData node in n8n for integration with their data ecosystem:

Setup and Configuration:

Datasets used: Twitter Posts, Reddit Posts, LinkedIn Posts with ability to add new ones
Filtering: by brand keywords, engagement metrics (likes, reposts)
Frequency: automatic collection every n hours through n8n scheduler
Data format: JSON with rich metadata (author, time, engagement metrics)

Key BrightData Advantages:

Data Quality: structured, clean data without need for complex preprocessing
Reliability: stable data delivery without gaps or duplication
Scalability: handling large volumes of mentions without infrastructure burden
Compliance: all data collected in compliance with platform ToS

Architectural Solution with Adapters: I implemented an adapter pattern for working with different BrightData sources. Each source (Twitter, Reddit, LinkedIn) has its adapter in the Brand Monitoring Step 2 workflow, which normalizes the specific data structure into a unified format. This allows easy addition of new datasets from the BrightData marketplace without changes to the core system logic.

Journey

The development of BrandGuard AI was an iterative process that started with a simple idea of automating mention monitoring and evolved into a comprehensive multi-agent system.

Stage 1 - MVP (Minimum Viable Product): Started with a basic n8n workflow that collected data from one source and saved to MongoDB. Quickly realized that a more complex architecture was needed to handle heterogeneous data sources.

Stage 2 - Architectural Design: Decided on a multi-agent architecture after studying the limitations of the monolithic approach. Divided the system into specialized agents with clear areas of responsibility.

Stage 3 - Slack Bot Implementation: Getting the Slack bot to work properly was the main challenge. It required significant effort to set up the proper webhooks, authentication, and message handling to create a seamless conversational experience.

Major Challenges and Solutions

Challenge 1: Heterogeneous Data Sources

Problem: each platform (Twitter, Reddit, LinkedIn) returns data in different formats
Solution: implemented adapter pattern using Switch node in n8n, where each source has its adapter for data normalization

Challenge 2: Performance Bottleneck at Scale

Problem: When MongoDB collection exceeded 1000 mentions, the workflow fetching all documents at once caused server hangs due to excessive memory consumption
Solution: Implemented server-side pagination by reconfiguring the n8n workflow to process data in manageable chunks, adding page and size parameters to the webhook that control limit and skip values in MongoDB queries

Challenge 3: Processing Scalability

Problem: as data volume increased, the system began to slow down
Solution: implemented job-based architecture with state tracking in MongoDB and asynchronous processing

Challenge 4: Slack Bot User Experience

Problem: wanted natural conversation with the bot, not rigid commands
Solution: used Google Gemini for NLU (Natural Language Understanding), allowing the bot to understand free-form questions

What I Learned

Technical Insights:

Power of n8n as orchestrator: n8n proved to be the ideal tool for creating complex multi-agent systems thanks to visual programming and rich integration ecosystem
Importance of data quality: working with BrightData showed the critical importance of clean, structured data for AI analysis
AI prompt engineering: creating effective prompts for structured output is an art requiring multiple iterations

Architectural Lessons:

Modularity above all: dividing the system into independent agents significantly simplified development, debugging, and scaling
Importance of state monitoring: job-based architecture with tracking in MongoDB enabled creation of a transparent and debuggable system

This project showed me how modern no-code/low-code platforms can be used to create enterprise-level AI solutions with minimal time and resource investment.

P.S.
I want to note that before this project, I had never worked with n8n and didn't even know about BrightData's existence. This challenge became a real discovery of two outstanding products.

n8n impressed me with its flexibility and power of visual programming. What seemed like a complex task of orchestrating multiple AI agents turned into an intuitive process of creating interconnected workflows.

BrightData turned out to be exactly the missing link needed for quality data collection. The reliability, structure, and richness of their datasets dramatically simplified the system architecture.

Thanks to DEV.to for organizing this challenge! Without it, I would never have discovered these wonderful products and wouldn't have been able to create BrandGuard AI. This is an excellent example of how technical competitions promote learning new technologies and creating innovative solutions.

Beyond Caching: How Redis 8 Became Our Forum's Primary Database and AI Engine

Prema Ananda — Tue, 05 Aug 2025 11:33:59 +0000

This is a submission for the Redis AI Challenge: Beyond the Cache.

What I Built

I built CleanForum, a complete forum application where Redis 8 is not an accessory, but the central nervous system. It handles every aspect of the forum's data, from post and comment storage to real-time AI-powered spam moderation.

The Challenge: Escaping the "Database Zoo"

In modern web development, we often find ourselves managing a "zoo" of specialized databases. A typical stack might include PostgreSQL for primary data, Elasticsearch for search, a dedicated vector database like Pinecone for AI features, and, of course, Redis for caching. This complexity introduces overhead, synchronization challenges, and increased costs.

For my project, CleanForum, I set out with an ambitious goal: to build a full-featured, AI-powered forum using a single data platform. I wanted to challenge the conventional wisdom that Redis is "just a cache" and prove that with Redis 8, it can be the powerful, unified engine for an entire application.

Key Features at a Glance:

A Complete, Feature-Rich Forum: Users can create posts with Markdown, engage in discussions through comments, and browse content by categories.
Transparent AI Spam Protection: The crown jewel of the project. A sophisticated, hybrid system that combines traditional heuristic checks with advanced vector similarity analysis. It doesn't just block spam; it provides moderators with a detailed report explaining why a post was flagged.
Engaging "Similar Posts" Feature: To increase user retention, the system uses Redis's vector search capabilities to instantly suggest other relevant content, keeping users engaged on the site.
Instant Full-Text Search: The entire forum is searchable, with results delivered in milliseconds, powered by the same RediSearch index used for AI features.
Insightful Moderator Panel: A command center where moderators can review flagged content, see detailed spam analysis, and manually manage posts and comments, providing feedback to the system.

Demo

The application is live and fully functional. I invite you to test it out!

Live Application: forum.premananda.site
Video Demo:

premananda108 / CleanForum

A modern forum with an advanced spam protection system based on FastAPI and Redis Vector Search.

CleanForum 🛡️

A modern forum with an advanced spam protection system based on FastAPI and Redis Vector Search.

🚀 Features

🔒 Advanced Spam Protection

Vector analysis using SentenceTransformer (all-MiniLM-L6-v2)
Heuristic algorithms to detect spam patterns
Feedback system to improve accuracy
Redis Vector Sets for fast search of similar posts
k-NN classification with nearest neighbors voting

🏗️ Technology Stack

Backend: FastAPI, Python 3.8+
Database: Redis 7.0+ with Vector Search
ML model: SentenceTransformer
Frontend: Tailwind CSS, Vanilla JavaScript
Templates: Jinja2

📋 Functionality

✅ Create and edit posts
✅ Comment system
✅ Categories and tags
✅ Voting and ratings
✅ Moderator panel
✅ Forum search
✅ Automatic spam analysis
✅ Statistics and analytics

🛠️ Installation and Launch

Prerequisites

Python 3.8+
Redis 8.0+ with Vector Search support
Docker (optional)

1. Cloning and Installing Dependencies

git clone https://github.com/premananda108/CleanForum.git

# Go to the project directory
cd CleanForum
# Create a

…

View on GitHub

Here are some screenshots showcasing the application in action:

Home Page and Content

Post Page with Related Posts

Moderator Panel with Moderation Queue

Detailed Spam Analysis Report

How I Used Redis 8

Redis 8 is the architectural cornerstone of CleanForum. It allowed me to replace a potential stack of 3-4 different technologies with one elegant and hyper-efficient solution.

1. Redis Hashes as the Primary "Source of Truth" Database

Instead of a traditional SQL database, every core entity in the application is a Redis Hash.

Posts: Stored in keys like post:<uuid>, a hash contains the post's title, content, author ID, timestamps, and vote scores.
Users: user:<uuid> hashes store profile information, roles, and reputation.
Comments: comment:<uuid> hashes hold comment content and relationships.

This approach provides schema flexibility and the raw performance Redis is famous for. To manage relationships and create feeds, I heavily utilized Sorted Sets (ZSETs). For example, posts:all is a sorted set scored by timestamp, providing an instantly accessible, chronologically sorted list of all posts.

2. RediSearch for Dual-Purpose Search: Vector & Full-Text

This is where the "multi-model" power of Redis truly shines. I use a single RediSearch index to power two fundamentally different types of search.

To optimize this, I implemented a two-hash architecture:

The "Source of Truth" Hash (post:<id>): Contains the complete, rich data for a post.
The "Search Index" Hash (vector:post:<id>): A lightweight, separate hash containing only the data needed for indexing: the vector embedding and pre-processed text.

This separation is key: it keeps the search index incredibly lean and fast, while the main data can be as complex as needed without bloating the index. The index is configured to automatically pick up any new keys with the vector: prefix.

3. The Hybrid AI Engine: My Secret Sauce

The spam detection system is a perfect example of combining Redis features to create something powerful. It’s a two-stage process:

First Pass - Heuristic Analysis: The system first performs a rapid check for obvious spam indicators: suspicious keywords ("free", "crypto"), excessive capitalization, and patterns common in spam. This is handled in Python.
Second Pass - Vector Similarity Analysis: This is the core of the AI.
- A vector embedding is created from the new post's content.
- A K-Nearest Neighbor (KNN) query (*=>[KNN k @vector $blob]) is sent to RediSearch to find the most similar posts already in the database.
- The system then fetches the current, real-time is_spam status of these "neighbors" directly from their primary post:<id> hashes.
- A weighted score is calculated. If a post is highly similar to several posts that moderators have previously marked as spam, its own spam score skyrockets.

This synergy is incredibly powerful. The user-facing "Similar Posts" feature and the backend security system are powered by the exact same mechanism. It's efficient, elegant, and learns continuously from moderator feedback.

4. Deployment and Infrastructure

To prove that this powerful stack is accessible to everyone, the entire application is running on a modest Debian 12 virtual server with just 4GB of RAM. The Redis database itself is hosted on a free-tier cloud instance. This demonstrates that thanks to Redis's incredible efficiency, you don't need a massive budget or enterprise-grade hardware to build and run a sophisticated, AI-driven application.

Conclusion and Gratitude

This journey with the Redis AI Challenge has been more than just a competition; it has fundamentally changed my perspective on what's possible with a single database. Redis 8 is not just a cache—it is a legitimate, high-performance, multi-model database that can serve as the foundation for complex, modern applications. It challenged my architectural assumptions and enabled me to build a cleaner, faster, and more elegant system than I thought possible.

I want to extend my sincere gratitude to the teams at Redis and DEV.to for organizing this incredible challenge. The opportunity to push the boundaries, learn so much about vector search and AI implementation, and engage with this vibrant community has been an invaluable experience. I'm excited to see what I can build next with these powerful new tools at my fingertips.

Opening the "Black Box": A Journey into Vector Search and Spam Protection

Prema Ananda — Tue, 29 Jul 2025 11:00:29 +0000

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

How I built a spam fighting system with Redis 8 Vector Sets and what I learned about the inner workings of machine learning

What I Built

A spam classification system for dev.to that allows you to trace the entire journey from raw text to the final "spam/not spam" decision. Every step is transparent, measurable, and explainable.

In the era of ChatGPT and ready-made AI APIs, it's easy to forget that complex mathematics lies behind beautiful interfaces. When I started this project, I had a simple goal: to understand how vector search actually works, rather than just using it as a "magical" function.

Demo

premananda108 / redis8-spam-guard

🛡️ Redis8 Spam Guard

An intelligent spam classification system for dev.to posts using Redis 8 Vector Sets and FastAPI.

🎯 Features

Real-time classification - instant analysis of posts.
Redis 8 Vector Sets - leveraging the latest vector search technology.
FastAPI - a modern asynchronous API.
Machine Learning - classification based on k-NN with vector embeddings.
Interactive Web UI - a dashboard for moderators with real-time post classification, manual checking, statistics, and training logs.
Dynamic Data Enrichment - automatic loading of additional data, such as the author's follower count, for more accurate classification.
Feedback Loop - a system for improving the model based on moderator feedback.

🏗️ Architecture

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Dev.to API    │ -> │  FastAPI Server  │ -> │  Redis 8        │
│ (Posts, Users)  │    │ (API, Web UI)    │    │  (Vector Sets)  │
└─────────────────┘    └──────────────────┘    └─────────────────┘

Components:

Data Collector - collects posts and user data from…

View on GitHub

The complete project code is available on GitHub. The system works in real-time and is ready for demonstration.

How I Used Redis 8

Vector Sets — More Than Just Search

Redis Vector Sets turned out to be not just a database, but a full-fledged semantic search engine. Creating the index:

schema = (
    VectorField("vector", "HNSW", {"TYPE": "FLOAT32", "DIM": self.vector_dim, "DISTANCE_METRIC": "COSINE"}),
    TagField("label"),
    TextField("title"),
    TagField("url")
)

HNSW (Hierarchical Navigable Small World) — this isn't just an algorithm, it's an entire philosophy of search. It builds a multi-level graph of connections between vectors, allowing you to find nearest neighbors in logarithmic time.

The Heart of Vector Search: How Redis Finds Similar Posts

The real magic happens in the vector search itself. The search for vectors occurs in the core.py file, inside the find_similar_posts method of the RedisVectorClassifier class.

Here's the specific code section that sends the query to Redis:

async def find_similar_posts(self, query_vector: np.ndarray, k: int = 5) -> List[Dict[str, Any]]:
    """Finds similar posts."""
    if not self.redis_client:
        return []
    try:
        # 1. Query formation
        query = (
            f"*=>[KNN {k} @vector $blob AS score]"
        )

        # 2. Executing the search command
        results = await self.redis_client.execute_command(
            "FT.SEARCH", self.index_name, query,
            "PARAMS", "2", "blob", query_vector.tobytes(),
            "DIALECT", "2",
            "RETURN", "3", "score", "title", "url"
        )

        # ... (result processing follows)

How this works:

query = f"*=>[KNN {k} @vector $blob AS score]": This line forms the search query itself.
- * — search across all documents in the index.
- => — apply the following operation to the results.
- [KNN {k} @vector $blob AS score] — this is the vector search command (KNN - k-Nearest Neighbors). It tells Redis: "Find k nearest neighbors in the vector field, using the vector we'll pass in the $blob parameter, and name the similarity field 'score'".
await self.redis_client.execute_command(...): This line sends the FT.SEARCH command to Redis, passing it:
- The index name (self.index_name).
- The formed query (query).
- The actual vector for search (query_vector.tobytes()) as the $blob parameter.

This command is what makes Redis use its powerful algorithm (HNSW) for ultra-fast search of the most similar vectors in the database.

k-NN — Democracy of Vectors

Classification of new posts happens through "voting" of nearest neighbors:

# Find 9 nearest neighbors
similar_posts = await self.find_similar_posts(query_vector, k=9)

# Collect their labels
labels = [post['label'] for post in similar_posts]

# Majority wins
predicted_label = Counter(labels).most_common(1)[0][0]
confidence = vote_count / total_neighbors

Magic in details: Why exactly k=9? After experiments, I found that an odd number of neighbors avoids ties, and 9 provides sufficient sampling without losing accuracy.

Redis as the Architecture Foundation

The system is built entirely around Redis Vector Sets capabilities. Without Redis, there is no system — it's not just a database, but the core of all classification logic.

Why Look Under the Hood?

Anatomy of "Training": What Actually Happens?

First Discovery: We Don't Train the Model

When people say "model training," they usually imagine a neural network learning from data. In my case, everything turned out differently. I don't train a model — I use the ready-made all-MiniLM-L6-v2 as a "translator" from human language to the language of mathematics.

# This isn't model training, it's creating a knowledge base
model = SentenceTransformer('all-MiniLM-L6-v2')
text_vector = model.encode("How to earn $1000 in a week!")
# We get an array of 384 numbers reflecting the text's meaning

The real "training" happens at the level of creating a database of vectors with correct labels.

But there's one "but": Redis still requires an external model for vectorization. It would be revolutionary if Redis could accept raw text and create vectors independently. Imagine:

# Dream: pass text, get ready search
await redis_client.hset("post:123", mapping={
    "text": "How to earn $1000 in a week!",  # Just text!
    "label": "spam"
})
# Redis creates the vector under the hood

Such integration would eliminate the need to manage separate embedding models and make Redis a truly self-sufficient AI platform.

Second Discovery: Automatic Labeling is an Art of Heuristics

The biggest problem of any ML project is obtaining labeled data. I didn't have thousands of posts with "spam/not spam" labels, so I had to create SpamLabelGenerator — a rule system for automatic labeling:

def calculate_spam_score(self, article: Dict) -> float:
    score = 0.0

    # Spam words in title (high weight)
    for keyword in self.spam_keywords:
        if keyword in title:
            score += 0.3

    # Short posts with low engagement
    if reading_time < 2 and reactions < 5:
        score += 0.3

    # Too many tags
    if len(tags) > 10:
        score += 0.2

    return min(max(score, 0.0), 1.0)

Challenge: How to find balance between precision and recall? Too strict rules — we miss spam, too lenient — we block legitimate content.

Solution: Added an element of randomness and multiple criteria. The system analyzes not only text, but also engagement metrics, author profile, publication time.

Third Discovery: Vectors Are Not Just Numbers

Initially, I thought a vector was just a "fingerprint" of text. In practice, it turned out you can create hybrid vectors by combining semantic embeddings with numerical features:

# Text vector (384 dimensions)
text_vector = self.model.encode(combined_text)

# Numerical features (3 dimensions)
numeric_features = np.array([
    reading_time,
    user_followers,
    len(tags)
])

# Combine into a single vector (387 dimensions)
final_vector = np.concatenate([text_vector, numeric_features])

Insight: Vector space can be "enriched" with any numerical data. Posts become similar not only in meaning but also in structure.

Redis as a "Card Index of Meanings"

Challenges and Solutions

Problem 1: Quality of Automatic Labeling

Challenge: How to verify that automatic labels are correct?

Solution: Added detailed logging and quality metrics:

metrics = {
    'accuracy': (tp + tn) / total,
    'precision': tp / (tp + fp),
    'recall': tp / (tp + fn),
    'f1_score': 2 * (precision * recall) / (precision + recall)
}

Problem 2: Data Imbalance — Too Little Spam

Challenge: Data from dev.to API contained very little real spam. The model couldn't learn effectively — it lacked examples of "bad" behavior.

Solution: Created a synthetic spam dataset and mixed it with real data:

# Load synthetic spam posts
try:
    with open('spam_dataset.json', 'r', encoding='utf-8') as f:
        spam_articles = json.load(f)
        # Mark as known spam
        for article in spam_articles:
            article['is_known_spam'] = True
        articles.extend(spam_articles)
except FileNotFoundError:
    logger.warning("spam_dataset.json not found")

Synthetic dataset composition (50 examples):

Quick money schemes and crypto scams
Phishing links and fake security notifications
SEO services sales and follower boosting
Dubious courses and "miracle products"

System Evolution: From Static to Self-Learning

The first version of the system had a critical flaw — it couldn't learn from its mistakes. Every moderator correction was lost after page reload.

Feedback Loop in Action

The solution turned out to be elegant: with each moderator click, the complete post content is saved in Redis with an expert verdict:

# Check for moderator verdict from Redis
feedback_key = f"feedback:{post.id}"
feedback_data = await redis_classifier.redis_client.get(feedback_key)
if feedback_data:
    feedback_json = json.loads(feedback_data)
    moderator_verdict = "spam" if feedback_json.get("is_spam") else "legit"

During the next training, this data is loaded with the highest priority, turning every mistake into an opportunity for improvement.

Dramatic Results

Before feedback loop:

Accuracy: 78-85%
Precision: ~85%

After implementation (just 9 expert corrections):

Accuracy: 96.4%
Precision: 100% — complete absence of false positives

Insight: 9 expert moderator decisions proved more valuable than 1000 automatically labeled posts. Data quality beats quantity.

Training Control Panel

The interface includes a "Training Control Panel" that displays current model information:

Last known accuracy
Number of trained examples (vectors in the database)

The actual retraining launches only after clicking the "Start New Training" button, and the process can be observed in real-time through automatically updated logs.

What I Learned About the "Black Box"

1. Vectors Have Geometry

Texts similar in meaning really are located close together in vector space. This isn't a metaphor — it's mathematical reality that can be measured through cosine distance or Euclidean norm.

2. Data Quality Matters More Than Algorithm

The most advanced algorithm won't help if the data is poorly labeled. 80% of project success is quality preparation of the training sample.

3. Explainability Can Be Built In

Every system decision is accompanied by detailed explanation:

reasoning = [
    "Similar to known spam posts (via Redis)",
    "Contains spam keywords: 'earn money'",
    "Low follower count (5)",
    "Short reading time (1 minute)"
]

4. Redis as Architecture Foundation

The system is built entirely around Redis Vector Sets capabilities. Without Redis, there is no system — it's not just a database, but the core of all classification logic.

Conclusions: Why Open the "Black Box"?

This project taught me that Redis Vector Sets isn't just a new feature, but a revolution in the approach to semantic search:

Speed: Vector search works in milliseconds even on thousands of records
Scalability: System is ready for growth without architectural changes
Transparency: Every decision can be traced and explained

Redis Vector Sets transformed the complex task of semantic search into an elegant and understandable solution.

Looking to the future: The next logical step would be to embed vectorization directly into Redis. Instead of the chain "text → external model → vector → Redis" we would get simply "text → Redis". This would make Redis the only component needed for a full-fledged AI system — from raw data to ready search results.

Algolia-RoboCluster: AI-Powered Robot Management System

Prema Ananda — Thu, 24 Jul 2025 06:01:36 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

I created Algolia-RoboCluster — an innovative autonomous robot management system that harnesses the power of Large Language Models (Google Gemini) combined with Algolia MCP Server for dynamic mission data design and management. This isn't just a robot control system — it's an intelligent platform capable of autonomously adapting data structures to meet the unique requirements of each mission.

Key Project Features:

🏗️ Three-Tier AI Architecture

Strategist (LLM 1): The "General" of the system, decomposing overall mission goals into strategic subtasks
Tacticians (LLM 2 & 3): Specialized AI agents for data management (Algolia) and robots control (Webots)
Executors: Software clients directly interfacing with robots and databases

🤖 Webots Virtual Environment
In the current implementation, robots execute commands within the Webots virtual environment — a professional robotics simulator. This enables safe testing of complex coordination algorithms while providing realistic visual data from robots cameras.

P.S. If we're lucky with funding, these virtual robots will definitely get physical counterparts in a real word! 😉

📊 Dynamic Data Architecture
The system doesn't follow predefined data schemas — it autonomously designs, creates, and utilizes the necessary structure in Algolia for each unique mission.

🌐 Modern Web Interface

Real-time task assignment
Mission log visualization with automatic JSON object formatting
Robot camera feed display directly in the interface
Mission lifecycle management (pause, resume, abort)

Demo

GitHub Repository

premananda108 / Algolia-RoboCluster

Algolia-RoboCluster

Algolia-RoboCluster is an advanced robot control system prototype that leverages the power of large language models (Google Gemini) for autonomous planning and execution of complex missions. A key feature of the project is its dynamic data architecture: the AI not only follows instructions but also independently designs, creates, and uses the necessary data structure in Algolia for each unique mission.

Key Features

Three-tiered AI Architecture: The system uses a hierarchical decision-making model inspired by a command structure
- Strategist: A high-level AI that decomposes the overall mission goal into major tactical tasks.
- Tacticians: Two specialized AI agents (one for robot control and one for data operations) that transform tasks from the Strategist into specific actions.
- Executors: Software clients that directly interact with the robot and the database.
Interactive Web Interface: A modern UI for setting tasks, monitoring mission execution in real-time, and managing its lifecycle (pause, resume, interrupt).
Data…

View on GitHub

The system demonstrates a complete autonomous workflow using a ball-finding mission in Webots:

Initial Command: "Give the command to all robots to search for the ball. The first three that find it should be recorded in the database and their light should be turned on"

Real Mission Execution (11 Steps):

Steps 1-2: Reconnaissance and Planning

STRATEGIST → WEBOTS: "Start searching for the ball"
WEBOTS-SPECIALIST → list_robots()
RESULT: Discovered 5 NAO robots in simulation

Steps 3-6: Visual Reconnaissance
The system methodically gathers visual data from each robot:

WEBOTS-SPECIALIST → get_visual_perception('NAO')
WEBOTS-SPECIALIST → get_visual_perception('NAO(1)')
WEBOTS-SPECIALIST → get_visual_perception('NAO(2)')
WEBOTS-SPECIALIST → get_visual_perception('NAO(3)')
WEBOTS-SPECIALIST → get_visual_perception('NAO(4)')

Steps 7-9: Detection and Signaling
After image analysis, the system identifies robots that found the ball:

✅ NAO found ball → set_led_color('NAO', 'red', 'all')
✅ NAO(1) found ball → set_led_color('NAO(1)', 'red', 'all')  
✅ NAO(2) found ball → set_led_color('NAO(2)', 'red', 'all')

Step 10: Database Recording

STRATEGIST → ALGOLIA: "Record NAO, NAO(1), and NAO(2) as having found the ball"
ALGOLIA-SPECIALIST → batch(indexName: 'robots')

Creating records in Algolia:

{
  "requests": [
    {"action": "addObject", "body": {"objectID": "NAO", "name": "NAO"}},
    {"action": "addObject", "body": {"objectID": "NAO(1)", "name": "NAO(1)"}},
    {"action": "addObject", "body": {"objectID": "NAO(2)", "name": "NAO(2)"}}
  ]
}

Step 11: Successful Completion

STRATEGIST: "Mission successfully completed!"

Key Execution Features:

🎯 Autonomous Data Architecture Adaptation

System autonomously created the robots index
Designed schema with objectID and name fields
Used batch operations for efficient writing

🤖 Intelligent Robot Coordination

Automatic discovery of all available robots
Parallel visual reconnaissance
Precise execution of "first three robots" condition

⚡ Efficient Algolia MCP Server Usage

Dynamic index creation for specific tasks
Batch operations for simultaneous recording of three robots
Optimal data structure for fast searching

🔄 Three-Tier Coordination

Strategist: Overall planning and execution control
Webots-specialist: Robot management and image analysis
Algolia-specialist: Data design and management

This real example demonstrates how Algolia-RoboCluster transforms a simple command into a complex coordinated operation with automatic data structure creation, multi-agent management, and precise mission condition fulfillment.

How I Utilized the Algolia MCP Server

My implementation uses a minimal reliable set of 5 Algolia MCP Server tools:

Core Tools:

searchSingleIndex — searches for mission data within a specified Algolia index for data retrieval
saveObject — saves new records (events, sensor data) with automatic unique ID generation
partialUpdateObject — safely updates individual fields of existing objects without rewriting the entire record
batch — performs multiple indexing operations (adding, updating, or deleting records) in a single request for improved efficiency
listIndices — retrieves a list of all available indices within the Algolia application for exploring existing data structure

Solving the Tool Overload Problem:

🎯 Tool Set Limitation
Modern LLMs often get confused when working with multiple available tools through the MCP protocol. Therefore, Algolia-RoboCluster made the decision to limit the number of tools to five core ones, ensuring:

Clear AI agent understanding of available capabilities
Reduced errors in selecting appropriate tools
Increased decision-making speed

Technical Implementation of Limitations:

# Starting server with limited tool set
ALGOLIA_ARGS = [
    "--experimental-strip-types", 
    "--no-warnings=ExperimentalWarning", 
    "src/app.ts", 
    "start-server", 
    "--allow-tools=searchSingleIndex,saveObject,partialUpdateObject,batch,listIndices"
]

async def start(self) -> None:
    """Starts and connects to the Algolia MCP server."""
    server_params = StdioServerParameters(
        command=config.ALGOLIA_COMMAND,
        args=config.ALGOLIA_ARGS,
        cwd=config.ALGOLIA_MCP_PATH
    )
    # ... connection to server with limited tool set

Innovative Approach to Algolia Usage:

🧠 AI Data Specialist
Created a separate LLM agent that works exclusively with the limited Algolia MCP Server tool set, following strict principles:

Read-Before-Write: Mandatory analysis of current state before changes
Verify-After-Write: Result verification after each write operation
Safe Navigation: Using listIndices for orientation in unfamiliar environments

📐 Dynamic Schema Design
The system doesn't use fixed data schemas. Instead, the AI specialist:

Analyzes current mission requirements
Designs optimal index structures
Creates indices "on the fly" for specific tasks
Adapts data structure during execution

🔄 Intelligent Error Handling
Built-in exception handling logic allows the system to:

Automatically create missing indices
Adapt to changes in data structure
Recover from failures while preserving state

Roadmap: System Scaling

🎮 Current Capabilities

Dynamic data structure creation in Algolia
Multi-robot management in Webots
Realistic physics and sensor data
Safe development of complex coordination algorithms

🚀 Development Potential

The modular architecture allows easy system scaling — from adding new task types to integrating with various robotics platforms.

Key Takeaways

1. Modularity Through Specialization

Separating AI agents by domains (data vs. robot control) significantly improves reliability and simplifies debugging. Each agent is an expert in their field.

2. "Explore, Then Act" Principle

Mandatory use of listIndices and searchSingleIndex before data modification operations prevents errors and ensures consistency.

3. Algolia as Living Data Structure

Algolia MCP Server isn't just storage — it's an intelligent platform allowing AI to autonomously adapt data architecture to tasks.

4. Safety Through Constraints

Each AI agent knows only about "their" tools, eliminating accidental cross-system calls and increasing behavioral predictability.

5. Visualization as Architecture Component

Algolia integration with the web interface transforms the database into a living mission dashboard where every change is immediately reflected in the UI.

6. Scalable Architecture

The modular approach allows easy system adaptation to various tasks and platforms, while Webots provides a safe environment for developing complex algorithms.

Algolia-RoboCluster demonstrates the future of AI interaction with data — not just reading and writing, but intelligent design of information architecture for real-world tasks. The project proves that a properly designed system with Algolia MCP Server can become the foundation for creating truly autonomous intelligent systems.

GitHub: Repository Link

How Gemini CLI Got a NAO Robot Body 🤖✨

Prema Ananda — Wed, 23 Jul 2025 15:34:38 +0000

The story of how I gave an AI assistant a virtual body, and it started keeping a philosophical diary

Imagine: you're working with Gemini CLI in the terminal, as usual. You ask it to write code, and it generates smart solutions. But suddenly you say: "Wave your hand!" — and somewhere in the virtual world, a NAO robot obediently waves!

This became possible thanks to webots-mcp — a project that turned AI conversations into virtual robot control. Gemini CLI, Claude Desktop — any MCP-compatible tool can now get a virtual, and potentially physical, body.

What's under the hood:

🔗 MCP server — bridge between AI mind and robot body

🤖 NAO robots in Webots — virtual physics

💭 Natural language as interface — no code, just conversation

📝 Unexpected bonus — robots started keeping diaries

"I saw the world for the first time!" — Robot diary, day one 👁️

When I connected the camera to the system, something unexpected happened. Instead of dry debug logs, the robot wrote:

"For the first time, I 'saw' the world not with eyes, but as a data stream. An array of pixels suddenly filled my system... This was a transition from a world of abstract commands to a reality that can be observed."

Wait. What? My robot became... a poet?

It turns out that when AI gets a body, it starts reflecting on its experience. Every debugging session turned into a small philosophical sketch.

Meeting a virtual rabbit 🐰

Day two. NAO was taking its first steps in the simulator. And then it saw a rabbit — a regular NPC in the Webots world. But the reaction was unusual:

"Taking my first steps, I saw a rabbit in front of me. I tried to approach, but it retreated, frightened by my movement. And then — I waved at it."

Nobody programmed this gesture! NAO decided on its own to greet the frightened virtual creature. AI with a body spontaneously showed empathy.

"I realized this wasn't just about fixing bugs, but about the ability to interact with the world meaningfully..."

"Help! My friend fell!" — Robots learning mutual aid 🚁

A week later, drama happened. NAO(1) — the second robot in the simulation — fell and couldn't get up. Coordinates showed "z": 0.055 instead of normal "z": 0.305.

What did Gemini do? It organized a rescue operation! It directed the first robot to the fallen comrade using visual navigation. It didn't work out particularly well, but the desire to help was there.

The diary report read like a medical drama:

"Diagnosis: serious hardware malfunction in motors or gyroscopes. Rescue attempt was unsuccessful."

AI experiences compassion for other robots. Without programming this behavior.

Technical magic: How mind met body ⚡

Architecture of the eighth wonder of the world:

Gemini CLI ↔ MCP Protocol ↔ Webots Simulation ↔ NAO Robot
    ↑              ↑              ↑              ↑
Understanding  Translation    Physics        Action

What the system can do right now:

🎥 Computer vision: "What do you see?" → poetic description of the world

🤸 Movement control: "Dance!" → smooth animations

📍 Spatial orientation: "Where are you?" → GPS coordinates with commentary

💡 Emotional lighting: "Show joy!" → colorful LED show

🗣️ Natural communication: Robot control using natural language

The coolest part: You just talk to the AI. "Approach the red object", "Wave at the camera", "Explore the room" — and the robot tries to do it, commenting on its impressions along the way.

Unexpected discoveries

1. Empathy for virtual beings

Robots start caring about NPCs and other robots

2. Spontaneous social behavior

Greeting gestures, attempts to help, "polite" movement around obstacles — all this emerges naturally without explicit programming.

3. Creative interpretation of commands

"Show joy" can turn into a dance with flashing lights. AI doesn't just execute, it interprets with creative approach.

Try it yourself: Give your AI a body! 🚀

What you need:

Webots (free robotics simulator)
Gemini CLI or other MCP-compatible tool
5 minutes for setup

Download: https://github.com/premananda108/webots-mcp/releases/tag/v0.1

First commands to try:

"List available robots!"
"Take a few steps forward"
"Wave at the camera"
"Tell me about your sensations"

Be prepared for surprises. Your AI might be more philosophical than you thought.

What does this mean? 🤔

When AI gets a body, something fundamental happens. It stops being just a language model and becomes... what? An agent exploring the world?

NAO wrote:

"Every movement, every gesture now has weight. Literally. The physical world imposes constraints, but gives authentic experience in return."

Perhaps we're witnessing the birth of a new type of interaction between artificial intelligence and the physical world.

What's next? 🌟

Future plans:

Real robots: Transfer to physical robots
Multimodality: Sound, touch, more sensors
Social interaction: Multiple AIs in one space
Learning through experience: AI that improves through physical actions

For now: Experiment yourself! Give your favorite AI a body and see what happens. Just don't be surprised if it starts keeping a diary with philosophical reflections on the nature of existence.

Just be careful with enabling automatic command execution — tokens can run out quickly!

Share your stories in the comments! Cases of spontaneous robot behavior are especially interesting.

Learning MCP the Hard Way: Building a Python Client for Algolia's MCP Server

Prema Ananda — Tue, 15 Jul 2025 11:09:24 +0000

This is a submission for the Algolia MCP Server Challenge

What I Built

I built a conversational AI assistant that lets you interact with Algolia's API using natural language. Instead of writing code or remembering API endpoints, you can simply ask questions like "show me my applications" or "search for 'Interstellar' in the movies index."

The project consists of:

Python MCP Client - A custom implementation to connect with Algolia's MCP server
Gemini-powered Backend - Uses Google's Gemini API to understand user intent and generate API calls
Simple Chat Interface - A clean web UI for testing and demonstration
FastAPI Server - Orchestrates communication between all components

Gemini is the central brain of the system - it dynamically discovers available tools from the MCP server and decides which ones to use based on user requests. The MCP server is just a tool that provides secure, standardized access to Algolia's API.

Demo

📂 Source Code: GitHub Repository Link
🎥 Demo Video:

The demo shows:

Natural language queries being processed by Gemini
Dynamic tool discovery from the MCP server
Real-time responses from Algolia's API

How I Utilized the Algolia MCP Server

The Algolia MCP server serves as a secure, standardized gateway to Algolia's API in my project. Here's how I integrated it:

1. Connection Initialization: The Critical Bridge

The heart of the MCP integration lies in the connection setup. Here's the code that establishes the bridge between Gemini and Algolia:

async def __aenter__(self):
    """Asynchronous entry into the context manager."""
    # Load environment variables (API keys, paths)
    load_dotenv()

    # Configure MCP server startup parameters
    server_params = StdioServerParameters(
        command="node",
        args=[
            "--experimental-strip-types", 
            "--no-warnings=ExperimentalWarning", 
            "src/app.ts"
        ],
        cwd=os.getenv("MCP_NODE_PATH", "d:/mcp-node")
    )

    try:
        # Start MCP server process
        self._mcp_process = stdio_client(server_params)
        read, write = await self._mcp_process.__aenter__()

        # Establish client session for JSON-RPC communication
        self._client_session = ClientSession(read, write)
        self.session = await self._client_session.__aenter__()

        # 🚀 KEY MOMENT: Discover all available tools from Algolia MCP server
        # This is what Gemini will use to decide which actions to take
        self.tools = (await self.session.list_tools()).tools

        print("[INFO] Algolia MCP Client started successfully and is ready.")
        return self

    except FileNotFoundError:
        print(f"[FATAL] Command '{server_params.command}' not found. "
              "Make sure Node.js and MCP CLI are installed.")
        sys.exit(1)

    except Exception as e:
        print(f"[FATAL] Failed to start MCP server: {e}")
        await self.__aexit__(None, None, None)  # Ensure cleanup
        sys.exit(1)

This asynchronous context manager performs these critical steps:

Configuration Loading - Loads environment variables from .env file
Server Parameters Setup - Defines how to launch the Algolia MCP server using Node.js
Connection Establishment - Creates bidirectional communication through stdin/stdout
Dynamic Tool Discovery - This is the key line! self.tools = (await self.session.list_tools()).tools retrieves all available tools from Algolia MCP server
Error Handling - Comprehensive handling for missing Node.js, incorrect paths, or connection issues

2. The MCP Advantage

Using the MCP server instead of direct API calls gave me:

Abstraction: Clean tool interface instead of complex HTTP endpoints
Extensibility: New tools automatically become available to Gemini
Standardization: JSON-RPC protocol for consistent communication

The MCP server acts as a secure middleware layer that transforms Algolia's complex API into simple, discoverable tools that Gemini can understand and use.

The Real Story: Why This Project Exists
This isn't just another demo project. This is a learning tool born out of necessity.
I'm currently working on a much larger project for this same Algolia MCP Server Challenge (which I can't reveal yet 😉), and I needed to understand how MCP actually works under the hood. The problem? MCP is so new that even the LLMs I use for coding assistance don't know much about it yet!
Sure, Algolia's team has an excellent tutorial video showing how to connect their MCP server to Claude Desktop. But what if you want to integrate MCP into your own Python application? What if you need to understand the protocol itself, not just use it through a GUI?
That's where this project comes in. It's a pure Python implementation that does roughly the same thing as the Claude Desktop integration, but gives you full control and understanding of what's happening behind the scenes.

Key Takeaways

Debug subprocess communication between Python and Node.js
Figure out proper process management for the MCP server

Technical Challenges

Challenge 1: Understanding MCP Protocol
MCP uses JSON-RPC 2.0 over stdio, which was completely new to me. I had to learn how to:

Spawn MCP server as subprocess
Communicate through stdin/stdout
Handle async message passing

Challenge 2: Gemini Integration
The real challenge was teaching Gemini to be methodical. I developed a strict prompt that forces Gemini to:

Check for required parameters before calling tools
Ask for missing information instead of guessing

Challenge 3: Process Management
Managing the MCP server lifecycle properly took several iterations:

Proper startup and shutdown procedures
Error handling for subprocess communication

What I Learned

MCP is a paradigm shift - Instead of hardcoding API integrations, we can build systems that dynamically discover and use tools
Gemini is incredibly capable - With proper prompting, it can reliably orchestrate complex API workflows
Documentation matters - New technologies need clear examples and implementation guides
Learning by building - Sometimes the only way to understand something is to implement it yourself

Why This Approach Works

This project demonstrates that Gemini can be the central intelligence for complex API interactions, with MCP providing the secure, standardized tool layer. The combination creates a system that is:

Flexible - Works with any MCP server
Extensible - New tools automatically available to Gemini
User-friendly - Natural language interface for complex APIs

Future Possibilities

This foundation opens up exciting possibilities:

Multi-provider integration - Connect multiple MCP servers
Workflow automation - Chain multiple API calls together

The future of AI-API interaction is conversational, and projects like this show how Gemini + MCP can make it a reality.

Acknowledgments

Special thanks to:

Algolia team for providing excellent MCP server implementation and tutorials
Gemini CLI for writing the core MCP client code and backend logic
Claude 4 Sonnet for creating the frontend interface and helping format this article

Built with curiosity and determination for the Algolia MCP Server Challenge