This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
What I Built
I built CircuitMate — an AI lab partner for Electronics & Communication Engineering (ECE) students.
I built it for a friend who is studying ECE and spends a lot of time working through lecture notes, PDFs, engineering concepts, numerical problems, and exam preparation.
The problem was simple:
When you're stuck on a topic, a normal AI chatbot can give you an answer — but that answer might not be based on the material you're actually studying.
You end up switching between:
- lecture PDFs
- YouTube
- AI chatbots
- formulas
- and your own notes
I wanted to make that workflow much simpler.
So CircuitMate starts with the material the student is already studying.
Upload your ECE notes, and CircuitMate lets you:
- Ask My Notes — ask questions about your uploaded material
- Explain Concept — break difficult concepts into clearer explanations
- Solve Problem — work through engineering problems step by step
- Exam Simulator — practice questions and get evaluated
The important part is that CircuitMate keeps the student's own material at the center of the experience.
For example, I can upload a Network Theory PDF and ask:
What is maximum power transfer?
CircuitMate answers the question from the uploaded study material and shows the pages used to produce the answer.
So the workflow becomes:
Upload notes → Ask → Understand → Solve → Practice
Instead of:
Search → Compare → Switch tabs → Find the right explanation → Go back to the notes.
Demo
Live app:
https://circuitmate-theta.vercel.app
Demo video:
https://drive.google.com/file/d/1DmvnKhvvqn-BTRlCncO0kckSiWiVosCl/view?usp=sharing
The demo shows the complete workflow:
- Uploading an ECE lecture PDF
- Extracting and indexing the study material
- Asking a question about the notes
- Getting an answer with page-level sources
- Using Explain Concept
- Working through a problem with Solve Problem
- Practicing with the Exam Simulator
The uploaded Network Theory material in the demo contains 46 pages and 51 indexed sections.
Code
CircuitMate is open source.
GitHub:
https://github.com/Yasir761/circuitmate
The application is split into a frontend and backend.
The frontend provides the study workspace and different learning modes.
The backend handles:
- PDF extraction
- document chunking
- retrieval
- prompt construction
- Gemma inference
- chat history
- exam generation and evaluation
The goal was to keep the core workflow understandable rather than hiding everything behind a single AI API call.
How I Built It
CircuitMate is built around Gemma, Google's open-weight model.
The basic flow is:
ECE PDF
↓
Text extraction
↓
Chunking
↓
Retrieval
↓
Relevant study material
↓
Gemma
↓
Grounded answer
↓
Source pages
For document processing, CircuitMate extracts text from uploaded PDFs and divides the material into smaller sections that can be retrieved when a student asks a question.
The retrieved material is then provided to Gemma along with instructions about how CircuitMate should behave.
This allows the same model to support different study workflows.
Ask My Notes
Answer questions using the uploaded material and show relevant source pages.
Explain Concept
Turn a concept from the material into a clearer explanation, with intuition, equations, and an exam-friendly explanation where appropriate.
Solve Problem
Break an engineering problem into structured steps such as the problem statement, given values, approach, solution, and result.
CircuitMate is also deliberately instructed not to silently invent missing information.
If the uploaded material doesn't contain enough information to solve something, it should say that rather than pretending that the missing information exists.
Exam Simulator
Generate questions from the student's study material and evaluate the student's answer against the same material.
The backend is built with Python and FastAPI.
The frontend is built with Next.js and TypeScript.
MongoDB is used for application and session data.
The frontend is deployed on Vercel, while the backend is deployed on Render.
Why Does Open Innovation Matter?
For me, the biggest reason to use an open-weight model was control and replaceability.
I didn't want CircuitMate to be designed around the assumption that one closed model had to power the entire product forever.
I used Gemma, Google's open-weight model, for the generation layer.
That gives me more freedom to experiment with how the model is used, how the prompts and retrieval workflow are designed, and how the application can evolve.
That matters for an education product.
The retrieval layer, the prompts, the document processing, and the model should all be things I can change and experiment with.
It also makes future directions possible, such as experimenting with different open-weight models, local inference, fine-tuning, or adapting the model specifically for engineering education.
For this weekend project, I chose to serve Gemma through a hosted API instead of running inference locally.
That was a deliberate trade-off.
My laptop has limited GPU memory, and I wanted to spend the challenge building the actual student experience rather than spending the entire weekend optimizing local inference.
So CircuitMate isn't claiming to be a completely local or private AI tutor today.
Instead, the project is built around an open-weight model and keeps the model layer replaceable.
That's the part of open innovation that mattered most to me.
My Agent Session
I didn't use a separate agent-session workflow as part of the final product, so I'm leaving this section out rather than adding something that doesn't represent how CircuitMate was actually built.
Prize Categories
I'm entering CircuitMate for:
Best Use of Gemma
CircuitMate uses Gemma as the core generation model behind its ECE study workflows.
The model receives relevant material retrieved from the student's uploaded notes and turns it into grounded explanations, problem-solving responses, and exam evaluations.
Best Use of Render
The CircuitMate backend is deployed on Render, which runs the FastAPI application responsible for document processing, retrieval, Gemma inference, and the application's backend workflow.
Building for a Friend
The most important part of this challenge for me wasn't choosing the technology.
It was choosing the person.
Instead of starting with:
"What AI app can I build?"
I started with:
"What would actually make studying ECE easier for someone I know?"
That led me away from building another general-purpose chatbot.
I ended up building something much narrower:
an AI lab partner that works around the material an ECE student is already studying.
That constraint shaped almost every product decision.
The interface became simpler.
The AI needed to be grounded.
Source pages became important.
Problem solving needed structure.
And an exam mode made more sense than adding another generic chatbot feature.
What I Learned
The biggest lesson from building CircuitMate was that a narrower problem can make an AI product much more useful.
"AI tutor" is vague.
"An AI lab partner that helps an ECE student study from their own notes" is much more concrete.
It also changed how I thought about the engineering.
I didn't need to build a huge agent framework.
I needed:
- useful document extraction
- retrieval
- grounded prompts
- source references
- structured problem solving
- an exam workflow
- and an interface that gets out of the student's way
There are still plenty of things I want to improve.
For example:
- better retrieval for diagrams and mathematical notation
- better numerical problem solving
- more robust handling of scanned PDFs
- persistent document indexing
- more ECE-specific workflows
- support for additional open-weight models
- eventually supporting local inference
But for this challenge, I wanted to build something small enough to finish and useful enough to actually hand to someone.
Final Thought
I started with a simple question:
What if studying from a long engineering PDF felt less like searching through a document and more like having a lab partner sitting next to you?
That's CircuitMate.
Your AI lab partner for ECE.
Top comments (0)