DEV Community: Prathamesh Guram

ContextBridge — Switch AI Models Without Losing Your Context

Prathamesh Guram — Sat, 17 Oct 2026 02:55:50 +0000

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

What I Built

I built ContextBridge, a Chrome extension that helps you switch between AI models without losing the context of your work.

Ever hit a usage limit while working on a project with ChatGPT, only to realize that switching to another AI means explaining everything all over again? ContextBridge solves this by extracting your conversation and using Gemma 3 (4B) to turn it into a structured handoff containing project details, important decisions, constraints, current blockers, and next steps. You can then copy it into another AI and continue where you left off.

Built around open-weight AI running locally through Ollama, ContextBridge is designed for developers, freelancers, students, and researchers who rely on AI for ongoing work.

The business opportunity is simple: people who use AI professionally could pay for a Pro version with saved project context, longer conversation handling, reusable handoff templates, and project workspaces—helping them spend less time repeating themselves and more time getting things done.

Demo

Code

GitHub Repository:

Prathamesh2007-o7 / Context_Bridge

ContextBridge

Carry your working context between AI conversations.

ContextBridge is a Chrome Manifest V3 extension that captures a visible AI conversation, uses a local Ollama model such as Gemma 3 (4B) to create a structured continuation handoff, and lets you edit, copy, or export the result as Markdown.

Features

Capture visible conversation messages from supported ChatGPT, Claude, and Gemini page layouts (best-effort DOM extraction; sites can change their markup).
Review and edit extracted text before it is processed.
Generate a structured handoff covering project state, decisions, constraints, failed attempts, blockers, and next steps.
Run inference against Ollama on your own computer; no ContextBridge cloud backend or remote AI API is used.
Edit the final handoff, copy it to the clipboard, or export a .md file.
Keeps the current session in the popup only; Clear session removes the current text.

Requirements

Google Chrome or another Chromium browser that supports Manifest V3.
…

View on GitHub

How I Built It

I built ContextBridge as a Chrome extension using HTML, CSS, JavaScript, and Chrome's Manifest V3.

At its core is Gemma 3 (4B), an open-weight model running locally through Ollama. The extension captures the conversation from a supported AI website, lets users review the extracted messages, and sends the context to the local model to generate a structured handoff.

Gemma organizes the conversation into key information such as project state, important decisions, constraints, blockers, and next steps. Users can then edit the result, copy it, or export it as Markdown and continue their work with another AI model.

By using local inference instead of a paid cloud AI API, ContextBridge gives users more control over their conversation data while making open-weight AI useful for a practical, everyday problem.

Why Does Open Innovation Matter?

Open innovation made ContextBridge possible without depending on a paid, closed AI API.

By using Gemma 3 (4B) through Ollama, I could run the AI locally, experiment with prompt design, and generate conversation handoffs without sending chat content to a third-party AI inference service. It also means there are no per-request API charges for generating handoffs, although users still need compatible hardware to run the model.

More importantly, open-weight AI makes it easier for developers to build on existing models, customize their behavior, and create tools that solve real problems.

ContextBridge is my attempt to turn that openness into something practical: helping people move between AI tools without repeatedly explaining their work from scratch.

Prize Categories

Best Use of Gemma — Uses Gemma 3 (4B) through Ollama to transform AI conversations into structured, reusable context, helping users switch between AI models without losing track of their work.

TrailWise

Prathamesh Guram — Sat, 10 Oct 2026 10:54:11 +0000

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

What I Built

I built Trailwise, an AI-powered hiking companion designed to help people trade screen time for time outdoors.

Currently focused on hiking destinations across Maharashtra, Trailwise helps users discover trails, check current weather, understand estimated risk levels, and find trail details such as difficulty, distance, and elevation. It also generates a hiking gear checklist using AI and lets users save their experiences in photo albums.

Demo

Code

Prathamesh2007-o7 / trailwise

Trailwise

Find your next good climb.

Trailwise is a hiking companion web app that helps users discover trails across Maharashtra, check weather conditions, assess potential risks, prepare for hikes, and save memories through photo albums.

Features

Trail Discovery — Explore hiking locations with difficulty, distance, elevation, and descriptions.
Live Weather — Check current weather conditions for a trail.
Risk Assessment — View an estimated risk score before your hike.
AI Gear Checklist — Get hiking preparation recommendations powered by Gemma 3 (4B).
Photo Albums — Upload and organize memories from your hikes.

Tech Stack

Frontend: HTML, CSS, JavaScript
Backend: Python, Flask
AI Model: Gemma 3 (4B) via Ollama
Weather: Open-Meteo API
Photo Storage: Local uploads/ directory

Getting Started

Prerequisites

Python 3
Ollama

Installation

Clone the repository

git clone <repository-url>
cd <repository-folder>

Install Python dependencies
```
pip install -r requirements.txt
```
Download the AI model
```
ollama pull gemma3:4b
```
Start…

View on GitHub

How I Built It

Trailwise is built with a Flask backend and an HTML, CSS, and JavaScript frontend.

I integrated Gemma 3 (4B) through Ollama to power the AI-generated hiking gear checklist. The application combines trail information with weather data from Open-Meteo to help users prepare for their hikes. Uploaded photos are stored locally in an uploads/ directory.

Using an open-weight model locally makes AI an integral part of the application while keeping the model deployment under my control.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment, build, and learn without depending entirely on closed AI APIs.

Using Gemma 3 through Ollama gives Trailwise a locally runnable AI component, greater control over deployment, and the freedom to adapt the experience to outdoor planning needs. It also makes the project easier for other developers to explore, modify, and extend.

I want Trailwise to be more than a finished application. I want it to be something the open-source community can improve with better trail data, smarter preparation tools, and more ways to encourage people to get outdoors.

Prize Categories

Best Use of Gemma — Uses Gemma 3 (4B) through Ollama to generate AI-powered hiking gear checklists tailored to outdoor adventures.

VoxBuddy

Prathamesh Guram — Sun, 04 Oct 2026 09:26:59 +0000

What I Built

I built my friend a voice-note assistant that keeps their audio on their laptop
My friend has a habit I think a lot of us have: they record voice notes whenever something comes to mind, then almost never come back to them.
assignments. People to call. Things to buy. Meetings. Random details they know they will forget.

So for this Hacktoberfest weekend, I built VoxBuddy — a small local AI app that turns a messy voice note into a clear summary, actionable tasks, priorities, and important details.

Demo

Code

Prathamesh2007-o7 / voxbuddy

VoxBuddy 🎙️

Turn messy voice notes into things you can act on — privately, with local open AI.

VoxBuddy was built for a friend who records lots of voice notes but rarely revisits them. Instead of sending those recordings to a cloud AI API, VoxBuddy keeps the AI pipeline on the user's machine:

Voice note → Whisper → transcript → Qwen3 → summary + tasks + important details

Why this project exists

A voice note is easy to record and surprisingly easy to forget.

VoxBuddy takes the few seconds your friend already spends speaking and turns them into something actionable:

A short summary
Clear tasks
Priority levels
Deadlines when they were actually mentioned
The original transcript for verification

The goal is not to create another general-purpose chatbot. It is a tiny tool built around one real person's habit.

Why open AI matters here

The most important design choice is that…

View on GitHub

How I Built It

I built VoxBuddy as a local-first AI application using open-source AI models and local inference.

The app starts with a voice note recorded or uploaded through the browser. The audio is sent to a Flask backend, where Whisper runs locally to convert the speech into text. This gives VoxBuddy an accurate transcript without sending the recording to a cloud speech API.

The transcript is then passed to Qwen3 (4B) running locally through Ollama. I prompt the model to turn the unstructured voice note into structured information such as a summary, actionable tasks, priorities, and deadlines. The backend validates the model's response and extracts the JSON before sending the results back to the frontend.

The main flow is:

Voice note → Local Whisper → Transcript → Local Qwen3/Ollama → Structured tasks & summary → Web UI

I used HTML, CSS, and JavaScript for the frontend and Python + Flask for the backend. Everything is designed to run on the user's own laptop once the models and dependencies are installed.

The open-source/local approach is an important part of the project rather than just a technical choice: voice notes can contain personal or sensitive information, so VoxBuddy can process them locally without requiring a third-party AI server. It also means the models can be swapped, modified, or upgraded without redesigning the entire application.

Why Does Open Innovation Matter?

Privacy: Voice notes can contain personal information, and VoxBuddy processes them locally instead of sending them to a cloud AI service.
Offline use: After setup, the core AI processing can run without an internet connection.
No per-request API costs: Local inference avoids ongoing cloud API charges.
Model freedom: I can swap or experiment with different open models instead of being locked into one provider.
Control: I can change the prompts, processing pipeline, and application behavior to fit the user's needs.

Prize Categories

Overall Winner