Studying from long notes or textbook material can be time-consuming, especially when you have to identify the important concepts yourself. The AI Flashcard Generator makes this process easier by turning a study topic or study material into a set of question-and-answer flashcards.

The application is built using Python, Streamlit, PyTorch, and Hugging Face Transformers. It uses Google's google/flan-t5-base model to generate the questions and answers. Users can choose the number of flashcards, select a difficulty level, and either enter a topic or paste their study material.
 

Table of Contents

Technologies Used

MODEL_NAME = "google/flan-t5-base"

Importing the Libraries

import re
import streamlit as st
import torch
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

Loading the FLAN-T5 Model

tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)

he tokenizer converts the prompt into tokens that FLAN-T5 can process. The model then uses those tokens to generate the flashcards.

The application also checks whether CUDA is available:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
model.eval()

This allows the application to use a GPU when available and fall back to the CPU otherwise.

The @st.cache_resource decorator is used so that Streamlit does not repeatedly reload the model every time the application reruns.

Creating the AI Prompt

The main generation happens inside generate_cards().

The application creates a structured prompt that tells the model exactly what it needs to produce:

prompt = f"""Create exactly {count} study flashcards from the material below.

Difficulty: {difficulty}

IMPORTANT OUTPUT FORMAT:

Q1: question

A1: short answer

Q2: question

A2: short answer
...
"""

This is an example of prompt engineering. The model is given the required number of cards, difficulty level, output format, and rules for creating the questions and answers.

The prompt also instructs the model not to invent information that is not present in the study material.

Generating the Flashcards

The generate_ai_text() function sends the prompt to FLAN-T5.

First, the prompt is tokenized:

inputs = tokenizer(
    prompt,
    return_tensors="pt",
    truncation=True,
    max_length=512
)

output = model.generate(
    **inputs,
    max_new_tokens=max_new_tokens,
    num_beams=5,
    do_sample=False,
    no_repeat_ngram_size=3,
    repetition_penalty=1.1
)

Parsing the AI Response

Q1: What is normalization?

A1: Normalization is a database design technique used to reduce redundancy.

Q2: Why is normalization important?

A2: It helps organize data and reduce data duplication.

The parse_cards() function uses a regular expression to find these question-and-answer pairs.

It then stores them as Python tuples:

(question, answer)

Fallback Generation

AI models do not always follow formatting instructions perfectly. To make the application more reliable, the project includes a fallback_cards() function.

If the model generates fewer flashcards than requested, the application creates additional cards using predefined templates.

For example:

What is [topic]?
Why is [topic] important?
What is a key idea related to [topic]?
Where can [topic] be applied?

This ensures that the application can still return the requested number of cards even when the model does not follow the expected format.
 

Choosing the Number and Difficulty

count = st.slider(
    "Number of flashcards",
    min_value=3,
    max_value=20,
    value=10
)

["Easy", "Medium", "Hard"]

Study Topic
Study Material

Database Management Systems - Normalization

with st.expander(f"Card {index}: {question}"):
    st.write(answer)

flashcards.txt

Study Topic / Material
        ↓
Prompt Engineering
        ↓
FLAN-T5 Model
        ↓
Question + Answer Generation
        ↓
Output Parsing
        ↓
Validation + Fallback
        ↓
Flashcard Deck
        ↓
Display / Download

streamlit>=1.40.0
transformers>=4.45.0,<5.0.0
torch>=2.2.0
sentencepiece>=0.2.0

pip install -r requirements.txt

streamlit run app.py