LLM Course Planner | Sadhana Geddam

Overview

This project builds a course planning assistant that takes a student's academic background and target course, then queries a local LLM API to generate structured, step-by-step learning path recommendations. Four progressively sophisticated prompting strategies were implemented and compared.

Python Prompt Engineering LLM API JSON Parsing Chain-of-Thought Multi-step Reasoning Retry Logic Error Handling

System Pipeline

Student Input

Department, degree level, completed courses, target course

Prompt Build

Dynamic prompt with course catalog, constraints, and output format

LLM Query

POST to local API with retry logic on malformed responses

Structured Plan

Parsed JSON learning path with ordered prerequisite steps

Four Prompting Strategies

Zero-Shot JSON Prompting

Single prompt instructing the LLM to return only a valid JSON object with prerequisites and learning path. No examples provided.

structured output

Retry Logic + JSON Repair

Added automatic retry on malformed JSON — strips comments, sanitizes response, re-queries up to 3 times before fallback. Handles LLM hallucinations gracefully.

error handling

Chain-of-Thought (CoT)

Explicit multi-step reasoning — LLM identifies required concepts, compares with student background, identifies gaps, then recommends only courses from the catalog.

CoT reasoning

Multi-Step Decomposition

Breaks the task into 3 independent LLM calls: (1) required knowledge topics, (2) gap analysis, (3) course recommendations — each step feeds the next.

pipeline decomposition

Prompts & Outputs

Part 1 — Zero-Shot JSON Prompt

System Prompt

You are an academic advisor. Based on the student profile and available courses, return only a valid JSON object. Do not add any explanation, notes, or markdown.

Student Profile:
Department: Computer Science
Level: Undergraduate
Completed: CSCI 256, CSCI 356, CSCI 343
Target Course: Deep Learning

LLM Response — Parsed JSON

"target_course": "CSCI 492 Deep Learning (Undergraduate)",
"recommended_prerequisites": [
  { "course_number": "CSCI 356", "course_name": "Data Structures in Python" },
  { "course_number": "CSCI 343", "course_name": "Fundamentals of Data Science" }
],
"suggested_learning_path": [
  { "step": 1, "course_number": "CSCI 343" },
  { "step": 2, "course_number": "CSCI 632", "course_name": "Machine Learning" },
  { "step": 3, "course_number": "CSCI 492", "course_name": "Deep Learning" }
]

Part 3b — Multi-Step Decomposition Output

Step 1 — Required Knowledge Topics

✓ Programming in Python
✓ Machine Learning
✓ Optimization Algorithms (e.g., Gradient Descent)
✓ Data Handling and Preprocessing
✓ Neural Networks (basic architecture, backpropagation)

Step 2 — Gap Analysis

✓ Python — covered via CSCI 256
✓ Data Science basics — covered via CSCI 343
✗ Machine Learning — not taken, gap identified
✗ Neural Networks — not taken, gap identified
✗ Optimization Algorithms — gap identified

Step 3 — Final Learning Path

Step 1: CSCI 632 — Machine Learning
Step 2: CSCI 356 — Data Structures in Python
Final: CSCI 492 — Deep Learning (Target)

Technique Comparison

4prompting strategies

3max retry attempts

3decomposed LLM calls

Part	Technique	Output Format	Reliability	Key Feature
1	Zero-shot JSON	JSON	Moderate	Simple, fast
2	Retry + JSON repair	JSON	High	Handles malformed responses
3a	Chain-of-Thought	Free text → structured	High	Explicit reasoning steps
3b	Multi-step decomposition	3 × JSON	Highest	Each step verifiable

Multi-step decomposition (Part 3b) produced the most reliable and explainable results — breaking the problem into independent LLM calls means each step can be validated separately, hallucinations are caught early, and the reasoning chain is fully transparent. Chain-of-Thought (3a) improved reasoning quality by forcing the model to justify each recommendation before committing to a course suggestion.

LLM-BasedCourse Planner