DEV Community: Avradeep Nayak

🌿 Herbal Remedy Advisor – Grandma's Wisdom Meets LLMs

Avradeep Nayak — Sat, 21 Jun 2025 07:37:48 +0000

“Because your grandma’s tea deserves LLM-level respect.”

A few weeks ago, while sipping ginger tea during a coding session (thanks, Grandma!), a curious thought struck me:
What if ancient herbal remedies could be queried like ChatGPT?
What if we could combine AI, semantic search, and knowledge graphs to revive traditional wisdom in a modern, developer-friendly way?

That's how Herbal Remedy Advisor was born. 💡

🔮 Meet the App
Herbal Remedy Advisor is an AI-powered herbal medicine search engine. It's like if ChatGPT trained with your grandma and also learned SQL.

It lets you:

🧠 Ask questions like “what helps with a sore throat?” and get meaningful, filtered results.

🌿 Browse a full knowledge base of natural remedies with safety and usage info.

➕ Add your own remedies—because healing wisdom shouldn’t retire.

🤖 Chat with a helpful agent powered by Gemini and Ollama, trained on herbal context.

⚡ Enjoy fast semantic queries with vector-powered SQL magic via MindsDB.

🧠 Under the Hood
I didn’t want to just throw another Flask app into the wild. I wanted this to be smooth, fast, and hackable.

Stack Highlights:
Layer What I Used
LLM Agent gemini-2.0-flash
Embeddings deepseek-r1:1.5b via Ollama
AI Database MindsDB + native Knowledge Base
Backend Flask + Jinja2
UI Bootstrap 5 (quick and clean)
Dev Tooling uv (because pip deserves better)

💻 Dev Magic – Fast Setup
I wanted the setup to be beginner-friendly but still "cool dev-approved".

bash
Copy
Edit

clone the repo

git clone https://github.com/Zedoman/Herbal.git
cd Herbal

install with uv

uv venv
uv pip install . # or compile with pyproject.toml

run MindsDB and Ollama locally

docker run -p 47334:47334 mindsdb/mindsdb
ollama run deepseek-r1:1.5b
Then just run the Flask app and boom — you’re in herbal heaven.

🌱 Features I Loved Building
🔍 Semantic Search via SQL — semantic_search('cold remedy', content) — yep, it's a real thing.

🛡️ Safety filters — because not everything natural is safe for everyone.

🤖 Agent mode — ask about pregnancy-safe remedies, and it checks context from the KB.

📦 Auto init — first run sets up everything: knowledge base, LLM engine, sample data.

📸 A Peek into the UI

Responsive cards, clear safety info, and minimal fuss.

🧪 SQL, but Cool
Want to find a remedy that helps with "headache", is marked safe, and feels semantic?

sql
Copy
Edit
SELECT *
FROM herbal_remedy_kb
WHERE semantic_search('headache relief', content)
AND symptom = 'Headache'
AND safety LIKE '%Safe%'
LIMIT 20;
LLM power, SQL-style. 😎

🙏 Shoutouts
MindsDB – ML meets SQL without the drama.

Ollama – Local models that just work.

uv – My new favorite Python package manager.

🚀 What’s Next?
Add user accounts and favorites

More detailed interaction metadata (e.g., drug interactions)

Support for Ayurveda & TCM

Maybe even turn this into a mobile app?

🧝‍♂️ Final Thought
If you're into AI, dev tooling, or you’ve ever been cured by a cup of clove tea—
you’ll enjoy building on this. 🌿

Check it out on GitHub →
🔗 github.com/Zedoman/Herbal

Let me know your thoughts, feature ideas, or which remedy you’d love to see next!

How I Built a GitHub Visualization Tool After 1 Month of Sweat and Broken Code

Avradeep Nayak — Sun, 27 Apr 2025 14:15:55 +0000

The Problem: Lost in the GitHub Jungle

I was trying to contribute to an open-source project—a massive Next.js monorepo with thousands of files. I spent 3 days just trying to figure out:

Where is the main entry point?

Why does this utility file import from 7 different places?

What the hell is this lib/legacy/utils-deprecated/old_v2 folder even for?

I tried:

Eraser.ai → Hit paywall after 3 tries.

VS Code dependency graphs → Useless for large repos.

Manual Mermaid diagrams → Took hours, then the code changed.

I needed a tool that:
✅ Visualized any GitHub repo in one click
✅ Showed file dependencies clearly
✅ Let me export diagrams (PNG, PDF, Mermaid)
✅ Was free & open-source (no paywalls)

So I decided to build it myself.

The 1-Month Struggle: How This Tool Came to Life

Week 1: "This Should Be Easy, Right?" (Spoiler: It Wasn’t)

Step 1: Fetching GitHub Repo Data

First Attempt: Used GitHub’s REST API.

Problem: Rate limits (60 requests/hour).

Solution: Switched to GitHub GraphQL API (more efficient).

Second Attempt: Recursively fetching directories.

Problem: Nested folders made it messy.

Solution: Tree traversal algorithm to map all files.

Step 2: Building the Visualizer

First Idea: Use D3.js for graphs.

Problem: Too complex for my needs.

Final Choice: React Flow (perfect for interactive node-based UI).

Challenge: Making it zoomable, pannable, and responsive.

Solution: Custom viewport controls + auto-layout.

Week 2: "Why Is Everything Breaking?"

Step 3: Dependency Mapping

Goal: Show which files import which.

Problem: Parsing imports from raw code.

Solution: Used regex (for simple cases) + Babel AST parsing (for complex JS/TS).

Step 4: Mermaid Diagram Generation

Dream Feature: One-click Mermaid export.

Struggle: Mermaid syntax is whitespace-sensitive.

Breakthrough: Built a custom converter from React Flow → Mermaid.

Step 5: File Previews & Syntax Highlighting

Problem: Displaying code nicely.

Solution: Used Monaco Editor (same as VS Code).

Week 3: "I Hate PDF Export Now"

Step 6: Exporting Diagrams

PNG Export: Easy with html2canvas.

PDF Export: A nightmare.

Tried jsPDF → Ugly, broken layouts.

Tried Puppeteer → Overkill.

Final Solution: html2canvas + PDF stitching.

Step 7: Performance Optimizations

Problem: Large repos (10k+ files) crashed the browser.

Fix: Virtualized rendering (only load visible nodes).

Week 4: "It’s Alive… Mostly"

Final Touches

Dark/Light Mode → Because devs love options.

File Type Colors → JS = yellow, CSS = blue, etc.

Error Handling → When GitHub API fails, show useful errors.

The Launch

Deployed on Netlify → Instant live demo.

The Final Product: What It Does Now

Repo Visualization
Drag, zoom, pan like Google Maps for code.
Dependency Graph
See what imports what.
Mermaid Export
PDF/PNG Export

For presentations & documentation.

Live: https://sourcecodeatlas.netlify.app/

Lessons Learned (So You Don’t Suffer Like I Did)

Start small → MVP first, polish later.

GraphQL > REST for GitHub API.

React Flow is amazing for node-based UIs.

PDF export will always suck—accept it.

From Zero to AI-Powered Job Assistant: How I Built JobQuest AI in 48 Hours with Autogen and Selenium

Avradeep Nayak — Mon, 07 Apr 2025 07:13:41 +0000

Just two days ago, terms like "Autogen" and "headless browser automation" were foreign concepts to me. Today, I'm proud to share JobQuest AI - an intelligent job-hunting assistant that completely transforms how professionals search for opportunities. Here's my journey from complete beginner to functional AI product.

The Inspiration: Frustration Leads to Innovation
As someone who recently went through the exhausting job search process, I experienced firsthand how inefficient traditional methods are:

Endlessly scrolling through job boards

Manually tailoring each application

Guessing at salary expectations

Preparing uniquely for every interview

I realized: What if AI could handle 80% of this grind? That spark led me down a 48-hour coding marathon.

Day 1: Diving Into the Unknown
My first challenge was understanding Autogen, Microsoft's framework for creating collaborative AI agents. After reading documentation and experimenting:

I built a "Searcher Agent" to understand job requirements

Created a "Writer Agent" specialized for cover letters

Developed a "Salary Analyst" using Gemini's market data

Implemented conversation flows between agents

Key breakthrough: Autogen's ability to have agents debate and refine outputs before presenting to users resulted in significantly higher quality suggestions.

Day 2: The Web Scraping Challenge
When I hit API limitations, I turned to Selenium:

Mastered headless browser automation

Built LinkedIn job scrapers that mimic human browsing patterns

Implemented intelligent pagination handling

Added proxy rotation to avoid detection

The most satisfying moment? Watching the scraper perfectly extract and categorize 50+ job listings in under a minute.

The Complete Tech Stack
Core Framework:

Python 3.11 (for stability and async support)

Streamlit (for the clean, interactive dashboard)

Autogen (multi-agent orchestration)

AI Components:

Groq API (ultra-fast LLM inference)

Google Gemini (for salary/insight generation)

Custom fine-tuned prompts (to maintain professional tone)

Data Pipeline:

Selenium WebDriver (headless Chrome)

BeautifulSoup4 (HTML parsing)

Custom NLP filters (for skill matching)

Utility Layer:

Python-dotenv (secure credential management)

Loguru (beautiful logging)

Pandas (data organization)

Key Features That Make It Powerful

Smart Job Matching

Analyzes 100+ listings in minutes

Scores matches based on your profile

Highlights best-fit opportunities

AI-Powered Cover Letters

Generates tailored drafts in 15 seconds

Maintains consistent professional voice

Incorporates key job requirements

Interview Preparation Suite

Technical question predictions

Company-specific advice

Behavioral question drills

Salary Negotiation Assistant

Real-time market benchmarks

Customized compensation analysis

Benefits package evaluation

The Development Challenges
Rate Limiting: Solved with intelligent request throttling and cacheing

Dynamic Web Content: Overcame with hybrid CSS/XPath selectors

AI Hallucinations: Implemented a verification layer using consensus scoring

Why This Changes Job Hunting
Traditional job search tools are passive. JobQuest AI is:

Proactive (searches for you)

Adaptive (learns from your preferences)

Comprehensive (handles the entire application cycle)

What's Next?
Adding Indeed and Glassdoor integration

Developing a Chrome extension

Implementing PDF resume parsing

Final Thoughts
This 48-hour sprint taught me that:

Modern AI tools can automate complex workflows

Web scraping remains an essential skill

The best solutions come from personal pain points

Try JobQuest AI Today:
https://github.com/Zedoman/Job_Hunt

🌟 From Vision to Victory: Building Decentralized EtherEd AI for EDU Chain 🚀 🌟

Avradeep Nayak — Mon, 03 Mar 2025 17:51:43 +0000

A few weeks ago, I set out on an exhilarating journey to redefine education through technology as part of a hackathon challenge. The mission? Build a decentralized AI tutoring platform that empowers learners with personalized, gamified education while harnessing the power of blockchain for transparency and trust. After countless late nights, rigorous debugging, and a relentless passion for innovation, I’m thrilled to unveil Decentralized EtherEd AI—a project that blends cutting-edge AI with Ethereum blockchain to create a transformative learning experience!

The Vision: Democratizing Education with AI and Blockchain
Imagine a world where students can master complex topics like Data Structures, Programming, Blockchain, Aerospace, or even casual chit-chat about movies—all on a single platform. A world where every lesson, payment, and achievement is transparently tracked on the blockchain, empowering learners with a verifiable record of their progress. That’s the vision behind EtherEd AI! We aimed to create a decentralized tutoring DApp that not only educates but also engages, gamifies, and rewards learners in a futuristic, immersive environment.

What We Built: Decentralized EtherEd AI
Powered by Groq’s LLAMA3 AI, Decentralized EtherEd AI offers personalized tutoring across five distinct learning paths, each with strict question validation to ensure focused education:

DSA Only: Master Data Structures and Algorithms (e.g., sorting, graphs, dynamic programming).
Programming: Dive into coding (e.g., debugging, syntax, any language).
BlockChain: Explore blockchain concepts (e.g., Ethereum, smart contracts, decentralization).
Non-Tech Field: Learn Aerospace, Mechanical, or Electrical topics (e.g., aerodynamics, circuits, robotics).
Random: Enjoy casual conversations (e.g., movies, hobbies, fun topics).
We enhanced the learning experience with fuzzy matching for typos (e.g., "linkedlist" matches "linked list") and multi-topic prompt handling (e.g., intelligently handling "What is a blockchain algorithm?"), ensuring a seamless user experience.

Blockchain-Powered Transparency
Built on the Ethereum Sepolia testnet (via Infura), our platform uses Solidity smart contracts to:

Handle secure ETH payments for tutoring sessions.
Store progress, award badges, and log lifetime chat history on-chain.
Track achievements transparently, tied to the user’s Ethereum address, ensuring immutability and trust.
A Futuristic Cyberpunk Experience
The UI is where EtherEd AI truly shines—a neon-themed, cyberpunk-inspired frontend that immerses users in a sci-fi learning adventure:

Holographic effects and animated backgrounds.
Glowing buttons and smooth scrolling.
Dynamic visibility of UI elements (avatar, response, feedback, dashboard) for a cleaner interface.
Styled code responses with structured sections (e.g., Explanation, Example, Notes) for better readability.
We added interactive features to make learning fun:

Dynamic Avatar System (using Blockies for Ethereum address visualization).
Voice Input for hands-free queries.
Real-Time Leaderboard to foster competition.
Achievement Badges and Confetti Animations to celebrate milestones.
Optional Text-to-Speech for responses, enhancing accessibility.
A ChatGPT-style sidebar to organize lifetime chat history by path, making it easy to revisit past lessons.
The Tech Stack
AI: Groq LLAMA3 for personalized tutoring.
Backend: Python Flask for scalability.
Blockchain: Solidity smart contracts, Web3.py, Truffle, deployed on Sepolia via Infura.
Frontend: HTML/CSS/JavaScript with a cyberpunk UI.
Hosting: Render’s free tier for deployment.
The Journey: Challenges and Triumphs
Building EtherEd AI was no small feat! From integrating Groq’s LLAMA3 AI to deploying smart contracts on Sepolia, I faced challenges like:

Handling typos and multi-topic prompts with fuzzy matching.
Styling code responses for a user-friendly experience.
Ensuring environment variables (like GROQ_API_KEY) worked seamlessly on Render.
Each hurdle taught me resilience, problem-solving, and the power of combining AI and blockchain for social good. The late-night debugging sessions and countless iterations were worth it when I saw the platform come to life—a testament to teamwork, innovation, and perseverance.
Why It Matters for EDU Chain
Decentralized EtherEd AI aligns perfectly with the EDU Chain ecosystem by:

Empowering learners with personalized, gamified education.
Providing transparent, blockchain-backed progress tracking and achievements.
Offering a scalable model for decentralized education with future plans like NFT-based tutoring sessions and MetaMask integration.
Try It Out!
🚀 Check out: [https://github.com/Zedoman/Tutor]

I’d love to hear your feedback! Let’s connect and explore how decentralized education can shape the future of learning. 📚✨

Special Thanks to @ethereum, @github, Groq, Llama, and Open Campus for their tools and communities that made this possible!

EDUChain #AI #Blockchain #Education #Hackathon #Innovation #EtherEdAI

🔱 From Dilemma to Creation: How I Brought Raavan to Life with AI

Avradeep Nayak — Mon, 03 Feb 2025 16:40:25 +0000

LiveLink: https://huggingface.co/spaces/Zedoman/Raavan

A few weeks ago, I found myself in a creator’s dilemma—I was exploring Groq with LLAMA, eager to implement it in a meaningful project, but I had no idea what to build. I wanted something unique, something that wasn’t just another chatbot but an experience that could immerse users in deep conversations.

Then, one evening, as I was flipping through Raavan: Enemy of Aryavarta by Amish Tripathi, I was struck by an idea.

Raavan has always been a mystery—a king, a scholar, a warrior, a Shiva devotee, and yet the most misunderstood figure of the Ramayan. He was brilliant, yet arrogant. Powerful, yet tragic. What if people could talk to him today? What if he could defend his own actions, narrate his own story, and even share his knowledge on philosophy, strategy, and astrology?

That was the spark.

And so, Shastra-Raavan was born—a powerful AI chatbot where users can engage with Raavan, ask him about his life, wisdom, and past decisions, and even seek astrological guidance based on Vedic calculations.

But beyond just the idea, this project became an intense learning journey, teaching me so much about AI, NLP, and astrology calculations.

🧠 What I Learned from This Journey
🔥 LLAMA (via Groq) – Breathing Life into Raavan’s Voice
Building a chatbot is one thing, but making it sound like Raavan himself was a whole different challenge.

With LLAMA models running on Groq, I had to fine-tune the responses to match Raavan’s persona—his intellect, pride, devotion, and depth. I learned how to:

Control temperature and repetition settings to keep responses engaging yet historically accurate.
Optimize the prompt structure so that Raavan never broke character.
Use Groq’s lightning-fast processing to ensure that the chatbot responds instantly, making conversations fluid and immersive.
The result? An AI that doesn’t just answer questions—it debates, challenges, and provokes thought, just like Raavan himself would.

💻 Streamlit – Crafting a Seamless User Interface
I wanted this chatbot to feel modern yet mythological—a balance between an AI experience and an ancient storyteller.

Streamlit made it incredibly easy to create a clean, interactive, and minimal UI, with features like:

✅ A persistent chat history to make conversations feel continuous and immersive.
✅ A dynamic input box that allows real-time conversations with Raavan.

I learned how frontend simplicity can enhance AI engagement, keeping users focused on the experience rather than clutter.

🔑 Python-Dotenv – Securing API Keys the Right Way
Working with Groq with LLAMA3 meant handling multiple API keys, and dotenv helped me store them securely.

Instead of hardcoding sensitive credentials, I learned:

How to use .env files to keep API keys safe.
How to load environment variables dynamically without exposing them in public repositories.
Best practices for securing AI-powered applications when working with cloud services.
This was a small yet crucial part of the project that ensured scalability and security.

🔭 Pyswisseph – The Power of Vedic Astrology in AI
One of the coolest features of Shastra-Raavan is its ability to provide astrological insights. I wanted users to not just talk to Raavan but also consult him for astrology readings, just as kings and scholars once did.

Enter Pyswisseph—the Swiss Ephemeris library that allowed me to calculate planetary positions, Nakshatras, and Dasha periods with accuracy.

Working with Pyswisseph, I learned:

How Vedic astrology works and how planetary positions are calculated.
How to use longitude, latitude, and time zones to determine an individual’s astrological chart.
How to integrate astronomical precision into an AI-powered experience.
This added an esoteric depth to the chatbot, making it more than just a conversation tool—it became a mystical advisor.

⏳ Datetime – The Foundation of Astrology Predictions
Since astrology is deeply tied to time, I needed a way to handle birth dates, planetary movements, and time zones.

The Datetime library was my savior. I used it to:

Convert birth times into universal timestamps for accurate astrology calculations.
Align planetary data with specific historical periods to make Raavan’s responses feel contextually accurate.
Ensure that every astrological reading was based on the exact second of birth, just like traditional astrologers do.
This was a game-changer because it added precision to the chatbot’s astrology functionality, making it feel authentic and powerful.

🚀 The Bigger Picture – AI Meets Mythology
This project was never just about building another chatbot. It was about bridging the gap between technology and mythology, creating something that engages, educates, and intrigues.

I realized that:
📌 AI isn’t just about data—it’s about storytelling.
📌 A chatbot isn’t just a tool—it can be a character with depth, emotion, and knowledge.
📌 Mythology and AI can co-exist, bringing ancient wisdom into modern conversations.

Now, users can talk to Raavan as if he were alive today, ask him about his devotion to Shiva, his war strategies, his downfall, and his misunderstood legacy. They can even seek astrological guidance, making the experience deeply personal.

🔥 What’s Next?
This is just the beginning.

🔹 I plan to expand Raavan’s knowledge base with more Shlokas, Vedic texts, and hidden scriptures.
🔹 I want to refine the astrology feature to provide even more detailed readings.
🔹 I’m exploring ways to make the chatbot more dynamic, allowing users to have longer, evolving conversations.

The journey of Shastra-Raavan continues.

Would you talk to Raavan? What would you ask him? 🔱🔥

Let me know your thoughts! 👇

Winter Solstice

Avradeep Nayak — Sat, 21 Dec 2024 16:49:52 +0000

This is a submission for Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice

What I Built

Celebrate the Winter Solstice in style with an enchanting page designed to captivate and inspire. We’ve enhanced the UI to create a visually stunning experience that’s not only beautiful but also immersive—making it the perfect place for everyone to embrace the magic of this seasonal shift.

Demo

https://drive.google.com/file/d/1hq5HeoFsqzO1xnEN_7F8rUA2oXxEqS23/view?usp=sharing
https://github.com/Zedoman/Winter_Solstice

Journey

I leveraged Figma to design the layout, gaining valuable insights into both the tool and the design process. I then translated this design into a fully functional website using HTML and CSS, focusing on making it visually appealing and user-friendly. Along the way, I learned how to enhance the overall aesthetic while improving the user experience. I’m particularly proud of how the site turned out, and I’m excited to further refine my skills in design and web development in future projects.

InspireInk

Avradeep Nayak — Sat, 14 Dec 2024 18:21:44 +0000

Title: Unleash Your Creativity with InspireInk: Your AI-Powered Writing Companion

Writing can sometimes feel like a solitary journey, but what if you had a companion to guide you through plot twists, character arcs, and stylistic inspiration? Introducing InspireInk, a powerful AI-driven tool designed for writers who want to elevate their craft and bring their stories to life.

What is InspireInk?
InspireInk is more than just a tool—it's your creative partner. Whether you're crafting a novel, screenplay, or poem, InspireInk leverages cutting-edge technologies like LangChain, CopilotKit, and Google’s Gemini AI to provide personalized writing assistance. It even supports real-time collaborative storyboarding to help you brainstorm and refine ideas with others.

Key Features
Plot Twist Generator: Add an unexpected twist or craft a compelling ending with AI suggestions.
Character Development Tips: Create multidimensional characters with tailored traits and backstories.
Style Inspiration: Get writing tips inspired by famous authors to refine your voice.
Collaborative Storyboarding: Work on ideas with others in real-time for a dynamic creative process.

Why InspireInk Stands Out
Unlike generic writing tools, InspireInk integrates AI-powered insights directly into your workflow. Built with a FastAPI backend and a sleek Next.js frontend, it's designed for speed, reliability, and seamless interaction. The tool uses LangGraph to manage writing tools and states, and CopilotKit ensures intuitive integration.

Get Started
Getting InspireInk up and running is straightforward. Clone the repository, set up the dependencies, and you're ready to dive into your creative process. Full instructions can be found on the GitHub repository [https://github.com/Zedoman/InspireInk].

Join the Writing Revolution
With InspireInk, you're not just writing—you’re crafting something extraordinary. Join the growing community of writers who are transforming their storytelling process with the power of AI.

Share Your Journey
Have you tried InspireInk? Share your thoughts or examples of your work in the comments below. Let's inspire each other!

Building a Dynamic Emotion-Based Playlist Generator Using Python and Daytona (TuneTailor)

Avradeep Nayak — Tue, 03 Dec 2024 06:57:05 +0000

GITHUB LINK: https://github.com/Zedoman/Dynamic_Emotion-Based_Playlist_Generator

🎵 TuneTailor: Crafting Playlists That Feel You

Have you ever wondered how it would feel to have a playlist that truly gets you? One that syncs with your mood, whether you're on cloud nine, seeking solace, or just vibing to your own groove? Enter TuneTailor, a Dynamic Emotion-Based Playlist Generator that merges the magic of music and machine learning to create personalized playlists that match your emotions.

This is the story of how TuneTailor came to life, built with Python, Daytona, and popular music APIs. Let me take you behind the scenes and show you how we made it happen.

💡 The Spark of an Idea

It all started on a cloudy afternoon with a simple thought: music isn’t just sound; it’s a companion. But what if music could dynamically change based on how we feel? This led us to the idea of TuneTailor, a system designed to:

Generate playlists based on user preferences and emotions.

Personalize every detail, from genre to language.

Offer a seamless and intuitive experience.

We knew this would require integrating machine learning for emotion recognition, APIs for music data, and a scalable development setup—and that’s where Daytona came into the picture.

🚀 Why Daytona Was a Game-Changer

Building an application like TuneTailor demands a reliable and efficient development environment. Daytona emerged as the perfect solution, simplifying every aspect of project setup and management. Here’s how Daytona made TuneTailor possible:

Install Daytona

Daytona is your developer workspace wizard. Follow the installation guide to get it up:

https://github.com/daytonaio/daytona/

Streamlined Setup

Daytona’s simplicity starts with its streamlined setup process. With a single command, we created a fully-configured workspace:

daytona create https://github.com/Zedoman/Dynamic_Emotion-Based_Playlist_Generator

This command did it all—cloning the repository, setting up the environment, and managing dependencies. Daytona ensured we had everything we needed, including Flask, scikit-learn, and Spotipy, without any manual intervention.

Hassle-Free Dependency Management

Daytona automatically handles dependencies for you, making traditional methods like pip install -r requirements.txt obsolete. With Daytona, there’s no need to worry about missing libraries or mismatched versions—everything just works. It even ensures compatibility across machines, solving the infamous "works on my machine" problem.

Seamless Containerization

Daytona goes beyond basic setups by integrating Docker directly into the workflow. When creating the workspace, Daytona includes pre-configured Docker support, allowing us to spin up the application effortlessly:

docker-compose up

No additional setup was required—Daytona ensured the containerization was ready to go from the start. This consistency across environments made development, testing, and deployment a breeze.

Environment Replication Made Easy

One of Daytona’s standout features is its ability to replicate environments across machines. Whether you’re switching devices or onboarding a new team member, Daytona ensures everyone has an identical setup. This reliability saved us countless hours of troubleshooting and configuration.

Run the Application

Finally, we fired up the application:

python app.py

🛠️ Building TuneTailor

Here’s a quick peek into the tech stack and how each component played a role:

Python: The backbone of our project, powering the emotion classification and backend logic.

Flask: A lightweight web framework to serve the playlist generation API seamlessly.

scikit-learn: The powerhouse for emotion recognition. We trained a model to map user input to emotions like "happy," "sad," or "energetic."

Spotify API (Spotipy): To fetch music data based on user preferences and emotional cues.

Docker: To containerize the app, ensuring it runs smoothly on any machine.

Daytona: To streamline the setup and manage dependencies with ease.

✨ Features That Make TuneTailor Special

Personalized Playlist Generation: Users input their favorite artists, genres, and languages to create tailored playlists.

Emotion-Based Suggestions: Whether you’re feeling relaxed or upbeat, TuneTailor’s emotion recognition ensures the music matches your vibe.

Customizable Playlist Size: Generate playlists ranging from a quick 10-song vibe to a full 60-song marathon.

Genre and Language Filters: Curate playlists that align with cultural and emotional contexts.

🌟 Why Daytona?

Daytona simplified everything. From setting up a consistent environment to replicating it across multiple machines, it became the unsung hero of our project. Its seamless integration with Docker and Python made the entire development process hassle-free.

🎧 What’s Next?

TuneTailor is more than a playlist generator; it’s a glimpse into the future of emotion-driven systems. With potential expansions like real-time emotion detection (via wearables) and integration with other streaming platforms, the possibilities are endless.

What feature would you like to see in TuneTailor? Share your ideas in the comments—we’re all ears!

📢 Get Started

Ready to dive into the world of emotion-based playlists? Follow the steps above, and let TuneTailor be your guide. Happy coding, and even happier listening!

SwiftSupport

Avradeep Nayak — Sun, 27 Oct 2024 09:23:03 +0000

SwiftSupport - A Real-Time AI-Powered Chatbot for Customer Support

This Customer Support Chatbot is designed to assist Customers in providing AI-driven customer service. It leverages the Google Generative AI model via CopilotKit to handle customer queries in real-time, offering automated and intelligent responses.

Name of Issue/Topic

39 - Customer Support Bot (Hacktoberfest Demo) #786

Technologies Being Used

Express.js: Backend framework for Node.js
React: Frontend JavaScript library for building user interfaces
CopilotKit: AI copilots integration for advanced features
Google Generative AI: AI model for generating intelligent responses
Axios: For handling API requests
TypeScript: Strongly typed JavaScript for better development experience

App Link

TravelTally

Avradeep Nayak — Sat, 26 Oct 2024 17:40:09 +0000

TravelTally - A budgeting and expense management tool for Travel Expenses.

TravelTally is a travel budget planner that allows users to efficiently manage their finances by tracking expenses related to their trips, including airfare, lodging, and activities. Users can monitor their budgets, view how much money they have spent compared to their allocated budget, and receive assistance from a built-in Copilot assistant. The application features a clean, responsive UI built with TailwindCSS, while leveraging React and Redux for robust state management, along with CopilotKit and Shadcn-UI for enhanced functionality and styling.

Name of Issue/Topic
24 - Travel Budget Planner (Hacktoberfest Demo)

Technologies Being Used
React: JavaScript library for building user interfaces
Redux: State management library for JavaScript apps
TailwindCSS: Utility-first CSS framework
CircularProgressbar: For visualizing budget and expense data
Vite: Fast and modern build tool that enhances development with native ES modules and instant hot module replacement.
JavaScript: Primary programming language for development
Shadcn-UI: UI component library built with accessibility and customization in mind, styled with TailwindCSS.
CopilotKit: Ai CopilotBot

Leveraging AWS S3 for a Robust E-commerce Platform: A Web Developer's Perspective

Avradeep Nayak — Sat, 05 Oct 2024 07:00:49 +0000

In June 2024, I embarked on an exciting journey as a Web Developer at I-Galaxy, where I had the opportunity to build backend services for a production-level e-commerce platform. This experience not only allowed me to refine my technical skills but also gave me insights into the importance of efficient storage solutions. Central to this journey was my adoption of AWS S3 (Amazon Simple Storage Service).

In this post, I’ll walk you through the role of AWS S3 in the project, why I chose it, and how it became an integral part of our scalable and user-focused e-commerce platform.

About the Project: An E-commerce Platform with a Purpose

The platform aimed to provide users with a seamless online shopping experience. It featured core functionalities like user registration, cart management, wish lists, checkout processes, invoice generation, and even schema generation for future scalability.

To ensure smooth operations, I adopted the MERN stack (MongoDB, Express.js, React.js, Node.js) and integrated Razorpay for secure payments. However, the challenge was managing the vast array of product images efficiently while ensuring cost-effectiveness, scalability, and accessibility. That’s where AWS S3 came into play.

Why AWS S3?

AWS S3 was the perfect solution for our platform's storage needs. Here’s why it stood out:

Scalability:
As our product catalog expanded, so did the number of images. AWS S3 provided virtually unlimited storage, ensuring that we could scale effortlessly without worrying about running out of space.

Cost-Effectiveness:
AWS S3's pay-as-you-go model meant we only paid for the storage and data transfer we used. This was ideal for a growing platform where budget constraints were a consideration.

High Availability and Durability:
S3 ensures 99.999999999% (11 nines) durability by replicating data across multiple facilities. This was critical for an e-commerce platform, as product images must always be accessible to users.

Global Accessibility:
With S3, we could ensure low-latency access to images globally, thanks to Amazon CloudFront, which integrates seamlessly with S3 for content delivery.

Security:
Using S3’s fine-grained access control, I could ensure that sensitive data (like user-uploaded files) was stored securely, while public product images were accessible for viewing.

Ease of Integration with MERN Stack:
AWS S3 integrates effortlessly with Node.js through the AWS SDK, allowing us to perform operations like uploading, retrieving, and deleting files programmatically.

How S3 Enhanced the Platform

Improved User Experience:
By storing and serving product images directly from S3, we reduced page load times significantly. Faster-loading pages meant happier users and higher conversion rates.

Simplified Management:
With S3, managing thousands of images became hassle-free. I could automate tasks like lifecycle policies to archive or delete unused images after a specific period.

Optimized Development Workflow:
The separation of storage and application logic allowed for a cleaner codebase and faster feature rollouts. Developers could focus on building new features without worrying about storage complexities.

Streamlined Invoice Generation:
AWS S3 also played a role in storing dynamically generated invoices, which could be accessed by users anytime after a purchase.

Beyond S3: Building a Future-Ready Platform

While AWS S3 played a crucial role in image and document storage, the platform's success also relied on:

Razorpay Integration: For a seamless and secure payment experience.
MERN Stack Implementation: To ensure a robust and flexible architecture.
Amazon S3’s SDK: For simplifying API calls to manage assets programmatically.
Key Takeaways
Building the backend services for I-Galaxy’s e-commerce platform was a deeply rewarding experience. The decision to use AWS S3 proved pivotal in addressing challenges related to scalability, security, and performance.

AWS S3 demonstrated that a robust storage solution could do more than just store files—it could transform the way a platform operates and scales. For anyone developing applications requiring extensive file handling, AWS S3 is a game-changer.

Have questions about integrating AWS S3 into your projects? Drop them in the comments below or connect with me. Let’s build something incredible!

Event Planner

Avradeep Nayak — Fri, 04 Oct 2024 13:18:32 +0000

The Event Planner web application allows users to manage events with features like creating, editing, and deleting events. It includes a user-friendly interface displaying event details such as title, description, date, time, location, category, and priority. Events are displayed in card format, making it easy to view and interact with. Additionally, the app integrates Copilot Assistant, which aids users by providing suggestions and automating certain tasks. You can explore the app here.

It's built using modern web technologies such as React and integrates a backend API for event management.