This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
Simplify AI — An Open-Model Study Buddy Built for a Friend
Sometimes the problem is not that a topic is difficult.
The problem is that the explanation is difficult.
A friend of mine often needs programming and college topics explained in a simpler way, especially before exams. Instead of sending long notes or complicated definitions every time, I decided to build something that could explain concepts the way a helpful friend would.
That became Simplify AI.
What I Built
Simplify AI is an open-model study companion that turns difficult topics into simple, exam-friendly explanations.
The user can choose:
- Beginner / Normal / Exam Tomorrow
- English / Hinglish
- Explain
- Short Notes
- Quiz
- Viva
The goal is to make studying faster and less overwhelming.
One feature I especially like is Exam Tomorrow mode, which focuses on must-know concepts, common mistakes, and quick revision instead of giving a long textbook-style explanation.
The Hinglish mode is also useful because sometimes a concept becomes much easier when it is explained in the same language we naturally use while studying with friends.
Demo
Live Demo:
https://simplify-ai-beige.vercel.app/
Example prompt:
Explain binary search in simple Hinglish with one example and 3 viva questions.
Simplify AI can then return:
- a simple explanation
- step-by-step logic
- an example
- time complexity
- viva questions
- quick revision questions
Code
GitHub Repository:
https://github.com/prince-kr-gupta/simplify-ai
How I Built It
The project has a simple architecture:
React Frontend
↓
Node.js + Express Backend
↓
Hugging Face Inference Providers
↓
Open-weight LLM
↓
Simplified Study Response
Frontend
The frontend is built with:
- React
- Vite
- React Markdown
React Markdown is used so that AI-generated headings, lists, code blocks, and tables are displayed properly instead of showing raw Markdown syntax.
Backend
The backend is built with:
- Node.js
- Express
The frontend sends:
- topic
- difficulty level
- language
- study mode
to the backend.
The backend then builds a study-focused prompt and sends it to the model.
Open-Weight AI
For the current version, Simplify AI uses:
OpenAI GPT-OSS 120B
through Hugging Face Inference Providers.
The model powers the core functionality of the app, so the project is built around open-weight AI rather than using AI only as an extra feature.
I intentionally kept the model integration flexible so that the model can be changed later without rebuilding the entire frontend.
Challenges I Faced
The project looked simple at first, but I ran into several issues while building it.
Model Provider Compatibility
One of the biggest problems was getting hosted open-model inference working properly.
At one point I received this error:
model_not_supported
The model I initially selected was not supported by any provider enabled for my Hugging Face account.
I had to understand how Hugging Face Inference Providers route requests and then switch to a compatible open-weight model.
Authentication
I also had to correctly configure the Hugging Face access token and keep it only on the backend using environment variables.
This was important because I did not want the API token exposed in the frontend.
Deployment
The backend was deployed separately on Render, while the frontend was deployed on Vercel.
The frontend communicates with the deployed backend through an environment variable.
Markdown Rendering
The model generated good structured responses, but initially the website displayed raw syntax like:
**bold**
### headings
I fixed that by adding React Markdown so the final response looks much cleaner and easier to read.
Why Does Open Innovation Matter?
Open innovation matters for Simplify AI because I do not want the project to be permanently locked to one closed model provider.
Using an open-weight model gives me more freedom.
It allows me to:
- switch between models
- experiment with different model sizes
- self-host models in the future
- potentially run smaller models locally
- customize model behavior
- reduce dependence on a single proprietary API
For a study tool, this is especially interesting.
In the future, a smaller model could potentially run locally on a student's laptop so their study notes do not need to leave their own device.
That would make the project more private, flexible, and accessible.
Why I Built It for a Friend
This project was inspired by a real situation.
Sometimes before an exam, a friend does not need a huge explanation.
They just need someone to say:
This is the main idea. This is the example. These are the mistakes to avoid.
That is the experience I tried to recreate with Simplify AI.
The goal was not to build the biggest AI project.
The goal was to build something small that could actually help someone I know.
Tech Stack
- React
- Vite
- React Markdown
- Node.js
- Express
- Hugging Face Inference Providers
- OpenAI GPT-OSS 120B
- Render
- Vercel
- GitHub
Prize Categories
Best Use of Render
The Node.js and Express backend is deployed on Render and handles the AI inference requests.
What's Next?
If I continue building Simplify AI, I would like to add:
- PDF and notes upload
- saved study sessions
- conversation history
- personalized learning levels
- subject-specific prompts
- local model support with Ollama
- offline/private study mode
- better quiz tracking
I would also like to test multiple open models and compare how well they explain educational topics.
Final Thoughts
Simplify AI started with a simple idea:
What if difficult topics could just be explained the way a helpful friend would explain them?
That is what I tried to build this weekend.
Live Demo:
https://simplify-ai-beige.vercel.app/
GitHub:
https://github.com/prince-kr-gupta/simplify-ai
Top comments (1)
Nice