AI Notes Generator

Deterministic Content Orchestration

Static PDF Generation for Educational Content

A production-grade pipeline that converts raw curriculum data into structured, visually rich PDF textbooks using multi-layer caching and layout-aware rendering. This system demonstrates how to apply Static Site Generator (SSG) principles to AI-powered content generation.

The Problem: Generating educational content is computationally expensive. LLM token costs multiply when generating the same chapter for thousands of students. Additionally, raw LLM output lacks structure—no proper formatting, page breaks, or academic standards compliance.

The Solution: Cache-First Architecture treating notes as immutable artifacts. Once generated, PDFs are cached and served globally. The first user pays the generation cost; subsequent users get instant delivery from cloud storage at sub-second latency.

Key Innovation - Artifact Caching: Three-stage pipeline with content-addressable hashing. Stage 1 generates curriculum structure (JSON). Stage 2 enriches content with media and formatting. Stage 3 renders to layout-aware HTML and compiles to PDF. Each stage's output is hashed and cached, achieving 85% cache hit rates.

Production Results: 80% cost reduction per PDF, print-quality output compliant with CBSE standards, sub-second delivery for cached content, support for KaTeX/LaTeX mathematical equations.

Core Technologies

Python 3.10WeasyPrint (PDF Engine)Jinja2 (Templating)Google Cloud StorageAsyncIOBeautifulSoup4

The Engineering Challenge

LLMs output text. Students need Textbooks.

There is a massive gap between a ChatGPT response and a usable study document.

Structure: LLMs often forget to nest sections correctly.
Formatting: Raw Markdown doesn't handle page breaks, headers, or image alignment suitable for printing.
Cost: Regenerating the same chapter for 1,000 students is a waste of compute resources.

The Solution: A Static Generation Pipeline. We built a system inspired by Static Site Generators (SSG). Instead of generating notes on every request, we treat the notes as artifacts. Once generated, they are immutable, cached, and served globally via CDN logic.

python

class AINotesGenerator:
    """
    Production-grade static generation pipeline that transforms
    curriculum data into structured, layout-aware PDF textbooks.

    Deterministic. Cached. Immutable.
    """

    async def generate(self, subject: str, grade: str, chapter: str, language: str):
        # Resolve Artifact Identity (content-addressable)
        artifact_key = self._compute_artifact_key(
            subject, grade, chapter, language
        )

        # Multi-Layer Cache Check (Local → Cloud → Generate)
        if await self._artifact_exists_in_cache(artifact_key):
            return await self._serve_cached_artifact(artifact_key)

        # Curriculum Resolution Layer
        curriculum = await self._resolve_or_generate_curriculum(
            subject, grade, chapter
        )

        # Structured Content Synthesis (LLM Orchestration)
        structured_markdown = await self._synthesize_notes(curriculum, language)

        # Layout-Aware Rendering Pipeline
        html = self._compile_to_layout(structured_markdown)
        html = self._inject_visual_assets(html)
        html = self._render_math(html)

        # Deterministic PDF Compilation
        pdf_path = await self._render_pdf_artifact(html, artifact_key)

        # Artifact Persistence (Immutable + CDN-ready)
        await self._persist_artifact(pdf_path, artifact_key)

        return pdf_path

85%

Cache Hit Rate

Print-Ready

PDF Quality

KaTeX/LaTeX

Math Support

~80%

Cost Saving

The 'Idempotent' Caching Strategy

The most critical engineering decision was the Cache-First Architecture. LLM tokens are expensive; storage is cheap.

When a request comes in for *"Physics

Class 10
Electricity"*, the system does not call the AI immediately.

GCS Lookup: It constructs a deterministic path (e.g., notes/physics/10/electricity.pdf) and checks Google Cloud Storage.
Instant Delivery: If the file exists, it returns the signed URL instantly. Zero AI cost.
Generation (Cache Miss): Only if the file is missing does it trigger the expensive generation pipeline.

This turns an O(N) cost model (cost scales with users) into an O(1) cost model (cost scales with subjects).

services/notes_services.py

class ArtifactCacheResolver:
    """
    Idempotent, cache-first architecture.
    LLM generation is triggered ONLY on cache miss.
    """

    async def resolve_notes(self, subject: str, grade: str, chapter: str) -> str:
        # Deterministic Artifact Path
        artifact_path = self._build_artifact_path(
            subject=subject,
            grade=grade,
            chapter=chapter
        )

        # Cloud Storage Lookup (Cheap Operation)
        if await self._exists_in_gcs(artifact_path):
            return await self._get_signed_url(artifact_path)

        # Cache Miss → Trigger Expensive Pipeline
        pdf_path = await self._generate_notes_artifact(
            subject, grade, chapter
        )

        # Persist Immutable Artifact
        await self._upload_to_gcs(pdf_path, artifact_path)

        return await self._get_signed_url(artifact_path)

Structured Intelligence: JSON before Text

To ensure the notes adhere to the CBSE curriculum, we don't ask the AI to "write notes" immediately. We use a Two-Pass Generation Strategy.

Pass 1: The Skeleton (JSON) We force the AI to generate a JSON object representing the curriculum tree (Sections, Subsections, Activity Headers). This guarantees the structure is correct before we write a single word of content. It also allows us to cache the curriculum structure locally "curriculum.json" to speed up future regenerations.

services/notes_services.py

prompt = """
You are a curriculum designer. Output JSON ONLY.
Schema:
{
  "chapter_title": "...",
  "sections": [
    { "title": "...", "difficulty": "Medium", "subsections": [...] }
  ]
}
"""
# We parse this JSON to guide the actual content generation later

Content Expansion & Enrichment

Once we have the curriculum skeleton, we pass it to the Content Engine.

Markdown Generation: The AI fills in the flesh of the document using Markdown, strictly enforcing LaTeX formatting for mathematical equations (e.g., $E=mc^2).
Media Injection: The system parses the generated content. If it sees a header like "Electromagnetic Induction," it asynchronously queries Wikipedia's Media API, finds a relevant diagram, and injects the <img> tag into the content stream. This happens automatically without human intervention.

The Rendering Engine (HTML to PDF)

The final step is converting raw text into a beautiful document. We use WeasyPrint, a browser-grade rendering engine.

We treat the notes like a web page.

Jinja2 Templating: We inject the content into an HTML template that defines fonts, margins, and branding.
Math Rendering: We run a pre-processing pass to convert LaTeX equations into SVG/HTML using KaTeX, ensuring math symbols look crisp in print.
PDF Conversion: The HTML is compiled into a binary PDF file. This allows us to control page breaks so headers are not stranded at the bottom of a page.

services/notes_services.py

def _render_pdf(self, html_content, output_path, base_url):
    # WeasyPrint renders the HTML/CSS to a PDF binary
    # 'base_url' ensures local images/fonts are resolved correctly
    
    font_config = FontConfiguration()
    html = HTML(string=html_content, base_url=base_url)
    
    html.write_pdf(
        output_path, 
        font_config=font_config,
        presentational_hints=True
    )

Async Cleanup & Delivery

The moment the PDF is generated, we perform two actions in parallel using FastAPI Background Tasks:

Serve to User: The file is streamed to the user's browser immediately.
Hydrate Cache: The file is uploaded to GCS in the background. The next user who asks for this chapter will get the cached version instantly.
Self-Destruct: Local temporary files are wiped to ensure the server remains stateless and storage does not bloat.