Academic Hub |

Concept Graph

Sun, 11 Oct 2026 00:00:00 +0000

Concept Graph maps the ideas in a course and the conditions that connect them. An arrow can say that one idea implies another, but it also records the assumption needed to make that claim. Selecting it gives me a sentence to examine and references to the course material behind it.

For example, the package’s sample graph connects a partial order to a total order when every pair can be compared. A partial order can leave two items unranked relative to one another; adding that comparison requirement produces a total order. The condition on the arrow explains what changed, rather than leaving me to infer it from two nearby boxes.

The first full graph covers the first half of a graduate microeconomic theory sequence: . As of October 15, 2026, it contains 104 concepts and 159 connections across eight course sections. A second graph now covers a graduate econometrics course: . Completed on October 21, 2026, it contains 112 concepts and 135 connections across eight course sections, all awaiting the owner’s review. Those counts describe each draft’s scale; every concept and connection remains marked as proposed until reviewed.

Following an idea

Each box represents an idea, such as a definition, theorem, or example. Selecting it opens an explanation, its mathematical statement, and its connections written out in words. Course-section filters and several layouts help narrow a crowded graph to the part I want to study.

That makes the graph useful for tracing a result back through the assumptions and definitions it depends on. Section summaries offer another way in, though those summaries are AI drafts and some wording is looser than the underlying theory.

Building and reviewing the connections

An AI agent drafts explanations and connections from task cards containing passages found through the . The and tools prepare the notes, slides, assignments, and books it searches. Code then checks the submitted structure: references must come from the supplied passages, required conditions must be present, and circular definition chains are rejected. A cited passage can still be misinterpreted.

The same collection supports the . A guide develops a topic through explanations and examples; the graph exposes the relationships and assumptions between ideas. They have separate drafting workflows, so building one does not automatically produce the other.

The drafts remain marked as proposed until a person accepts or edits them. Reviewers can comment, reject a connection, or suggest a missing idea through the page. Suggestions from several reviewers are combined before the maintainer handles them. Submission through GitHub has not yet been tested from start to finish.

What a second course taught

Applying the drafting pipeline to econometrics revealed where a data-driven statistics course differs from a theory course:

Checking against the syllabus: Initial drafting from lecture notes and textbook passages missed 21 key concepts, including an entire syllabus topic on dynamic causal effects. Adding an explicit gap check that compares the course syllabus against the drafted concept list caught those omissions before review.
Specialized connection types: The original vocabulary grouped too many relationships into generic categories. Econometrics required two new connection types—one (defined_via) for concepts formally defined in terms of other concepts, and another (assumption_of) to separate the conditions an empirical estimator requires from the mathematical premises of a theorem.
Rotating agent roles: To prevent a model from approving its own blind spots, the pipeline rotates responsibilities: Gemini drafts nodes and connections from source passages, Codex evaluates whether each proposed link is supported or weak, and Claude reviews vocabulary additions and structural repairs. The agent that drafted or corrected an item no longer critiques it.
Separating source data from publication: The graph’s source data and review history stay in a private repository, and only the built interactive page is published to a public site.

Evidence and limits

The October 15 status records 331 Python tests, 45 viewer tests, browser checks, and a graph built from actual course materials. These establish different things: the tests exercise the software, while the graph shows what the drafting process produced. Neither establishes a learning benefit.

For the microeconomics graph, connections were drafted and critiqued by the same model, and that critic approved almost every connection (154 of 155), so its review may be lenient. The econometrics graph used a separate critic, but no model replaces subject-matter judgment: every item in both graphs remains proposed until a person reviews it. The records the open issues; the explains how the graph is built and reviewed.

Corpus Health

Sun, 11 Oct 2026 00:00:00 +0000

Having a converted lecture note on disk does not mean its latest text is available in search. Corpus Health checks for gaps between source documents, converted text, and the , then presents specific findings for review. It remembers declined or deferred findings so the same unchanged item does not keep appearing as a new problem.

The repair scope is deliberately small: it can rebuild searchable passages for one identified document whose search record is already current. Before acting, it checks that the document and record still match the reviewed finding. Afterward, it audits the result. A changed source needs another check rather than relying on an old approval.

For an illustrative case, a transcript may have been updated while its searchable passages still reflect the earlier version. The scan flags the mismatch. I can accept, decline, or defer it on a local review page; running accepted repairs is a separate step. Rebuilding those passages can incur an AI embedding charge, so acceptance is recorded for each source.

Keeping those passages current matters to the and that read them. A missing source may look like a gap in the model’s explanation when the material was never available to search.

The scanner itself makes no model calls or edits to course materials. Repair uses a shared lock to coordinate with participating tools, but some writers, including Obsidian sync, do not follow that protocol. They must not write to the same destination during a repair. Transcription, textbook conversion, and broader catalog rebuilds remain outside the enabled repair action.

Initial live scans on October 9, 2026 took about 21–28 seconds, but their roughly 305 findings still needed sample review to distinguish genuine gaps from classification mistakes. A daily discovery-only trial was scheduled for October 10–16. An October 16 read-only check found completed reports for several days alongside empty logs for others; the observation period still needs review before claiming reliable daily operation. The scheduled task performs no repairs.

The separates fixture tests from live observations. The documents the scan policies and current repair boundary.

Guided Solutions

Sun, 11 Oct 2026 00:00:00 +0000

Guided Solutions brings three contributions to a problem set together: an AI-written derivation, space for my own intuition, and a proof developed through tutoring. Each has its own labelled block, so I can compare approaches and see whose reasoning I am reading.

The separation matters when the routes differ. In the recorded microeconomics run, the agent supplied detailed reference proofs; later tutoring on two questions produced more compact proofs following the student’s approach. Both were kept, with room for the student’s interpretation alongside them.

An illustrative layout, rather than an excerpt from the private coursework, looks like this:

My reasoning: I think adding another option changes the chance of choosing the default, but I need to identify why.

Agent derivation: Work through the choice probabilities under the question’s stated rule, showing the intermediate steps.

After tutoring: Record the proof developed during the discussion and compare its key step with the reference derivation.

To prepare a document, I use the assignment and a question-by-question hints sheet to organize the work. The make lecture notes available to the , which finds the course’s definitions and notation alongside textbook passages. The agent is instructed to show its algebra and assumptions, while leaving the student’s writing intact. A later audit checks the document’s structure and mathematical work.

This is a procedure I direct using the existing conversion, search, and tutoring tools. The records one completed problem-set run and its tutoring follow-up. It provides a playbook for another assignment; each new solution still needs review. The course documents remain private, and the workflow has no dedicated automated test suite.

Project Steering

Sun, 11 Oct 2026 00:00:00 +0000

Project Steering helps me choose the next task from a long project list. I review each task’s impact, urgency, effort, and dependencies; the tool uses those decisions to produce an explained shortlist. Tasks that still need estimates stay visible in a separate queue.

Each task keeps its identity when it moves within the list, but suggestions are tied to its wording. If the description changes after an AI agent proposes an estimate or assignment, that proposal becomes stale and needs a fresh review. That keeps an old suggestion from being approved for changed work.

The review page also lets me hold a task until a chosen date without changing its priority score. Reviewing , for example, can remain important while staying out of today’s shortlist until the trial finishes. Suggested assignments to coding agents have their own approval step, separate from priority estimates.

Scanning the list makes no AI or network calls and does not edit the source tracker. AI-generated estimates and assignments can be imported for review, but the software never treats them as approved decisions. Choosing or ranking a task does not start its implementation.

An October 10, 2026 scan accounted for 69 active tasks with no unresolved parsing warnings. That establishes coverage of that list, while the quality of the priorities still depends on the estimates and decisions I supply. Many estimates remained unfinished at that checkpoint. Scans currently run on demand; unattended scheduling is still planned. The and describe the current review rules.

Socratic Tutor

Sun, 11 Oct 2026 00:00:00 +0000

The Socratic Tutor gives an AI study conversation a record of which steps the student has established. Before the tutor sends a reply, a local program checks it against that record and rules intended to hold back unreached solution steps. The conversation can then be reviewed against what the student actually said.

That restraint also exposed the central difficulty. In two recorded sessions on one microeconomics problem set, the tutor followed several session rules but struggled to teach unfamiliar material: an explanation could itself reveal a step the student had not reached. The system was better at assessing existing understanding than helping a learner build it.

An illustrative version of that failure pattern is:

Student: I don’t understand why this condition matters.

Tutor: Which part of the condition could you use?

Another question preserves the student’s chance to solve the problem, but it may provide little help with the missing concept. A more permissive teaching mode is still a design direction, not an observed solution to this problem.

What the program keeps track of

An AI agent conducts the dialogue; the Python program maintains the session record and checks proposed replies locally, without asking another model to judge every turn. Preparation defines the problem’s key claims, reference steps, glossary, and review criteria. During the conversation, word-pattern checks look for evidence that the student has established a claim or encountered a known pitfall.

When enough progress has been recorded, the reference steps are released for a comparison using quotations from the student’s messages. Pausing saves the transcript, summary, and learner record. Skip and defer rules allow incomplete parts to be parked, though the live runs found that returning to a parked question was too rigid.

The checks have limits: unfamiliar wording can be missed, unrelated phrases can trigger a match, and an agent can credit weak evidence. They provide an inspectable record rather than a guarantee against revealing an answer or misjudging understanding. Automated tests exercise the session rules; the explain what happened in the two sessions. The documents the current workflow.

For a hint or feedback on a single attempt, offers those tools within RAG Analysis. describes a document workflow for keeping my reasoning and later tutoring work beside an agent’s reference derivation. Those are useful alternatives when I need a specific study task rather than a tracked conversation.

Study Guide Pipeline

Sun, 11 Oct 2026 00:00:00 +0000

The Study Guide Pipeline builds a guide from selected course materials, then lets me review proposed edits before they change the text. Topics can draw on named textbook sections, particular lecture notes, or newly discovered passages. Keeping that source selection explicit makes it easier to investigate a gap in the finished guide.

One early run exposed a useful mismatch: a requested textbook section did not cover the statistical test it was supposed to explain. The stronger expanded guide described what that section actually contained and developed the topic from other relevant material. That was more useful than repeating the requested reference as though it were correct.

From materials to a reviewed guide

I start with a topic list, instructions, and rules for choosing sources. The supplies passages from the converted and . Those passages need to be in the search catalog before guide planning can use them.

The tool assembles a source plan; newly discovered passages normally wait for review before drafting. The draft records which passages were supplied for each topic, and an optional can develop explanations and worked examples further. For tracing relationships between ideas rather than reading a topic in sequence, uses the same source foundation in a separate drafting workflow.

Revision is a separate step. It proposes specific changes for relevance, repetition, correctness, and organization. I can accept or reject them individually. Applying the decisions writes a new guide and checks that untouched passages remain unchanged and that no new page citations have appeared. It also refuses to apply an old review if the guide has changed underneath it.

That approach makes a long guide easier to refine without asking the model to regenerate every section. Spending limits can stop a run between sections or review tasks, and saved revision work can be resumed when its inputs are unchanged.

What changed in practice

In the first econometrics comparison, three draft-only variants were too short and conceptual for the intended study use. The expanded version supplied deeper derivations and examples, though it still lacked some of the exam-focused structure I wanted. Later topic-based drafts improved the worked problems but also wandered into irrelevant software discussion.

A subsequent review of one draft accepted 27 of 30 proposals. Applying the review made 18 text edits; other accepted items included advisory notes. The run reduced repetition, repaired headings, and added cross-references. An accepted warning can still leave a mathematical issue unresolved when it calls for investigation rather than supplying a correction.

A later microeconomics guide made the remaining gap clear: comparison against the assignment found missing material and errors the revision pass had missed. That check led to hand repairs. The and record the observations; the documents the current workflow. A generated guide still needs that final coverage and correctness review before I rely on it.

Summary Enhancement

Sun, 11 Oct 2026 00:00:00 +0000

A short summary can name a result without giving me enough detail to use it. Summary Enhancement returns to the exact textbook and note passages recorded by an existing AI-generated summary, then develops fuller explanations by topic. It can also add worked examples whose arithmetic is computed by running code.

The useful expansion is in the reasoning between the result and its application. For a statistical test, for example, a section can explain its assumptions, derive the formula, and walk through a small numerical calculation. An introductory description of what a test measures can then become something I can work through step by step.

The starting document can be a saved , or a draft from the . It needs the recorded passage references those tools write. The enhancer uses them to reopen the same material in the , rather than search again and possibly choose different evidence.

The tool can plan the topics itself or use a list I supply. It writes a separate expanded guide, leaving the original intact. Long equations get their own lines and long paragraphs are split to make the result easier to read.

One important distinction is preserved behind the reading text: which paragraphs draw on the sources, which add broader explanation, and which contain generated examples. A source map records the passages used by each section. This keeps the main text readable while giving me a way to inspect where its explanations came from.

Those records support review; they do not establish that every claim follows from its source. The validator checks that source labels exist, and code execution checks the example’s arithmetic. A person still needs to inspect the reasoning and interpretation around those calculations.

This is useful when I already have the right sources but need a fuller explanation. Starting a guide from a topic list also requires source selection and drafting, which the broader Study Guide Pipeline handles. The documents the current interface; the linked status record describes earlier implementation and testing.

Tutor Diagnosis & Hint Generator

Mon, 28 Sep 2026 00:00:00 +0000

A correct conclusion can hide a gap in the argument, while an otherwise sound attempt may use a method the course has not introduced. Tutor Diagnosis examines those differences separately: whether the result is right, whether the steps are justified, and whether the explanation fits the course’s definitions and methods. Its scores are model feedback for review, not instructor grades.

The tool can also give a hint before I have a full attempt. It searches course material for a useful direction and aims to leave the final derivation to me. When the available passages do not cover the topic, it labels a general hint instead of attaching an unsupported course reference.

An illustrative learning loop, not a transcript or a new test result:

Claim: Every even integer is divisible by four.

Attempt: It works for 4 and 8, so it must hold for all even integers.

Hint: What would you need to check beyond those two examples?

Revision: Two is even but not divisible by four. One counterexample disproves the claim.

The point is to identify the reasoning gap: examples that support a claim do not establish that it holds in every case. For course problems, the tool compares an attempt with a reference answer and retrieved passages, then names the most important gap to revisit.

A fresh solution for comparison

A separate solver receives the question without the tutor’s earlier answer or the source passages used to write it. In a recorded econometrics trial, this second solution identified an intercept condition the first answer had omitted. The user still compares both arguments; agreement or disagreement is not automatically resolved into a verdict.

Other recorded checks included identifying an intentionally flawed regression argument and producing a hint on a microeconomics problem without a final derivation. Those are limited examples of the workflow, not evidence that feedback will be accurate on every assignment.

Course-scoped logs preserve attempts, hints, feedback, and solution comparisons for later summaries. The describes the trials. This is a set of tools within ; the separate tracks an interactive session and applies different conversation rules.

Obsidian Git Sync

Mon, 21 Sep 2026 00:00:00 +0000

I want to write a lecture note on my tablet and find the editable drawing on my laptop, without bringing the whole textbook archive onto the tablet. This setup uses Obsidian, a notes app, and Excalidraw, its drawing tool. Working notes sync separately from the large source files used to process them.

The tablet currently uses Fit, which exchanges files through GitHub’s API rather than maintaining a local Git history. That avoids the history-download problem that caused trouble with an earlier plugin. The laptop uses Obsidian Git, and some settings remain device-specific.

Lightweight notes vault	Separate source archive
Markdown notes, editable Excalidraw scenes, processed text	PDFs, exported drawing images, and generated audio

Saving an Excalidraw file automatically creates an SVG image. The use those images to make the handwriting searchable; saving alone does not perform that transcription. The source-relocation record reports the existing course materials moved into the archive, with the tools adapted to find them there while keeping processed text in the notes vault.

Keeping the boundary intact required more than a folder move. An earlier sync plugin rewrote ignore rules from each device’s settings, letting PDFs enter the notes history. Removing those large files from the old history reduced its size from about 217 MB to 35 MB. That incident explains the emphasis on separate storage and device settings; the current tablet sync uses a different mechanism.

Customization was another reason I chose this approach. Editing plugin code let me translate a pen menu and add an eraser button. A separate interface-style change moved zoom and undo controls clear of the tablet’s gesture bar. Being able to fix those details myself was an advantage over my experience with OneNote.

Fit does not transfer plugin source files, so changes to that customized plugin still need a manual copy to the tablet. The interface-style snippet can sync when explicitly included, but enabling it and other settings may need attention on each device.

Matching handwritten-only notes with later copies containing slides is handled by the . The and distinguish the configuration from the completed archive move.

Audio Generator

Wed, 09 Sep 2026 00:00:00 +0000

Audio Generator turns course notes into MP3 episodes for listening away from a screen. Mathematical notation needs an extra step: a speech engine can read words, but raw formula commands often sound unintelligible. The tool rewrites that notation into spoken language before synthesizing the recording.

For an illustrative translation, E[X] becomes “the expected value of X.” Denser equations need more than symbol replacement to preserve what the expression means. The pipeline sends math-heavy passages to a cloud model for that rewrite, while text cleanup and speech synthesis run locally. Plain prose can skip the model call.

Notes are split into episodes targeting 10–20 minutes. The current code can divide oversized sections at paragraph boundaries; one indivisible paragraph may still exceed the target. Textbook inputs follow a different path and currently produce one MP3 per source file. Editing any part of a note regenerates all of that file’s episodes; unchanged sources can be skipped.

The September 9, 2026 stress test used one equation-dense, roughly 122,000-character note. It took 3.8 minutes to prepare the narration and another 19.4 minutes to synthesize speech, producing nine files in 23.2 minutes overall. One episode was about 62 minutes long. That historical result predates the paragraph-splitting fix; a new listening test is needed to judge the revised output.

The local model tried earlier took about six hours on the same difficult input. Cloud rewriting reduced the wait but introduced API cost. Its speed does not establish that every formula was explained correctly, so the saved narration text provides something to inspect before relying on the audio.

and now exist, but an automatic weekly-summary-to-audio workflow is not established. Notes audio is stored with the larger course resources, outside tablet notes sync. The describes current output and regeneration behavior.

Problem Corpus Extraction

Sun, 06 Sep 2026 00:00:00 +0000

A useful practice collection needs more than a list of questions: it needs to say where each question came from and what kind of answer accompanies it. Problem Corpus Extraction gathers exercises from course materials and preserves that distinction. A student’s handwritten attempt stays labelled as an attempt.

That choice came from inspecting the available materials. Some exercises had no answer; others had the student’s working beside them, with no basis for calling it an answer key. The stored records therefore mark accompanying text as a student attempt or leave the solution absent. The extractor does not turn an unverified derivation into a verified one.

A clearly illustrative card, rather than an excerpt from private coursework:

Question: Show that the sum of two even integers is even.

Source: Example worksheet, Question 2.

Accompanying work: Student attempt, not checked.

The tool first detects numbered question boundaries, then asks a model to separate each statement from any accompanying solution and assign a short topic label. It stores the results by course and skips unchanged files on later runs. A failed extraction can be recorded without discarding other successful questions.

A September 2026 math-camp run produced 196 records from eight problem-set files, with no reported extraction failures. Four slide files had no recognized numbered-question boundaries and were skipped. That is evidence of the run’s output, not an accuracy audit of all 196 statements or solutions.

The current tool stops at creating the stored collection. Connecting it to remains separate work; that generator currently retrieves its own examples. The explains the output and provenance rules.

Problem Generation Sub-Agent

Sun, 06 Sep 2026 00:00:00 +0000

Extra practice is most useful when it exercises the method I am trying to learn. Problem Generation uses examples from my course to draft a new question and worked solution, then checks two things separately: whether the solution is mathematically valid and whether it uses the requested technique. A correct proof by a different method may miss the point of the exercise.

That distinction came from actual trials. A model asked for a proof using explicit error bounds, known as an epsilon-delta argument, kept using a different approach from its retrieved examples. Splitting the review into “requested technique” and “correctness” caught those mismatches, although the local model still failed to produce an accepted answer in two full trials. The check exposed a limitation; it did not make the model capable of solving the task.

An illustrative request makes the difference easier to see:

Practice question: Show that the sequence 1/n approaches zero.

Requested method: Use the definition of convergence.

Solution sketch: For any positive error tolerance ε, choose an integer N greater than 1/ε. Whenever n is larger than N, the distance 1/n from zero is less than ε.

Checking the sketch means inspecting both the inequalities and the use of the definition, rather than accepting a graph or a bare statement of the limit. This is an invented demonstration, not a transcript of a generation trial.

Course examples guide the draft

The finds problem-set passages for style and difficulty, plus textbook passages when available. The generator will not proceed without style examples, but can work without textbook passages. A weakly related style match can also pull the draft off topic; the closest available example is not necessarily a suitable one.

Generation now defaults to Gemini, with API cost. In the September 6, 2026 comparison, nine trials across three constrained topics passed the model checks and recorded manual review, while the local alternative had struggled with the requested method. That narrow result motivated the default; it does not establish reliable mathematics across a course. Local generation remains optional.

The second check is another model call, so it can repeat the first call’s mistakes. Earlier trials accepted flawed reasoning, including a circular argument. Rejected attempts can be revised within a bounded retry loop, but students still need to inspect the result.

The separately extracted is not yet connected to this generation loop. Current examples come through passage retrieval. The documents that distinction and the generation options.

Video Lecture Notes

Sun, 06 Sep 2026 00:00:00 +0000

A lecture series can contain several explanations of the same idea, spread across videos with unhelpful titles. Video Lecture Notes downloads the audio, transcribes it, and combines related lectures into study notes that can be searched alongside textbooks and handwritten notes. The combination step matters: it tries to turn a sequence of recordings into one explanation rather than leave a separate transcript for every file.

One trial exposed a surprisingly basic limit. A three-video group produced a note reflecting only one video’s content because the local model was receiving only the end of the combined transcript. The shared model helper now requests enough context for the prompt. Rechecking showed better coverage and structure, although reliable links from each concept to the exact video moment remain unfinished.

From recording to study note

Audio download, speech transcription, and note synthesis run locally. The transcript retains timed segments; the synthesis model receives them when drafting the combined note. Registering that note with the uses the existing classification and embedding API calls, so the full searchable workflow is not entirely offline.

Grouping first uses playlist context and recognizable lecture-series titles. When that context is insufficient, it can compare transcript contents. This saves manual sorting, but shared vocabulary is not the same as belonging to the same lecture: the recorded trial grouped some differently numbered videos together and split another lecture’s two parts.

For an illustrative output, a note might organize “Sets and functions” into definitions, examples, and a comparison of related ideas. That describes the intended format, not an excerpt from the recorded run. To check an explanation, I still need the recordings and transcripts; a general video link at the end is less useful than a precise reference beside the claim.

What the trial covered

The September 2026 record covers eight videos from a 105-video Math Camp playlist, across two passes. They produced five indexed notes. That establishes a working download-to-note path on a subset, not full-playlist coverage or complete retention of every explanation.

Long groups remain expensive to synthesize on CPU hardware, and the remaining timestamp and grouping issues affect practical review. The and linked status record distinguish the implemented workflow from those open checks.

Visualization Sub-Agent

Thu, 03 Sep 2026 00:00:00 +0000

A formula for gradient descent describes repeated steps toward a minimum. A picture can show what those steps do: the prepared example in this tool traces a path across the contours of a bowl-shaped surface toward its center. I can zoom in and inspect the points alongside the written explanation, rather than infer the whole path from the update rule.

The important distinction is how that picture is made. A small library covers familiar concepts with prepared Plotly charts, which run without a chart-generation model call. For other topics, the tool asks a model to write chart code using the question and retrieved course passages. That opens up more concepts, but introduces another judgment: a script can run successfully while illustrating the wrong idea.

A plot beside the answer

Visualization is optional within . A report can combine the question, answer, source references, and interactive chart in one HTML file. If chart generation fails, the text report can still be produced. A recorded September 6, 2026 trial combined a , its solution, and an embedded interactive plot in the same report.

Generated charts currently use Gemini by default, with API cost. Local Ollama generation is an explicit alternative, but it timed out or produced broken scripts in the recorded comparison. Gemini succeeded twice on the same request. Two successes are useful evidence for that change of default, not a broad chart-accuracy evaluation.

Running code is one check

The tool executes generated code with a time limit, a separate working directory, and an environment that excludes inherited API secrets. Execution errors can be returned to the model for a bounded retry. These measures limit particular failure modes; the process is not a comprehensive security sandbox.

Past scripts that ran successfully can be offered as examples to later generation. They stay separate from the prepared templates because successful execution alone does not make an example mathematically correct. Whether that small example store improves results over sustained use remains unmeasured.

Template matching also needs care: “convergence in probability” should not receive a generic series-convergence plot just because both contain the same word. Inspecting what the chart represents remains part of using it. The explains templates, generation, and the execution limits.

RAG Analysis

Sun, 30 Aug 2026 00:00:00 +0000

RAG Analysis answers a question using passages found in my textbooks and course notes, with references back to the material it used. That lets me inspect an explanation and continue reading at its source. The reference is a starting point for checking the answer, not a guarantee that the model interpreted it correctly.

One useful choice is limiting how many passages a single file can contribute. Otherwise, a relevant textbook can fill the available space and crowd out lecture notes or another author’s explanation. Follow-up questions are also rewritten using the recent conversation, so “explain that differently” becomes a specific question the search tools can use.

A clearly illustrative example, rather than a quotation from a recorded answer:

Question: What does the spectral theorem help explain about a real symmetric matrix?

Answer sketch: It gives perpendicular directions along which the transformation acts by scaling, making its action easier to describe.

Reference format: Section 7.4, pages 264–266.

The name RAG means retrieval-augmented generation: find relevant passages first, then supply them to the model writing the answer. This project reuses the for that search. An August 2026 trial answered a spectral-theorem question using two source files; a follow-up exchange also exercised the conversation-based search step. Those were specific trials, not a broad evaluation of answer accuracy.

What is remembered

The running chat retains its conversation, but restarting the process does not restore the full dialogue. With a course selected, the tool can save answer, hint, draft-feedback, and verification events. Recent recorded learning gaps can inform later answers, and a session recap can turn the recorded discussion into a study note.

Requesting a report also saves the answer as a note with its source references. Those references identify the passages in the , so can reopen that material and develop a short answer into fuller explanations and examples. The offers another starting point when I already have a topic list. Saved notes and logs survive separately from the live chat history.

A companion resolver answers question markers in handwritten notes. Its recorded seven-question run included four source-grounded answers and three marked as ungrounded. General answers remain leads to check, and retrieving a handful of passages is too narrow to establish comprehensive coverage of a week’s study.

The describes the current interfaces. adds feedback on an attempt; the separate manages an ongoing tutoring session.

Source Indexer

Sun, 30 Aug 2026 00:00:00 +0000

A question about eigenvalues might belong with a textbook proof, a lecture explanation, or an exercise I have already attempted. Source Indexer searches converted course materials in two stages: first finding promising documents, then locating passages inside them. The result includes a heading, page, or paragraph reference so I can continue reading where the match came from.

The search catalog has a record for each document, much like a library card with a brief description and subject labels. These descriptions help find material; the longer summaries I study are written by the answering and guide tools. A record’s identity comes from the source file’s contents rather than its filename, so renaming a PDF does not have to create a new document. Course-level records narrow the search before it compares individual files.

Give other study tools something to read

The and converters register their outputs with the indexer. Search uses document descriptions, subject labels, and numerical representations of meaning to rank related material, then returns excerpts from selected documents. PDF-derived passages can carry page references; Word-derived notes without page markers can use headings or numbered paragraphs instead.

Several study tools use that foundation:

retrieves passages for a question and records their references with the answer. can reopen the exact passages saved with a study summary to develop it further.
selects indexed sources for a topic list, then drafts and revises a longer guide.
retrieves evidence for explanations and connections, including the conditions a theorem needs.

The same search infrastructure supports , keeping their collection identities distinct from course materials. Each downstream tool still has to interpret the passages it receives.

Similar subjects are not always duplicate notes

A lecture may exist as handwriting alone and as a later version with slides pasted beside the same handwriting. Searching both can crowd out other useful sources. Whole-document similarity was too broad to distinguish these pairs from different lectures on the same subject. The subset linker instead compares short word sequences from the handwritten portions, then hides the smaller version when its fuller counterpart survives the search. Both remain accessible.

Links across different years of a course are another feature. The tool reuses existing document comparisons to identify related material, with uncertain matches held for review. That supports revisiting an older explanation without claiming every note has already been matched correctly.

An early August 2026 checkpoint recorded 30 healthy document cards in one course, with 14 subject labels. Those are historical catalog checks, not current totals or a measure of search accuracy. Dense proofs and narrative notes can still need different passage boundaries. can report missing or stale outputs, but its available repair is narrowly scoped rather than a general automatic cleanup. The describes the catalog, search, and linking behavior.

Notes Post-Processing

Fri, 28 Aug 2026 00:00:00 +0000

A square-root sign once became the letter p in my extracted notes. The text still looked printable and ordinary, so the initial checks let it through. Notes Post-Processing was built to catch that kind of plausible-looking error after transcription, then compare it with the original page before making a correction.

Context on both sides of a symbol mattered. Looking only at the text before the corrupted character missed evidence that appeared afterward; a second local model could use that surrounding context to judge which positions deserved attention. The models flag candidates rather than deciding what the source must have said.

The recorded motivating run repaired that square-root error on page 6 and left nine other flagged candidates unchanged. The notation below illustrates the difference:

Extracted text	Corrected reading
`p(h² + k²)`	`√(h² + k²)`

The tool first identifies suspicious text using structural checks and local language-model scores. Surviving candidates go to an image-based comparison with the PDF page. It records whether the page was changed, left alone, or could not be verified.

Testing across more notes exposed another problem: legitimate mathematical language can look unusual to a general language model. Joined words from an upstream spacing error also produced many false alarms. Fixing the spacing and tuning the checks reduced unnecessary flags, but did not eliminate them.

False positives consume review time and image-checking calls. Comparing with an image supplies additional evidence; the model can still misread that evidence or make a bad change. Corrected material therefore needs spot checks rather than being treated as automatically clean.

This tool follows and helps improve material used by the . The describes the reproduced error and broader precision limits.

Notes Transcription Pipeline

Thu, 27 Aug 2026 00:00:00 +0000

A question scribbled beside a lecture slide is easy to lose in a folder of drawings. Notes Transcription turns handwritten canvases and short course PDFs into searchable text, keeping references to the original material. It also separates pasted slides from handwriting, so later study tools can tell which explanation came from the lecturer and which note I added.

Typed PDFs need care too. A small raised character can carry the difference between R² and R2, yet ordinary text extraction may flatten them into the same line. The pipeline uses character size and vertical position to recover exponents and subscripts locally before deciding whether a page needs AI transcription. That preserves useful structure without paying a model to reread every clean page.

Once the output is registered with the , its passages can be found alongside textbook material. That is what lets the draw on a handwritten explanation, or cite course notes behind a proposed connection. Transcription prepares the material those tools read.

Choose how much of the source needs rereading

The PDF path uses three levels of work. Clean digital text can be extracted locally. If only a few pages look defective, those pages receive image-based repair with neighboring text for context. Handwriting, difficult exports, or documents with widespread defects need fuller transcription. Some note-taking exports can omit entire equation regions from their text layer, so an apparently clean extraction is insufficient evidence for trusting them.

The recorded August 2026 comparison checked recovered exponents and subscripts across 13 pages from two documents against existing transcriptions. In one 43-page problem set, the local improvements reduced the detected defect rate from 63% to 5%, leaving two pages for repair. Those results concern the checked notation and routing decisions, not the accuracy of every word in the collection.

Drawings and PDFs take different paths

Excalidraw saves its SVG images automatically. The canvas path cuts a tall drawing at whitespace gaps, transcribes the pieces with some preceding context, and produces both a raw transcript and an expanded note for search. Expansion adds prose and can introduce interpretation; the raw version and source drawing remain important for checking it. Handwritten questions can be marked for a separate answering tool.

The current command-line workflow can prepare page images and task cards for a subscription agent, then validate the submitted cards before writing the usual outputs. This is a manual handoff. The metered API path is also available, and search indexing has its own API calls; running the scripts locally does not mean all processing stays on the device.

Supported sources here are PDFs and Excalidraw scenes with exported images. Word-produced PDFs fit the PDF route; native Word documents are a separate conversion task. Most importantly, plausible-looking errors can survive transcription. checks suspicious text against source images afterward, while the explains the available routes.

Marker PDF Conversion

Wed, 19 Aug 2026 00:00:00 +0000

Finding a word in a textbook PDF does not necessarily find the argument around an equation or the information inside a diagram. Marker PDF Conversion prepares those books for the study tools in Academic Hub: searchable text, mathematical notation, extracted figures, and references back to the source pages. A separate description pass makes figures easier to find through text search too.

Where a long book is divided matters. A fixed page limit can cut through a table or a proof, so the converter looks for chapter boundaries in the PDF outline or printed contents first. It also distinguishes the PDF’s page position from the page number printed in the book. That lets a reference such as “see page 157” remain useful even when a preface has shifted the file’s numbering.

The makes the converted material available as referenced passages. A can then select a textbook section for an explanation, while a can cite evidence for the conditions linking two ideas. Preserving the book’s structure gives those later tools something specific to read and cite.

Rent the hardware for the batch

Marker is an open-source tool for recognizing text and page layout. Here it runs on a temporary graphics-processing machine in Google Cloud, which provides the computing capacity needed for dense books. The model loads once for a batch rather than starting again for every title. Converted files return locally before the temporary machine and disk are removed; keeping an idle disk would continue to cost money.

This is the heavier conversion route. Short documents and handwriting use instead. The inputs are source PDFs I am authorized to process for my own study; the website does not distribute those books.

Keep the source available for comparison

In the recorded four-book check, printed-page labels were recovered for roughly 96-98% of pages, with no duplicate internal anchors. That is encouraging coverage across those layouts, with gaps still requiring the PDF page reference. It does not establish that every formula or cross-reference was transcribed correctly.

The separate figure pass described 764 of 793 candidate images across five books, skipping 29 as decorative. Its derived text leaves the original conversion intact. Descriptions make a chart discoverable but cannot replace examining its axes, values, or visual argument in the source.

Before spending GPU time, duplicate checks can reuse an existing conversion. Less certain matches remain subject to review. Recovery from memory failures also has a documented retry and escalation policy, tested separately from the content checks; those tests do not establish reliability across every cloud interruption.

The covers operation and costs. The page’s linked status records document the conversion, chapter, and figure trials.