# 🪷 Sanskrit Saathi: I Built a Local AI Study Companion for My BAMS Friend

Shikha Shukla — Sun, 04 Oct 2026 08:49:45 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Sanskrit Saathi, a local AI study companion for my friend who is studying BAMS (Bachelor of Ayurvedic Medicine and Surgery).

Sanskrit is a core part of BAMS, but it's hard when you don't come from a Sanskrit background. My friend was struggling with exactly that.

The problem wasn't that she couldn't study. It was that a single Sanskrit word or shloka could turn into five separate tasks:

What does this mean?
How do I pronounce it?
What does each word mean on its own?
What's the simple Hindi meaning?
And when it shows up in an Ayurveda context, what am I supposed to take from it?

So I built a small tool around that exact problem. You paste a Sanskrit word, sentence, or shloka, and Sanskrit Saathi turns it into a structured lesson:

	What you get
📜	Original Sanskrit
🔤	IAST transliteration
🇬🇧	Simple English meaning
🇮🇳	Simple Hindi meaning
🧩	Word-by-word breakdown
📚	Context and usage
⚠️	A note about uncertainty
🧠	A quiz to practice what you just read

Two study modes

🌿 General Sanskrit focuses on learning the Sanskrit itself.
🪷 BAMS Sanskrit adds Ayurveda/BAMS context when it's relevant.

Both the explanation and the quiz follow whichever mode is selected.

I didn't want to build another general-purpose chatbot. I wanted something my friend could open, paste a line from her textbook into, and actually use while studying.

I tested it with a BAMS student, and she found the word-by-word breakdown and Hindi explanations particularly useful when working through unfamiliar Sanskrit terms.

Demo

 🎥 **Watch the demo:** https://youtu.be/DCMK8N5VwmQ

Sanskrit Saathi runs locally with Ollama, so there's no hosted link. The video shows the full flow.

The demo covers:

Pasting a Sanskrit word or shloka (or tapping a Quick practice chip)
Switching between General and BAMS mode
Getting an explanation from local Gemma
Reading the IAST transliteration and word-by-word meanings
Generating a quiz and checking answers

Screenshots

BAMS Sanskrit mode

General Sanskrit explanation

Quiz mode

Code

Shikha18Shukla / sanskrit-saathi

An AI-powered Sanskrit study companion for BAMS students using local Gemma 3.

🪷 Sanskrit Saathi

Your AI study companion for Sanskrit & Ayurveda

Understand Sanskrit. Learn Ayurveda. Study smarter.

An AI-powered Sanskrit study companion built for BAMS students. Runs fully on your own computer. No paid API. No cloud AI.

🌿 What is Sanskrit Saathi?

Sanskrit can be hard for BAMS students who don't have a strong Sanskrit background. Sanskrit Saathi helps by turning any Sanskrit word, sentence or shloka into a clear, beginner-friendly lesson, then testing you on it.

Paste Sanskrit → get an explanation → take a quiz → repeat. 🔁

✨ Features

Feature	What you get
📜	Sanskrit explanation	A structured breakdown of any word, sentence or shloka
🔤	IAST transliteration	Accurate Roman script, generated with `indic-transliteration`
🇬🇧	English meaning	Simple, easy-to-read English
🇮🇳	Hindi meaning	Simple Hindi explanation
🧩	Word-by-word breakdown	See how each word builds the meaning
📚	Context & usage	Where and how the text is

…

View on GitHub

(If the embed doesn't render, use the link: https://github.com/Shikha18Shukla/sanskrit-saathi)

Run it yourself

git clone https://github.com/Shikha18Shukla/sanskrit-saathi
cd sanskrit-saathi
python -m venv venv
.\venv\Scripts\activate        # macOS/Linux: source venv/bin/activate
pip install -r requirements.txt
ollama pull gemma3:4b
python app.py

Then open http://127.0.0.1:5000 in your browser.

How I Built It

The stack

Python + Flask for the backend and two API endpoints
Ollama + Gemma 3 4B for the AI, running locally on my own machine
indic-transliteration for IAST
Plain HTML, CSS, and vanilla JavaScript for the frontend, with no framework and no build step

Architecture

Sanskrit Text + Study Mode
          ↓
  Sanskrit Saathi Web UI
          ↓
     Flask Backend
       (/api/explain, /api/quiz)
          ↓
        Ollama
          ↓
      Gemma 3 4B
          ↓
  Explanation / Quiz
          ↓
        Web UI

The frontend sends { text, study_mode } to /api/explain or /api/quiz, where study_mode is "general" or "bams". The backend adjusts the prompt for the selected mode and returns plain text, either { "answer": ... } or { "quiz": ... }.

Transliteration comes from a library

IAST transliteration is generated by the indic-transliteration library on the backend, not written by the model. Transliteration is a mechanical conversion, so I wanted a deterministic tool for it and left the explaining to the model.

A frontend that expects messy output

The backend returns plain text, and a small local model doesn't always format things the same way twice. So I designed the UI defensively:

It looks for section headings (Original Sanskrit, IAST, English, Hindi, word-by-word, context, note) and turns them into separate cards.
If the response doesn't parse cleanly, it falls back to a readable formatted card instead of breaking.
The quiz works the same way. It tries to detect questions and A/B/C/D options and builds question cards, and if it can't, it shows the original quiz text.
Everything the model returns is rendered as text, never as HTML.

Small details for real study sessions

Copy buttons on the Original Sanskrit, the IAST, and the full explanation, so notes can go straight into a notebook app.
Quick practice chips that fill the input without sending anything to the AI.
Ctrl + Enter to explain.
Friendly loading and error states. Gemma runs on a local machine, so answers take a moment. The app says "Understanding your Sanskrit..." instead of sitting silent, and if Ollama isn't running it tells you to start it rather than showing a raw error.
Accessibility: keyboard-friendly controls, visible focus states, aria-live updates, and reduced-motion support.

Why Does Open Innovation Matter?

For this project, an open-weight model is what makes the whole idea practical.

It costs nothing per question. A student shouldn't have to pay for every shloka she looks up.
Her study material stays on her computer. Gemma runs locally through Ollama, so the text she pastes is not sent to a hosted AI provider.
**I could choose a model that fits. Gemma 3 4B runs locally on my CPU-only machine. The tradeoff is that responses take longer than they would with a hosted or GPU-backed model.
I could shape it for one person's problem. The two study modes, the structured output, and the quiz exist because I could control the prompts and the whole pipeline.

With a closed API, every explanation would be a paid request, and the app would need an account, a key, and a connection. For a study tool built for a friend, that's the wrong fit.

The tradeoff is setup: you need Ollama and the model installed, and local inference is slower than a hosted API. I think that's worth it for a tool someone will use every day.

Honest limitations

Sanskrit Saathi is a language-learning tool. It is not a substitute for a Sanskrit teacher, a textbook, or a qualified medical professional.
A 4B model can make mistakes, especially with rare words and complex grammar. Ayurvedic context in BAMS mode should be checked against textbooks and teachers.
It needs Ollama running locally, and responses are slower on CPU-only machines.

What's Next

This version intentionally stays small. If I continue developing Sanskrit Saathi, I'd like to add study history, more structured shloka practice, and test other open-weight models to see how well they handle Sanskrit.
But for this weekend, the goal was simple: build something my friend could actually use.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and powers the explanations and quizzes in Sanskrit Saathi, adapting them to both General and BAMS study modes.

Thanks for reading! 🪷 If you're learning Sanskrit, studying BAMS, or building tools for a friend, I'd love to hear your thoughts in the comments.

DEV Community: Shikha Shukla