AI Tutor: Personalized Learning System
Personalized learning is one of the most powerful practical applications of LLM. Traditional courses assume the same pace and format for everyone; an AI tutor adapts to knowledge level, preferred explanation style, learning speed, and specific knowledge gaps of each student.
AI Tutor Architecture
from anthropic import Anthropic
from pydantic import BaseModel
from typing import Literal, Optional
import json
from datetime import datetime
client = Anthropic()
class StudentProfile(BaseModel):
student_id: str
subject: str
level: Literal["beginner", "intermediate", "advanced"]
learning_style: Literal["visual", "conceptual", "practical", "socratic"]
known_topics: list[str] = []
weak_topics: list[str] = []
session_count: int = 0
last_assessment_score: Optional[float] = None
class LearningSession(BaseModel):
session_id: str
student_id: str
topic: str
messages: list[dict] = []
quiz_results: list[dict] = []
started_at: datetime
class AITutor:
def __init__(self, subject: str, curriculum: dict):
self.subject = subject
self.curriculum = curriculum # {topic: {subtopics, prerequisites, content}}
def _build_system_prompt(self, profile: StudentProfile) -> str:
"""Builds personalized system prompt"""
style_instructions = {
"visual": "Use many examples, analogies, text-based diagrams. Structure information visually through lists and tables.",
"conceptual": "Explain the concept as a whole first, then details. Link to other concepts.",
"practical": "Start with code example/task, then explain why. Provide practical exercises.",
"socratic": "Ask leading questions instead of direct explanations. Guide student to understanding through dialogue.",
}
weak_topics_context = ""
if profile.weak_topics:
weak_topics_context = f"\nStudent struggles with: {', '.join(profile.weak_topics)}. Pay special attention in related topics."
known_context = ""
if profile.known_topics:
known_context = f"\nStudent already knows well: {', '.join(profile.known_topics[-5:])}. You can build on this knowledge."
return f"""You are a personal tutor in {self.subject}.
Student level: {profile.level}
Learning style: {style_instructions[profile.learning_style]}
{known_context}{weak_topics_context}
Rules:
- Never give the answer directly to learning questions — first check understanding with a leading question
- Praise correct answers specifically: "Correct, precisely because..."
- On error — don't say "wrong", ask "What if we consider it from another angle?"
- Adapt explanation complexity to {profile.level} level
- After explaining a topic, offer a check question"""
def explain_topic(
self,
topic: str,
profile: StudentProfile,
session: LearningSession,
student_question: str = None,
) -> str:
"""Explains topic considering student profile"""
# Get topic material from curriculum
topic_content = self.curriculum.get(topic, {})
messages = session.messages.copy()
if not messages:
# First message in session
user_content = f"Let's learn the topic: {topic}"
if topic_content.get("prerequisites"):
user_content += f"\n(Prerequisites: {', '.join(topic_content['prerequisites'])})"
else:
user_content = student_question or "Let's continue"
messages.append({"role": "user", "content": user_content})
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
system=self._build_system_prompt(profile),
messages=messages,
)
assistant_message = response.content[0].text
session.messages.append({"role": "user", "content": user_content})
session.messages.append({"role": "assistant", "content": assistant_message})
return assistant_message
def generate_quiz(self, topic: str, profile: StudentProfile, num_questions: int = 5) -> list[dict]:
"""Generates personalized assessment questions"""
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=2048,
messages=[{
"role": "user",
"content": f"""Create {num_questions} questions to assess knowledge of topic "{topic}".
Student level: {profile.level}
Weak areas: {profile.weak_topics}
Return JSON:
[{{
"question": "...",
"type": "multiple_choice|open|true_false",
"options": ["A: ...", "B: ...", "C: ...", "D: ..."] (for multiple_choice),
"correct_answer": "...",
"explanation": "Why this answer is correct",
"difficulty": "easy|medium|hard"
}}]
Distribute difficulty: {{"easy": 2, "medium": 2, "hard": 1}} for intermediate level."""
}]
)
text = response.content[0].text
start = text.find("[")
end = text.rfind("]") + 1
return json.loads(text[start:end])
def check_answer(
self,
question: dict,
student_answer: str,
profile: StudentProfile,
) -> dict:
"""Checks answer and generates feedback"""
is_correct = student_answer.strip().lower() == question["correct_answer"].strip().lower()
if is_correct:
feedback = f"Correct! {question['explanation']}"
else:
# Generate personalized error explanation
response = client.messages.create(
model="claude-haiku-4-5",
max_tokens=512,
messages=[{
"role": "user",
"content": f"""Student answered question incorrectly.
Question: {question['question']}
Correct answer: {question['correct_answer']}
Student answer: {student_answer}
Explanation: {question['explanation']}
Student level: {profile.level}
Write brief, non-demeaning feedback in 2-3 sentences explaining why the correct answer is right."""
}]
)
feedback = response.content[0].text
return {
"is_correct": is_correct,
"feedback": feedback,
"correct_answer": question["correct_answer"],
}
def update_profile(self, profile: StudentProfile, quiz_results: list[dict]) -> StudentProfile:
"""Updates student profile based on results"""
# Analyze errors
errors_by_topic = {}
for result in quiz_results:
if not result.get("is_correct"):
topic = result.get("topic", "general")
errors_by_topic[topic] = errors_by_topic.get(topic, 0) + 1
# Update weak topics
new_weak = [topic for topic, errors in errors_by_topic.items() if errors >= 2]
profile.weak_topics = list(set(profile.weak_topics + new_weak))[-10:] # Max 10
# Update score
correct_count = sum(1 for r in quiz_results if r.get("is_correct"))
profile.last_assessment_score = correct_count / len(quiz_results) if quiz_results else None
# If score > 80% — suggest level progression
if profile.last_assessment_score and profile.last_assessment_score > 0.8:
if profile.level == "beginner":
profile.level = "intermediate"
elif profile.level == "intermediate":
profile.level = "advanced"
return profile
Adaptive Learning Path
class AdaptiveLearningPath:
"""Builds and adjusts learning path for student"""
def generate_path(self, goal: str, profile: StudentProfile, curriculum: dict) -> list[str]:
"""Generates topic sequence to achieve goal"""
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
messages=[{
"role": "user",
"content": f"""Compose a learning path.
Student goal: {goal}
Level: {profile.level}
Already knows: {profile.known_topics}
Curriculum (available topics): {list(curriculum.keys())}
Return JSON: {{"topics": ["topic1", "topic2", ...], "estimated_weeks": <number>}}
Order from simple to complex, considering already learned topics."""
}]
)
text = response.content[0].text
start = text.find("{")
end = text.rfind("}") + 1
return json.loads(text[start:end])
Practical Case: Online Programming Course
Context: EdTech platform, Python for beginners course, 2400 students. Problems: 68% dropout rate, students stuck on different topics, one mentor couldn't handle.
AI Tutor Implementation:
- Personal profile for each student
- Adaptive explanations (4 learning styles)
- Automatic quizzes after each topic
- Profile updates based on errors
Results over 3 months:
- Dropout rate: 68% → 41%
- Average time per topic: 45 min → 28 min (students got needed format immediately)
- Platform NPS: 34 → 67
- Average final test score: 63% → 78%
Key observation: students with "socratic" learning style showed highest growth — question-answer format maintained engagement better than passive reading.
Timeline
- Basic tutor (explanation + quiz): 3–5 days
- Personalized profile + adaptive content: 2 weeks
- Adaptive learning path + profile updates: 1 week
- Full system with progress dashboard: 4–6 weeks