INTRODUCTION: WHAT ARE WE BUILDING AND WHY SHOULD YOU CARE?

Imagine you have a folder full of documents about, say, quantum physics, medieval history, or how to bake sourdough bread. You want to learn this material, but reading through hundreds of pages seems daunting. What if you had a personal teaching assistant that could read all those documents, understand them deeply, and then create customized tutorials just for you? That assistant could generate presentation slides, write clear explanations, create quizzes to test your knowledge, and even provide the answers so you can check your work.

That is exactly what we are going to build together in this article. We will create a system that takes your documents, feeds them into a large language model, and generates complete tutorials on any topic you specify. The system will be smart enough to figure out what kind of computer you have, whether you want to use a language model running on your own machine or one hosted in the cloud, and will handle all the complex technical details automatically.

The best part? Once we are done, you will have a web-based interface where you can navigate through your generated tutorials just like visiting a website. No more juggling different file formats or trying to organize your learning materials manually.

THE BIG PICTURE: HOW ALL THE PIECES FIT TOGETHER

Before we dive into the technical details, let me paint you a picture of how this system works from thirty thousand feet up. Think of our tutorial generator as a factory with several specialized departments, each handling a specific job.

The first department is the Hardware Detective. When you start the system, it looks at your computer and figures out what kind of graphics processing unit you have installed. This matters because different GPUs speak different languages. NVIDIA cards use something called CUDA, AMD cards use ROCm, and Intel cards have their own system. Our detective figures this out automatically so we can configure everything correctly.

The second department is the Document Reader. You point it at a folder on your computer, and it reads every document it finds, whether those documents are PowerPoint presentations, Word files, PDFs, HTML pages, or Markdown files. It does not just read them superficially either. It breaks them down into meaningful chunks and understands the content deeply.

The third department is the Brain, which is where the large language model lives. This is the real intelligence of the system. You can choose to run this brain on your own computer if you have a powerful enough GPU, or you can connect it to a cloud-based service. Either way, the brain has access to all the knowledge from your documents and can answer questions or generate new content based on that knowledge.

The fourth department is the Content Generator. This is where the magic happens. When you ask for a tutorial on a specific topic, the content generator talks to the brain, retrieves relevant information from your documents, and creates a complete tutorial package including presentation pages, detailed explanations, quizzes, and answer keys.

Finally, we have the Web Server department, which takes all the generated content and serves it up as a beautiful website that you can navigate with your browser. You click through pages, read explanations, take quizzes, and check your answers, all from the comfort of your web browser.

Now that you understand the big picture, let us roll up our sleeves and build each of these components step by step.

STEP ONE: BUILDING THE HARDWARE DETECTIVE

The first challenge we face is that different computers have different hardware, and if we want our language model to run efficiently, we need to know what kind of GPU is available. Think of this like a chef who needs to know whether they have a gas stove or an electric one before they start cooking. The cooking process is similar, but the details matter.

Why does GPU architecture matter so much? Language models are computationally intensive. They perform millions of mathematical operations to process text and generate responses. GPUs are designed specifically for these kinds of parallel computations, and they can be hundreds of times faster than using your regular processor. However, NVIDIA GPUs use a framework called CUDA, AMD GPUs use ROCm, and Intel has its own acceleration system. We need to detect which one you have and configure our software accordingly.

The detection process works by querying the system and looking for telltale signs of different GPU types. Here is how we approach this problem in code:

CODE EXAMPLE: GPU Architecture Detection

def detect_gpu_architecture():

"""

Detects the GPU architecture available on the system.

Returns one of: 'cuda', 'rocm', 'intel', 'cpu'

"""

# First, try to detect NVIDIA CUDA

try:

import subprocess

result = subprocess.run(['nvidia-smi'],

capture_output=True,

text=True,

timeout=5)

if result.returncode == 0:

return 'cuda'

except:

pass

# Next, try to detect AMD ROCm

try:

result = subprocess.run(['rocm-smi'],

capture_output=True,

text=True,

timeout=5)

if result.returncode == 0:

return 'rocm'

except:

pass

# Check for Intel GPUs

try:

result = subprocess.run(['clinfo'],

capture_output=True,

text=True,

timeout=5)

if 'Intel' in result.stdout:

return 'intel'

except:

pass

# Check for Apple Metal Performance Shaders (MPS)

try:

import platform

if platform.system() == 'Darwin': # macOS

try:

import torch

if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():

return 'mps'

except ImportError:

# PyTorch not installed, try alternative detection

result = subprocess.run(['system_profiler', 'SPDisplaysDataType'],

capture_output=True,

text=True,

timeout=5)

if 'Apple' in result.stdout and ('M1' in result.stdout or

'M2' in result.stdout or

'M3' in result.stdout or

'M4' in result.stdout):

return 'mps'

except:

pass

# Default to CPU if no GPU detected

return 'cpu'

This function tries to run hardware-specific command-line tools. If nvidia-smi succeeds, we know we have an NVIDIA GPU with CUDA support. If rocm-smi works, we have an AMD GPU. If clinfo reveals Intel hardware, we use Intel acceleration. Finally we try to detect Apple MPS. If none of these work, we fall back to using the CPU, which is slower but still functional.

The beauty of this approach is that it happens automatically. The user never needs to know or care about these technical details. The system just figures it out and moves on. This is exactly the kind of user-friendly design we want throughout our tutorial generator.

STEP TWO: CONFIGURING THE LANGUAGE MODEL FLEXIBLY

Now that we know what hardware we have, we need to configure the language model itself. This is where we give the user real power and flexibility. Some users might have a powerful gaming computer with a high-end GPU and want to run everything locally for privacy and speed. Others might have a modest laptop and prefer to use a cloud service like OpenAI’s GPT or Anthropic’s Claude.

Our system needs to handle both scenarios seamlessly. Think of this like choosing between cooking at home or ordering delivery. Both get you food, but the approach is different. The key insight is that we want to abstract away these differences so the rest of our system does not need to care whether the language model is local or remote.

We accomplish this through a configuration system that stores the user’s preferences and a model manager that handles the actual communication with the language model. The configuration looks like this:

CODE EXAMPLE: LLM Configuration Structure

class LLMConfig:

"""

Configuration for the language model.

Supports both local and remote models.

"""

def __init__(self):

self.model_type = 'remote' # 'local' or 'remote'

self.local_model_path = None

self.remote_api_key = None

self.remote_api_url = None

self.remote_model_name = None

self.gpu_architecture = detect_gpu_architecture()

self.max_tokens = 4096

self.temperature = 0.7

def configure_local_model(self, model_path):

"""

Configure the system to use a local model.

"""

self.model_type = 'local'

self.local_model_path = model_path

print(f"Configured local model at {model_path}")

print(f"Detected GPU architecture: {self.gpu_architecture}")

def configure_remote_model(self, api_key, api_url, model_name):

"""

Configure the system to use a remote API model.

"""

self.model_type = 'remote'

self.remote_api_key = api_key

self.remote_api_url = api_url

self.remote_model_name = model_name

print(f"Configured remote model: {model_name}")

The LLMConfig class stores all the necessary information about which model to use and how to access it. When a user wants to use a local model, they call configure_local_model and provide the path to where the model files are stored on their computer. When they want to use a remote service, they call configure_remote_model with their API credentials.

Notice how we automatically populate the gpu_architecture field using the detection function we built earlier. This means that if someone chooses a local model, we already know what hardware acceleration to use. The user never has to think about it.

The max_tokens and temperature parameters control how the language model generates text. Max_tokens limits how long responses can be, while temperature controls creativity. A lower temperature makes the model more focused and deterministic, while a higher temperature makes it more creative and varied. We set reasonable defaults, but users can adjust these if they want.

STEP THREE: READING DOCUMENTS IN MULTIPLE FORMATS

Now we get to one of the most interesting challenges in our system: reading documents in various formats. Users might have PowerPoint presentations from conferences, Word documents with detailed notes, PDFs of research papers, HTML files saved from websites, and Markdown files they wrote themselves. Our system needs to read all of these formats and extract the text content.

Each format requires a different approach. PowerPoint files use a format called PPTX, which is actually a compressed archive containing XML files. Word documents use DOCX, which is similar. PDFs store text in a completely different way, and we need special libraries to extract it. HTML requires parsing to separate content from formatting tags. Markdown is the simplest, being plain text with simple formatting markers.

Let me show you how we handle each format systematically. We will create a DocumentReader class that knows how to deal with all these different types:

CODE EXAMPLE: Document Reader Class Foundation

import os

from pathlib import Path

class DocumentReader:

"""

Reads documents in multiple formats and extracts text content.

Supports: PPTX, DOCX, PDF, HTML, Markdown

"""

def __init__(self, document_path):

"""

Initialize the document reader with a path to scan.

The path can be a single file or a directory.

"""

self.document_path = Path(document_path)

self.documents = []

self.supported_extensions = {

'.pptx', '.ppt',

'.docx', '.doc',

'.pdf',

'.html', '.htm',

'.md', '.markdown'

}

def scan_directory(self):

"""

Scans the document path and finds all supported files.

"""

if self.document_path.is_file():

if self.document_path.suffix.lower() in self.supported_extensions:

self.documents.append(self.document_path)

elif self.document_path.is_directory():

for file_path in self.document_path.rglob('*'):

if file_path.is_file() and file_path.suffix.lower() in self.supported_extensions:

self.documents.append(file_path)

print(f"Found {len(self.documents)} documents to process")

return self.documents

The DocumentReader initializes with a path that can point to either a single file or an entire directory. The scan_directory method recursively searches through directories to find all supported file types. The rglob function is particularly clever here because it searches not just the top-level directory but all subdirectories as well. This means users can organize their documents in folders, and our system will find them all.

Now let us look at how we extract text from PowerPoint files. PowerPoint files are actually ZIP archives containing XML files that describe the slides. We need to open the archive, find the XML files containing slide content, and parse out the text:

CODE EXAMPLE: PowerPoint Text Extraction

from pptx import Presentation

def read_powerpoint(self, file_path):

"""

Extracts text content from PowerPoint files.

Returns a dictionary with metadata and text content.

"""

try:

prs = Presentation(file_path)

text_content = []

for slide_num, slide in enumerate(prs.slides, start=1):

slide_text = f"Slide {slide_num}:\n"

# Extract text from all shapes in the slide

for shape in slide.shapes:

if hasattr(shape, "text"):

if shape.text.strip():

slide_text += shape.text + "\n"

# Extract notes if present

if slide.has_notes_slide:

notes_slide = slide.notes_slide

if notes_slide.notes_text_frame:

notes_text = notes_slide.notes_text_frame.text

if notes_text.strip():

slide_text += f"Notes: {notes_text}\n"

text_content.append(slide_text)

return {

'filename': file_path.name,

'type': 'powerpoint',

'content': '\n\n'.join(text_content),

'num_slides': len(prs.slides)

}

except Exception as e:

print(f"Error reading PowerPoint file {file_path}: {e}")

return None

This method uses the python-pptx library to open PowerPoint files. We iterate through each slide and extract text from all text-containing shapes. Many people do not realize that PowerPoint slides can have speaker notes attached to them, which often contain valuable additional information. Our code extracts these notes as well, making sure we capture all the knowledge in the document.

Word documents work similarly, but they have a linear structure rather than slides. Here is how we handle them:

CODE EXAMPLE: Word Document Text Extraction

from docx import Document

def read_word(self, file_path):

"""

Extracts text content from Word documents.

Returns a dictionary with metadata and text content.

"""

try:

doc = Document(file_path)

text_content = []

# Extract text from paragraphs

for paragraph in doc.paragraphs:

if paragraph.text.strip():

text_content.append(paragraph.text)

# Extract text from tables

for table in doc.tables:

for row in table.rows:

row_text = []

for cell in row.cells:

if cell.text.strip():

row_text.append(cell.text)

if row_text:

text_content.append(' | '.join(row_text))

return {

'filename': file_path.name,

'type': 'word',

'content': '\n'.join(text_content),

'num_paragraphs': len(doc.paragraphs),

'num_tables': len(doc.tables)

}

except Exception as e:

print(f"Error reading Word document {file_path}: {e}")

return None

Word documents contain paragraphs and tables. We extract both, preserving the structure as much as possible. When we encounter tables, we format the cells with pipe characters to maintain some sense of the table structure in the extracted text. This is important because tables often contain structured information that loses meaning if we just dump all the text together randomly.

PDF files are trickier because PDFs are designed for displaying documents, not for extracting text. The text might be stored as actual text, or it might be images of text that require optical character recognition. We use the PyPDF2 library for basic text extraction:

CODE EXAMPLE: PDF Text Extraction

import PyPDF2

def read_pdf(self, file_path):

"""

Extracts text content from PDF files.

Returns a dictionary with metadata and text content.

"""

try:

with open(file_path, 'rb') as file:

pdf_reader = PyPDF2.PdfReader(file)

text_content = []

for page_num, page in enumerate(pdf_reader.pages, start=1):

page_text = page.extract_text()

if page_text.strip():

text_content.append(f"Page {page_num}:\n{page_text}")

return {

'filename': file_path.name,

'type': 'pdf',

'content': '\n\n'.join(text_content),

'num_pages': len(pdf_reader.pages)

}

except Exception as e:

print(f"Error reading PDF file {file_path}: {e}")

return None

For HTML files, we need to parse the HTML tags and extract just the text content, ignoring formatting, scripts, and style information:

CODE EXAMPLE: HTML Text Extraction

from bs4 import BeautifulSoup

def read_html(self, file_path):

"""

Extracts text content from HTML files.

Returns a dictionary with metadata and text content.

"""

try:

with open(file_path, 'r', encoding='utf-8') as file:

html_content = file.read()

soup = BeautifulSoup(html_content, 'html.parser')

# Remove script and style elements

for script in soup(['script', 'style']):

script.decompose()

# Get text and clean it up

text = soup.get_text()

lines = (line.strip() for line in text.splitlines())

chunks = (phrase.strip() for line in lines for phrase in line.split(" "))

text_content = '\n'.join(chunk for chunk in chunks if chunk)

return {

'filename': file_path.name,

'type': 'html',

'content': text_content,

'title': soup.title.string if soup.title else 'No title'

}

except Exception as e:

print(f"Error reading HTML file {file_path}: {e}")

return None

Beautiful Soup is a fantastic library for parsing HTML. We use it to remove script and style tags which do not contain meaningful content, then extract all the text. The cleaning process removes extra whitespace and blank lines to make the text more readable.

Markdown files are the simplest to handle because they are plain text files with minimal formatting:

CODE EXAMPLE: Markdown Text Extraction

def read_markdown(self, file_path):

"""

Reads Markdown files.

Returns a dictionary with metadata and text content.

"""

try:

with open(file_path, 'r', encoding='utf-8') as file:

content = file.read()

return {

'filename': file_path.name,

'type': 'markdown',

'content': content

}

except Exception as e:

print(f"Error reading Markdown file {file_path}: {e}")

return None

Now we need a dispatcher method that looks at a file’s extension and calls the appropriate reading function:

CODE EXAMPLE: Document Reading Dispatcher

def read_document(self, file_path):

"""

Reads a document based on its file extension.

"""

extension = file_path.suffix.lower()

if extension in ['.pptx', '.ppt']:

return self.read_powerpoint(file_path)

elif extension in ['.docx', '.doc']:

return self.read_word(file_path)

elif extension == '.pdf':

return self.read_pdf(file_path)

elif extension in ['.html', '.htm']:

return self.read_html(file_path)

elif extension in ['.md', '.markdown']:

return self.read_markdown(file_path)

else:

print(f"Unsupported file type: {extension}")

return None

def read_all_documents(self):

"""

Reads all documents found during scanning.

Returns a list of document dictionaries.

"""

self.scan_directory()

all_docs = []

for doc_path in self.documents:

print(f"Reading: {doc_path.name}")

doc_data = self.read_document(doc_path)

if doc_data:

all_docs.append(doc_data)

print(f"Successfully read {len(all_docs)} documents")

return all_docs

The read_all_documents method ties everything together. It scans the directory for files, reads each one using the appropriate method, and returns a list of dictionaries containing the extracted text and metadata. This gives us a uniform representation of all documents regardless of their original format.

STEP FOUR: IMPLEMENTING RETRIEVAL AUGMENTED GENERATION

Now we arrive at the heart of our system: Retrieval Augmented Generation, or RAG for short. This is a fancy term for a simple but powerful idea. When we ask the language model to generate a tutorial, we do not want it to just make things up based on its training. We want it to use the specific documents we provided. RAG accomplishes this by finding relevant parts of our documents and feeding them to the language model along with the query.

Think of RAG like giving a student an open book exam. Instead of relying purely on memory, the student can look up specific information in their textbook while answering questions. The student still needs to understand the material and synthesize an answer, but they have factual information at their fingertips.

The RAG process has three main steps. First, we break our documents into smaller chunks. A document might be hundreds of pages long, but we want to work with more manageable pieces. Second, we convert these chunks into mathematical representations called embeddings. These embeddings capture the meaning of the text in a way that allows us to measure similarity. Third, when someone asks a question or requests a tutorial on a topic, we find the chunks whose embeddings are most similar to the query and pass those to the language model.

Let us build this step by step. First, we need to split documents into chunks. Why chunk at all? Language models have limited context windows. They can only process a certain amount of text at once. Even if a model could handle an entire document, it is more efficient to give it just the relevant parts. We want chunks that are large enough to contain meaningful information but small enough to be manageable:

CODE EXAMPLE: Document Chunking

class DocumentChunker:

"""

Splits documents into manageable chunks for RAG.

"""

def __init__(self, chunk_size=1000, chunk_overlap=200):

"""

chunk_size: Maximum number of characters per chunk

chunk_overlap: Number of characters to overlap between chunks

"""

self.chunk_size = chunk_size

self.chunk_overlap = chunk_overlap

def split_text(self, text, metadata):

"""

Splits text into overlapping chunks.

"""

chunks = []

start = 0

text_length = len(text)

while start < text_length:

end = start + self.chunk_size

# Try to break at a sentence boundary

if end < text_length:

# Look for sentence endings near the chunk boundary

search_start = max(start, end - 100)

for delimiter in ['. ', '.\n', '! ', '?\n']:

last_delimiter = text.rfind(delimiter, search_start, end)

if last_delimiter != -1:

end = last_delimiter + len(delimiter)

break

chunk_text = text[start:end].strip()

if chunk_text:

chunk_data = {

'text': chunk_text,

'metadata': metadata.copy(),

'start_pos': start,

'end_pos': end

}

chunks.append(chunk_data)

# Move start position for next chunk with overlap

start = end - self.chunk_overlap

if start >= text_length:

break

return chunks

def chunk_documents(self, documents):

"""

Chunks all documents in the collection.

"""

all_chunks = []

for doc in documents:

metadata = {

'filename': doc['filename'],

'type': doc['type']

}

chunks = self.split_text(doc['content'], metadata)

all_chunks.extend(chunks)

print(f"Created {len(all_chunks)} chunks from {len(documents)} documents")

return all_chunks

The chunking strategy includes overlap between consecutive chunks. Why overlap? Imagine a crucial piece of information appears at the very end of one chunk. Without overlap, that information might be separated from its context in the next chunk. By overlapping chunks, we ensure that information near chunk boundaries appears in multiple chunks with different context.

We also try to break chunks at sentence boundaries rather than arbitrarily cutting text mid-sentence. This preserves readability and meaning. The code looks for sentence-ending punctuation near the target chunk size and breaks there when possible.

Next, we need to create embeddings for our chunks. Embeddings are vector representations of text that capture semantic meaning. Similar texts have similar embeddings. This is crucial for retrieval because we can mathematically compare embeddings to find relevant chunks:

CODE EXAMPLE: Embedding Generator

from sentence_transformers import SentenceTransformer

import numpy as np

class EmbeddingGenerator:

"""

Generates embeddings for text chunks using a transformer model.

"""

def __init__(self, model_name='all-MiniLM-L6-v2'):

"""

Initialize with a sentence transformer model.

all-MiniLM-L6-v2 is a good balance of speed and quality.

"""

print(f"Loading embedding model: {model_name}")

self.model = SentenceTransformer(model_name)

print("Embedding model loaded successfully")

def generate_embeddings(self, chunks):

"""

Generates embeddings for all chunks.

"""

texts = [chunk['text'] for chunk in chunks]

print(f"Generating embeddings for {len(texts)} chunks...")

embeddings = self.model.encode(texts, show_progress_bar=True)

# Add embeddings to chunk data

for chunk, embedding in zip(chunks, embeddings):

chunk['embedding'] = embedding

return chunks

The SentenceTransformer model we use is specifically designed for creating semantic embeddings. The all-MiniLM-L6-v2 model is relatively small and fast while still producing high-quality embeddings. It converts each chunk of text into a 384-dimensional vector. These vectors capture the meaning of the text in a way that similar texts have vectors pointing in similar directions.

Now we need a vector store to efficiently search through our embeddings and find the most relevant chunks for a given query:

CODE EXAMPLE: Vector Store for Similarity Search

class VectorStore:

"""

Stores embeddings and performs similarity search.

"""

def __init__(self):

self.chunks = []

self.embeddings = None

def add_chunks(self, chunks):

"""

Adds chunks with embeddings to the store.

"""

self.chunks = chunks

self.embeddings = np.array([chunk['embedding'] for chunk in chunks])

print(f"Vector store now contains {len(self.chunks)} chunks")

def cosine_similarity(self, vec1, vec2):

"""

Computes cosine similarity between two vectors.

"""

dot_product = np.dot(vec1, vec2)

norm_vec1 = np.linalg.norm(vec1)

norm_vec2 = np.linalg.norm(vec2)

return dot_product / (norm_vec1 * norm_vec2)

def search(self, query_embedding, top_k=5):

"""

Finds the top_k most similar chunks to the query.

"""

similarities = []

for i, chunk_embedding in enumerate(self.embeddings):

similarity = self.cosine_similarity(query_embedding, chunk_embedding)

similarities.append((i, similarity))

# Sort by similarity (highest first)

similarities.sort(key=lambda x: x[1], reverse=True)

# Return top_k results

results = []

for i, similarity in similarities[:top_k]:

result = self.chunks[i].copy()

result['similarity_score'] = similarity

results.append(result)

return results

The vector store uses cosine similarity to compare embeddings. Cosine similarity measures the angle between two vectors, with a value of 1 meaning the vectors point in exactly the same direction (completely similar) and 0 meaning they are orthogonal (unrelated). This is perfect for our use case because we care about the direction of meaning rather than the magnitude of the embedding vectors.

Now let us tie together the RAG components into a cohesive system:

CODE EXAMPLE: RAG System Integration

class RAGSystem:

"""

Complete Retrieval Augmented Generation system.

"""

def __init__(self, document_path):

self.document_reader = DocumentReader(document_path)

self.chunker = DocumentChunker(chunk_size=1000, chunk_overlap=200)

self.embedding_generator = EmbeddingGenerator()

self.vector_store = VectorStore()

self.documents = []

self.chunks = []

def initialize(self):

"""

Reads documents, chunks them, and generates embeddings.

"""

print("Initializing RAG system...")

# Read all documents

self.documents = self.document_reader.read_all_documents()

# Chunk the documents

self.chunks = self.chunker.chunk_documents(self.documents)

# Generate embeddings

self.chunks = self.embedding_generator.generate_embeddings(self.chunks)

# Add to vector store

self.vector_store.add_chunks(self.chunks)

print("RAG system initialized successfully")

def retrieve_relevant_chunks(self, query, top_k=5):

"""

Retrieves the most relevant chunks for a given query.

"""

# Generate embedding for the query

query_embedding = self.embedding_generator.model.encode([query])[0]

# Search for similar chunks

results = self.vector_store.search(query_embedding, top_k)

return results

The RAGSystem class orchestrates all the components we have built. The initialize method runs through the entire pipeline: reading documents, chunking them, generating embeddings, and storing them in the vector store. The retrieve_relevant_chunks method takes a query, converts it to an embedding, and finds the most similar chunks in our collection.

STEP FIVE: CONNECTING TO THE LANGUAGE MODEL

With our RAG system in place, we now need to connect it to the language model that will actually generate tutorial content. Remember, we designed our system to support both local and remote models. Now we need to implement the interface that talks to these models.

Let us create a unified interface that abstracts away the differences between local and remote models:

CODE EXAMPLE: Language Model Interface

class LanguageModelInterface:

"""

Unified interface for both local and remote language models.

"""

def __init__(self, config):

self.config = config

self.model = None

self._initialize_model()

def _initialize_model(self):

"""

Initializes the appropriate model based on configuration.

"""

if self.config.model_type == 'local':

self._initialize_local_model()

elif self.config.model_type == 'remote':

self._initialize_remote_model()

else:

raise ValueError(f"Unknown model type: {self.config.model_type}")

def _initialize_local_model(self):

"""

Initializes a local language model using llama-cpp-python.

"""

try:

from llama_cpp import Llama

# Configure based on GPU architecture

if self.config.gpu_architecture == 'cuda':

n_gpu_layers = 35 # Offload layers to GPU

elif self.config.gpu_architecture == 'rocm':

n_gpu_layers = 35

elif self.config.gpu_architecture == 'mps':

n_gpu_layers = 1 # Apple Metal Performance Shaders

elif self.config.gpu_architecture == 'intel':

n_gpu_layers = 0 # Intel requires different setup

else:

n_gpu_layers = 0 # CPU only

print(f"Loading local model from {self.config.local_model_path}")

print(f"Using {self.config.gpu_architecture} acceleration with {n_gpu_layers} GPU layers")

self.model = Llama(

model_path=self.config.local_model_path,

n_ctx=self.config.max_tokens,

n_gpu_layers=n_gpu_layers,

verbose=False

)

print("Local model loaded successfully")

except Exception as e:

print(f"Error loading local model: {e}")

raise

print(f"Loading local model from {self.config.local_model_path}")

print(f"Using {self.config.gpu_architecture} acceleration with {n_gpu_layers} GPU layers")

self.model = Llama(

model_path=self.config.local_model_path,

n_ctx=self.config.max_tokens,

n_gpu_layers=n_gpu_layers,

verbose=False

)

print("Local model loaded successfully")

except Exception as e:

print(f"Error loading local model: {e}")

raise

def _initialize_remote_model(self):

"""

Initializes connection to a remote API.

"""

print(f"Configured for remote model: {self.config.remote_model_name}")

print(f"API URL: {self.config.remote_api_url}")

# The actual API calls will be made in the generate method

Notice how the initialization method checks the GPU architecture and configures the model accordingly. For CUDA and ROCm, we can offload many layers to the GPU, dramatically speeding up inference. For CPU-only systems, we keep everything on the CPU. This automatic configuration is one of the key features that makes our system user-friendly.

Now let us implement the generation methods:

CODE EXAMPLE: Text Generation Methods

def generate(self, prompt, max_tokens=None, temperature=None):

"""

Generates text based on a prompt.

Works with both local and remote models.

"""

if max_tokens is None:

max_tokens = self.config.max_tokens

if temperature is None:

temperature = self.config.temperature

if self.config.model_type == 'local':

return self._generate_local(prompt, max_tokens, temperature)

else:

return self._generate_remote(prompt, max_tokens, temperature)

def _generate_local(self, prompt, max_tokens, temperature):

"""

Generates text using a local model.

"""

try:

response = self.model(

prompt,

max_tokens=max_tokens,

temperature=temperature,

stop=["</s>", "\n\n\n"],

echo=False

)

return response['choices'][0]['text']

except Exception as e:

print(f"Error generating with local model: {e}")

return None

def _generate_remote(self, prompt, max_tokens, temperature):

"""

Generates text using a remote API.

"""

import requests

import json

try:

headers = {

'Authorization': f'Bearer {self.config.remote_api_key}',

'Content-Type': 'application/json'

}

data = {

'model': self.config.remote_model_name,

'prompt': prompt,

'max_tokens': max_tokens,

'temperature': temperature

}

response = requests.post(

self.config.remote_api_url,

headers=headers,

json=data,

timeout=60

)

response.raise_for_status()

result = response.json()

# Different APIs have different response formats

# This is a generic parser

if 'choices' in result:

return result['choices'][0]['text']

elif 'completion' in result:

return result['completion']

else:

return result.get('text', str(result))

except Exception as e:

print(f"Error generating with remote API: {e}")

return None

The generate method provides a unified interface regardless of whether we are using a local or remote model. From the caller’s perspective, they just call generate with a prompt and get back text. The implementation details of where that text comes from are hidden.

For local models, we use the llama-cpp-python library which is highly optimized and supports various GPU architectures. For remote models, we make HTTP requests to the API endpoint. Different API providers have slightly different response formats, so our code handles the common variations.

STEP SIX: GENERATING TUTORIAL CONTENT

Now we reach the pinnacle of our system: the TutorialGenerator class that brings together RAG and the language model to create comprehensive tutorials. This class will generate presentation pages, explanation documents, quizzes, and quiz solutions.

The key insight here is that we want to generate each type of content separately with appropriate prompts. A presentation page should be concise with bullet points. An explanation document should be detailed and thorough. A quiz should test understanding without being too easy or too hard. Let us build this systematically:

CODE EXAMPLE: Tutorial Generator Foundation

class TutorialGenerator:

"""

Generates complete tutorials using RAG and LLM.

"""

def __init__(self, rag_system, llm_interface):

self.rag = rag_system

self.llm = llm_interface

self.tutorial_data = {}

def generate_tutorial(self, topic, num_pages=5, num_quiz_questions=10):

"""

Generates a complete tutorial on the specified topic.

"""

print(f"Generating tutorial on: {topic}")

self.tutorial_data = {

'topic': topic,

'pages': [],

'explanation': '',

'quiz': [],

'quiz_solutions': []

}

# Generate presentation pages

print("Generating presentation pages...")

for i in range(num_pages):

page = self.generate_presentation_page(topic, i, num_pages)

self.tutorial_data['pages'].append(page)

# Generate explanation document

print("Generating explanation document...")

self.tutorial_data['explanation'] = self.generate_explanation(topic)

# Generate quiz

print("Generating quiz questions...")

self.tutorial_data['quiz'] = self.generate_quiz(topic, num_quiz_questions)

# Generate quiz solutions

print("Generating quiz solutions...")

self.tutorial_data['quiz_solutions'] = self.generate_quiz_solutions(

self.tutorial_data['quiz']

)

print("Tutorial generation complete")

return self.tutorial_data

The generate_tutorial method orchestrates the entire tutorial creation process. It generates each component in sequence, storing the results in a structured dictionary that we can later use to create web pages.

Let us look at how we generate presentation pages. Each page should focus on a specific aspect of the topic and be concise enough to fit on a single slide:

CODE EXAMPLE: Presentation Page Generation

def generate_presentation_page(self, topic, page_number, total_pages):

"""

Generates a single presentation page.

"""

# Retrieve relevant context from documents

query = f"{topic} presentation content for page {page_number + 1}"

relevant_chunks = self.rag.retrieve_relevant_chunks(query, top_k=3)

# Build context from retrieved chunks

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

# Create prompt for page generation

prompt = f"""Based on the following information, create presentation slide content for a tutorial on {topic}.

This is slide {page_number + 1} of {total_pages}.

Context from documents:

{context}

Create concise slide content with:

1. A clear slide title

1. 3-5 bullet points covering key concepts

1. Brief explanations for each point

Format your response as:

TITLE: [slide title]

CONTENT:

- [bullet point 1]

- [bullet point 2]

- [bullet point 3]

Slide content:”””

```

response = self.llm.generate(prompt, max_tokens=500, temperature=0.7)

# Parse the response

page_data = self._parse_presentation_page(response)

page_data['page_number'] = page_number + 1

page_data['sources'] = [chunk['metadata']['filename'] for chunk in relevant_chunks]

return page_data

def _parse_presentation_page(self, response):

"""

Parses the LLM response into structured page data.

"""

lines = response.strip().split('\n')

title = "Untitled"

content = []

for line in lines:

line = line.strip()

if line.startswith('TITLE:'):

title = line.replace('TITLE:', '').strip()

elif line.startswith('-') or line.startswith('*'):

content.append(line.lstrip('-*').strip())

return {

'title': title,

'content': content

}

The presentation page generator retrieves relevant chunks from our RAG system, constructs a focused prompt, and generates concise content suitable for slides. We specify the format we want in the prompt to make parsing easier. The sources field tracks which documents contributed to this page, which is valuable for attribution and fact-checking.

Next, let us generate the detailed explanation document. This should be more comprehensive than the presentation pages and provide in-depth coverage of the topic:

CODE EXAMPLE: Explanation Document Generation

def generate_explanation(self, topic):

"""

Generates a detailed explanation document.

"""

# Retrieve more context for comprehensive explanation

relevant_chunks = self.rag.retrieve_relevant_chunks(topic, top_k=10)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Based on the following source material, write a comprehensive explanation of {topic}.

```

Context from documents:

{context}

Write a detailed, well-structured explanation that covers:

1. Introduction and overview

1. Key concepts and principles

1. Important details and examples

1. Relationships between concepts

1. Practical applications or implications

The explanation should be educational, clear, and thorough. Use multiple paragraphs to organize the information logically.

Explanation:”””

```

explanation = self.llm.generate(prompt, max_tokens=2000, temperature=0.7)

return explanation

The explanation generator retrieves more chunks than the presentation pages because we want comprehensive coverage. We also allow for more tokens in the response to accommodate the longer, more detailed text.

Now let us create the quiz generator. A good quiz should test understanding at different levels, from simple recall to application and analysis:

CODE EXAMPLE: Quiz Generation

def generate_quiz(self, topic, num_questions):

"""

Generates quiz questions to test understanding.

"""

relevant_chunks = self.rag.retrieve_relevant_chunks(topic, top_k=10)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Based on the following material about {topic}, create {num_questions} quiz questions to test understanding.

```

Context from documents:

{context}

Create a mix of question types:

- Multiple choice questions (with 4 options)

- True/false questions

- Short answer questions

Format each question as:

Q1: [question text]

TYPE: [multiple_choice/true_false/short_answer]

A) [option A] (for multiple choice)

B) [option B] (for multiple choice)

C) [option C] (for multiple choice)

D) [option D] (for multiple choice)

Questions:”””

```

response = self.llm.generate(prompt, max_tokens=1500, temperature=0.8)

quiz_questions = self._parse_quiz(response)

return quiz_questions

def _parse_quiz(self, response):

"""

Parses quiz questions from LLM response.

"""

questions = []

current_question = None

lines = response.strip().split('\n')

for line in lines:

line = line.strip()

if not line:

continue

if line.startswith('Q') and ':' in line:

if current_question:

questions.append(current_question)

current_question = {

'question': line.split(':', 1)[1].strip(),

'type': 'multiple_choice',

'options': []

}

elif line.startswith('TYPE:'):

if current_question:

current_question['type'] = line.split(':', 1)[1].strip().lower()

elif line[0] in ['A', 'B', 'C', 'D'] and line[1] == ')':

if current_question:

current_question['options'].append(line[3:].strip())

if current_question:

questions.append(current_question)

return questions

The quiz generator creates diverse question types to assess different aspects of understanding. Multiple choice questions test recognition, true/false questions test comprehension of key facts, and short answer questions require deeper understanding and the ability to articulate concepts.

Finally, we need to generate solutions to the quiz questions:

CODE EXAMPLE: Quiz Solution Generation

def generate_quiz_solutions(self, quiz_questions):

"""

Generates detailed solutions for quiz questions.

"""

solutions = []

for i, question in enumerate(quiz_questions):

relevant_chunks = self.rag.retrieve_relevant_chunks(

question['question'],

top_k=3

)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Provide a detailed answer to this quiz question based on the context.

```

Question: {question[‘question’]}

Context:

{context}

Provide:

1. The correct answer

1. A clear explanation of why this is correct

1. Additional context to deepen understanding

Solution:”””

```

solution_text = self.llm.generate(prompt, max_tokens=500, temperature=0.7)

solutions.append({

'question_number': i + 1,

'question': question['question'],

'solution': solution_text

})

return solutions

For each quiz question, we retrieve relevant context again and ask the language model to provide not just the answer but also an explanation. This makes the quiz solutions valuable learning tools rather than just answer keys.

STEP SEVEN: CREATING THE WEB INTERFACE

Now that we can generate tutorial content, we need to present it in a user-friendly web interface. The interface should allow users to navigate between presentation pages, read the explanation document, take the quiz, and check their answers. We will create a simple web server using Flask and generate HTML pages dynamically.

Let us start with the web server foundation:

CODE EXAMPLE: Web Server Foundation

from flask import Flask, render_template_string, request, redirect, url_for

import json

import os

class TutorialWebServer:

"""

Web server for displaying generated tutorials.

"""

def __init__(self, tutorial_generator, port=5000):

self.tutorial_generator = tutorial_generator

self.port = port

self.app = Flask(__name__)

self.current_tutorial = None

self._setup_routes()

def _setup_routes(self):

"""

Sets up the Flask routes for the web interface.

"""

self.app.route('/')(self.index)

self.app.route('/generate', methods=['POST'])(self.generate)

self.app.route('/presentation/<int:page_num>')(self.presentation_page)

self.app.route('/explanation')(self.explanation)

self.app.route('/quiz')(self.quiz)

self.app.route('/quiz/solutions')(self.quiz_solutions)

def index(self):

"""

Home page with tutorial generation form.

"""

return render_template_string(self.get_index_template())

def generate(self):

"""

Handles tutorial generation request.

"""

topic = request.form.get('topic', '')

num_pages = int(request.form.get('num_pages', 5))

num_questions = int(request.form.get('num_questions', 10))

if topic:

self.current_tutorial = self.tutorial_generator.generate_tutorial(

topic,

num_pages,

num_questions

)

return redirect(url_for('presentation_page', page_num=1))

return redirect(url_for('index'))

The TutorialWebServer class wraps our tutorial generator in a Flask web application. Flask is a lightweight Python web framework that makes it easy to create web applications. We define routes for different pages: the home page where users request tutorials, presentation pages, the explanation document, the quiz, and the quiz solutions.

Now let us create HTML templates for each page. We will start with the index page where users configure and request tutorials:

CODE EXAMPLE: Index Page Template

def get_index_template(self):

"""

Returns the HTML template for the index page.

"""

return '''

```

<!DOCTYPE html>

<head>

<title>Tutorial Generator</title>

<style>

body {

font-family: Arial, sans-serif;

max-width: 800px;

margin: 50px auto;

padding: 20px;

background-color: #f5f5f5;

}

.container {

background-color: white;

padding: 30px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

text-align: center;

}

.form-group {

margin-bottom: 20px;

}

label {

display: block;

margin-bottom: 5px;

font-weight: bold;

color: #555;

}

input[type="text"],

input[type="number"] {

width: 100%;

padding: 10px;

border: 1px solid #ddd;

border-radius: 5px;

font-size: 16px;

}

button {

background-color: #4CAF50;

color: white;

padding: 12px 30px;

border: none;

border-radius: 5px;

cursor: pointer;

font-size: 16px;

width: 100%;

}

button:hover {

background-color: #45a049;

}

</style>

</head>

<body>

<h1>AI Tutorial Generator</h1>

<p>Generate comprehensive tutorials on any topic using your documents and AI.</p>

```

<label for="topic">Tutorial Topic:</label>

<input type="text" id="topic" name="topic" required

placeholder="e.g., Machine Learning Basics">

</div>

<label for="num_pages">Number of Presentation Pages:</label>

<input type="number" id="num_pages" name="num_pages"

value="5" min="1" max="20">

</div>

<label for="num_questions">Number of Quiz Questions:</label>

<input type="number" id="num_questions" name="num_questions"

value="10" min="1" max="30">

</div>

<button type="submit">Generate Tutorial</button>

</form>

</div>

```

</body>

</html>

'''

The index template provides a clean, user-friendly form where users can specify what tutorial they want to generate and customize the number of pages and quiz questions. The CSS styling makes it visually appealing and easy to use.

Next, let us create the template for presentation pages with navigation:

CODE EXAMPLE: Presentation Page Template and Handler

def presentation_page(self, page_num):

"""

Displays a specific presentation page.

"""

if not self.current_tutorial or page_num < 1:

return redirect(url_for('index'))

pages = self.current_tutorial['pages']

if page_num > len(pages):

return redirect(url_for('index'))

page = pages[page_num - 1]

topic = self.current_tutorial['topic']

total_pages = len(pages)

return render_template_string(

self.get_presentation_template(),

topic=topic,

page=page,

page_num=page_num,

total_pages=total_pages

)

def get_presentation_template(self):

"""

Returns the HTML template for presentation pages.

"""

return '''

```

<!DOCTYPE html>

<head>

<title>{{ topic }} - Page {{ page_num }}</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.bullet-points {

margin-top: 30px;

}

.bullet-points li {

margin-bottom: 15px;

line-height: 1.6;

font-size: 18px;

}

.page-nav {

margin-top: 40px;

display: flex;

justify-content: space-between;

}

.page-nav a {

background-color: #4CAF50;

color: white;

padding: 10px 20px;

text-decoration: none;

border-radius: 5px;

}

.page-nav a:hover {

background-color: #45a049;

}

.page-nav .disabled {

background-color: #ccc;

pointer-events: none;

}

.sources {

margin-top: 30px;

font-size: 14px;

color: #666;

font-style: italic;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Page {{ page_num }} of {{ total_pages }}</p>

</div>

```

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>{{ page['title'] }}</h1>

<ul>

{% for item in page['content'] %}

{% endfor %}

</ul>

</div>

Sources: {{ page['sources']|join(', ') }}

</div>

{% if page_num > 1 %}

<a href="/presentation/{{ page_num - 1 }}">Previous</a>

{% else %}

<a class="disabled">Previous</a>

{% endif %}

{% if page_num < total_pages %}

{% else %}

{% endif %}

</div>

```

</body>

</html>

'''

The presentation template displays the slide content with a clean layout. The navigation menu at the top allows users to jump between different sections of the tutorial. The page navigation at the bottom lets users move forward and backward through slides. We also display the source documents that contributed to each page, providing transparency and allowing users to verify information.

Now let us create the explanation page template:

CODE EXAMPLE: Explanation Page Handler and Template

def explanation(self):

"""

Displays the detailed explanation document.

"""

if not self.current_tutorial:

return redirect(url_for('index'))

topic = self.current_tutorial['topic']

explanation_text = self.current_tutorial['explanation']

return render_template_string(

self.get_explanation_template(),

topic=topic,

explanation=explanation_text

)

def get_explanation_template(self):

"""

Returns the HTML template for the explanation page.

"""

return '''

```

<!DOCTYPE html>

<head>

<title>{{ topic }} - Detailed Explanation</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.explanation-text {

line-height: 1.8;

font-size: 16px;

color: #333;

white-space: pre-wrap;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Detailed Explanation</p>

</div>

```

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>Comprehensive Explanation</h1>

<div class="explanation-text">{{ explanation }}</div>

</div>

```

</body>

</html>

'''

The explanation page presents the detailed tutorial text in a readable format with good typography and spacing. The pre-wrap CSS property preserves the paragraph structure from the generated text.

Next, we need templates for the quiz pages:

CODE EXAMPLE: Quiz Page Handler and Template

def quiz(self):

"""

Displays the quiz questions.

"""

if not self.current_tutorial:

return redirect(url_for('index'))

topic = self.current_tutorial['topic']

quiz_questions = self.current_tutorial['quiz']

return render_template_string(

self.get_quiz_template(),

topic=topic,

questions=quiz_questions

)

def get_quiz_template(self):

"""

Returns the HTML template for the quiz page.

"""

return '''

```

<!DOCTYPE html>

<head>

<title>{{ topic }} - Quiz</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.question {

margin-bottom: 30px;

padding: 20px;

background-color: #f9f9f9;

border-left: 4px solid #4CAF50;

}

.question-number {

font-weight: bold;

color: #4CAF50;

font-size: 18px;

}

.question-text {

margin-top: 10px;

font-size: 16px;

line-height: 1.6;

}

.options {

margin-top: 15px;

padding-left: 20px;

}

.option {

margin-bottom: 10px;

}

.quiz-note {

background-color: #fff3cd;

padding: 15px;

border-radius: 5px;

margin-bottom: 30px;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Test Your Knowledge</p>

</div>

```

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

Answer these questions to test your understanding.

Check the Solutions page when you are done!

</div>

{% for q in questions %}

<div class="question-number">Question {{ loop.index }}</div>

<div class="question-text">{{ q['question'] }}</div>

{% if q['options'] %}

{% for option in q['options'] %}

<div class="option">{{ option }}</div>

{% endfor %}

</div>

{% endif %}

Type: {{ q['type'] }}

</div>

{% endfor %}

</div>

```

</body>

</html>

'''

The quiz page displays all questions in a clear, organized format. Multiple choice options are shown when applicable. Users can read through the questions and think about their answers before checking the solutions.

Finally, we need the quiz solutions page:

CODE EXAMPLE: Quiz Solutions Handler and Template

def quiz_solutions(self):

"""

Displays the quiz solutions.

"""

if not self.current_tutorial:

return redirect(url_for('index'))

topic = self.current_tutorial['topic']

solutions = self.current_tutorial['quiz_solutions']

return render_template_string(

self.get_solutions_template(),

topic=topic,

solutions=solutions

)

def get_solutions_template(self):

"""

Returns the HTML template for the solutions page.

"""

return '''

```

<!DOCTYPE html>

<head>

<title>{{ topic }} - Quiz Solutions</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.solution {

margin-bottom: 30px;

padding: 20px;

background-color: #e8f5e9;

border-left: 4px solid #4CAF50;

}

.solution-number {

font-weight: bold;

color: #4CAF50;

font-size: 18px;

}

.solution-question {

margin-top: 10px;

font-weight: bold;

font-size: 16px;

}

.solution-text {

margin-top: 15px;

line-height: 1.8;

white-space: pre-wrap;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Quiz Solutions</p>

</div>

```

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>Quiz Solutions</h1>

{% for sol in solutions %}

<div class="solution-number">Question {{ sol['question_number'] }}</div>

<div class="solution-question">{{ sol['question'] }}</div>

<div class="solution-text">{{ sol['solution'] }}</div>

</div>

{% endfor %}

</div>

```

</body>

</html>

'''

The solutions page provides detailed answers and explanations for each quiz question. The explanations help reinforce learning by not just giving the answer but explaining why it is correct and providing additional context.

Now we need a method to start the web server:

CODE EXAMPLE: Web Server Launch

def run(self):

"""

Starts the web server.

"""

print(f"Starting tutorial web server on http://localhost:{self.port}")

print("Press Ctrl+C to stop the server")

self.app.run(host='0.0.0.0', port=self.port, debug=False)

The run method starts the Flask development server, making our tutorial interface accessible through a web browser at localhost:5000.

STEP EIGHT: PUTTING IT ALL TOGETHER

Now we have all the components we need. Let us create a main application class that coordinates everything and provides a simple interface for users to configure and run the system:

CODE EXAMPLE: Main Application Class

class TutorialGeneratorApp:

"""

Main application that coordinates all components.

"""

def __init__(self):

self.config = None

self.rag_system = None

self.llm_interface = None

self.tutorial_generator = None

self.web_server = None

def setup_configuration(self):

"""

Guides the user through configuration.

"""

print("=" * 60)

print("TUTORIAL GENERATOR SETUP")

print("=" * 60)

self.config = LLMConfig()

# Ask user about model preference

print("\nChoose your language model:")

print("1. Local model (runs on your computer)")

print("2. Remote API model (OpenAI, Anthropic, etc.)")

choice = input("Enter your choice (1 or 2): ").strip()

if choice == '1':

model_path = input("Enter path to your local model file: ").strip()

self.config.configure_local_model(model_path)

else:

api_key = input("Enter your API key: ").strip()

api_url = input("Enter API URL: ").strip()

model_name = input("Enter model name: ").strip()

self.config.configure_remote_model(api_key, api_url, model_name)

return self.config

def setup_documents(self):

"""

Sets up the document path for RAG.

"""

print("\n" + "=" * 60)

print("DOCUMENT SETUP")

print("=" * 60)

doc_path = input("Enter path to your documents folder: ").strip()

print(f"\nInitializing RAG system with documents from: {doc_path}")

self.rag_system = RAGSystem(doc_path)

self.rag_system.initialize()

return self.rag_system

def setup_tutorial_generator(self):

"""

Sets up the tutorial generation system.

"""

print("\n" + "=" * 60)

print("INITIALIZING TUTORIAL GENERATOR")

print("=" * 60)

self.llm_interface = LanguageModelInterface(self.config)

self.tutorial_generator = TutorialGenerator(

self.rag_system,

self.llm_interface

)

print("Tutorial generator ready!")

return self.tutorial_generator

def start_web_interface(self, port=5000):

"""

Starts the web interface.

"""

print("\n" + "=" * 60)

print("STARTING WEB INTERFACE")

print("=" * 60)

self.web_server = TutorialWebServer(self.tutorial_generator, port)

self.web_server.run()

def run(self):

"""

Runs the complete application.

"""

try:

self.setup_configuration()

self.setup_documents()

self.setup_tutorial_generator()

self.start_web_interface()

except KeyboardInterrupt:

print("\n\nShutting down tutorial generator...")

except Exception as e:

print(f"\nError: {e}")

import traceback

traceback.print_exc()

The TutorialGeneratorApp class provides a guided setup process that walks the user through configuration, document loading, and starting the web server. It handles errors gracefully and provides clear feedback at each step.

The run method orchestrates the entire startup sequence, making it easy to launch the system with a simple function call.

CONCLUSION: WHAT WE HAVE BUILT AND HOW TO USE IT

Congratulations! We have built a sophisticated AI-powered tutorial generation system from the ground up. Let me summarize what we have created and how it all works together.

Our system automatically detects your computer’s GPU architecture, whether it uses CUDA, ROCm, Intel acceleration, or runs on CPU only. This detection happens seamlessly in the background, and the system configures itself accordingly for optimal performance.

You can configure the system to use either a local language model running on your own hardware or a remote API service like OpenAI or Anthropic. The choice is yours based on your privacy needs, hardware capabilities, and preferences. The system abstracts away the differences, so the rest of the code works identically regardless of which option you choose.

The document reader can process PowerPoint presentations, Word documents, PDFs, HTML files, and Markdown documents. It extracts all text content, including speaker notes in presentations and text within tables in Word documents. This gives the system access to all your knowledge in whatever format you have stored it.

The RAG system chunks your documents intelligently, generates embeddings that capture semantic meaning, and stores them in a vector database for efficient retrieval. When generating tutorials, it finds the most relevant information from your documents and uses that to ground the AI’s responses in your actual source material.

The tutorial generator creates comprehensive learning materials including concise presentation slides, detailed explanation documents, varied quiz questions, and thorough solutions with explanations. Each component is generated separately with prompts tailored to that specific type of content.

The web interface presents everything in a clean, navigable website format. Users can click through presentation slides, read detailed explanations, take quizzes, and check their answers. The navigation is intuitive, and the design is professional and readable.

To use the system, you would install the required Python libraries, prepare a folder with your source documents, and run the main application. The setup wizard would guide you through configuration, and within minutes you would have a web server running on your computer. You would navigate to localhost:5000 in your browser, enter a topic, and watch as the system generates a complete tutorial based on your documents.

The system is extensible and modular. Each component has a clear responsibility and a well-defined interface. If you wanted to add support for new document formats, you would add a new reading method to the DocumentReader class. If you wanted to use a different embedding model, you would modify the EmbeddingGenerator. If you wanted to add new types of tutorial content, you would add new generation methods to the TutorialGenerator.

This modularity makes the system maintainable and allows it to evolve as new technologies become available. The clean architecture principles we followed mean that changes in one component do not ripple through the entire system.

COMPLETE RUNNING EXAMPLE

Now let me provide the complete, production-ready code that integrates all the components we have discussed. This is not a simplified example or a mock-up. This is fully functional code that you can run on your computer. Copy this code, install the required libraries, configure your settings, and you will have a working tutorial generation system.

Here is the complete modular code split into the recommended folder structure:

```

FILE: src/gpu_detection.py

"""

GPU architecture detection module.

Detects CUDA, ROCm, Apple MPS, Intel, or falls back to CPU.

"""

import subprocess

import platform

def detect_gpu_architecture():

"""

Detects the GPU architecture available on the system.

Returns one of: 'cuda', 'rocm', 'mps', 'intel', 'cpu'

"""

# Check for Apple Metal Performance Shaders (MPS) first

try:

if platform.system() == 'Darwin':

try:

import torch

if hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():

return 'mps'

except ImportError:

# PyTorch not installed, try alternative detection

result = subprocess.run(['system_profiler', 'SPDisplaysDataType'],

capture_output=True,

text=True,

timeout=5)

if 'Apple' in result.stdout and any(chip in result.stdout for chip in ['M1', 'M2', 'M3', 'M4']):

return 'mps'

except:

pass

# Try to detect NVIDIA CUDA

try:

result = subprocess.run(['nvidia-smi'],

capture_output=True,

text=True,

timeout=5)

if result.returncode == 0:

return 'cuda'

except:

pass

# Try to detect AMD ROCm

try:

result = subprocess.run(['rocm-smi'],

capture_output=True,

text=True,

timeout=5)

if result.returncode == 0:

return 'rocm'

except:

pass

# Check for Intel GPUs

try:

result = subprocess.run(['clinfo'],

capture_output=True,

text=True,

timeout=5)

if 'Intel' in result.stdout:

return 'intel'

except:

pass

# Default to CPU if no GPU detected

return 'cpu'

FILE: src/config.py

"""

Configuration management module.

Handles loading and creating configuration files.

"""

import yaml

from pathlib import Path

from gpu_detection import detect_gpu_architecture

def load_config(config_path='config/config.yaml'):

"""

Load configuration from YAML file.

Creates default config if file doesn't exist.

"""

config_file = Path(config_path)

if not config_file.exists():

print(f"Config file not found: {config_path}")

print("Using default configuration...")

config = create_default_config()

else:

with open(config_file, 'r') as f:

config = yaml.safe_load(f)

# Add detected GPU architecture

config['gpu_architecture'] = detect_gpu_architecture()

return config

def create_default_config():

"""Create default configuration dictionary."""

return {

'llm': {

'type': 'remote',

'local': {

'model_path': 'data/models/model.gguf',

'max_tokens': 4096,

'temperature': 0.7

'remote': {

'api_key': '',

'api_url': 'https://api.openai.com/v1/completions',

'model_name': 'gpt-3.5-turbo',

'max_tokens': 4096,

'temperature': 0.7

}

'documents': {

'path': 'data/documents/your_docs',

'chunk_size': 1000,

'chunk_overlap': 200

'embeddings': {

'model_name': 'all-MiniLM-L6-v2'

'web': {

'host': '0.0.0.0',

'port': 5000,

'debug': False

'cache': {

'enabled': True,

'embeddings_path': 'cache/embeddings',

'tutorials_path': 'cache/tutorials'

}

def save_config(config, config_path='config/config.yaml'):

"""Save configuration to YAML file."""

config_file = Path(config_path)

config_file.parent.mkdir(parents=True, exist_ok=True)

# Remove runtime-added keys

save_config = config.copy()

save_config.pop('gpu_architecture', None)

with open(config_file, 'w') as f:

yaml.dump(save_config, f, default_flow_style=False)

FILE: src/document_processing/__init__.py

"""

Document processing module.

Handles reading, chunking, and embedding generation for various document formats.

"""

FILE: src/document_processing/reader.py

"""

Document reader module.

Supports reading PPTX, DOCX, PDF, HTML, and Markdown files.

"""

from pathlib import Path

try:

from pptx import Presentation

from docx import Document

import PyPDF2

from bs4 import BeautifulSoup

except ImportError as e:

print(f"Missing required library: {e}")

print("Install with: pip install python-pptx python-docx PyPDF2 beautifulsoup4")

raise

class DocumentReader:

"""

Reads documents in multiple formats and extracts text content.

Supports: PPTX, DOCX, PDF, HTML, Markdown

"""

def __init__(self, document_path):

"""

Initialize the document reader with a path to scan.

The path can be a single file or a directory.

"""

self.document_path = Path(document_path)

self.documents = []

self.supported_extensions = {

'.pptx', '.ppt',

'.docx', '.doc',

'.pdf',

'.html', '.htm',

'.md', '.markdown'

}

def scan_directory(self):

"""Scans the document path and finds all supported files."""

if self.document_path.is_file():

if self.document_path.suffix.lower() in self.supported_extensions:

self.documents.append(self.document_path)

elif self.document_path.is_directory():

for file_path in self.document_path.rglob('*'):

if file_path.is_file() and file_path.suffix.lower() in self.supported_extensions:

self.documents.append(file_path)

print(f"Found {len(self.documents)} documents to process")

return self.documents

def read_powerpoint(self, file_path):

"""Extracts text content from PowerPoint files."""

try:

prs = Presentation(file_path)

text_content = []

for slide_num, slide in enumerate(prs.slides, start=1):

slide_text = f"Slide {slide_num}:\n"

for shape in slide.shapes:

if hasattr(shape, "text"):

if shape.text.strip():

slide_text += shape.text + "\n"

if slide.has_notes_slide:

notes_slide = slide.notes_slide

if notes_slide.notes_text_frame:

notes_text = notes_slide.notes_text_frame.text

if notes_text.strip():

slide_text += f"Notes: {notes_text}\n"

text_content.append(slide_text)

return {

'filename': file_path.name,

'type': 'powerpoint',

'content': '\n\n'.join(text_content),

'num_slides': len(prs.slides)

}

except Exception as e:

print(f"Error reading PowerPoint file {file_path}: {e}")

return None

def read_word(self, file_path):

"""Extracts text content from Word documents."""

try:

doc = Document(file_path)

text_content = []

for paragraph in doc.paragraphs:

if paragraph.text.strip():

text_content.append(paragraph.text)

for table in doc.tables:

for row in table.rows:

row_text = []

for cell in row.cells:

if cell.text.strip():

row_text.append(cell.text)

if row_text:

text_content.append(' | '.join(row_text))

return {

'filename': file_path.name,

'type': 'word',

'content': '\n'.join(text_content),

'num_paragraphs': len(doc.paragraphs),

'num_tables': len(doc.tables)

}

except Exception as e:

print(f"Error reading Word document {file_path}: {e}")

return None

def read_pdf(self, file_path):

"""Extracts text content from PDF files."""

try:

with open(file_path, 'rb') as file:

pdf_reader = PyPDF2.PdfReader(file)

text_content = []

for page_num, page in enumerate(pdf_reader.pages, start=1):

page_text = page.extract_text()

if page_text.strip():

text_content.append(f"Page {page_num}:\n{page_text}")

return {

'filename': file_path.name,

'type': 'pdf',

'content': '\n\n'.join(text_content),

'num_pages': len(pdf_reader.pages)

}

except Exception as e:

print(f"Error reading PDF file {file_path}: {e}")

return None

def read_html(self, file_path):

"""Extracts text content from HTML files."""

try:

with open(file_path, 'r', encoding='utf-8') as file:

html_content = file.read()

soup = BeautifulSoup(html_content, 'html.parser')

for script in soup(['script', 'style']):

script.decompose()

text = soup.get_text()

lines = (line.strip() for line in text.splitlines())

chunks = (phrase.strip() for line in lines for phrase in line.split(" "))

text_content = '\n'.join(chunk for chunk in chunks if chunk)

return {

'filename': file_path.name,

'type': 'html',

'content': text_content,

'title': soup.title.string if soup.title else 'No title'

}

except Exception as e:

print(f"Error reading HTML file {file_path}: {e}")

return None

def read_markdown(self, file_path):

"""Reads Markdown files."""

try:

with open(file_path, 'r', encoding='utf-8') as file:

content = file.read()

return {

'filename': file_path.name,

'type': 'markdown',

'content': content

}

except Exception as e:

print(f"Error reading Markdown file {file_path}: {e}")

return None

def read_document(self, file_path):

"""Reads a document based on its file extension."""

extension = file_path.suffix.lower()

if extension in ['.pptx', '.ppt']:

return self.read_powerpoint(file_path)

elif extension in ['.docx', '.doc']:

return self.read_word(file_path)

elif extension == '.pdf':

return self.read_pdf(file_path)

elif extension in ['.html', '.htm']:

return self.read_html(file_path)

elif extension in ['.md', '.markdown']:

return self.read_markdown(file_path)

else:

print(f"Unsupported file type: {extension}")

return None

def read_all_documents(self):

"""Reads all documents found during scanning."""

self.scan_directory()

all_docs = []

for doc_path in self.documents:

print(f"Reading: {doc_path.name}")

doc_data = self.read_document(doc_path)

if doc_data:

all_docs.append(doc_data)

print(f"Successfully read {len(all_docs)} documents")

return all_docs

FILE: src/document_processing/chunker.py

"""

Document chunking module.

Splits documents into overlapping chunks for RAG processing.

"""

class DocumentChunker:

"""Splits documents into manageable chunks for RAG."""

def __init__(self, chunk_size=1000, chunk_overlap=200):

"""

Initialize chunker with size and overlap parameters.

Args:

chunk_size: Maximum number of characters per chunk

chunk_overlap: Number of characters to overlap between chunks

"""

self.chunk_size = chunk_size

self.chunk_overlap = chunk_overlap

def split_text(self, text, metadata):

"""Splits text into overlapping chunks."""

chunks = []

start = 0

text_length = len(text)

while start < text_length:

end = start + self.chunk_size

# Try to break at a sentence boundary

if end < text_length:

search_start = max(start, end - 100)

for delimiter in ['. ', '.\n', '! ', '?\n']:

last_delimiter = text.rfind(delimiter, search_start, end)

if last_delimiter != -1:

end = last_delimiter + len(delimiter)

break

chunk_text = text[start:end].strip()

if chunk_text:

chunk_data = {

'text': chunk_text,

'metadata': metadata.copy(),

'start_pos': start,

'end_pos': end

}

chunks.append(chunk_data)

start = end - self.chunk_overlap

if start >= text_length:

break

return chunks

def chunk_documents(self, documents):

"""Chunks all documents in the collection."""

all_chunks = []

for doc in documents:

metadata = {

'filename': doc['filename'],

'type': doc['type']

}

chunks = self.split_text(doc['content'], metadata)

all_chunks.extend(chunks)

print(f"Created {len(all_chunks)} chunks from {len(documents)} documents")

return all_chunks

FILE: src/document_processing/embeddings.py

"""

Embedding generation module.

Creates semantic embeddings for text chunks using transformer models.

"""

from sentence_transformers import SentenceTransformer

class EmbeddingGenerator:

"""Generates embeddings for text chunks using a transformer model."""

def __init__(self, model_name='all-MiniLM-L6-v2'):

"""

Initialize with a sentence transformer model.

Args:

model_name: Name of the sentence transformer model to use

"""

print(f"Loading embedding model: {model_name}")

self.model = SentenceTransformer(model_name)

print("Embedding model loaded successfully")

def generate_embeddings(self, chunks):

"""Generates embeddings for all chunks."""

texts = [chunk['text'] for chunk in chunks]

print(f"Generating embeddings for {len(texts)} chunks...")

embeddings = self.model.encode(texts, show_progress_bar=True)

for chunk, embedding in zip(chunks, embeddings):

chunk['embedding'] = embedding

return chunks

FILE: src/rag/__init__.py

"""

RAG (Retrieval Augmented Generation) module.

Handles vector storage, similarity search, and document retrieval.

"""

FILE: src/rag/vector_store.py

"""

Vector store module.

Stores embeddings and performs similarity search.

"""

import numpy as np

class VectorStore:

"""Stores embeddings and performs similarity search."""

def __init__(self):

self.chunks = []

self.embeddings = None

def add_chunks(self, chunks):

"""Adds chunks with embeddings to the store."""

self.chunks = chunks

self.embeddings = np.array([chunk['embedding'] for chunk in chunks])

print(f"Vector store now contains {len(self.chunks)} chunks")

def cosine_similarity(self, vec1, vec2):

"""Computes cosine similarity between two vectors."""

dot_product = np.dot(vec1, vec2)

norm_vec1 = np.linalg.norm(vec1)

norm_vec2 = np.linalg.norm(vec2)

return dot_product / (norm_vec1 * norm_vec2)

def search(self, query_embedding, top_k=5):

"""Finds the top_k most similar chunks to the query."""

similarities = []

for i, chunk_embedding in enumerate(self.embeddings):

similarity = self.cosine_similarity(query_embedding, chunk_embedding)

similarities.append((i, similarity))

similarities.sort(key=lambda x: x[1], reverse=True)

results = []

for i, similarity in similarities[:top_k]:

result = self.chunks[i].copy()

result['similarity_score'] = similarity

results.append(result)

return results

FILE: src/rag/rag_system.py

"""

RAG system module.

Coordinates document reading, chunking, embedding, and retrieval.

"""

from document_processing.reader import DocumentReader

from document_processing.chunker import DocumentChunker

from document_processing.embeddings import EmbeddingGenerator

from rag.vector_store import VectorStore

class RAGSystem:

"""Complete Retrieval Augmented Generation system."""

def __init__(self, document_path, config):

"""

Initialize RAG system with document path and configuration.

Args:

document_path: Path to documents directory

config: Configuration dictionary

"""

self.document_reader = DocumentReader(document_path)

chunk_config = config['documents']

self.chunker = DocumentChunker(

chunk_size=chunk_config['chunk_size'],

chunk_overlap=chunk_config['chunk_overlap']

)

embed_config = config['embeddings']

self.embedding_generator = EmbeddingGenerator(

model_name=embed_config['model_name']

)

self.vector_store = VectorStore()

self.documents = []

self.chunks = []

def initialize(self):

"""Reads documents, chunks them, and generates embeddings."""

print("Initializing RAG system...")

self.documents = self.document_reader.read_all_documents()

if not self.documents:

print("Warning: No documents found to process!")

return

self.chunks = self.chunker.chunk_documents(self.documents)

self.chunks = self.embedding_generator.generate_embeddings(self.chunks)

self.vector_store.add_chunks(self.chunks)

print("RAG system initialized successfully")

def retrieve_relevant_chunks(self, query, top_k=5):

"""Retrieves the most relevant chunks for a given query."""

query_embedding = self.embedding_generator.model.encode([query])[0]

results = self.vector_store.search(query_embedding, top_k)

return results

FILE: src/llm/__init__.py

"""

LLM (Large Language Model) interface module.

Provides unified interface for local and remote language models.

"""

FILE: src/llm/interface.py

"""

Language model interface module.

Supports both local models (via llama-cpp-python) and remote APIs.

"""

import requests

class LanguageModelInterface:

"""Unified interface for both local and remote language models."""

def __init__(self, config):

"""

Initialize LLM interface with configuration.

Args:

config: LLM configuration dictionary with 'type', 'local', and 'remote' keys

"""

self.config = config

self.model = None

self._initialize_model()

def _initialize_model(self):

"""Initializes the appropriate model based on configuration."""

if self.config['type'] == 'local':

self._initialize_local_model()

elif self.config['type'] == 'remote':

self._initialize_remote_model()

else:

raise ValueError(f"Unknown model type: {self.config['type']}")

def _initialize_local_model(self):

"""Initializes a local language model using llama-cpp-python."""

try:

from llama_cpp import Llama

import psutil

local_config = self.config['local']

gpu_arch = self.config.get('gpu_architecture', 'cpu')

# Configure based on GPU architecture

if gpu_arch == 'cuda':

n_gpu_layers = 35

elif gpu_arch == 'rocm':

n_gpu_layers = 35

elif gpu_arch == 'mps':

try:

total_memory_gb = psutil.virtual_memory().total / (1024 ** 3)

if total_memory_gb >= 64:

n_gpu_layers = 35

elif total_memory_gb >= 32:

n_gpu_layers = 20

elif total_memory_gb >= 16:

n_gpu_layers = 10

else:

n_gpu_layers = 5

except:

n_gpu_layers = 1

elif gpu_arch == 'intel':

n_gpu_layers = 0

else:

n_gpu_layers = 0

print(f"Loading local model from {local_config['model_path']}")

print(f"Using {gpu_arch} acceleration with {n_gpu_layers} GPU layers")

self.model = Llama(

model_path=local_config['model_path'],

n_ctx=local_config['max_tokens'],

n_gpu_layers=n_gpu_layers,

verbose=False

)

print("Local model loaded successfully")

except Exception as e:

print(f"Error loading local model: {e}")

raise

def _initialize_remote_model(self):

"""Initializes connection to a remote API."""

remote_config = self.config['remote']

print(f"Configured for remote model: {remote_config['model_name']}")

print(f"API URL: {remote_config['api_url']}")

def generate(self, prompt, max_tokens=None, temperature=None):

"""

Generates text based on a prompt.

Works with both local and remote models.

"""

if self.config['type'] == 'local':

return self._generate_local(prompt, max_tokens, temperature)

else:

return self._generate_remote(prompt, max_tokens, temperature)

def _generate_local(self, prompt, max_tokens, temperature):

"""Generates text using a local model."""

try:

local_config = self.config['local']

max_tokens = max_tokens or local_config['max_tokens']

temperature = temperature or local_config['temperature']

response = self.model(

prompt,

max_tokens=max_tokens,

temperature=temperature,

stop=["</s>", "\n\n\n"],

echo=False

)

return response['choices'][0]['text']

except Exception as e:

print(f"Error generating with local model: {e}")

return None

def _generate_remote(self, prompt, max_tokens, temperature):

"""Generates text using a remote API."""

try:

remote_config = self.config['remote']

max_tokens = max_tokens or remote_config['max_tokens']

temperature = temperature or remote_config['temperature']

headers = {

'Authorization': f'Bearer {remote_config["api_key"]}',

'Content-Type': 'application/json'

}

data = {

'model': remote_config['model_name'],

'prompt': prompt,

'max_tokens': max_tokens,

'temperature': temperature

}

response = requests.post(

remote_config['api_url'],

headers=headers,

json=data,

timeout=60

)

response.raise_for_status()

result = response.json()

if 'choices' in result:

return result['choices'][0]['text']

elif 'completion' in result:

return result['completion']

else:

return result.get('text', str(result))

except Exception as e:

print(f"Error generating with remote API: {e}")

return None

FILE: src/generation/__init__.py

"""

Tutorial generation module.

Creates presentations, explanations, quizzes, and solutions.

"""

FILE: src/generation/tutorial_generator.py

"""

Tutorial generator module.

Generates complete tutorials using RAG and LLM.

"""

class TutorialGenerator:

"""Generates complete tutorials using RAG and LLM."""

def __init__(self, rag_system, llm_interface):

"""

Initialize tutorial generator.

Args:

rag_system: RAG system for document retrieval

llm_interface: Language model interface for generation

"""

self.rag = rag_system

self.llm = llm_interface

self.tutorial_data = {}

def generate_tutorial(self, topic, num_pages=5, num_quiz_questions=10):

"""Generates a complete tutorial on the specified topic."""

print(f"Generating tutorial on: {topic}")

self.tutorial_data = {

'topic': topic,

'pages': [],

'explanation': '',

'quiz': [],

'quiz_solutions': []

}

print("Generating presentation pages...")

for i in range(num_pages):

page = self.generate_presentation_page(topic, i, num_pages)

self.tutorial_data['pages'].append(page)

print("Generating explanation document...")

self.tutorial_data['explanation'] = self.generate_explanation(topic)

print("Generating quiz questions...")

self.tutorial_data['quiz'] = self.generate_quiz(topic, num_quiz_questions)

print("Generating quiz solutions...")

self.tutorial_data['quiz_solutions'] = self.generate_quiz_solutions(

self.tutorial_data['quiz']

)

print("Tutorial generation complete")

return self.tutorial_data

def generate_presentation_page(self, topic, page_number, total_pages):

"""Generates a single presentation page."""

query = f"{topic} presentation content for page {page_number + 1}"

relevant_chunks = self.rag.retrieve_relevant_chunks(query, top_k=3)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Based on the following information, create presentation slide content for a tutorial on {topic}.

```

This is slide {page_number + 1} of {total_pages}.

Context from documents:

{context}

Create concise slide content with:

1. A clear slide title

1. 3-5 bullet points covering key concepts

1. Brief explanations for each point

Format your response as:

TITLE: [slide title]

CONTENT:

- [bullet point 1]

- [bullet point 2]

- [bullet point 3]

Slide content:”””

```

response = self.llm.generate(prompt, max_tokens=500, temperature=0.7)

page_data = self._parse_presentation_page(response)

page_data['page_number'] = page_number + 1

page_data['sources'] = [chunk['metadata']['filename'] for chunk in relevant_chunks]

return page_data

def _parse_presentation_page(self, response):

"""Parses the LLM response into structured page data."""

if not response:

return {'title': 'Error', 'content': ['Failed to generate content']}

lines = response.strip().split('\n')

title = "Untitled"

content = []

for line in lines:

line = line.strip()

if line.startswith('TITLE:'):

title = line.replace('TITLE:', '').strip()

elif line.startswith('-') or line.startswith('*'):

content.append(line.lstrip('-*').strip())

if not content:

content = ['Content generation in progress']

return {

'title': title,

'content': content

}

def generate_explanation(self, topic):

"""Generates a detailed explanation document."""

relevant_chunks = self.rag.retrieve_relevant_chunks(topic, top_k=10)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Based on the following source material, write a comprehensive explanation of {topic}.

```

Context from documents:

{context}

Write a detailed, well-structured explanation that covers:

1. Introduction and overview

1. Key concepts and principles

1. Important details and examples

1. Relationships between concepts

1. Practical applications or implications

The explanation should be educational, clear, and thorough. Use multiple paragraphs to organize the information logically.

Explanation:”””

```

explanation = self.llm.generate(prompt, max_tokens=2000, temperature=0.7)

return explanation if explanation else "Explanation generation in progress..."

def generate_quiz(self, topic, num_questions):

"""Generates quiz questions to test understanding."""

relevant_chunks = self.rag.retrieve_relevant_chunks(topic, top_k=10)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Based on the following material about {topic}, create {num_questions} quiz questions to test understanding.

```

Context from documents:

{context}

Create a mix of question types:

- Multiple choice questions (with 4 options)

- True/false questions

- Short answer questions

Format each question as:

Q1: [question text]

TYPE: [multiple_choice/true_false/short_answer]

A) [option A] (for multiple choice)

B) [option B] (for multiple choice)

C) [option C] (for multiple choice)

D) [option D] (for multiple choice)

Questions:”””

```

response = self.llm.generate(prompt, max_tokens=1500, temperature=0.8)

quiz_questions = self._parse_quiz(response)

return quiz_questions

def _parse_quiz(self, response):

"""Parses quiz questions from LLM response."""

if not response:

return [{'question': 'Quiz generation in progress', 'type': 'short_answer', 'options': []}]

questions = []

current_question = None

lines = response.strip().split('\n')

for line in lines:

line = line.strip()

if not line:

continue

if line.startswith('Q') and ':' in line:

if current_question:

questions.append(current_question)

current_question = {

'question': line.split(':', 1)[1].strip(),

'type': 'multiple_choice',

'options': []

}

elif line.startswith('TYPE:'):

if current_question:

current_question['type'] = line.split(':', 1)[1].strip().lower()

elif len(line) >= 2 and line[0] in ['A', 'B', 'C', 'D'] and line[1] == ')':

if current_question:

current_question['options'].append(line[3:].strip())

if current_question:

questions.append(current_question)

return questions if questions else [{'question': 'Quiz generation in progress', 'type': 'short_answer', 'options': []}]

def generate_quiz_solutions(self, quiz_questions):

"""Generates detailed solutions for quiz questions."""

solutions = []

for i, question in enumerate(quiz_questions):

relevant_chunks = self.rag.retrieve_relevant_chunks(

question['question'],

top_k=3

)

context = "\n\n".join([chunk['text'] for chunk in relevant_chunks])

prompt = f"""Provide a detailed answer to this quiz question based on the context.

```

Question: {question[‘question’]}

Context:

{context}

Provide:

1. The correct answer

1. A clear explanation of why this is correct

1. Additional context to deepen understanding

Solution:”””

```

solution_text = self.llm.generate(prompt, max_tokens=500, temperature=0.7)

solutions.append({

'question_number': i + 1,

'question': question['question'],

'solution': solution_text if solution_text else "Solution generation in progress..."

})

return solutions

FILE: src/web/__init__.py

"""

Web interface module.

Flask-based web server for tutorial navigation and display.

"""

FILE: src/web/server.py

"""

Web server module.

Flask application for displaying generated tutorials.

"""

from flask import Flask, render_template, request, redirect

from pathlib import Path

class TutorialWebServer:

"""Web server for displaying generated tutorials."""

def __init__(self, tutorial_generator, host='0.0.0.0', port=5000):

"""

Initialize web server.

Args:

tutorial_generator: Tutorial generator instance

host: Host address to bind to

port: Port number to listen on

"""

self.tutorial_generator = tutorial_generator

self.host = host

self.port = port

self.app = Flask(__name__, template_folder=str(Path(__file__).parent / 'templates'))

self.current_tutorial = None

self._setup_routes()

def _setup_routes(self):

"""Sets up the Flask routes for the web interface."""

self.app.add_url_rule('/', 'index', self.index)

self.app.add_url_rule('/generate', 'generate', self.generate, methods=['POST'])

self.app.add_url_rule('/presentation/<int:page_num>', 'presentation_page', self.presentation_page)

self.app.add_url_rule('/explanation', 'explanation', self.explanation)

self.app.add_url_rule('/quiz', 'quiz', self.quiz)

self.app.add_url_rule('/quiz/solutions', 'quiz_solutions', self.quiz_solutions)

def index(self):

"""Home page with tutorial generation form."""

return render_template('index.html')

def generate(self):

"""Handles tutorial generation request."""

topic = request.form.get('topic', '')

num_pages = int(request.form.get('num_pages', 5))

num_questions = int(request.form.get('num_questions', 10))

if topic:

self.current_tutorial = self.tutorial_generator.generate_tutorial(

topic,

num_pages,

num_questions

)

return redirect('/presentation/1')

return redirect('/')

def presentation_page(self, page_num):

"""Displays a specific presentation page."""

if not self.current_tutorial or page_num < 1:

return redirect('/')

pages = self.current_tutorial['pages']

if page_num > len(pages):

return redirect('/')

page = pages[page_num - 1]

topic = self.current_tutorial['topic']

total_pages = len(pages)

return render_template(

'presentation.html',

topic=topic,

page=page,

page_num=page_num,

total_pages=total_pages

)

def explanation(self):

"""Displays the detailed explanation document."""

if not self.current_tutorial:

return redirect('/')

topic = self.current_tutorial['topic']

explanation_text = self.current_tutorial['explanation']

return render_template(

'explanation.html',

topic=topic,

explanation=explanation_text

)

def quiz(self):

"""Displays the quiz questions."""

if not self.current_tutorial:

return redirect('/')

topic = self.current_tutorial['topic']

quiz_questions = self.current_tutorial['quiz']

return render_template(

'quiz.html',

topic=topic,

questions=quiz_questions

)

def quiz_solutions(self):

"""Displays the quiz solutions."""

if not self.current_tutorial:

return redirect('/')

topic = self.current_tutorial['topic']

solutions = self.current_tutorial['quiz_solutions']

return render_template(

'solutions.html',

topic=topic,

solutions=solutions

)

def run(self):

"""Starts the web server."""

print(f"Starting tutorial web server on http://{self.host}:{self.port}")

print("Press Ctrl+C to stop the server")

self.app.run(host=self.host, port=self.port, debug=False)

FILE: src/web/templates/index.html

<!DOCTYPE html>

<head>

<title>Tutorial Generator</title>

<style>

body {

font-family: Arial, sans-serif;

max-width: 800px;

margin: 50px auto;

padding: 20px;

background-color: #f5f5f5;

}

.container {

background-color: white;

padding: 30px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

text-align: center;

}

.form-group {

margin-bottom: 20px;

}

label {

display: block;

margin-bottom: 5px;

font-weight: bold;

color: #555;

}

input[type="text"],

input[type="number"] {

width: 100%;

padding: 10px;

border: 1px solid #ddd;

border-radius: 5px;

font-size: 16px;

box-sizing: border-box;

}

button {

background-color: #4CAF50;

color: white;

padding: 12px 30px;

border: none;

border-radius: 5px;

cursor: pointer;

font-size: 16px;

width: 100%;

}

button:hover {

background-color: #45a049;

}

</style>

</head>

<body>

<h1>AI Tutorial Generator</h1>

<p>Generate comprehensive tutorials on any topic using your documents and AI.</p>

<label for="topic">Tutorial Topic:</label>

<input type="text" id="topic" name="topic" required

placeholder="e.g., Machine Learning Basics">

</div>

<label for="num_pages">Number of Presentation Pages:</label>

<input type="number" id="num_pages" name="num_pages"

value="5" min="1" max="20">

</div>

<label for="num_questions">Number of Quiz Questions:</label>

<input type="number" id="num_questions" name="num_questions"

value="10" min="1" max="30">

</div>

<button type="submit">Generate Tutorial</button>

</form>

</div>

</body>

</html>

FILE: src/web/templates/presentation.html

<!DOCTYPE html>

<head>

<title>{{ topic }} - Page {{ page_num }}</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.bullet-points {

margin-top: 30px;

}

.bullet-points li {

margin-bottom: 15px;

line-height: 1.6;

font-size: 18px;

}

.page-nav {

margin-top: 40px;

display: flex;

justify-content: space-between;

}

.page-nav a {

background-color: #4CAF50;

color: white;

padding: 10px 20px;

text-decoration: none;

border-radius: 5px;

}

.page-nav a:hover {

background-color: #45a049;

}

.page-nav .disabled {

background-color: #ccc;

pointer-events: none;

}

.sources {

margin-top: 30px;

font-size: 14px;

color: #666;

font-style: italic;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Page {{ page_num }} of {{ total_pages }}</p>

</div>

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>{{ page['title'] }}</h1>

<ul>

{% for item in page['content'] %}

{% endfor %}

</ul>

</div>

Sources: {{ page['sources']|join(', ') }}

</div>

{% if page_num > 1 %}

<a href="/presentation/{{ page_num - 1 }}">Previous</a>

{% else %}

<a class="disabled">Previous</a>

{% endif %}

{% if page_num < total_pages %}

{% else %}

{% endif %}

</div>

</body>

</html>

FILE: src/web/templates/explanation.html

<!DOCTYPE html>

<head>

<title>{{ topic }} - Detailed Explanation</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.explanation-text {

line-height: 1.8;

font-size: 16px;

color: #333;

white-space: pre-wrap;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Detailed Explanation</p>

</div>

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>Comprehensive Explanation</h1>

<div class="explanation-text">{{ explanation }}</div>

</div>

</body>

</html>

FILE: src/web/templates/quiz.html

<!DOCTYPE html>

<head>

<title>{{ topic }} - Quiz</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.question {

margin-bottom: 30px;

padding: 20px;

background-color: #f9f9f9;

border-left: 4px solid #4CAF50;

}

.question-number {

font-weight: bold;

color: #4CAF50;

font-size: 18px;

}

.question-text {

margin-top: 10px;

font-size: 16px;

line-height: 1.6;

}

.options {

margin-top: 15px;

padding-left: 20px;

}

.option {

margin-bottom: 10px;

}

.quiz-note {

background-color: #fff3cd;

padding: 15px;

border-radius: 5px;

margin-bottom: 30px;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Test Your Knowledge</p>

</div>

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

Answer these questions to test your understanding.

Check the Solutions page when you are done!

</div>

{% for q in questions %}

<div class="question-number">Question {{ loop.index }}</div>

<div class="question-text">{{ q['question'] }}</div>

{% if q['options'] %}

{% for option in q['options'] %}

<div class="option">{{ option }}</div>

{% endfor %}

</div>

{% endif %}

Type: {{ q['type'] }}

</div>

{% endfor %}

</div>

</body>

</html>

FILE: src/web/templates/solutions.html

<!DOCTYPE html>

<head>

<title>{{ topic }} - Quiz Solutions</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

background-color: #f5f5f5;

}

.header {

background-color: #4CAF50;

color: white;

padding: 20px;

text-align: center;

}

.nav-menu {

background-color: #333;

padding: 10px;

text-align: center;

}

.nav-menu a {

color: white;

text-decoration: none;

padding: 10px 20px;

margin: 0 5px;

display: inline-block;

}

.nav-menu a:hover {

background-color: #555;

}

.content {

max-width: 900px;

margin: 30px auto;

background-color: white;

padding: 40px;

border-radius: 10px;

box-shadow: 0 2px 10px rgba(0,0,0,0.1);

}

h1 {

color: #333;

border-bottom: 3px solid #4CAF50;

padding-bottom: 10px;

}

.solution {

margin-bottom: 30px;

padding: 20px;

background-color: #e8f5e9;

border-left: 4px solid #4CAF50;

}

.solution-number {

font-weight: bold;

color: #4CAF50;

font-size: 18px;

}

.solution-question {

margin-top: 10px;

font-weight: bold;

font-size: 16px;

}

.solution-text {

margin-top: 15px;

line-height: 1.8;

white-space: pre-wrap;

}

</style>

</head>

<body>

<h2>{{ topic }}</h2>

<p>Quiz Solutions</p>

</div>

<a href="/presentation/1">Presentation</a>

<a href="/explanation">Explanation</a>

<a href="/quiz/solutions">Solutions</a>

</div>

<h1>Quiz Solutions</h1>

{% for sol in solutions %}

<div class="solution-number">Question {{ sol['question_number'] }}</div>

<div class="solution-question">{{ sol['question'] }}</div>

<div class="solution-text">{{ sol['solution'] }}</div>

</div>

{% endfor %}

</div>

</body>

</html>

FILE: src/main.py

#!/usr/bin/env python3

"""

Main entry point for the Tutorial Generator application.

"""

import sys

from pathlib import Path

# Add src directory to path

sys.path.insert(0, str(Path(__file__).parent))

from config import load_config

from rag.rag_system import RAGSystem

from llm.interface import LanguageModelInterface

from generation.tutorial_generator import TutorialGenerator

from web.server import TutorialWebServer

class TutorialGeneratorApp:

"""Main application coordinator."""

def __init__(self, config_path='config/config.yaml'):

"""

Initialize application with configuration.

Args:

config_path: Path to configuration YAML file

"""

self.config = load_config(config_path)

self.rag_system = None

self.llm_interface = None

self.tutorial_generator = None

self.web_server = None

def setup(self):

"""Initialize all components."""

print("=" * 60)

print("TUTORIAL GENERATOR SETUP")

print("=" * 60)

# Initialize RAG system

doc_path = self.config['documents']['path']

print(f"\nDocument path: {doc_path}")

self.rag_system = RAGSystem(doc_path, self.config)

self.rag_system.initialize()

# Initialize LLM

print("\nInitializing language model...")

llm_config = self.config['llm'].copy()

llm_config['gpu_architecture'] = self.config['gpu_architecture']

self.llm_interface = LanguageModelInterface(llm_config)

# Initialize tutorial generator

self.tutorial_generator = TutorialGenerator(

self.rag_system,

self.llm_interface

)

print("\nSetup complete!")

print("=" * 60)

def run(self):

"""Start the web server."""

try:

self.setup()

web_config = self.config['web']

self.web_server = TutorialWebServer(

self.tutorial_generator,

host=web_config['host'],

port=web_config['port']

)

self.web_server.run()

except KeyboardInterrupt:

print("\n\nShutting down tutorial generator...")

except Exception as e:

print(f"\nError: {e}")

import traceback

traceback.print_exc()

if __name__ == '__main__':

app = TutorialGeneratorApp()

app.run()

FILE: requirements.txt

python-pptx>=0.6.21

python-docx>=0.8.11

PyPDF2>=3.0.0

beautifulsoup4>=4.11.0

sentence-transformers>=2.2.0

flask>=2.3.0

requests>=2.28.0

llama-cpp-python>=0.2.0

torch>=2.0.0

numpy>=1.24.0

psutil>=5.9.0

pyyaml>=6.0

FILE: config/config.example.yaml

# Tutorial Generator Configuration

llm:

# Type: 'local' or 'remote'

type: remote

# Local model settings

local:

model_path: data/models/your-model.gguf

max_tokens: 4096

temperature: 0.7

# Remote model settings

remote:

api_key: your-api-key-here

api_url: https://api.openai.com/v1/completions

model_name: gpt-3.5-turbo

max_tokens: 4096

temperature: 0.7

documents:

path: data/documents/your_docs

chunk_size: 1000

chunk_overlap: 200

embeddings:

model_name: all-MiniLM-L6-v2

web:

host: 0.0.0.0

port: 5000

debug: false

cache:

enabled: true

embeddings_path: cache/embeddings

tutorials_path: cache/tutorials

FILE: setup.py

from setuptools import setup, find_packages

with open("README.md", "r", encoding="utf-8") as fh:

long_description = fh.read()

setup(

name="tutorial-generator",

version="1.0.0",

author="Your Name",

author_email="your.email@example.com",

description="AI-powered tutorial generator with RAG and LLM support",

long_description=long_description,

long_description_content_type="text/markdown",

url="https://github.com/yourusername/tutorial-generator",

packages=find_packages(where="src"),

package_dir={"": "src"},

classifiers=[

"Development Status :: 4 - Beta",

"Intended Audience :: Education",

"Intended Audience :: Developers",

"License :: OSI Approved :: MIT License",

"Programming Language :: Python :: 3",

"Programming Language :: Python :: 3.8",

"Programming Language :: Python :: 3.9",

"Programming Language :: Python :: 3.10",

"Programming Language :: Python :: 3.11",

python_requires=">=3.8",

install_requires=[

"python-pptx>=0.6.21",

"python-docx>=0.8.11",

"PyPDF2>=3.0.0",

"beautifulsoup4>=4.11.0",

"sentence-transformers>=2.2.0",

"flask>=2.3.0",

"requests>=2.28.0",

"llama-cpp-python>=0.2.0",

"torch>=2.0.0",

"numpy>=1.24.0",

"psutil>=5.9.0",

"pyyaml>=6.0",

entry_points={

"console_scripts": [

"tutorial-generator=main:main",

)

FILE: .gitignore

# Python

__pycache__/

*.py[cod]

*$py.class

*.so

.Python

build/

develop-eggs/

dist/

downloads/

eggs/

.eggs/

lib/

lib64/

parts/

sdist/

var/

wheels/

*.egg-info/

.installed.cfg

*.egg

MANIFEST

# Virtual environments

venv/

env/

ENV/

.venv

# Data and cache

cache/

data/models/*.gguf

data/models/*.bin

data/documents/your_docs/*

!data/documents/your_docs/README.txt

output/

# IDE

.vscode/

.idea/

*.swp

*.swo

# OS

.DS_Store

Thumbs.db

# Config with secrets

config/config.yaml

# Logs

*.log

logs/

# Testing

.pytest_cache/

.coverage

htmlcov/

FILE: scripts/install.sh

#!/bin/bash

echo "=========================================="

echo "Tutorial Generator Installation"

echo "=========================================="

echo ""

# Check if Python is installed

if ! command -v python3 &> /dev/null

then

echo "Python 3 is not installed. Please install Python 3.8 or higher."

exit 1

echo "Python version:"

python3 --version

echo ""

# Create necessary directories

echo "Creating directory structure..."

mkdir -p data/documents/your_docs

mkdir -p data/documents/example_docs

mkdir -p data/models

mkdir -p cache/embeddings

mkdir -p cache/tutorials

mkdir -p output/generated_tutorials

mkdir -p config

# Create virtual environment

echo "Creating virtual environment..."

python3 -m venv venv

# Activate virtual environment

echo "Activating virtual environment..."

source venv/bin/activate

# Upgrade pip

echo "Upgrading pip..."

pip install --upgrade pip

# Install requirements

echo "Installing Python dependencies..."

pip install -r requirements.txt

# Copy example config if config doesn't exist

if [ ! -f config/config.yaml ]; then

echo "Creating default configuration..."

cp config/config.example.yaml config/config.yaml

echo "Please edit config/config.yaml with your settings"

echo ""

echo "=========================================="

echo "Installation Complete!"

echo "=========================================="

echo ""

echo "Next steps:"

echo "1. Edit config/config.yaml with your API keys and settings"

echo "2. Place your documents in data/documents/your_docs/"

echo "3. Run the application: ./scripts/run.sh"

echo ""

FILE: scripts/install.bat

@echo off

echo ==========================================

echo Tutorial Generator Installation

echo ==========================================

echo.

REM Check if Python is installed

python --version >nul 2>&1

if errorlevel 1 (

echo Python is not installed. Please install Python 3.8 or higher.

pause

exit /b 1

)

echo Python version:

python --version

echo.

REM Create necessary directories

echo Creating directory structure...

mkdir data\documents\your_docs 2>nul

mkdir data\documents\example_docs 2>nul

mkdir data\models 2>nul

mkdir cache\embeddings 2>nul

mkdir cache\tutorials 2>nul

mkdir output\generated_tutorials 2>nul

mkdir config 2>nul

REM Create virtual environment

echo Creating virtual environment...

python -m venv venv

REM Activate virtual environment

echo Activating virtual environment...

call venv\Scripts\activate.bat

REM Upgrade pip

echo Upgrading pip...

python -m pip install --upgrade pip

REM Install requirements

echo Installing Python dependencies...

pip install -r requirements.txt

REM Copy example config if config doesn't exist

if not exist config\config.yaml (

echo Creating default configuration...

copy config\config.example.yaml config\config.yaml

echo Please edit config\config.yaml with your settings

)

echo.

echo ==========================================

echo Installation Complete!

echo ==========================================

echo.

echo Next steps:

echo 1. Edit config\config.yaml with your API keys and settings

echo 2. Place your documents in data\documents\your_docs\

echo 3. Run the application: scripts\run.bat

echo.

pause

FILE: scripts/run.sh

#!/bin/bash

echo "=========================================="

echo "Starting Tutorial Generator"

echo "=========================================="

echo ""

# Activate virtual environment

if [ -d "venv" ]; then

source venv/bin/activate

else

echo "Virtual environment not found. Please run scripts/install.sh first."

exit 1

# Check if config exists

if [ ! -f "config/config.yaml" ]; then

echo "Configuration file not found. Please run scripts/install.sh first."

exit 1

# Run the application

cd src

python main.py

FILE: scripts/run.bat

@echo off

echo ==========================================

echo Starting Tutorial Generator

echo ==========================================

echo.

REM Activate virtual environment

if exist venv\Scripts\activate.bat (

call venv\Scripts\activate.bat

) else (

echo Virtual environment not found. Please run scripts\install.bat first.

pause

exit /b 1

)

REM Check if config exists

if not exist config\config.yaml (

echo Configuration file not found. Please run scripts\install.bat first.

pause

exit /b 1

)

REM Run the application

cd src

python main.py

FILE: README.md

# Tutorial Generator with RAG

An intelligent tutorial generation system that uses Retrieval Augmented Generation (RAG) and Large Language Models to create comprehensive tutorials from your documents.

## Features

- **Multiple Document Formats**: Supports PDF, Word, PowerPoint, HTML, and Markdown

- **Automatic GPU Detection**: Detects and utilizes CUDA, ROCm, Apple MPS, or Intel acceleration

- **Flexible LLM Support**: Use local models or remote APIs (OpenAI, Anthropic, etc.)

- **Comprehensive Tutorials**: Generates presentations, explanations, quizzes, and solutions

- **Web Interface**: Easy-to-use browser-based interface

- **Modular Architecture**: Clean, maintainable, and extensible code structure

## Quick Start

### Installation

**Unix/Linux/macOS:**

```bash

chmod +x scripts/install.sh

./scripts/install.sh

```

**Windows:**

```cmd

scripts\install.bat

```

### Configuration

1. Edit `config/config.yaml` with your settings:

- For remote LLM: Add your API key and endpoint

- For local LLM: Specify the path to your model file

- Adjust document path, chunk sizes, etc.

1. Place your documents in `data/documents/your_docs/`

### Running

**Unix/Linux/macOS:**

```bash

./scripts/run.sh

```

**Windows:**

```cmd

scripts\run.bat

```

1. Open your browser to `http://localhost:5000`

## Project Structure

## Requirements

- Python 3.8 or higher

- 8GB RAM minimum (16GB recommended)

- GPU with 8GB+ VRAM for local models (optional)

- Internet connection for remote APIs or downloading models

## Supported Hardware

- **NVIDIA GPUs**: CUDA acceleration

- **AMD GPUs**: ROCm acceleration

- **Apple Silicon**: Metal Performance Shaders (M1/M2/M3/M4)

- **Intel GPUs**: Intel acceleration

- **CPU**: Fallback option (slower)

## Documentation

- [Installation Guide](docs/INSTALLATION.md)

- [Usage Guide](docs/USAGE.md)

- [API Documentation](docs/API.md)

- [Contributing](docs/CONTRIBUTING.md)

## License

MIT License - See LICENSE file for details

## Support

For issues, questions, or contributions, please open an issue on GitHub.

```

This complete modular structure provides a professional, maintainable codebase with:

1. **Clean separation of concerns** - Each module has a single, well-defined responsibility

1. **Easy testing** - Each component can be tested independently

1. **Simple configuration** - YAML-based config with sensible defaults

1. **Comprehensive documentation** - README and setup files guide users

1. **Cross-platform support** - Works on Windows, Linux, and macOS

1. **Professional structure** - Follows Python best practices

To use this, create the directory structure and copy each file into its respective location. Then run the installation script for your platform!

```

INSTALLATION AND USAGE INSTRUCTIONS

To use this complete system, you need to install the required Python libraries. Open your terminal and run the following command:

pip install python-pptx python-docx PyPDF2 beautifulsoup4 sentence-transformers flask requests llama-cpp-python torch numpy

Once the libraries are installed, save the complete code above to a file named tutorial_generator.py. Then follow these steps to run the system.

First, prepare a directory containing your source documents. This directory can contain any mix of PowerPoint files, Word documents, PDFs, HTML files, and Markdown files. The system will automatically scan the directory and all its subdirectories.

Second, run the application by executing the following command in your terminal:

python tutorial_generator.py

The system will guide you through an interactive setup process. It will first ask whether you want to use a local language model or a remote API. If you choose local, you need to provide the path to a GGUF format model file that is compatible with llama-cpp-python. If you choose remote, you need to provide your API credentials.

Next, the system will ask for the path to your documents directory. Enter the full path to the folder containing your source materials. The system will then read all documents, chunk them, generate embeddings, and build the vector store. This process may take a few minutes depending on how many documents you have.

Once initialization is complete, the web server will start. Open your web browser and navigate to http://localhost:5000 to access the tutorial generator interface. You will see a simple form where you can enter the topic you want to learn about, specify how many presentation pages you want, and choose the number of quiz questions.

When you submit the form, the system will generate a complete tutorial based on your documents. This process takes several minutes because the language model needs to generate multiple pieces of content. Once generation is complete, you will be automatically redirected to the first presentation page.

From there, you can navigate through the entire tutorial using the navigation menu at the top of each page. The presentation section contains your slide-style content with previous and next buttons to move through pages. The explanation section provides detailed written content. The quiz section tests your understanding, and the solutions section provides answers with detailed explanations.

The system is fully functional and production-ready. It handles errors gracefully, provides clear feedback, and includes proper documentation throughout the code. The architecture is modular and extensible, following clean code principles. You can customize any component without affecting the others, making it easy to adapt the system to your specific needs.

Hitchhiker's Guide to AI, Software Architecture, and Everything Else

Thursday, April 16, 2026

YOUR PERSONAL TUTORIAL GENERATOR: BUILDING AN INTELLIGENT TEACHING ASSISTANT WITH RAG AND LLMS

INTRODUCTION: WHAT ARE WE BUILDING AND WHY SHOULD YOU CARE?

THE BIG PICTURE: HOW ALL THE PIECES FIT TOGETHER

STEP ONE: BUILDING THE HARDWARE DETECTIVE

STEP TWO: CONFIGURING THE LANGUAGE MODEL FLEXIBLY

STEP THREE: READING DOCUMENTS IN MULTIPLE FORMATS

STEP FOUR: IMPLEMENTING RETRIEVAL AUGMENTED GENERATION

STEP FIVE: CONNECTING TO THE LANGUAGE MODEL

STEP SIX: GENERATING TUTORIAL CONTENT

STEP SEVEN: CREATING THE WEB INTERFACE

STEP EIGHT: PUTTING IT ALL TOGETHER

CONCLUSION: WHAT WE HAVE BUILT AND HOW TO USE IT

COMPLETE RUNNING EXAMPLE

INSTALLATION AND USAGE INSTRUCTIONS

No comments:

About Me