# Studymat

> Source: <https://dev.to/chanveer_singh/studymat-1b40>
> Published: 2026-10-03 08:32:42+00:00

*This is a submission for the [Hacktoberfest Weekend Challenge: Build for a Friend](https://dev.to/challenges/hacktoberfest-weekend-2026-10-01)*

I built **StudyMate**, an AI study partner for a friend who is a real student. She has plenty of study material, but when she gets stuck on a topic she often doesn't know **what to do next**: re-read, watch a video, practice, or revise.

Most AI tools work like this: **Ask → Get answer.** Then the student is on their own again.

StudyMate works like this:

**Ask → Understand → Practice → Revise → Improve**

It looks at what the student asked and offers the right next actions.

The options are **adaptive, not fixed.** The same app gives different next steps depending on what the student is doing.

*StudyMate's chat interface. After each answer, it offers adaptive next actions based on what the student asked.*

Personalized AI study partner with contextual learning actions.

This version uses **Ollama Cloud** by default. The default configurable model is `gpt-oss:120b`.

```
cd backend
python -m venv .venv
.venv\\Scripts\\activate
pip install -r requirements.txt
copy .env.example .env
```

Open `backend/.env` and add your Ollama Cloud API key:

```
AI_PROVIDER=ollama_cloud
OLLAMA_HOST=https://ollama.com
OLLAMA_API_KEY=YOUR_KEY_HERE
OLLAMA_MODEL=gpt-oss:120b
```

Then:

```
uvicorn app.main:app --reload --port 8000
```

Check:

```
http://127.0.0.1:8000/api/health
```

In a second terminal:

```
cd frontend
npm install
npm run dev
```

Open the Vite URL shown in the terminal.

Never commit `backend/.env`. It contains your private API key.

The React frontend does…

The repo has the React + Vite frontend, the FastAPI backend, and a `.env.example` with setup instructions.

📧 Contact: [chanveersinghdev@gmail.com](mailto:chanveersinghdev@gmail.com)

```
        Student (question / doubt)
                  │
                  ▼
         React + Vite (UI)
                  │
                  ▼
           FastAPI backend
                  │
                  ▼
      Context / prompt engine
                  │
                  ▼
   Ollama Cloud ─► gpt-oss:120b
                  │
                  ▼
     Answer + adaptive actions
```

| Part | Tool | 
|---|---|
| Frontend | React + Vite | 
| Backend | FastAPI | 
| AI | gpt-oss:120b (open-weight) via Ollama Cloud | 
| Storage | SQL database for user data | 
| Built with | Claude Code | 

StudyMate is designed around how people actually learn:

`Discover → Understand → Practice → Revise → Exam prep`

The prompt engine detects the question type and phase, then chooses which actions to show.

The AI is an **open-weight model (gpt-oss:120b)** running through Ollama Cloud, not a closed proprietary API. The learning logic is separated from the provider and model:

```
StudyMate learning logic → AI provider → Model
```

The model is set in `.env`, so I can switch models or providers, or move to local inference later, without rewriting the product. That means less vendor lock-in and more control over the AI layer.

The Ollama API key stays on the FastAPI backend (`.env`). The browser never sees it, and only `.env.example` is committed to GitHub.

StudyMate **never calls AI-generated questions "PYQs."** They are labelled *Practice question*. Real previous-year questions will come from a verified database (year + exam + subject + chapter), so students can trust what they study.

I designed the interface like a real product: dark theme, rounded chat and composer, contextual action buttons, hover animations, chat history, and a responsive layout.

The biggest lesson was that a good study tool shouldn't stop at the answer. Knowing what to do next is what turns an answer into learning. StudyMate is the foundation for that, and I want to keep building it with my friend's feedback.
