DEV Community: Aditya

I Built a Multi-Agent AI Debate Arena Inside Notion Using MCP — Meet The Council

Aditya — Sun, 15 Mar 2026 11:06:24 +0000

This is a submission for the Notion MCP Challenge

What I Built

Engineering teams constantly face difficult technical decisions.

PostgreSQL or MongoDB?

Microservices or monolith?

Offline-first mobile app or web-first architecture?

Usually the process looks like this:

Engineers research the problem
Everyone has different opinions
A decision gets made
The reasoning disappears forever

Six months later someone asks:

"Why did we make this decision?"

And nobody remembers.

I wanted to fix that permanently.

So I built The Council — a multi-agent AI debate system that runs directly inside Notion.

Instead of a single AI giving generic advice, four specialized AI agents debate a technical question from completely different perspectives.

Each agent:

• Reads the current Notion page

• Generates an argument

• Counters other agents

• Writes its reasoning back to Notion

After several rounds of debate, an Arbiter AI evaluates the arguments and produces the final decision.

Everything gets documented:

every argument
every counter-argument
the final verdict
action items

Technical decisions become permanent institutional knowledge.

Meet The Council

Each AI agent represents a different engineering priority.

⚔️ SENTINEL — Security & Risk

Focuses on vulnerabilities, worst-case scenarios, and system failures.

⚡ MERCURY — Performance & Speed

Analyzes latency, throughput, and developer velocity.

💰 MIDAS — Cost & Business Value

Translates engineering decisions into ROI and operational cost.

🌍 ATLAS — Scale & Architecture

Focuses on long-term scalability and technical debt.

Instead of balancing perspectives, each agent defends its viewpoint strongly.

That tension produces realistic engineering debates.

A Real Debate Example

I asked The Council:

Should we build an offline-first mobile app?

Round 1 — Opening Arguments

Each agent writes its argument directly to the Notion page.

SENTINEL

Offline-first apps store sensitive data locally.

A compromised device could expose user data instantly.

MERCURY

Our web application deploys in seconds and serves requests with low latency.

Mobile build pipelines slow development speed dramatically.

MIDAS

Offline-first development costs significantly more than web-first architecture.

ATLAS

Offline synchronization introduces complexity that becomes dangerous at scale.

Round 2 — Counter Arguments

Agents read the Notion page through MCP and challenge each other's claims.

Security challenges performance.

Cost challenges scale assumptions.

Performance challenges cost projections.

The debate evolves dynamically.

The Verdict

After two rounds, the Arbiter evaluates every argument and produces the final decision.


DECISION:
Build a web-first architecture with PWA offline support.

REASONING:
This approach maintains centralized security controls,
preserves fast development velocity, minimizes cost,
and avoids large-scale synchronization complexity.

The system automatically generates action items:

Implement Service Workers
Add IndexedDB caching
Build unified CI/CD pipeline
Audit client-side storage security
Design scalable backend APIs

Everything is written directly into the Notion page.

What Happens When AI Cannot Decide?

Some engineering problems don't have a clear answer.

Instead of pretending certainty, The Council can declare a deadlock.

The Notion page shows:


⚖️ THE COUNCIL IS DEADLOCKED

Cast your deciding vote:

⚔️ SENTINEL — prioritize security
⚡ MERCURY — prioritize speed
💰 MIDAS — prioritize cost
🌍 ATLAS — prioritize scale

The engineer reads the debate and votes using the Vote property in Notion.

This creates a human-in-the-loop decision system.

AI prepares the analysis.

Humans make the final call when needed.

Video Demo

This demo shows the full workflow:

1️⃣ Create a Notion page

2️⃣ Set Status = pending

3️⃣ The Council begins debating

4️⃣ Agents write arguments live

5️⃣ The Arbiter publishes a final decision

Show us the code

GitHub repository:

TheCoderAdi / the-council

The Council — Multi-Agent AI Debate Arena (Notion MCP)

A Multi-Agent debate system that runs inside Notion using the Model Context Protocol (MCP) Four agents with distinct personas debate a technical question on a Notion page; an arbiter then writes a final decision, reasoning, and action items back to the page. Everything is done via MCP tools—no direct REST calls to Notion.

Quick summary

Input: a Notion database page with the Question title and Status: pending.
Process: watcher detects pending pages → opens MCP connection → runs 3 rounds (based on your choice) of parallel agent debates → arbiter writes decision.
Output: Notion page updated with debate callouts, Decision rich text, Status set to completed

Agents: ⚔️ SENTINEL (security), ⚡ MERCURY (performance), 💰 MIDAS (cost), 🌍 ATLAS (scale).

What you'll find in this repo

api/ — Express server and SSE endpoints for streaming debates to the dashboard.
src/core/mcpClient.js —…

View on GitHub

Run locally:

git clone https://github.com/TheCoderAdi/the-council
cd the-council
npm install
cp .env.example .env
npm run dev

Example .env configuration:

NOTION_API_KEY=secret_xxx
NOTION_DATABASE_ID=xxx

GEMINI_API_KEY=xxx
GROQ_API_KEY=xxx

LLM_MAX_CONCURRENCY=2
LLM_MIN_DELAY_MS=150

How I Used Notion MCP

This project is built entirely around Notion MCP (Model Context Protocol).

Traditional integrations use the Notion REST API, where external code pushes data into Notion.

MCP changes the model completely.

With MCP, AI agents can use Notion as native workspace tools.

Agents can:

• read page content
• write blocks
• update properties
• query databases

Example MCP usage:

const context = await mcp.callTool(
  "API-get-block-children",
  { block_id: pageId }
);

Writing an argument block:

await mcp.callTool("API-patch-block-children", {
  block_id: pageId,
  children: [
    {
      type: "callout",
      callout: {
        rich_text: [{ text: { content: response } }],
        icon: { emoji: "⚔️" }
      }
    }
  ]
});

The agents operate inside the Notion workspace just like human collaborators.

Architecture

Notion Database
        │
        ▼
Notion Watcher
(detects pending debates)
        │
        ▼
Council Orchestrator
        │
        ├── SENTINEL
        ├── MERCURY
        ├── MIDAS
        └── ATLAS
        │
        ▼
Arbiter
        │
        ▼
Decision written to Notion

A real-time dashboard streams debate progress using Server-Sent Events.

Technical Stack

Layer	Technology
MCP Server	@notionhq/notion-mcp-server
MCP SDK	@modelcontextprotocol/sdk
Primary LLM	Gemini 2.0 Flash
Fallback LLM	Groq
Backend	Node.js + Express
Streaming	Server-Sent Events
Frontend	Vanilla JavaScript

Why This Matters

Most technical decisions disappear into Slack threads and meetings.

The Council turns engineering debates into structured, searchable knowledge.

Future engineers can see exactly:

• what arguments were made
• which tradeoffs were considered
• why the final decision was chosen

Instead of repeating the same debate every year, teams build decision history.

Try It

Drop a technical question in the comments.

I'll run it through The Council and share the full debate output.

Built for the Notion MCP Challenge

🚀 Stop Typing Long Terminal Commands. Use Aliases Instead

Aditya — Mon, 02 Mar 2026 07:09:33 +0000

As developers, we optimize APIs, databases, and smart contracts.

But we rarely optimize our own workflow.

I realized I was typing the same commands every single day:

npm run dev
git add .
git commit -m "message"
git push
docker compose up --build
npx hardhat test
forge build

It seems small.

But friction compounds.

So I reduced it.

🧠 What Are Shell Aliases?

Aliases are shortcuts you define in your shell (bash or zsh) that map short commands to longer ones.

Instead of typing:

npm run dev

You type:

nd

Same result. Less friction.

🛠 Step 1: Open Your Shell Config

If you’re using:

Zsh (Mac / Linux default nowadays)

nano ~/.zshrc

Bash

nano ~/.bashrc

✍ Step 2: Add Aliases

Here are some practical ones for Full-Stack + Web3 developers:

# 📦 NPM
alias nd="npm run dev"
alias nb="npm run build"
alias ni="npm install"

# 🌿 Git
alias gs="git status"
alias ga="git add ."
alias gc="git commit -m"
alias gp="git push"
alias gpl="git pull"
alias gcb="git checkout -b"
alias gl="git log --oneline"

# 🐳 Docker
alias dcu="docker compose up"
alias dcub="docker compose up --build"
alias dcd="docker compose down"
alias dps="docker ps"

# 🔐 Hardhat
alias hhc="npx hardhat compile"
alias hht="npx hardhat test"
alias hhn="npx hardhat node"

# ⚒ Forge
alias fb="forge build"
alias ft="forge test"

Save the file.

Then reload:

source ~/.zshrc

(Or source ~/.bashrc)

Done.

🔥 Real Before vs After

Before

git add .
git commit -m "fix: JWT verification bug"
git push

After

ga
gc "fix: JWT verification bug"
gp

Before

docker compose up --build

After

dcub

Before

git checkout -b feature/jwt-auth

After

gcb feature/jwt-auth

⚡ Level 2: Combine Commands

You can even chain commands:

alias gacp="git add . && git commit -m"

Now:

gacp "feat: add middleware"
gp

One step closer to flow state.

🎯 Why This Matters

This isn’t about saving 3 seconds.

It’s about reducing cognitive load.

When friction decreases:

You stay in flow longer
You ship faster
You feel less drained

Most developers try to optimize performance.

Few optimize themselves.

🧩 Bonus: Modern Git Alternative

Instead of:

git checkout -b feature/auth

You can use:

git switch -c feature/auth

And alias it:

alias gsw="git switch -c"

💭 Final Thought

Productivity isn’t about working more hours.

It’s about removing unnecessary resistance from your system.

If you’re a developer:

What’s one shortcut you can’t live without?

🏏 CrickSquad — The App That Replaced 50 WhatsApp Messages for My Cricket Group

Aditya — Sun, 01 Mar 2026 17:42:36 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

I'm part of a weekend cricket group of 25 people. Every Sunday at 7 AM, we play cricket at a local turf ground. It's been going on for 3 years now — rain or shine.

But here's the thing nobody talks about: organizing a casual cricket match is harder than playing it.

Every single week, the same chaos unfolds:

🔴 WhatsApp Hell

"Who's coming this Sunday?"
50+ messages later... still no clear count.

🔴 Team Selection Drama

"Last time teams were unfair!"
"Why am I always bowling first?"
Every. Single. Week.

🔴 Money Collection Nightmare

"Bro, you haven't paid for the last 3 matches"
"I paid! Check the chat"
scrolls through 500 messages

🔴 No Memory of Performance

"How many runs did I score last month?"
Nobody knows. No records. No stats.

🔴 Zero Recognition

Score 50 runs on Sunday. By Monday, nobody remembers.
Attendance drops because people feel "it doesn't matter."

I know millions of weekend sports groups around the world face the same problems. So this weekend, I decided to fix it.

What I Built

🏏 CrickSquad — Less WhatsApp. More Cricket.

An all-in-one web app for weekend cricket groups that handles everything from RSVP to AI-powered match reports.

One app to replace 50 WhatsApp messages every weekend.

Core Features:

🎯 One-Tap RSVP
No more "who's coming?" chaos. Open the app, tap Yes/No/Maybe. Done. Everyone sees the count in real-time with a countdown to the deadline.

⚖️ Smart Team Balancer
Every player has skill ratings (batting, bowling, fielding). The algorithm creates the most balanced 2 teams possible. No more "unfair teams" complaints. Ever.

🤖 AI-Powered Features (Gemini)
This is where it gets fun:

AI Team Analysis — Gemini explains why the team split is balanced
AI Match Reports — Commentary-style match summaries after every game
AI Player Insights — "You're the Virat Kohli of your group!" with actual improvement tips
AI POTM Suggestions — Top 3 Player of Match candidates with reasoning
Smart Reminders — Personalized nudge messages for pending RSVPs
Season Analytics — Trends, fun facts, predictions

💰 Expense Splitter
Set ground cost → auto-split among players → track who paid → send reminders. Running balances across multiple matches so you always know who owes what.

📊 Scorecards & Leaderboards
Enter batting/bowling stats after each match. Auto-calculated averages, strike rates, economy rates. Season leaderboards with medals 🥇🥈🥉

🎲 Digital Toss
Animated coin flip. No more "my coin, my call" disputes.

📢 Polls & Announcements
"Should we play Saturday instead?" — Quick polls with deadlines. Important announcements that don't get buried in chat.

📸 Match Gallery
Upload and share photos from every match. Organized per game day.

🏟️ Venue Management
Save venues with address, Google Maps link, facilities, pricing. One-tap directions.

🔥 Mail System
When admin creates poll, announcement, pay notifications, new match alert.

Demo

🔗 Github Code: https://github.com/TheCoderAdi/cricksquad

Screenshots:

Project Haul

Excalidraw Whiteboard

Excalidraw is a virtual collaborative whiteboard tool that lets you easily sketch diagrams that have a hand-drawn feel to them.

excalidraw.com

Landing Page

Dashboard — Upcoming Match + RSVP

Team Balancer — AI-Powered Fair Teams

Leaderboard — Season Stats

AI Match Report

Expense Tracker

Scorecard

Profile + AI Player Insights

Venue Page

Match Gallery

Key Algorithms

Team Balancer Algorithm:

const balanceTeams = (players) => {
  // Sort by overall rating (descending)
  const sorted = [...players].sort((a, b) => b.overallRating - a.overallRating);

  let teamA = [], teamB = [];
  let ratingA = 0, ratingB = 0;

  // Greedy assignment: add to weaker team
  for (const player of sorted) {
    if (ratingA <= ratingB) {
      teamA.push(player);
      ratingA += player.overallRating;
    } else {
      teamB.push(player);
      ratingB += player.overallRating;
    }
  }

  // Role balancing pass (ensure bowlers are distributed)
  // ... swap players to balance roles without hurting ratings

  return { teamA, teamB };
};

Skill Rating System:

// Weighted by player role
const weights = {
  batsman:    { batting: 0.5, bowling: 0.2, fielding: 0.3 },
  bowler:     { batting: 0.2, bowling: 0.5, fielding: 0.3 },
  allrounder: { batting: 0.35, bowling: 0.35, fielding: 0.3 },
  keeper:     { batting: 0.4, bowling: 0.1, fielding: 0.5 }
};

overallRating = batting * w.batting + bowling * w.bowling + fielding * w.fielding;

Gemini AI Integration:

const { GoogleGenerativeAI } = require('@google/generative-ai');
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);

const generateMatchSummary = async (matchData) => {
  const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' });
  const prompt = `You are a cricket commentator. Write a fun match report...`;
  const result = await model.generateContent(prompt);
  return result.response.text();
};

How I Built It

Tech Stack

Layer	Technology	Why
Frontend	React + Vite	Fast dev experience, instant HMR
Styling	Tailwind CSS	Rapid UI development
State	Zustand	Lightweight, no boilerplate
Data Fetching	React Query + Axios	Caching, loading states
Animations	Framer Motion	Smooth page transitions
Backend	Node.js + Express	Fast REST API development
Database	MongoDB + Mongoose	Flexible schema for cricket data
AI	Google Gemini	Fast, accurate, free tier
Image Storage	Cloudinary	Auto-compression, CDN delivery
Auth	JWT + bcrypt	Secure, stateless authentication

Architecture

React → Axios → Express API → MongoDB Atlas
                                    ↓
                              Gemini AI API
                              Cloudinary CDN

Development Timeline

When	What	Hours
Friday Evening	Project setup, DB models, Express config	3h
Saturday Morning	Auth, Groups, Matches, RSVP APIs	5h
Saturday Afternoon	Teams, Expenses, Scorecard, Leaderboard APIs	5h
Saturday Evening	Frontend: Auth, Dashboard, RSVP pages	4h
Sunday Morning	Frontend: Teams, Expenses, Scorecard, Leaderboard	5h
Sunday Afternoon	Gemini AI integration, Polls, Gallery	5h
Sunday Evening	Polish & write this post	3h
Total		~30h

Challenges & Learnings

1. Team Balancing is NP-hard 😅
Turns out, perfectly splitting teams is a partition problem. The greedy algorithm works surprisingly well for groups under 30. Adding a role-balancing second pass made it even better.

2. Gemini AI JSON Responses
Getting Gemini to consistently return valid JSON was tricky. I added replace(/`json\n?/g, '') cleanup and wrapped everything in try-catch with user-friendly fallbacks.

3. Real-Time Feel Without WebSockets
Instead of adding Socket.io complexity, I used React Query's refetchInterval for the RSVP page. Feels real-time, fraction of the complexity.

4. Mobile-First is Non-Negotiable
Cricket groups use WhatsApp on phones. If this app isn't phone-friendly, nobody will use it. Every component was designed thumb-first.

What's Next

If the cricket group likes it (they will 😎), here's what I'd add next:

📱 React Native mobile app with push notifications
💬 WhatsApp API integration for automated reminders
🏏 Ball-by-ball live scoring
📊 Season playoffs & tournament mode
🎥 AI-generated highlight reels from uploaded videos
💳 UPI payment integration (India-specific)

The Real Test

I shared this with my cricket group yesterday. Within 10 minutes:

22 out of 25 members had joined
18 RSVPs for this Sunday
Zero WhatsApp messages about "who's coming?"

That's the real demo. 🏏

Built with ❤️ and way too much coffee during the DEV Weekend Challenge.

If you play weekend cricket (or any weekend sport), drop a comment — I'd love to hear about the chaos in YOUR group! 😄

Holistic Webdev: Office Space

Aditya — Sat, 26 Jul 2025 16:52:40 +0000

🌐 This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

🛠️ What I Built

OrbitSpace is a futuristic, glassmorphism-inspired intranet homepage designed to bring elegance, clarity, and functionality to digital office environments.

I envisioned a modern digital workspace that merges essential internal tools with an aesthetic that inspires creativity. The layout includes:

✨ Hero section with office branding
🚀 Quick links for essential tools
👥 Team spotlight to highlight members
📅 Upcoming events area
📊 Metrics dashboard
📚 Knowledge base
🧭 Navigation bar with smooth UX

The UI uses glassmorphism layered with TailwindCSS and ShadCN UI components for responsiveness, theme consistency, and accessibility. Every card is softly frosted with transparency, letting the gradient background shine through.

🎥 Demo

🔗 Live URL: Preview
📁 Source Code: GitHub Repo

🛣️ Journey

I started this project with the idea of redefining how office intranets feel — moving away from outdated, cluttered dashboards into something that feels alive, light, and forward-thinking.

Some things I'm proud of:

Using glassmorphism with care to avoid readability issues
Seamless integration of ShadCN components with Tailwind
A fully modular component structure (HeroSection, Navigation, TeamSpotlight, etc.)
Layout that adapts beautifully to different screen sizes
Subtle hover interactions and gradients that enhance UX

Throughout this build, I focused on component reusability and aesthetic balance, ensuring each section contributes to a cohesive whole.

👤 Author

Made by @aditya_007
Available for collaborations and open-source opportunities 🚀

📝 License

MIT License — free to use with credit.

Office Desk - CSS Art Edition

Aditya — Sun, 20 Jul 2025 07:47:10 +0000

🎨 CSS Art: "Hacker's Haven" — Office Culture Redefined

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, CSS Art: Office Culture.

🧠 Inspiration

When you think of a modern digital workspace, what's more iconic than a dual-monitor setup, a mechanical keyboard, and a cozy desk filled with gadgets? For this CSS art challenge, I wanted to create a "Hacker-style home office" scene — a space that feels alive with glowing monitors, RGB keys, and small but intentional details like a water bottle, headphones, mouse, and pyramid-shaped wall art.

This is a tribute to those of us who spend countless hours building, coding, designing, and dreaming — in our own digital caves.

🚀 Demo

Here's the final output of my CSS office setup:

👉 Live Demo: https://thecoderadi.github.io/Hacker-s-Haven/
👉 Code: https://github.com/TheCoderAdi/Hacker-s-Haven

🔨 Journey

The scene was built using only HTML and CSS — no external images or JavaScript. Here’s a breakdown of the process:

Perspective & 3D Feel: I used transform, perspective, and rotateX/Y to give depth to the desk and devices.
Monitor Effects: Each monitor has a unique content block — one with glowing terminal-style text, and another with animated green bars.
Glassmorphism: The container div uses backdrop blur and soft borders to simulate a futuristic glass wall.
Accessories: Everything from the bottle to the headphones was hand-crafted using only CSS box-model elements and a lot of tweaking.
Keyboard Glow: A custom RGB-like animation simulates key lighting, giving it a cyberpunk vibe.
Robot Wall Art: A minimalist robot drawing mounted on the wall just for fun (and to add personality)!

I learned a ton about layering, keyframe animations, and perspective transforms — and just how expressive pure CSS can be.

💡 What’s Next

I’d love to:

Add a toggle for day/night mode
Animate the terminal text typing line-by-line
Make the scene partially interactive with small JS additions after the challenge ends

👥 Credits

This was a solo submission.
If you found this fun or inspiring, feel free to fork it or remix it for your own virtual office!

🏷 License

MIT License — feel free to use or adapt with attribution.

Thanks to DEV and Axero for this amazing challenge! 🙌
Let’s continue making the web more expressive and fun — one div at a time!

🚀 Startup Scout Agent: Find the Hottest New Startups with One AI Prompt | Runner H Challenge

Aditya — Sat, 28 Jun 2025 09:19:09 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

👋 Meet Startup Scout Agent — your weekly AI researcher that finds new startups, fills your spreadsheet, and sends it to your inbox. Built entirely with one prompt, using Runner H.

What I Built

I built Startup Scout Agent, an autonomous AI agent powered by Runner H that scans the web for newly launched startups every week and sends a neatly formatted report to my inbox.

It’s designed for:

Investors who want early access to rising startups
Job seekers exploring new, fast-growing companies
Startup community builders curating newsletters and communities

This project completely automates what normally takes hours of research — all with a single Runner H prompt.

Demo

📽️ Watch the full demo here:

🖼️ Screenshots:

✅ Sample Google Sheet: “Weekly Startup Radar”

✅ Confirmation Email

How I Used Runner H

I used Runner H’s autonomous agent system with this one prompt:

Every Sunday evening, find 10–15 recently launched startups in AI, HealthTech, or FinTech from sites like TechCrunch, Crunchbase, Product Hunt, or LinkedIn.

For each startup, extract the following:
- Startup name
- Description (what they do)
- Industry or category
- Funding stage (e.g., seed, Series A)
- Location
- Founders' names
- Public founder email (if available)

Add this data to a Google Sheet titled “Weekly Startup Radar”.

Once the sheet is updated, email it to me at [your-email@example.com] with the subject: “Your Weekly Startup Report is Ready 🚀”.

Repeat this task automatically every Sunday at 6:00 PM IST.

I also connected:

Google Sheets (to store the data)
Gmail (to send me the weekly email)

This prompt runs autonomously every Sunday, so I wake up to a fresh, curated startup list in my inbox.

Use Case & Impact

🔍 Real-world use cases:

VC analysts tracking fresh startups in specific sectors
Newsletter writers curating early-stage startup coverage
Job seekers or students exploring fast-moving companies
Accelerators and incubators scouting leads

⏱️ Impact:

Saves 4–5 hours/week of manual research
No scraping, no APIs, no code — just prompt + Runner H
Runs 100% hands-free

Social Love ❤️

✨ Shared on Twitter: View Tweet

Let me know what you think — and feel free to fork the prompt for your own industry! Thanks to @hcompany_ai and @thepracticaldev for making this challenge happen!

🚀 Building an AI-Powered Backend with Node.js + Groq for IdeaLens

Aditya — Sat, 12 Apr 2025 04:10:33 +0000

Welcome! 👋
In this tutorial, we’ll build a modular, production-ready Node.js backend for IdeaLens — an AI assistant that helps creators brainstorm, summarize, caption, and ideate content. We’ll also integrate Groq to access blazing-fast LLMs like LLaMA 3.

📦 Prerequisites

Make sure you have the following:

Node.js (v16+)
npm or yarn
MongoDB Atlas or local
A Groq API Key
REST client (Postman, Thunder Client, etc.)

📁 Folder Structure

backend/
├── controllers/
│   └── summary.controller.js
├── routes/
│   └── summary.route.js
├── utils/
│   └── groqClient.js  <-- ✨ Groq integration
├── app.js
├── server.js
└── .env

📦 Install Dependencies

npm install express cors cookie-parser dotenv mongoose axios

We’ll use axios to call the Groq API.

🧠 Integrating Groq: Ultra-fast Open-Source LLMs

Create utils/groqClient.js:

const axios = require("axios");

const GROQ_API_KEY = process.env.GROQ_API_KEY;

const groq = axios.create({
  baseURL: "https://api.groq.com/openai/v1/chat/completions",
  headers: {
    "Authorization": `Bearer ${GROQ_API_KEY}`,
    "Content-Type": "application/json"
  }
});

async function chatWithGroq(messages, model = "llama-3.3-70b-versatile") {
  try {
    const response = await groq.post("/chat/completions", {
      model,
      messages,
      temperature: 0.7
    });

    return response.data.choices[0].message.content;
  } catch (err) {
    console.error("Groq Error:", err.response?.data || err.message);
    throw new Error("Groq API failed");
  }
}

module.exports = { chatWithGroq };

You can now easily switch between llama-3.3-70b-versatileor others.

🔁 Using Groq in a Controller

In controllers/summary.controller.js:

const { chatWithGroq } = require("../utils/groqClient");

const generateSummary = async (req, res) => {
  const { idea } = req.body;

  const messages = [
    {
      role: "system",
      content: "You're a creative assistant helping generate content ideas."
    },
    {
      role: "user",
      content: `Summarize the following content idea: "${idea}". Include mood, genre, platform suggestions, hooks, and short video direction.`
    }
  ];

  try {
    const aiResponse = await chatWithGroq(messages);
    res.json({ summary: aiResponse });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
};

module.exports = { generateSummary };

📌 Example Route: `/api/summary`

In routes/summary.route.js:

const express = require("express");
const router = express.Router();
const { generateSummary } = require("../controllers/summary.controller");

router.post("/", generateSummary);

module.exports = router;

🔐 Environment Variables

In .env:

PORT=5000
CLIENT_URL=http://localhost:3000
MONGO_URI=your_mongo_url
GROQ_API_KEY=your_groq_api_key

🛠️ Bootstrapping the App

In app.js:

const express = require("express");
const cors = require("cors");
const cookieParser = require("cookie-parser");
const summaryRoutes = require("./routes/summary.route");

const app = express();

app.use(cors({ origin: process.env.CLIENT_URL, credentials: true }));
app.use(express.json());
app.use(cookieParser());

app.use("/api/summary", summaryRoutes);

app.get("/", (req, res) => {
  res.send("IdeaLens backend is up 🚀");
});

module.exports = app;

In server.js:

const app = require("./app");
const mongoose = require("mongoose");
require("dotenv").config();

const PORT = process.env.PORT || 5000;

mongoose.connect(process.env.MONGO_URI)
  .then(() => {
    app.listen(PORT, () =>
      console.log(`Server running at http://localhost:${PORT}`)
    );
  })
  .catch((err) => console.error("MongoDB connection failed", err));

📌 Route Overview

Endpoint	Method	Description
`/api/summary`	POST	Generate structured summary with Groq
`/api/analyze`	POST	Content analysis
`/api/captions`	POST	Generate captions + hashtags
`/api/songs`	POST	Suggest music tracks
`/api/chat`	POST	General AI chat
`/api/refine`	POST	Refine based on user feedback
`/api/upload-media`	POST	Upload audio/video for analysis
`/api/auth`	POST	Auth with JWT & cookies

All powered by modular routes and AI controller functions.

🎯 Done! Your Groq-Powered Node.js Backend🚀

You’ve now got a fully working Express backend with Groq integrated — giving you high-performance LLM workflows for idea summarization, creative chatting, and content generation in your IdeaLens platform.

Discord Image Generation Bot with Daytona

Aditya — Sat, 28 Dec 2024 07:31:30 +0000

This project demonstrates how to build a Discord bot that generates images from text prompts using the Prodia API, while utilizing Daytona for an optimized and scalable development environment. With Daytona's devcontainers, the bot ensures a standardized, fast, and efficient setup process.

🚀 Getting Started
✨ Features
💬 How to Use
📜 License
📚 Learn More

🚀 Getting Started

1. Install Daytona

First, make sure you have Daytona installed. You can follow the installation guide from the Daytona documentation.
Start the server

   daytona serve;

2. Clone the Repository

Clone this repository to your local machine:

   git clone https://github.com/TheCoderAdi/discord-bot.git
   cd discord-bot

3. Create a Daytona Workspace

Create a development workspace using Daytona:

   daytona create https://github.com/TheCoderAdi/discord-bot

4. Install Dependencies

Once you have set up your workspace, ensure all dependencies are installed by running:

   pip install -r requirements.txt

5. Configure the Bot

Create a .env file in the root directory of the project and add your Discord bot token and Prodia API key as follows:

   DISCORD_TOKEN=your_discord_bot_token
   PRODIA_API_KEY=your_prodia_api_key

6. Run the Bot

After configuring the bot, you can start it by running:

   python bot.py

This will start the bot, which will listen to messages on your Discord server and respond with generated images based on text prompts.

✨ Features

Integration with Daytona:

Daytona ensures a consistent, reproducible development environment with devcontainers for easy setup and scaling.
Modular Python Bot Framework:

The bot is designed to be modular and extendable. You can easily add new features or commands.
Discord API Integration:

Uses the Discord API to handle real-time message interaction in the server.
Image Generation with Prodia API:

Generates images based on text prompts, utilizing the Prodia API to create AI-driven images.

💬 How to Use

Once the bot is up and running, you can interact with it directly in any Discord channel where the bot is present.

1. Text Prompt Command

To generate an image, use the command !generate followed by the text prompt. For example:

   !generate A sunset over a mountain range

The bot will process your request and return the generated image. The output will be displayed in the channel like so:

Output Image:

The bot will send back the image in the Discord channel once the image generation is completed.

📜 License

This repository is licensed under the MIT License. See the LICENSE file for more details.

📚 Learn More

For more information on Daytona, visit the official Daytona documentation.
For more on Discord bot development, check out the Discord.py documentation.