DEV Community: Soumyadeep Dey

👻 GHOSTNOTE AI: Some Memories Refuse to Stay Buried

Soumyadeep Dey — Tue, 27 Oct 2026 22:44:16 +0000

This is my submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What if your computer could turn mysterious notes and forgotten memories into haunting stories?

Meet GHOSTNOTE AI — a spooky, AI-powered digital diary inspired by haunted terminals, forgotten memories, and the supernatural side of technology.

🕯️ What I Built

GHOSTNOTE AI is a digital archive that transforms story ideas, mysterious incidents, and personal reflections into atmospheric narratives.

Inspired by the Ghost in the Machine theme, I wanted to combine AI storytelling with an immersive, cinematic interface that feels like stepping into a haunted digital archive.

✨ Features

👻 AI Storytelling: Transform notes and story ideas into atmospheric narratives.

🌑 Cinematic UI: A dark, mysterious interface inspired by supernatural archives.

📓 Digital Archive: Save and revisit your stories.

🔐 Privacy-Conscious Design: Keep saved entries local wherever supported.

🧠 Open AI Architecture: Explore integration with Ollama and open-weight models for greater control over AI inference.

🚀 Live Demo

👉 https://ghostnote-ai-sigma.vercel.app/

💻 Source Code

⭐ https://github.com/SOUMYADEEPDEY1217/GHOSTNOTE

Contributions, feedback, and ideas are welcome!

🛠️ How I Built It

I used AI-assisted development to build the application, focusing on a polished web experience and a practical storytelling workflow.

The project uses a React and TypeScript-based frontend. Its AI architecture is designed to support replaceable model providers, including Ollama for locally hosted open-weight models.

My goal is to make the application adaptable rather than permanently dependent on a single proprietary AI provider.

🌍 Why Does Open Innovation Matter?

Open innovation gives developers the freedom to experiment, adapt, and build beyond the limitations of a single provider.

An open-weight AI approach can offer several advantages:

Privacy: Properly configured local inference can keep private prompts and stories on the user's device.

Offline access: A downloaded model can run without an internet connection when the local environment is configured correctly.

Flexibility: Developers can switch compatible models and customize their behavior.

Independence: Projects can evolve without being completely tied to one proprietary AI service.

For me, open AI is about more than using a model. It's about giving developers and users more control over the technology they build with.

🕸️ The Spirit of It

Halloween celebrates the mysterious, but the idea behind GHOSTNOTE AI goes beyond horror.

Our stories and memories can outlive the devices that hold them. Technology gives us new ways to preserve, reinterpret, and share them.

With GHOSTNOTE AI, I wanted to explore that idea through a digital archive where a forgotten note can become the beginning of something extraordinary.

Some memories refuse to stay buried. Some stories deserve to live on.

🏆 Challenge

Built for the Hacktoberfest Open-Source AI Challenge — Week 4: Ghost in the Machine.

I'd love to hear your thoughts and suggestions!

🦥 SlothAI: Work Less, Automate More, Stay Slow

Soumyadeep Dey — Tue, 20 Oct 2026 19:38:38 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

Meet SlothAI — a local-first, open-weight AI productivity workspace designed to take the repetitive work off your plate.

We spend too much time summarizing documents, digging through notes for action items, renaming files, and turning scattered information into useful updates. SlothAI brings these everyday tasks together in one workspace, so you can spend less time on digital busywork and more time on what matters.

🦥 What can SlothAI do?

AI Document Summarizer: Turn long documents into short, balanced, or detailed summaries, with key takeaways and notable terms.

Task Extractor: Identify actionable tasks from your notes, edit them, track completion, and export them. Deadlines are grounded in the source text rather than invented.

Intelligent File Organizer: Generate cleaner filenames and destination suggestions, review proposed changes, and approve individual operations before execution.

Daily Briefing Compiler: Turn notes and documents into concise summaries, key points, action items, deadlines, and follow-up questions.

Local Model Management: Check model availability, inspect backend health, and choose or download compatible local models.

The idea is simple: let AI handle the repetitive work without giving up control of your files or workflow.

Demo

🚀 Try SlothAI: https://sloth-ai-lemon.vercel.app/

Explore the deployed interface and discover the SlothAI workflow.

For local model inference, use the full application with its FastAPI backend and Ollama runtime, as described in the repository's setup guide.

Code

💻 GitHub Repository: https://github.com/SOUMYADEEPDEY1217/Sloth-AI

The project is released under the MIT License.

Explore the source code, run it locally, experiment with compatible models, and contribute improvements.

How I Built It

SlothAI combines a modern web interface with a Python backend and local language-model inference.

Tech stack

Frontend: React 19, TypeScript, Vite, Tailwind CSS

Backend: Python, FastAPI, Uvicorn, and Pydantic

AI runtime: Ollama

Default suggested model: Qwen3 4B (qwen3:4b)

Document processing: Python libraries for formats such as PDF, DOCX, TXT, Markdown, CSV, and JSON

Testing: Python unit tests and TypeScript/build checks

How the architecture works

The React frontend provides the workspace for summarizing documents, extracting tasks, organizing files, and compiling briefings.

The FastAPI backend validates requests, processes supported documents, and coordinates application logic.

Ollama runs a compatible open-weight language model locally and supplies AI-generated results.

The application structures outputs and applies additional checks, including source-grounded deadlines and controlled file operations.

Safety is part of the design

SlothAI is designed to suggest changes before executing them. File organization includes an approval workflow and directory restrictions, with safeguards against path traversal, accidental overwrites, and unsafe file extensions.

The goal isn't to make an agent that does everything without asking. It's to make an assistant that saves effort while keeping the user in control.

Why Does Open Innovation Matter?

For SlothAI, open innovation is not just a technology choice. It shapes how the application can be used, customized, and trusted.

🔒 Privacy through local inference

When configured and run locally, SlothAI can process documents through a local FastAPI backend and Ollama rather than sending their contents to a hosted LLM API.

This matters when working with personal notes, internal documents, or other information that shouldn't automatically leave your machine.

📴 Useful without a constant internet connection

After installing the dependencies and downloading a compatible model, local inference can run offline. This makes supported AI workflows available even when an internet connection is unavailable.

The hosted demo and the local application have different requirements: offline inference applies to the locally configured application, not the Vercel-hosted website.

🔧 Freedom to change models

The application is designed to support configurable local models. Qwen3 4B is the suggested default, but compatible alternatives can be selected according to hardware, speed, and output quality.

This flexibility lets developers experiment with different models instead of being locked into one provider's API.

💸 Fewer dependencies on paid APIs

Local inference avoids per-request charges from a hosted LLM provider. There are still costs associated with hardware, electricity, storage, and setup, but running the model locally can make repeated use more predictable.

🛠️ Transparent, modifiable software

The MIT-licensed codebase gives developers the freedom to inspect, adapt, and extend the application. The backend's validation and file-operation safeguards can also be reviewed and improved by the community.

For this project, the advantage of open AI is control: control over where inference runs, which compatible model is used, how the workflow behaves, and how the code evolves.

The Lazy Payoff

The biggest payoff is reducing the number of small, repetitive tasks that interrupt a productive day.

Instead of manually condensing a long document, searching through notes for action items, or deciding how to rename a batch of files, users can start with AI-generated suggestions and review the results.

The file organizer adds another useful detail: it stages proposed changes for review rather than silently moving files.

I haven't published a measured time-saving benchmark yet, so I won't invent numbers. The practical goal is to reduce repetitive effort while keeping important decisions and file operations under user control.

Why Slow and Steady?

A useful AI assistant doesn't have to be a giant cloud service or an agent with unlimited permissions.

Sometimes, the better solution is a small, customizable tool that runs on your own machine, handles the boring work, and lets you decide what happens next.

SlothAI is my exploration of that idea: less busywork, more control, and open AI that works at your pace.

I'd love to hear what repetitive task you'd automate first.

PitchCraft AI — Turn Client Briefs into Winning Proposals with Open-Source AI

Soumyadeep Dey — Thu, 15 Oct 2026 11:12:56 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

🚀 PitchCraft AI — Turn Client Briefs into Winning Proposals with Open-Source AI

What if freelancers could spend less time writing proposals and more time doing the work they love?

Every freelancer knows the struggle: finding a promising client, understanding their requirements, preparing a convincing proposal, estimating a fair price, and following up professionally.

And after all that effort, there's no guarantee the client will respond.

That's the problem that inspired me to build PitchCraft AI, an AI-powered freelance proposal and client-management platform designed around open-source intelligence.

The goal is simple: help freelancers spend less time on repetitive administrative work and more time delivering value.

🛠️ What I Built

PitchCraft AI is a freelancer-focused SaaS project that brings proposal writing, quotation planning, and client management into one workspace.

Instead of starting every proposal from a blank document, freelancers can use AI to help structure their pitch, communicate their value, and organize project information.

✨ Core Features

AI Proposal Generator: Transform client briefs into structured, professional proposals.
Client Brief Analyzer: Identify requirements, deliverables, and important project details.
Smart Pricing Calculator: Estimate project quotations using rates, hours, and additional costs.
Cover Letter & Follow-Up Assistant: Draft professional client communication.
Proposal Editor & PDF Export: Customize and prepare proposals for sharing.
Client CRM: Organize client information and related proposals.
Proposal Dashboard: Manage proposals, statuses, and workflow activity.
Personal Workspace: Designed to support individual accounts and user-specific saved data.

💼 Who Would Pay for It?

PitchCraft AI is designed for freelance developers, designers, writers, marketers, consultants, and small agencies.

These professionals repeatedly spend time preparing proposals, estimating costs, and managing clients.

The business opportunity is to offer a useful, affordable subscription that saves time on those recurring tasks.

My proposed monetization model includes a free entry tier and paid plans for additional proposal generation, productivity tools, and advanced workflow features.

The pricing is a product concept, not a claim of existing paid customers.

The value proposition: spend less time preparing the pitch and more time building the project.

🌐 Demo

🔗 Try PitchCraft AI Live

The deployed website showcases PitchCraft AI's futuristic metallic interface and freelancer-focused workspace.

The product experience is designed around a straightforward workflow:

Client Brief → AI Analysis → Proposal Draft → Pricing → Editing → PDF Export

The website uses a cinematic black-chrome aesthetic, titanium-inspired surfaces, orange accents, and a dedicated application dashboard.

The AI-powered backend is designed around Ollama. Actual generation requires a reachable, configured model-serving backend; a deployed frontend alone does not guarantee that local Ollama inference is available to every visitor.

💻 Code

GitHub: https://github.com/SOUMYADEEPDEY1217/PitchCraft-AI

The project is built with a modular architecture so that the frontend, application logic, and AI model integration can evolve independently.

The codebase is intended to support model experimentation, new freelancer tools, and future contributions.

⚙️ How I Built It

I wanted PitchCraft AI to be more than a generic text-generation interface.

The application is designed as a practical workflow where AI handles language-heavy tasks while the surrounding software manages structured business data.

🧠 Open-Source AI Core

The AI architecture centers on:

Ollama + Qwen3:4b

Ollama provides a way to run open-weight models locally, while Qwen supplies the language-generation capabilities used for tasks such as proposal drafting, brief interpretation, and client communication.

This matters because the model is part of the actual product workflow, rather than simply being used during development.

🧰 Technology Stack

Layer	Technology
Frontend	React, TypeScript, Tailwind CSS
Backend	Python, FastAPI
AI Runtime	Ollama
Language Model	Qwen3:4b
Database	SQLite / PostgreSQL architecture
UI	Metallic design system, responsive components
Deployment	Vercel frontend

🏗️ System Architecture

                  FREELANCER
                      |
                      v
            PITCHCRAFT AI WEB APP
             React + TypeScript
                      |
                      v
               FASTAPI BACKEND
                      |
         +------------+------------+
         |            |            |
         v            v            v
    AI SERVICES   BUSINESS LOGIC   DATABASE
         |        Pricing / CRM    User Data
         v
       OLLAMA
         |
         v
      QWEN3:4b
         |
         v
   GENERATED PROPOSAL
         |
         v
    EDIT / SAVE / EXPORT

🔄 The AI Workflow

Step 1 — Understand the client brief

The freelancer enters the project description, expected deliverables, budget, and timeline.

Step 2 — Prepare the AI request

The backend organizes the supplied context and prepares a structured prompt for the language model.

Step 3 — Generate a proposal

The open-weight model produces a draft containing relevant proposal sections, such as the project overview, scope, deliverables, and timeline.

Step 4 — Refine and calculate

The freelancer can revise the generated content and use deterministic calculations for pricing rather than relying on invented AI estimates.

Step 5 — Prepare for delivery

The proposal can be organized into a professional document for review and sharing.

The key design principle is that AI assists the freelancer; the freelancer remains in control of the final proposal.

🌍 Why Does Open Innovation Matter?

This is the most important part of PitchCraft AI.

I didn't want to build a product where every core AI operation was permanently dependent on a single proprietary provider.

1. Model Freedom

Using Ollama and open-weight models creates opportunities to switch models, experiment with different sizes, and customize generation behavior.

A freelancer-focused product should be able to evolve without being locked into one model vendor.

2. More Control Over Costs

A subscription-based side hustle needs sustainable operating costs.

Self-hosted inference can reduce dependence on per-request commercial API charges, although it still requires computing resources, electricity, and maintenance.

That flexibility matters when exploring affordable plans for individual freelancers.

3. Privacy-Oriented Architecture

Client briefs can contain sensitive commercial information.

Local inference offers a deployment option where model processing can happen on infrastructure controlled by the user or operator.

However, privacy still depends on the actual deployment, storage, authentication, and networking configuration.

4. Customization for a Specific Niche

A general chatbot can draft text.

PitchCraft AI aims to go further by organizing AI around a freelancer's workflow: understanding briefs, creating proposals, estimating projects, managing clients, and preparing follow-ups.

Open models make it possible to experiment with prompts, structured outputs, and future domain-specific adaptations.

5. Learning Through Open Technology

Building around open-source tools also makes the system easier to study, extend, and improve.

For me, that is one of the most valuable parts of the project: understanding how the pieces fit together rather than treating AI as an inaccessible black box.

🚧 Challenges and Lessons Learned

Building PitchCraft AI brought several important engineering challenges.

Integrating AI into a real workflow: Generating text is only one part of the experience. The output also needs to be editable, organized, and useful for a real business task.

Separating frontend and model inference: A browser-hosted application cannot automatically access an Ollama instance running on a developer's laptop. A publicly usable AI demo needs an appropriately deployed inference backend.

Designing for multiple users: Proposal and client data must be isolated by authenticated account. Frontend filtering alone is not sufficient; authorization belongs on the backend.

Balancing visual design and usability: I explored a futuristic metallic interface, but proposal editing and business workflows still need readable forms, clear navigation, and accessible controls.

These challenges helped shape the architecture and the product roadmap.

🔮 What's Next?

My next priorities are improving production-ready authentication and user isolation, strengthening AI deployment reliability, refining proposal quality, and validating the product with real freelancers.

I also want to explore more customizable proposal templates, multilingual generation, and additional open-weight models.

Most importantly, I want to learn whether freelancers find the workflow valuable enough to use regularly—and eventually pay for.

🏆 Prize Categories

I'm submitting PitchCraft AI for the overall Hacktoberfest Week 2: Side Hustle challenge.

The project's core open-source AI technologies are Ollama and Qwen. I'm not claiming a partner-specific prize category without a verified integration with that partner's technology.

❤️ Final Thoughts

PitchCraft AI started with a simple question:

What if open-source AI could help freelancers spend less time chasing opportunities and more time creating value?

The result is my attempt to turn that question into a practical product.

This project is about more than generating proposals. It's about exploring how open-weight AI can power useful, affordable, customizable software for independent professionals.

And that's what makes the Side Hustle theme exciting to me: building something small enough to start, useful enough to matter, and flexible enough to grow.

🚀 Explore PitchCraft AI

Thanks for reading! I'd love to hear what features freelancers would find most valuable.

TrailMind AI 🌿 — The AI That Wants You to Stop Using AI | Hacktoberfest Touch Grass Challenge

Soumyadeep Dey — Fri, 09 Oct 2026 23:05:16 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

🌿 TrailMind AI — The AI That Wants You to Stop Using AI

Less Screen. More World.

What if the best AI application was one that encouraged you to stop using it?

We live in a world where most technology is designed to maximize screen time. Every recommendation, notification, and endless feed encourages us to stay connected just a little longer.

I wanted to build something that does the opposite.

Introducing TrailMind AI, an AI-powered outdoor adventure companion that transforms your mood, energy, available time, and surroundings into personalized real-world experiences.

The goal is simple:

Use AI for a minute. Experience the real world for the next hour.

🌍 What I Built

TrailMind AI is an outdoor exploration application designed to help people spend less time scrolling and more time experiencing the world around them.

Instead of recommending another video to watch, TrailMind suggests an adventure to experience.

Whether you have 10 minutes between classes, 30 minutes after work, or an entire afternoon to explore, TrailMind helps turn free time into meaningful outdoor activities.

✨ Key Features

🧠 AI-Powered Adventure Generation

TrailMind generates outdoor missions based on:

Available time
Current mood
Energy level
Preferred activity
Surrounding environment
Personal interests and previous adventures

🌲 Personalized Outdoor Missions

Adventures can include nature observation, photography, walking, mindfulness, running, gardening, and neighborhood exploration.

For example, selecting 20 minutes, low energy, and a park environment might produce a relaxing nature observation challenge.

📱 Phone Down, Adventure On

Once an adventure begins, TrailMind switches to a distraction-free experience with a mission checklist and timer.

The goal isn't to keep the user interacting with the application. It's to encourage them to put their phone away.

🌐 Offline-First Experience

TrailMind includes an offline mission engine and PWA capabilities, allowing outdoor activities to remain accessible when connectivity is limited.

🤖 Open-Weight AI Architecture

TrailMind includes an Ollama provider designed to support local inference with Llama 3.2, alongside Gemini cloud AI and a fallback mission generator.

📖 Adventure Memories and History

Users can record completed adventures, save reflections, and revisit their outdoor experiences.

📊 Personalized Progress

Adventure statistics and activity history help users understand how much time they're spending outdoors.

🏔️ Immersive Nature-Inspired Interface

Rather than using a conventional AI chatbot interface, TrailMind features cinematic outdoor visuals, responsive layouts, environmental animations, and an exploration-focused design.

🎯 Who Is It For?

TrailMind is designed for students, developers, remote workers, nature enthusiasts, and anyone who wants a little encouragement to step away from their screen.

You don't need to be an experienced hiker.

Sometimes an adventure is simply noticing five beautiful things during a ten-minute walk.

🚀 Demo

🌐 Live Application

Try TrailMind AI

The application is deployed on Vercel and can be accessed directly through a web browser.

How to Experience TrailMind

Open the application and start exploring.
Choose your available time, mood, energy, environment, and preferred activity.
Generate a personalized outdoor mission.
Review the mission objectives.
Start your adventure and put your phone away.
Return to record your experience and save a memory.

Suggested demo video: Show the landing page, mission generation, adventure timer, completion experience, and adventure history. For the open-source AI demonstration, show Ollama running locally and successfully generating a mission.

💻 Code

The project source code is publicly available on GitHub.

GitHub Repository:

https://github.com/SOUMYADEEPDEY1217/TrailMind-AI

TrailMind is built around a modular AI architecture, making it possible to experiment with different model providers and improve the outdoor recommendation experience.

Developers can explore the source code, suggest improvements, and contribute new adventure ideas.

🛠️ How I Built It

I developed TrailMind AI using Google AI Studio as part of the application-building workflow, then organized the project around a modern React and TypeScript architecture.

Technology Stack

Layer	Technology
Frontend	React 19, TypeScript, Vite
Styling	Tailwind CSS
Animation	Motion
Backend	Node.js, Express
Cloud AI	Google Gemini
Local AI integration	Ollama, Llama 3.2
Offline AI	Local mission fallback engine
Data integration	Firebase
Offline capabilities	Progressive Web App
Deployment	Vercel
Version control	GitHub

🧠 AI Architecture

The core of TrailMind is its provider-independent mission generation system.

Instead of tightly coupling the application to one AI service, the backend exposes a mission generation endpoint that coordinates multiple providers.

The architecture supports three approaches:

1. Local AI — Ollama

An Ollama integration allows an open-weight model such as Llama 3.2 to generate personalized outdoor missions when the application backend has access to a local Ollama instance.

This enables local inference without requiring every prompt to be processed by a proprietary cloud model.

2. Cloud AI — Gemini

Gemini provides an optional cloud-based generation path when configured and available.

3. Offline Mission Engine

When model inference is unavailable, TrailMind can use its fallback mission generator to provide outdoor activities without depending on a live AI service.

This separation helps make the application more resilient and easier to extend.

System Architecture

                USER
                  |
                  v
          React + TypeScript
            TrailMind PWA
                  |
                  v
         Adventure Generator
                  |
                  v
          Express Backend
                  |
                  v
          AI Coordinator
           /      |      \
          /       |       \
     Ollama     Gemini    Offline
     Llama 3.2   API      Engine
          \       |       /
           \      |      /
                  v
           Mission Output
                  |
                  v
           Adventure Mode
                  |
                  v
       History / Memories / Stats
                  |
                  v
         User Personalization

🔄 Adventure Workflow

The adventure experience follows a simple sequence:

Understand → Generate → Explore → Reflect → Personalize

The user provides a few preferences.

The AI creates an outdoor challenge.

The user leaves the screen and completes the activity.

The application records the experience and uses that information to support future personalization.

🎨 Design Philosophy

One of my biggest priorities was ensuring TrailMind didn't feel like another generic AI application.

I designed the experience around cinematic landscapes, layered environmental visuals, responsive layouts, and simple interactions.

The interface is meant to inspire exploration before the user even starts an adventure.

The most important design principle is that technology should support the experience rather than become the experience.

🌱 Why Does Open Innovation Matter?

Open innovation is central to the direction of TrailMind AI.

Outdoor adventures shouldn't require constant connectivity, expensive API calls, or dependence on one proprietary AI provider.

1. Local AI Gives Developers More Control

With Ollama and an open-weight model such as Llama 3.2, developers can run inference on compatible local hardware.

This makes it possible to experiment with outdoor mission generation without requiring a cloud AI provider for every request.

2. Privacy-Friendly AI

Mood, interests, and personal activity preferences can be sensitive information.

Local inference offers an architecture where these inputs can be processed on a device controlled by the user rather than automatically sent to an external AI provider.

3. Freedom to Experiment

Open-weight models allow developers to explore different model choices, prompts, and inference configurations.

TrailMind's provider abstraction is designed to make this experimentation easier.

4. Lower Dependency on Paid APIs

Local inference can reduce reliance on paid per-request cloud AI services.

Although local hardware still consumes computing resources, developers gain more flexibility over where and how inference happens.

5. Reliability When Connectivity Is Limited

Outdoor activities often happen in places where internet access is unreliable.

TrailMind's offline mission engine and local-first design help preserve useful functionality even when cloud services cannot be reached.

6. Community-Driven Innovation

An open project creates opportunities for contributors to build:

New outdoor mission templates
Regional and culturally relevant adventures
Accessibility improvements
Additional open-model integrations
Better personalization strategies
New nature exploration experiences

For me, open innovation isn't just about publishing code.

It's about making technology more accessible, customizable, and useful in the real world.

The best part of TrailMind is that its AI is designed to become less necessary once the adventure begins.

🤖 My Agent Session

I used Google AI Studio as part of my AI-assisted development workflow to build and refine TrailMind's frontend, mission generation architecture, responsive experience, and application integration.

The development process involved iterative prompts, implementation changes, and debugging.

An agent-session recording or DevRelay link can be added here if available.

🏆 Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass

TrailMind AI aligns with the challenge by combining an open-weight AI integration, an offline-first outdoor companion, and a product experience intentionally designed to get people away from their screens.

🔮 What's Next?

Some areas I would like to explore further include:

On-device AI inference on mobile hardware
Offline bird and plant recognition
More location-aware outdoor missions
Community-created adventure packs
Multilingual outdoor recommendations
Accessibility-focused adventures
Improved offline map experiences

💚 Final Thoughts

Most AI products are designed to make us spend more time with technology.

I wanted to explore a different possibility:

What if AI could help us disconnect?

TrailMind AI is my attempt to make artificial intelligence a starting point for real-world experiences rather than a destination.

Sometimes the most valuable recommendation an AI can give you is simply:

Put your phone down. Go outside. Discover something new. 🌿

🌐 Live Demo: https://trail-mind-ai-three.vercel.app/

💻 GitHub: https://github.com/SOUMYADEEPDEY1217/TrailMind-AI

Built with curiosity, open innovation, and a love for exploring beyond the screen.

devchallengesvg #hf26challengesvg #opensource #ai