abhyasa

abhyasa (अभ्यास) means steady practice. It is a tutor that asks you questions and makes you do the thinking. It never gives the answer first. You answer in text or by voice, and you can think aloud. The tutor grades your reasoning, not only the result. A learner model keeps the depth of each concept that you know, and the date of its next review.

How it works

Each question goes through one loop:

1. Pick. Code chooses the next concept and the depth: a due review first, then the frontier. The app shows the reason.
2. Ask. A model writes one question at that depth, with a hidden model answer and a rubric.
3. Struggle. You answer. A wrong try gets the first error and a nudge, but no fix. You can ask for hints, one rung at a time.
4. Grade. The model grades the answer and the think-aloud. Code grades choice questions and code exercises.
5. Update. Correctness and confidence move the floor, the ceiling and the next review date of the concept.
6. Teach. After a miss, the tutor teaches the smallest step that fixes the first error. Then it asks a check question.

Install and run

Install the package and its dependencies:

uv sync

Start the web app on http://127.0.0.1:5077:

uv run abhyasa

The app listens on the loopback address only. These variables change the defaults:

Surfaces

All surfaces use the same tutor and the same data.

Web app

The web app is made from blocks under abhyasa/blocks:

ramabana

The /learn extension gives the tutor in the terminal, beside your code. To turn it on, make the file ~/.config/ramabana/extensions/abhyasa.py with this line:

from abhyasa.rama import setup

Notebooks

In leela or Jupyter, learn shows a question card. exercise gives a code exercise that its tests check in the kernel.

from abhyasa.nb import learn, exercise
learn('reciprocal-rank-fusion')
ex = exercise('reciprocal-rank-fusion')

Where the data is

All data is on the learning shelf of the vishalakshi vault. Each concept, attempt and session is one vault document, so other tools can search it. Tests use a vault in a temporary folder and never open your real vault.

Demos

Some ideas are easier to see than to read. A demo is one interactive figure from rupaka. It asks you to predict first, and it hides the result until you lock in (⌘↩). Then the controls are live, and the last line asks a new question.

• After two misses on a concept with the same kind of error, or for a concept with visual: true in its meta, the tutor makes a demo in the background. A model writes it as data, and rupaka checks it in a headless browser. You never wait.
• After a miss on a concept that has a demo, the session shows the demo under the lesson.
• “Show me a demo” (⌥E) on a concept page shows the newest demo, or makes one.
• Each prediction is kept as an attempt with kind='demo'. It does not change the learner model.

abhyasa.demo.import_gallery(learning) stores the rupaka gallery demos (vowel sandhi and others) for the concepts that match.

Example

This example runs offline. temp_learning makes a shelf in a temporary vault, and Fake replaces the model.

from abhyasa.store import temp_learning
from abhyasa.llm import Fake
from abhyasa.tutor import Tutor

lr = temp_learning()
lr.put('Ranking', 'Order items by a score.', 'ml')
fake = Fake({'You grade one answer': dict(correct=True, grade=8, first_error='', misconception='', feedback='Yes. Only the order counts.')},
            dflt=dict(question='Why can you compare ranks from two systems, but not their scores?', answer='Ranks share one scale.', rubric=['ranks share one scale']))
t = Tutor(lr, fake, context=False)

Ask the first question. why gives the reason for the choice. A new concept starts at depth 3 (explain).

q = t.next()
assert q.why == 'next on the frontier: its prereqs are in place'
assert q.depth == 3
print(q.question)

Answer with high confidence. A solid pass at depth 3 raises the floor to 3.

r = t.answer(q.id, 'A rank is a position, and positions use the same scale in each list.', confidence=80)
assert r.outcome == 'solid'
assert lr.concept('ranking').floor == 3