DEV Community: Bharat Bhagat

GHOSTBYTE 👻 — A Little Memory. An Endless Afterlife.

Bharat Bhagat — Thu, 29 Oct 2026 05:13:55 +0000

GHOSTBYTE 👻 — A Little Memory. An Endless Afterlife.

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

What I Built

GHOSTBYTE is a local-first, AI-powered memory archive that gives forgotten memories a second life.

What if the memories we save could tell us stories we never imagined?

Inspired by Halloween, Día de los Muertos, and the stories we carry about people and places from our past, I built GHOSTBYTE to preserve personal memories and transform them into something new.

GHOSTBYTE lets users:

👻 Preserve Memories: Save personal stories, important moments, people, places, and details in a persistent archive.
🔎 Ask the Archive: Ask questions about saved memories and explore fragments of the past with local AI.
🕯️ Generate Ghost Stories: Transform selected memories into eerie, melancholic, supernatural, or psychological horror fiction.
🗄️ Keep Memories Persistent: Store memories and generated stories in Microsoft SQL Server.
🔒 Keep Data Local: Run AI inference on your own computer instead of sending personal stories to a hosted AI API.

The idea behind GHOSTBYTE is simple: our memories deserve a place that doesn't depend on a third-party AI service staying online.

Some memories fade. Others become part of the machine.

Demo

Run GHOSTBYTE locally:

Install Node.js, Microsoft SQL Server, and Ollama.
Download the model using ollama pull qwen2.5:1.5b.
Configure the database connection in your .env file.
Start the application with npm start.
Open http://127.0.0.1:3000.

The application runs locally, and the AI uses your local Ollama installation.

Demo Image:

GHOSTBYTE is currently designed to run locally.

Code

GitHub repository: https://github.com/Bharatefb/Ghost-Byte-AI.git

The project uses a straightforward architecture:

public/ — HTML, CSS, and browser JavaScript.
server.js — Node.js and Express backend.
database/schema.sql — SQL Server database schema.
.env — Local configuration for the database and Ollama.
Ollama — Local inference using Qwen2.5 1.5B.

The code is designed to keep the application understandable and extensible, without requiring a hosted AI API.

How I Built It

GHOSTBYTE combines traditional web technologies with open-weight AI running locally.

Technology stack:

Frontend: HTML, CSS, and vanilla JavaScript.
Backend: Node.js and Express.
AI model: Qwen2.5 1.5B through Ollama.
Database: Microsoft SQL Server.
Inference: Local model execution through the Ollama API.

The frontend lets users create and explore memories, ask questions, and generate stories. Express handles API requests and communicates with SQL Server and Ollama.

SQL Server provides persistent storage for personal memories and generated fiction. Ollama runs Qwen2.5 1.5B locally, allowing the application to generate responses without relying on a hosted AI inference API.

I initially planned to use Qwen 3.5 2B, but I switched to Qwen2.5 1.5B to improve responsiveness on my development machine. This also made model selection an important part of the project: the model can be changed to suit the hardware and desired performance.

After the initial installation, model download, and dependency setup, the core application can work offline, provided the database, application server, and local model are running.

Why Does Open Innovation Matter?

Personal memories are among the most private things we have.

I didn't want GHOSTBYTE to require uploading family stories, personal experiences, or sensitive details to a remote AI provider just to explore them.

Using an open-weight model through Ollama makes local inference possible. Memories stay in the locally configured SQL Server database, and AI requests are sent to the local Ollama service rather than a hosted AI API.

Open innovation makes several things possible:

Privacy and control: Personal stories can remain on a computer controlled by the user.
Offline capability: Once dependencies and the model are installed, core features can work without internet access.
Model flexibility: Developers can experiment with different compatible local models and adjust prompts to change the experience.
No hosted AI request fees: Local inference avoids per-request charges from a hosted AI provider, although running the computer still consumes resources.
Long-term independence: The project does not depend on one proprietary AI API being available forever.

For a project about preserving memories, this independence matters. A private archive should remain useful even when a cloud service changes its pricing, access rules, or availability.

Open AI makes GHOSTBYTE more than a storytelling interface. It makes a locally controlled memory archive possible.

The Spirit of It

Imagine saving a memory about your grandmother's old house.

Years later, you open GHOSTBYTE and ask what you remember about that place. The archive helps you revisit the details you preserved. Then you select that memory, choose Eerie and atmospheric, and ask the machine to turn it into a ghost story.

The resulting story might describe a hallway clock stopping at midnight or footsteps echoing through an empty room.

Those supernatural details are fiction, not recovered facts. The real memory remains yours; the machine simply gives it another form.

That is the spirit of GHOSTBYTE: preserving the past while letting imagination wander through it.

A little memory. An endless afterlife. 👻

Built with Node.js, Microsoft SQL Server, Ollama, and Qwen2.5 1.5B.

Some memories fade. Others become part of the machine.

LazyRead AI: Your Webpage, Simplified with Local AI 🦥

Bharat Bhagat — Sun, 25 Oct 2026 13:39:00 +0000

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

LazyRead AI: Your Webpage, Simplified with Local AI 🦥
What I Built

Meet LazyRead AI — a browser extension that helps you understand webpages without reading every single word.

We all open articles, tutorials, documentation, and blogs intending to read them carefully. Then we see a wall of text, scroll endlessly, and sometimes give up before finding the information we need.

LazyRead AI makes that easier.

With one click, it reads the current webpage and generates a concise summary, key takeaways, important facts, and actionable points using a locally running AI model.

Instead of spending 10 minutes reading a long article to understand its main idea, you can start with a quick summary and decide what deserves your attention.

The goal is simple: less scrolling, less effort, and more understanding.

Features
✨ One-click summaries: Get the main idea of the current webpage.
🎯 Key takeaways: See the most important points at a glance.
📌 Important facts: Identify useful facts, dates, and details.
⚡ Local AI inference: Generate summaries using Ollama and Qwen 3.5:2B.
🔒 Privacy-focused: Webpage content is processed by your local backend and model instead of being sent to a hosted AI summarization API.
🦥 Built for doing less: Spend less time reading and more time using what you learn.
Demo

GitHub repository: https://github.com/Bharatefb/LazyRead-AI

LazyRead AI runs as a Chrome extension connected to a local FastAPI backend and Ollama.

To demonstrate it, open a long article, click the LazyRead AI extension, and select Summarize this page. The extension displays the summary and key points in its popup.

Demo video or screenshots:

Code

Explore the complete project here:

🚀 LazyRead AI on GitHub

The project combines a browser extension frontend with a Python backend and a locally running language model.

The main components are:

Chrome Extension: HTML, CSS, and JavaScript for extracting webpage content and displaying results.
Backend: FastAPI receives the extracted webpage text and coordinates summarization requests.
AI Inference: Ollama runs Qwen 3.5:2B locally and generates the summary.
Response Processing: Python parses the model's output into structured JSON that the extension can display.
How I Built It

I built LazyRead AI using a straightforward architecture designed to keep the AI processing local.

Tech stack:

Qwen 3.5:2B: The open-weight language model used to summarize webpages.
Ollama: Runs the model locally and provides an API for inference.
FastAPI: Handles requests from the browser extension and communicates with Ollama.
HTML, CSS, and JavaScript: Power the extension's user interface and webpage text extraction.
Chrome Extension Manifest V3: Connects the popup interface to the active webpage and local backend.
How it works
The user opens a webpage and clicks the LazyRead AI extension.
JavaScript extracts the page title, URL, and readable text.
The extension sends the extracted content to the local FastAPI server.
FastAPI forwards a concise summarization prompt to Qwen 3.5:2B through Ollama.
The model generates a structured response containing the summary, key points, important facts, and action items.
FastAPI returns the result, and the extension displays it in a clean, readable interface.

One challenge was handling incomplete JSON responses and slow model inference. I improved the backend's timeout handling, limited the amount of webpage text sent to the model, and added response validation and error handling.

That debugging process helped make the extension more reliable and its failure modes easier to understand.

Why Does Open Innovation Matter?

For LazyRead AI, open innovation is what makes the project possible.

I wanted to build a useful AI tool without making every webpage depend on a paid, remotely hosted AI API.

Using an open-weight model with Ollama gives me control over where inference happens, which model I use, and how the summarization process works.

Your content stays under your control

Webpages are processed by a local FastAPI backend and a local Ollama instance. The project does not need to send webpage content to a third-party AI inference API.

That matters when summarizing internal documentation, personal research, or content users prefer not to share with an external service. The extension still needs local services to be configured correctly, and other browser or network activity is outside this guarantee.

No per-summary AI API bill

Once the model has been downloaded, local inference does not require a paid hosted-model API for each summary. Users still need a compatible computer, and local inference consumes computing resources and electricity.

Freedom to experiment

I can change prompts, adjust output limits, modify the response format, and experiment with other compatible models without rebuilding the entire application around a single closed provider.

Offline potential

After the model and dependencies are installed, the summarization pipeline can operate without an internet connection, provided the local services are running and the webpage content is already accessible. Downloading the model and installing dependencies initially requires connectivity.

Learning by building

Open tools let me inspect the complete request flow, debug inference problems, and understand how the model responds. Instead of treating AI as a black box behind an API, I can improve the system at every layer.

For this project, open innovation means ownership, flexibility, and the freedom to build an AI tool around the user's needs rather than a provider's limitations.

My Agent Session

LazyRead AI currently uses a direct FastAPI-to-Ollama inference pipeline rather than a dedicated autonomous agent framework.

I haven't included a DevRelay agent session in this submission. If I record one, I'll add the session link here.

The Lazy Payoff 🦥

The biggest benefit is that users no longer need to read an entire article before deciding whether it is worth their time.

LazyRead AI gives them a quick overview first, helping them decide what to read deeply, what to save for later, and what they already understand.

I built this project around a simple idea:

AI should take the repetitive work off our hands, not make us work harder to use it.

The project is an early version, and I still want to improve summary quality, response speed, and support for different kinds of webpages.

For now, the goal is to make everyday reading a little less exhausting — one click at a time.

Prize Categories

Select the applicable partner categories listed on the official challenge page before publishing. I haven't selected any specific partner categories because the current category list hasn't been verified.

Built with curiosity, open-source tools, and a little sloth energy. 🦥💜

Repository: https://github.com/Bharatefb/LazyRead-AI

Hacktoberfest #OpenSource #AI #Ollama #Qwen #FastAPI #ChromeExtension #LocalAI #BuildInPublic

PageCraftGenie AI: Turn Any Webpage into Documents and Visual Assets with Local AI ✨

Bharat Bhagat — Fri, 16 Oct 2026 07:24:05 +0000

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

PageCraftGenie AI: Turn Any Webpage into Documents and Visual Assets with Local AI ✨
What I Built

PageCraftGenie AI is an AI-powered browser extension that transforms the content of the current webpage into useful digital documents and visual assets.

Have you ever found a useful webpage and wished you could instantly turn its information into a professional report, spreadsheet, presentation, or image? That's the problem I wanted to solve.

With PageCraftGenie AI, users can open any webpage, capture the page or screen, choose the output they need, and let AI handle the content transformation.

It supports generating:

Word documents for editable notes, summaries, and reports.
Excel spreadsheets for organizing information into structured data.
PowerPoint presentations for turning webpage content into presentation-ready material.
PDF reports for sharing and saving information.
Images and visual assets for creative and visual content generation.

The goal is to reduce the time and effort required to manually copy, organize, format, and transform information from websites.

Who is it for?

PageCraftGenie AI can be useful for students, researchers, developers, content creators, freelancers, and professionals who regularly work with online information.

For example, a student could turn educational content into study notes, a researcher could convert information into a report, or a freelancer could transform webpage content into a client-ready document.

As a potential side hustle, the project could evolve into a productivity tool for individuals and businesses that need faster document creation and content processing.

Demo

The demo showcases the workflow:

Open a webpage in the browser.
Capture the webpage content or screen.
Select the desired output format.
Let the AI process the content.
Download the generated document or visual asset.
Code

💻 GitHub Repository: https://github.com/Bharatefb/PageCraftGenie-AI

Explore the source code, review the implementation, and contribute ideas or improvements.

The project brings together a browser extension, a backend API, and locally running AI models to make webpage-to-content generation possible.

How I Built It

I built PageCraftGenie AI by combining browser-based content capture, a Python backend, and open-weight language models running locally.

Technology Stack
Browser Extension: Captures webpage content and screen information and lets users select their desired output.
Python and FastAPI: Provides the backend API and handles generation requests.
Ollama: Runs open-weight AI models locally.
Qwen 2.5 1.5B: Used for generating structured content from prompts.
Document and Image Generation: The backend processes the model's output into downloadable files, including PDFs and PNG images, with support for additional document formats.
How it works
Capture: The extension gathers the relevant webpage content or screenshot.
Understand: The backend prepares a prompt containing the user's request and available page information.
Generate: The request is sent to a locally running Ollama model.
Transform: The generated content is processed into the requested document or visual output.
Download: The user receives a generated file through the application.

During development, I tested the backend with Uvicorn and verified requests to the generation API, including successful PDF and PNG downloads.

One of my main goals was to explore how a small, locally running model can power a practical AI productivity tool without depending entirely on paid, hosted model APIs.

Why Does Open Innovation Matter?

Open innovation is essential to a project like PageCraftGenie AI because it makes experimentation with AI more accessible.

By using Ollama and open-weight models, I can experiment with different models, test prompts, adjust the generation workflow, and build around my own requirements.

This approach offers several advantages:

Local inference: Run supported models on your own machine instead of sending every generation request to a hosted AI provider.
Greater control: Choose and switch between available models based on performance, quality, and hardware requirements.
Lower experimentation costs: Avoid per-request charges from hosted model APIs when running models locally, although local hardware and electricity still have costs.
Privacy-conscious design: Local inference can reduce external data sharing, provided the rest of the application also keeps webpage content and generated files local.
Community-driven development: Open-source tools make it easier for developers to inspect the implementation, report issues, contribute improvements, and build new features.

For me, open innovation is not just about using open-source software. It is about making AI capabilities more accessible and giving developers the freedom to build useful products on top of them.

My Agent Session

I would use this section to show how I developed the project, experimented with local AI models, debugged the generation pipeline, and connected the AI backend to the browser extension.

Prize Categories

[Add the applicable partner prize categories from the official challenge page, or remove this section if none apply.]

What's Next?

I want to continue improving PageCraftGenie AI by exploring:

Better extraction of meaningful content from complex webpages.
More reliable document formatting and structured spreadsheet generation.
Improved visual generation workflows.
Support for additional local AI models.
A smoother user experience for switching between output formats.
Better error handling and generation quality.

My long-term vision is to make PageCraftGenie AI a practical AI-powered productivity assistant that helps people transform information they find online into something they can immediately use.

Building this project has been an opportunity to explore the potential of open-weight AI models and turn them into a real-world tool.

I'd love to hear your feedback! What webpage-to-document or webpage-to-visual feature would you find most useful?

Thanks for reading! 🚀

🌱 TouchGrass-AI: Your Local AI Guide to Get Outside

Bharat Bhagat — Wed, 07 Oct 2026 10:56:13 +0000

🌱 TouchGrass-AI: Your Local AI Guide to Get Outside

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

What I Built

TouchGrass-AI is a local-first AI outdoor activity guide designed to help people spend less time on their screens and more time outside.

The idea is simple:

Tell the AI where you are, what you want to do, and how much time you have — then go touch some grass. 🌱

A user provides:

📍 Their general area

🌳 The outdoor activity they want to do

⏱ How much time they have

💪 Their fitness/experience level

✨ Their preferences

⚠️ Any constraints

TouchGrass-AI then generates a personalized outdoor plan containing:

An activity recommendation

Difficulty level

Suggested duration

Best time of day

A step-by-step activity plan

Things to bring

Safety considerations

A small "Touch Grass Challenge"

An offline tip so the user can put their phone away

The project is aimed at people who want to explore their surroundings but don't know what outdoor activity to do or how to start.

The most important UX principle is:

The screen should be the shortest part of the experience.

The user gets their plan, reads it, puts their phone away, and goes outside.

Demo
Local Demo

The application runs locally at:

http://127.0.0.1:8000

Demo Flow
Enter location
↓
Choose outdoor activity
↓
Set available time
↓
Set fitness level
↓
Add preferences
↓
TouchGrass-AI generates a plan
↓
Read the plan
↓
Put the phone away 📵
↓
GO OUTSIDE 🌱

Example

Input:

Location: Bandra, Mumbai
Activity: Walking
Time: 1-2 hours
Experience: Beginner
Preferences: Photography and quiet places
Constraints: Avoid steep climbs

TouchGrass-AI generates a personalized walking experience with a practical plan, preparation checklist, safety suggestions, and a small outdoor challenge.

Code
🌱 GitHub Repository

Repository:
https://github.com/Bharatefb/TouchGrass-AI

The complete source code is available on GitHub:

https://github.com/Bharatefb/TouchGrass-AI

The project is built as a simple local-first application:

TouchGrass-AI/
│
├── app/
│ ├── init.py
│ ├── main.py
│ └── prompts.py
│
├── static/
│ ├── index.html
│ ├── style.css
│ └── app.js
│
├── requirements.txt
└── README.md

Architecture
┌─────────────────────────────┐
│ HTML + JavaScript │
│ Frontend │
└──────────────┬──────────────┘
│
│ POST /api/guide
▼
┌─────────────────────────────┐
│ FastAPI │
│ Python Backend │
└──────────────┬──────────────┘
│
│ localhost
▼
┌─────────────────────────────┐
│ Ollama │
│ Local AI Runtime │
└──────────────┬──────────────┘
│
▼
┌─────────────────────────────┐
│ gemma4:e2b │
│ Local AI Model │
└──────────────┬──────────────┘
│
▼
Personalized Guide
│
▼
🌱 OUTSIDE

The code is intentionally simple so that someone can clone the project, install Ollama, download the model, and run the entire application locally.

How I Built It

TouchGrass-AI uses Ollama for local model execution and the open-weight Gemma model gemma4:e2b as the AI engine.

The backend is built with Python and FastAPI.

The frontend uses:

HTML

CSS

Vanilla JavaScript

There is no React and no cloud AI API required.

When the user submits the form, the browser sends the information to the FastAPI backend:

Browser
↓
POST /api/guide
↓
FastAPI
↓
Prompt construction
↓
Ollama
↓
gemma4:e2b
↓
Structured JSON
↓
FastAPI
↓
Browser

The model is instructed to return structured JSON containing the activity, plan, preparation checklist, safety information, and the final "Touch Grass Challenge".

I also added response parsing and validation so that the backend can handle cases where the model accidentally returns JSON wrapped in markdown.

Local AI

The model runs through:

http://localhost:11434

The application communicates with Ollama locally instead of sending the user's request to a hosted LLM API.

To run the project:

git clone https://github.com/Bharatefb/TouchGrass-AI.git

cd TouchGrass-AI

python -m venv venv

venv\Scripts\activate

pip install -r requirements.txt

ollama pull gemma4:e2b

uvicorn app.main:app --reload

Then open:

http://127.0.0.1:8000

Why Does Open Innovation Matter?

For TouchGrass-AI, local and open AI isn't just a technical choice — it is part of the product idea.

The application asks for information that can be personal, such as someone's location, preferences, fitness level, and outdoor habits.

Instead of requiring that information to be sent to a proprietary AI service, TouchGrass-AI can process the AI request locally through Ollama.

That gives the project several advantages.

🔒 Privacy

The AI inference happens locally.

The user's request goes from:

TouchGrass-AI → localhost → Ollama → Local Model

rather than requiring a cloud AI API.

For an application involving location and personal preferences, keeping this information on the user's machine can be a meaningful advantage.

🧩 Model Flexibility

Because the application communicates with Ollama, the AI model can potentially be changed without rebuilding the entire application.

The architecture separates:

Application
↓
AI Runtime
↓
Model

This means the project isn't fundamentally tied to one proprietary AI provider.

💻 Local-First Experience

A major goal of the challenge is getting people outside.

Ironically, an AI outdoor application shouldn't require a permanent cloud connection just to generate a simple activity plan.

Running the model locally makes a local-first experience possible.

🛠 Open Development

Using open AI infrastructure also makes the project easier to experiment with.

Developers can modify:

The system prompt

The model

The application logic

The response format

The frontend

The safety rules

The activity recommendation strategy

without having to rebuild the entire product around a closed AI API.

My Agent Session

I built TouchGrass-AI as a local AI application and iterated on the architecture, prompt design, JSON response format, and user experience.

Agent session:

Prize Categories
Open-Source AI / Local AI

TouchGrass-AI is built around local AI inference using:

Ollama

Gemma open-weight model

FastAPI

HTML/CSS/JavaScript

Touch Grass Theme

The entire product is designed around the theme:

Use AI to spend less time using AI.

The AI creates the plan.

Then the user closes the screen and goes outside.

🌱 Plan less. Explore more. Touch grass.

AI-Lyrics-Generator

Bharat Bhagat — Sun, 04 Oct 2026 17:03:25 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built AI Lyrics Generator, a local AI-powered web application that helps a friend turn an idea, topic, or feeling into an original song.

The goal was simple: instead of struggling with a blank page or needing access to a paid AI service, my friend can enter a few details such as:

🎵 Song name or topic

🎸 Genre

😊 Mood

🌍 Language

📝 Number of verses

The application then generates an original song structure with sections such as verses, chorus, bridge, and final chorus.

The project runs locally using Qwen2.5-Coder 3B through Ollama, with a FastAPI backend and a lightweight HTML/CSS/JavaScript frontend.

The main problem I'm solving is making AI-assisted songwriting simple, accessible, and local.

Demo

🎥 Demo Video: Coming soon

🌐 Live Demo: Coming soon

The application can be run locally with Ollama, so users don't need a cloud AI API to generate lyrics.

Code
GitHub Repository

AI-Lyrics-Generator

https://github.com/Bharatefb/AI-Lyrics-Generator

The repository contains the complete frontend, FastAPI backend, prompt logic, and setup instructions.

Project Architecture
┌─────────────────────┐
│ Browser │
│ │
│ Song / Topic │
│ Genre │
│ Mood │
│ Language │
│ Verse Count │
└──────────┬──────────┘
│
HTTP POST
│
▼
┌─────────────────────┐
│ FastAPI │
│ │
│ /generate │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Ollama │
│ │
│ qwen2.5-coder:3b │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Generated Lyrics │
└──────────┬──────────┘
│
▼
┌─────────────────────┐
│ Browser │
│ │
│ [Verse 1] │
│ [Chorus] │
│ [Verse 2] │
│ [Bridge] │
│ [Final Chorus] │
└─────────────────────┘

How I Built It

The project is built around open-weight AI and local inference.

AI Model

I use:

Qwen2.5-Coder 3B

through:

Ollama

The model runs locally on the user's machine rather than requiring a remote AI API.

Backend

The backend is written in:

Python

FastAPI

Pydantic

Requests

Uvicorn

The frontend sends the user's song requirements to the FastAPI /generate endpoint.

FastAPI then builds a structured prompt and sends it to the local Ollama API.

Browser
↓
POST /generate
↓
FastAPI
↓
Ollama
↓
qwen2.5-coder:3b
↓
Generated lyrics
↓
Browser

Frontend

The frontend uses standard web technologies:

HTML

CSS

JavaScript

No large frontend framework is required, keeping the project simple and easy to understand.

Prompt Design

Instead of simply asking the model:

Write a song about summer.

the application provides structured information:

Song/topic: Summer Love
Genre: Pop
Mood: Happy
Language: English
Number of verses: 3

The model is instructed to create completely original lyrics and organize them into a recognizable song structure.

For example:

[Verse 1]

...

[Pre-Chorus]

...

[Chorus]

...

[Verse 2]

...

[Bridge]

...

[Final Chorus]

...

Local AI

One of the key parts of the project is that the AI inference happens locally.

After installing Ollama and the model:

ollama pull qwen2.5-coder:3b

the application can communicate with the local Ollama API.

This means the basic application does not require an OpenAI, Anthropic, Gemini, or other paid cloud AI API.

Why Does Open Innovation Matter?

Open innovation made this project possible because I could build around an openly available model and run inference locally.

A closed AI API would certainly make the implementation possible, but local open-weight inference gives the project some important advantages.

🔒 More control

The user controls where the model runs and how the application communicates with it.

💻 Local-first development

The project can be developed and tested without requiring a cloud AI account or API key.

💰 Lower barrier to experimentation

Anyone with suitable hardware can experiment with the application without paying for every generated song.

🧑‍💻 Learning and customization

Because the application controls the prompt, backend, frontend, and model connection, developers can modify the entire pipeline.

They can experiment with:

Prompt engineering

Different models

Temperature settings

Song structures

Languages

Genres

UI features

Local AI workflows

🌍 Open innovation encourages experimentation

The most interesting part for me is that the AI is not treated as a black box.

The project connects an open model, local inference, a Python backend, and a web interface into one small application.

That makes it easier to learn how AI applications actually work from end to end.

My Agent Session

I did not use DevRelay for this project.

Prize Categories

The project is primarily entering the categories related to:

🤖 Open-source AI / open-weight models

🖥️ Local AI / local inference

🧑‍💻 Developer tools and AI applications

Project Stack
AI Model → Qwen2.5-Coder 3B
Inference → Ollama
Backend → Python + FastAPI
Frontend → HTML + CSS + JavaScript
API → REST / JSON
Runtime → Local machine

Running the Project Locally

Clone the repository:

git clone https://github.com/Bharatefb/AI-Lyrics-Generator.git
cd AI-Lyrics-Generator

Install and run the Qwen model:

ollama pull qwen2.5-coder:3b

Set up the backend:

cd backend

python -m venv venv

On Windows:

venv\Scripts\activate

On macOS/Linux:

source venv/bin/activate

Install dependencies:

pip install -r requirements.txt

Start FastAPI:

uvicorn main:app --reload --port 8000

Then open the frontend using a local development server such as VS Code Live Server.

What's Next?

I plan to continue improving the project with features such as:

🔄 Generate Again

📋 Copy Lyrics

💾 Download Lyrics

📝 Edit generated lyrics

📚 Song history

🌍 Better multilingual support

🎤 More vocal and writing controls

🎶 Custom verse/chorus structures

🎨 Improved UI

🌙 Dark/light mode

⚡ Streaming generation

The long-term goal is to make AI-assisted songwriting a simple local-first experience that anyone can experiment with.

Built with ❤️, open-source AI, and a little musical inspiration.

Thanks for checking out AI-Lyrics-Generator! 🎵