DEV Community: Bharat Bhagat

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! 🎵