Jigyasa

Your multilingual AI tutor that listens, questions, and maps how you learn.

Comment

Jigyasa — Learn by Talking It Through

Inspiration

Most educational tools explain concepts to learners. We wanted to build something that learns with them.

Many students understand more than they can express in a written test, especially when learning in a language that is not their first. Traditional learning platforms also tend to provide the same explanation to everyone, regardless of what the learner already understands.

Jigyasa was inspired by the Socratic method: instead of immediately giving answers, it asks focused questions, listens to the learner’s reasoning, identifies missing connections, and helps them construct their own mental model.

Our goal was to make personalized AI education accessible in English and Indian languages through a natural, voice-first conversation.

What it does

Jigyasa is a multilingual AI learning interviewer.

A learner chooses:

  • A topic or question
  • Their learning goal
  • Their current level
  • A conversation duration
  • One of 11 supported languages
  • Optional notes or textbook material

Jigyasa then creates a personalized learning interview. It begins by asking what the learner already thinks, adapts its next question to each response, offers small hints when needed, and gradually moves through diagnosis, discovery, application, and teach-back.

At the end, Jigyasa generates a learning map containing:

  • Concepts the learner understands
  • Ideas that are still developing
  • Misconceptions worth revisiting
  • Connections formed during the conversation
  • Recall questions for future practice
  • A recommended next topic

The complete interface, tutor responses, concept map, and final report use the learner’s selected language.

How we built it

We built Jigyasa as a full-stack Next.js application using React and TypeScript.

Sarvam AI powers the intelligence and speech experience:

  • sarvam-105b generates structured learning plans, adaptive Socratic questions, concept assessments, and final learning summaries.
  • saaras:v3 transcribes spoken answers.
  • bulbul:v3 converts Jigyasa’s responses into speech.

Every model response follows a validated JSON schema. Zod validation ensures that generated learning plans, tutor turns, mastery updates, and final reports have predictable structures before they reach the interface.

Supabase provides:

  • Google OAuth authentication
  • PostgreSQL persistence
  • User profiles and language preferences
  • Learning sessions and conversation history
  • Row Level Security for user-owned data

The application is deployed on Render and connected to GitHub for automatic deployments.

We also built a deterministic demo engine so the complete experience remains testable without consuming AI credits. Playwright runs full browser journeys across all 11 supported languages, checking session creation, localized tutor responses, native-script fonts, concept maps, report generation, browser errors, and layout overflow.

Personalization approach

Jigyasa does not assign a single numerical score. Instead, it maintains a mastery state for each concept:

[ M(c) \in {\text{understood},\ \text{developing},\ \text{revisit}} ]

After every learner response, the tutor updates only the concepts supported by evidence from that response. This makes the final learning map more transparent and avoids pretending that participation automatically means mastery.

The interview progresses approximately through:

[ \text{Diagnose} \rightarrow \text{Discover} \rightarrow \text{Apply} \rightarrow \text{Teach Back} \rightarrow \text{Map} ]

Challenges we faced

Making the entire experience multilingual

Changing a dropdown label was not enough. The setup form, interview controls, tutor questions, hints, concept evidence, progress states, reports, and speech settings all needed to remain in the selected language.

We also had to load script-specific fonts for Devanagari, Bengali, Gujarati, Gurmukhi, Kannada, Malayalam, Odia, Tamil, and Telugu so every language rendered correctly.

Reliable structured AI responses

A conversational model naturally produces free-form text, but the application requires structured learning plans and mastery updates. We designed strict JSON schemas, disabled unnecessary reasoning output, validated every response with Zod, and added safe error handling for malformed or empty responses.

Voice support across browsers

Browsers record audio using different codecs and MIME types. We built format detection, recording limits, transcription handling, cloud speech playback, and browser speech-synthesis fallback behavior.

Model and API changes

During development, a previously available Sarvam chat model was deprecated. We centralized model selection and locked every chat request to sarvam-105b, with regression tests that verify the exact outgoing request body.

Testing every language realistically

Manual spot checks were not enough. We created an automated Playwright matrix that completes an entire learning journey in every supported language using native-script questions and answers.

What we learned

We learned that meaningful AI personalization is less about producing longer explanations and more about asking the right next question.

We also learned that multilingual support must be treated as a complete product architecture concern. Language affects prompts, typography, speech recognition, text-to-speech, validation, accessibility labels, generated reports, and automated testing.

Finally, strict schemas and deterministic fallback systems made the AI experience substantially more reliable and easier to debug.

Accomplishments we are proud of

  • A complete adaptive Socratic learning workflow
  • Native interface support for 11 languages
  • Voice input and spoken AI responses
  • Evidence-based concept mastery maps
  • Grounding interviews in learner-provided notes
  • Secure Google authentication and user-owned data
  • Automated end-to-end coverage for every supported language
  • A polished, responsive educational interface
  • Production deployment with automatic GitHub integration

What’s next

We would like to add:

  • Teacher dashboards for reviewing class-wide misconceptions
  • Upload support for PDFs and textbook chapters
  • Spaced-repetition reminders generated from learning maps
  • Shared study rooms
  • More Indian languages
  • Improved voice interruption and real-time streaming
  • Long-term learner models that connect concepts across sessions
  • Exportable learning portfolios for students and teachers

Jigyasa’s long-term vision is to make an excellent personal tutor available to anyone—one that listens first, speaks the learner’s language, and helps them discover what they are capable of understanding.

Built With

Share this project:

Updates

Submission history