Inspiration

What it does## Inspiration

Many students are eligible for government scholarships and schemes but never apply. The information is scattered across portals, written in dense language, and hard to match to one's own situation. A student has to read each scheme's rules and guess whether they qualify. one

We built Scheme Navigator (SchemeSetu) so a student can describe themselves in plain words and quickly see which schemes they qualify for, why or why not, and what to do next.

What it does

Chat-style profile: the student describes themselves (age, state, income, category, course) and the app asks follow-up questions for anything missing.
Ranked schemes with sources: every result links to the official page.
Gap analysis and what-if: if a student fails a scheme, the app shows the exact shortfall (for example, income over the cap by a certain amount) and which other schemes they would pass.
Friction and time-to-dispersal: results can be sorted by benefit amount or by speed, with "typical" estimates.
Live check with Tavily: the app confirms scheme details at runtime and shows a "verified on [date]" tag. If the live result disagrees with our data, it shows a warning instead of silently changing anything.
Draft generator: a copyable self-declaration or statement of purpose with the profile filled in.
CSC operator view: upload a CSV of student profiles and see a table of students by eligible schemes.
Optional certificate OCR and a language selector.

Current scope: Karnataka students, with a small set of hand-curated schemes. Other states show a clear "not covered yet" message.

How we built it

The core idea is: the LLM never decides eligibility.

An NVIDIA Nemotron model through Nebius Token Factory turns messy text into a structured profile and asks follow-up questions.
Plain Python code checks the profile against curated rules stored as JSON, with the source URL kept beside every rule. It returns pass or fail for each criterion.
A larger model is used only to phrase explanations. The numbers come from the rules engine.
Tavily checks the live deadline and status, and attaches the official source link.

Built with Python, Streamlit, Nebius Token Factory (NVIDIA Nemotron), Tavily, GitHub (MIT license) and Streamlit Community Cloud. The project has 22 automated tests for the rules engine and its edge cases.

Challenges we faced

Correctness over coverage: a wrong eligibility rule is worse than a missing scheme. We removed schemes we couldn't confirm and keep a verified flag on every scheme.
A state bug: changing the state to Telangana still showed Karnataka schemes. We fixed it by adding a state check to the rules engine and a test for it.
Token Factory billing: our payment verification failed close to the deadline, so the public demo currently runs in demo mode. Real mode works by adding the key in Streamlit Secrets and setting MOCK_MODE to false.
Time: we chose a narrow scope (one state, one audience) so the demo is correct rather than broad and flaky.

What we learned

Keeping the LLM for language and the code for decisions makes the results explainable and trustworthy.
Showing the reason for a failure (the gap) is as useful as showing the matches.
Good data work (official sources, verification flags) matters as much as the model.

What's next

Add more states by adding verified JSON entries, with no code changes.
Verify every scheme against its official page and mark it verified.
Run in real mode on Token Factory and expand certificate OCR.
Roll out the CSC operator view so one operator can screen many students at once.