Building TAssist: My Journey Creating an AI-Powered Teaching Assistant for Google Classroom
How I built a full-stack application to revolutionize assignment evaluation using FastAPI, Next.js, and AI models
The Problem That Started It All
As a teaching assistant struggling with the overwhelming task of evaluating hundreds of coding assignments, I witnessed firsthand how much time and effort goes into providing meaningful feedback. The manual process was not only time-consuming but often led to inconsistent grading and delayed feedback for students. I was lazy not to take manual vivas which would take 2-3 days so I decided to build TAssist so I can check assignments with a single click.
What TAssist Does
TAssist is a modern web application that:
- Automatically evaluates student coding assignments using AI models
- Integrates seamlessly with Google Classroom
- Provides detailed feedback based on assignment rubrics and instructions
- Supports multiple file formats including code files, PDFs, and Jupyter notebooks
- Offers granular control - evaluate entire submissions or specific files
The Tech Stack That Made It Possible
Backend: FastAPI + Python
- FastAPI for the robust REST API
- Google API Client for Classroom integration
- Firebase Admin SDK for data management
- Redis for caching evaluation results
- OpenAI/DeepSeek models for AI evaluation
- PyMuPDF & python-docx for file parsing
Frontend: Next.js + TypeScript
- Next.js 15 with the App Router
- TypeScript for type safety
- TailwindCSS for modern styling
- Framer Motion for smooth animations
- React Context API for state management
The Architecture Deep Dive
1. Authentication Flow with Google OAuth
The authentication system was one of the most challenging parts. I needed to implement a secure OAuth flow that could handle Google Classroom permissions:
# backend/routes/auth.py
@router.get("/auth")
async def authenticate():
creds = None
# Load existing credentials if available
if os.path.exists('token.json'):
creds = Credentials.from_authorized_user_file('token.json', SCOPES)
# Refresh or re-authenticate if needed
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
creds = flow.run_local_server(
port=9090,
access_type='offline',
prompt='consent' # Forces refresh token
)
return {
"token": creds.token,
"refresh_token": creds.refresh_token,
"token_uri": creds.token_uri,
"client_id": creds.client_id,
"client_secret": creds.client_secret
}
2. Smart File Parsing System
One of TAssist's standout features is its ability to parse various file formats from student submissions. Here's how I built the ZIP file parser:
# backend/parse_students_zip.py
import zipfile
import json
import fitz # PyMuPDF
from docx import Document
def parse_zip_contents(zip_stream):
extracted_text = ""
with zipfile.ZipFile(zip_stream, 'r') as archive:
for file_name in archive.namelist():
if should_skip(file_name):
continue
with archive.open(file_name) as file:
content = ""
if is_supported_text_file(file_name):
content = file.read().decode('utf-8', errors='ignore')
elif file_name.endswith('.pdf'):
content = extract_text_from_pdf(io.BytesIO(file.read()))
elif file_name.endswith('.docx'):
content = extract_text_from_docx(io.BytesIO(file.read()))
elif file_name.endswith('.ipynb'):
content = extract_text_from_ipynb(io.TextIOWrapper(file, encoding='utf-8'))
if content:
extracted_text += f"\n--- {file_name} ---\n{content.strip()}\n"
return extracted_text
def extract_text_from_ipynb(file_stream):
"""Extract and format Jupyter Notebook content"""
try:
notebook = json.load(file_stream)
cells = notebook.get("cells", [])
parts = []
for i, cell in enumerate(cells):
cell_type = cell.get("cell_type", "unknown")
source = ''.join(cell.get("source", []))
if cell_type == "markdown":
parts.append(f"[Markdown Cell {i+1}]\n{source}")
elif cell_type == "code":
parts.append(f"[Code Cell {i+1}]\n{source}")
return '\n\n'.join(parts)
except Exception as e:
return "[Error reading .ipynb file]"
3. AI-Powered Evaluation Engine
The heart of TAssist is its evaluation system. I implemented a robust AI evaluation engine with failover support:
# backend/evaluate_assignment.py
from openai import OpenAI
def evaluate_with_failover(prompt):
for api_key in API_KEYS:
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key=api_key
)
try:
response = client.chat.completions.create(
model="deepseek/deepseek-chat-v3-0324:free",
messages=[
{"role": "system", "content": "You are an AI academic evaluator for programming assignments."},
{"role": "user", "content": prompt}
],
extra_body={
"temperature": 0.7,
"max_tokens": 1024,
"provider": {"order": ["Chutes"]}
}
)
return response.choices[0].message.content.strip()
except Exception as e:
print(f"[WARN] Failed with key '{api_key[:15]}...': {e}")
continue
return "❌ All API keys failed for DeepSeek model."
def evaluate_assignment(summary, assignment_text, rubric_text):
evaluation_prompt = f"""
You are an academic evaluator. Based on the provided assignment instructions and submitted content,
assess the student's work and assign a grade out of 100 with detailed feedback.
### Assignment Instructions (Summarized in JSON):
{summary}
### Rubric (Marks Breakdown):
{rubric_text}
### Student Submission Content:
{assignment_text}
### Your Response Format:
{{
"score": <Total marks>,
"breakdown": "<Marks breakdown according to rubric>",
"feedback": "<Detailed evaluation with technical feedback>"
}}
Evaluate fairly and provide specific technical feedback on code functionality and implementation.
"""
return evaluate_with_failover(evaluation_prompt)
The Challenges I Faced and How I Solved Them 🧗♂️
1. Google API Rate Limits
Problem: Google Classroom API has strict rate limits, especially when fetching student names for large classes.
Solution: I implemented concurrent request handling with semaphores and proper error handling:
# backend/fetch_submissions.py
MAX_CONCURRENT_REQUESTS = 50
async def fetch_all_names(user_ids, headers):
sem = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)
async with aiohttp.ClientSession() as session:
tasks = [fetch_name(session, headers, user_id, sem) for user_id in user_ids]
results = await asyncio.gather(*tasks, return_exceptions=True)
return {user_id: name for user_id, name in results if isinstance(name, str)}
2. Complex File Structure Parsing
Problem: Student submissions come in various formats - ZIP files containing multiple code files, PDFs, notebooks, etc.
Solution: I built a comprehensive file parser that handles multiple formats and nested structures while maintaining context about file origins.
3. State Management in React
Problem: Managing complex evaluation states, file selections, and real-time updates across components.
Solution: Used React Context API with TypeScript for type-safe state management:
// frontend/context/AssignmentContext.tsx
interface AssignmentContextType {
details: AssignmentDetails | null;
setDetails: (details: AssignmentDetails) => void;
evaluations: Record<string, EvaluationResult>;
setEvaluations: (evaluations: Record<string, EvaluationResult>) => void;
}
export const AssignmentProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const [details, setDetails] = useState<AssignmentDetails | null>(null);
const [evaluations, setEvaluations] = useState<Record<string, EvaluationResult>>({});
return (
<AssignmentContext.Provider value={{ details, setDetails, evaluations, setEvaluations }}>
{children}
</AssignmentContext.Provider>
);
};
Key Features That Make TAssist Special
1. Intelligent Instruction Parsing
TAssist automatically detects assignment types (coding vs. subjective) and adapts its evaluation approach:
# backend/summarize_instructions.py
def summarize_instructions(pdf_text: str):
assignment_type = detect_assignment_type(pdf_text)
if assignment_type == "coding":
prompt = CODING_ASSIGNMENT_PROMPT
else:
prompt = SUBJECTIVE_ASSIGNMENT_PROMPT
return evaluate_with_failover(prompt + "\n\nAssignment Instructions:\n" + pdf_text)
2. Granular File Selection
Teachers can choose to evaluate specific files rather than entire submissions:
const toggleFileSelection = (user_id: string, file_id: string) => {
setSelectedFiles(prev => {
const currentFiles = prev[user_id] || [];
const newFiles = currentFiles.includes(file_id)
? currentFiles.filter(id => id !== file_id)
: [...currentFiles, file_id];
return { ...prev, [user_id]: newFiles };
});
};
3. Redis-Powered Caching
Evaluation results are cached to avoid re-processing and provide instant access to previous evaluations:
# backend/redis_client.py
def store_evaluation(coursework_id: str, evaluation_data: dict):
try:
redis_client.setex(
f"evaluation:{coursework_id}",
3600, # 1 hour TTL
json.dumps(evaluation_data)
)
except Exception as e:
print(f"Failed to store evaluation: {e}")
What I Learned Building TAssist
1. API Integration at Scale
Working with Google's APIs taught me about proper authentication flows, rate limiting, and handling edge cases in third-party integrations.
2. AI Prompt Engineering
Crafting effective prompts for consistent, reliable evaluation results was an art form. I learned to be specific about output formats and provide clear evaluation criteria.
3. File Processing Challenges
Handling diverse file formats while maintaining performance taught me about streaming, memory management, and format-specific parsing libraries.
4. User Experience Design
Building an interface that teachers would actually want to use required understanding their workflow and pain points deeply.
The Impact and Future
TAssist has the potential to:
- Save hours of manual grading time for educators
- Provide consistent evaluation criteria across all submissions
- Offer immediate feedback to students
- Scale evaluation for large classes efficiently
Future Enhancements I'm Planning:
- Support for more programming languages and assignment types
- Integration with additional LMS platforms (Canvas, Moodle)
- Advanced analytics for class performance insights
- Plagiarism detection capabilities
- Mobile app for on-the-go evaluation review
Technical Lessons and Best Practices
1. Error Handling is Critical
With multiple external APIs and AI services, robust error handling and graceful degradation are essential:
try:
evaluation_result = evaluate_assignment(summary, assignment_text, rubric_text)
store_evaluation(coursework_id, result_data)
return {"evaluation_result": json_to_readable_string(evaluation_result)}
except Exception as e:
print(f" Unhandled exception: {e}")
raise HTTPException(status_code=500, detail=f"Error evaluating assignment: {str(e)}")
2. Type Safety Saves Time
Using TypeScript throughout the frontend prevented countless runtime errors:
interface Submission {
user_id: string;
name: string;
state: string;
is_empty: boolean;
files?: FileInfo[];
}
3. Performance Optimization
Implementing proper caching, lazy loading, and concurrent processing made the difference between a slow tool and a delightful experience.
Conclusion: Building with Passion
Building TAssist has been one of the most rewarding projects I've worked on. I feel that automating something meaningful is truly exciting. The codebase has many problems but it can always be improved.
Want to Try TAssist?
The project is currently in development, but I'm always looking for feedback from educators and developers. If you're interested in testing it out or contributing to the project, feel free to reach out!
Tech Stack Summary:
- Backend: FastAPI, Google APIs, OpenAI, Redis, Firebase
- Frontend: Next.js 15, TypeScript, TailwindCSS, Framer Motion
- Infrastructure: OAuth2, REST APIs, File Processing, AI Integration
What's your experience with educational technology? Have you built similar tools or faced challenges in the education space? I'd love to hear your thoughts and experiences in the comments below!
Tags: #AI #Education #FastAPI #NextJS #GoogleAPI #FullStack #Python #TypeScript #OAuth #WebDevelopment
Top comments (0)