import streamlit as st
import os
import re
import tempfile
import logging
import time
import base64
import json
from typing import List, Dict, Any, Union, Optional, Tuple
from dotenv import load_dotenv
import io
# Document processing libraries
from docx import Document
from docx.shared import Inches, Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.enum.style import WD_STYLE_TYPE
import PyPDF2
from pptx import Presentation
import docx2txt
from docx.oxml import OxmlElement
from docx.oxml.ns import qn
# CrewAI imports
from crewai import Agent, Task, Crew, Process, LLM
from crewai.tasks import TaskOutput
from crewai.tools import BaseTool, tool
from pydantic import BaseModel, Field
import litellm
from langchain.tools import Tool
# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
# Set page configuration
st.set_page_config(
page_title="Case Study Analysis Suite",
page_icon="đ",
layout="wide"
)
# Initialize session state variables
if 'active_tab' not in st.session_state:
st.session_state.active_tab = "Case Breakdown"
if 'uploaded_files' not in st.session_state:
st.session_state.uploaded_files = None
if 'extracted_text' not in st.session_state:
st.session_state.extracted_text = ""
if 'first_file_text' not in st.session_state:
st.session_state.first_file_text = ""
if 'breakdown_generated' not in st.session_state:
st.session_state.breakdown_generated = False
if 'teaching_plan_generated' not in st.session_state:
st.session_state.teaching_plan_generated = False
if 'board_plan_generated' not in st.session_state:
st.session_state.board_plan_generated = False
# Load environment variables
#load_dotenv()
# Page title and description
st.title("đ Case Study Analysis Suite")
st.subheader("Generate comprehensive Teaching Notes, Teaching Plans, and Board Plans")
st.write("Developed for BIA 568 (Business Intelligence and Analytics) -- Management of A.I. at Stevens Institute of Technology")
st.write("---")
# Sidebar for API key configuration
# In the sidebar section:
with st.sidebar:
st.title("âī¸ Configuration")
api_key = st.text_input("Enter your Gemini API Key", type="password",
help="Required for the AI model to function")
if api_key:
os.environ["GEMINI_API_KEY"] = api_key
os.environ["GOOGLE_API_KEY"] = api_key
os.environ["LITELLM_MODEL_DEFAULT_PROVIDER"] = "gemini"
# Configure litellm
litellm.set_verbose = True
litellm_config = {
"model": "gemini/gemini-2.0-flash",
"api_key": api_key,
"provider": "gemini"
}
st.divider()
# Reset button
if st.button("đ Reset Session", use_container_width=True):
for key in list(st.session_state.keys()):
del st.session_state[key]
st.rerun()
#---------------------------- Utility Functions ----------------------------#
def extract_text_from_pdf(file):
"""Extract text content from PDF file"""
if isinstance(file, bytes):
file = io.BytesIO(file)
pdf_reader = PyPDF2.PdfReader(file)
text = ""
for page in pdf_reader.pages:
text += page.extract_text()
return text
def extract_text_from_docx(file):
"""Extract text content from DOCX file"""
if isinstance(file, bytes):
file = io.BytesIO(file)
return docx2txt.process(file)
def extract_text_from_pptx(file):
"""Extract text content from PPTX file"""
if isinstance(file, bytes):
file = io.BytesIO(file)
prs = Presentation(file)
text = ""
for slide in prs.slides:
for shape in slide.shapes:
if hasattr(shape, "text"):
text += shape.text + "\n"
return text
def extract_text_from_any_file(file):
"""Extract text based on file type"""
if file.name.endswith('.pdf'):
return extract_text_from_pdf(file)
elif file.name.endswith('.docx'):
return extract_text_from_docx(file)
elif file.name.endswith(('.pptx', '.ppt')):
return extract_text_from_pptx(file)
else:
return "Unsupported file format"
def create_download_link(content, filename):
"""Create a download link for text content"""
b64 = base64.b64encode(content.encode()).decode()
href = f'Download {filename}'
return href
def process_files(uploaded_files):
"""Process uploaded files and extract text"""
combined_text = ""
first_file_text = ""
temp_file_paths = []
for file in uploaded_files:
file.seek(0) # Reset file pointer
# Extract text based on file type
if file.name.endswith('.pdf'):
text = extract_text_from_pdf(file)
elif file.name.endswith('.docx'):
text = extract_text_from_docx(file)
elif file.name.endswith(('.pptx', '.ppt')):
text = extract_text_from_pptx(file)
else:
continue
# Save first file's text for metadata extraction
if not first_file_text:
first_file_text = text
combined_text += text + "\n\n"
# Create temporary file for each uploaded file
with tempfile.NamedTemporaryFile(delete=False, suffix=f".{file.name.split('.')[-1]}") as tmp_file:
file.seek(0)
tmp_file.write(file.getvalue())
temp_file_paths.append(tmp_file.name)
return combined_text, first_file_text, temp_file_paths
#---------------------------- Document Generator (Case Breakdown) ----------------------------#
class DocumentGenerator:
def __init__(self):
self.bullet_counter = 1
def add_toc(self, doc):
"""Add native Word table of contents"""
paragraph = doc.add_paragraph()
run = paragraph.add_run()
# Start the TOC field
fldChar1 = create_element('w:fldChar')
create_attribute(fldChar1, 'w:fldCharType', 'begin')
run._r.append(fldChar1)
# Add TOC instruction text
instrText = create_element('w:instrText')
create_attribute(instrText, 'xml:space', 'preserve')
instrText.text = 'TOC \\o "1-3" \\h \\z \\u'
run._r.append(instrText)
# End the TOC field
fldChar2 = create_element('w:fldChar')
create_attribute(fldChar2, 'w:fldCharType', 'end')
run._r.append(fldChar2)
def setup_document_styles(self, doc):
"""Set up custom styles for the document"""
styles = doc.styles
# Heading styles
for level in range(1, 4):
style_name = f'Heading {level}'
if style_name not in styles:
style = styles.add_style(style_name, WD_STYLE_TYPE.PARAGRAPH)
style.base_style = styles['Normal']
style.font.size = Pt(16 - (level * 2))
style.font.bold = True
# Custom bullet point style
if 'Bullet Point' not in styles:
bullet_style = styles.add_style('Bullet Point', WD_STYLE_TYPE.PARAGRAPH)
bullet_style.base_style = styles['Normal']
bullet_style.font.size = Pt(11)
bullet_style.paragraph_format.left_indent = Inches(0.25)
bullet_style.paragraph_format.first_line_indent = Inches(-0.25)
def add_formatted_text(self, paragraph, text):
"""Add text to paragraph with proper formatting"""
# First handle double asterisks
parts = re.split(r'(\*\*.*?\*\*)', text)
for part in parts:
if part.startswith('**') and part.endswith('**'):
# Handle bold text (surrounded by double asterisks)
run = paragraph.add_run(part[2:-2])
run.bold = True
else:
# Handle single asterisks within the remaining text
# Split by single asterisks
subparts = re.split(r'(\*[^\*]+\*)', part)
for subpart in subparts:
if subpart.startswith('*') and subpart.endswith('*') and len(subpart) > 2:
# It's a bold text marked with single asterisks
run = paragraph.add_run(subpart[1:-1])
run.bold = True
else:
# Regular text
if subpart.strip():
paragraph.add_run(subpart)
def clean_content(self, text):
"""Clean content and formatting"""
# Remove HTML tags
text = re.sub(r'<[^>]+>', '', text)
# Remove markdown headers while preserving content
text = re.sub(r'^#+\s*(.+)$', r'\1', text, flags=re.MULTILINE)
# Remove duplicate section headers
text = re.sub(r'(?i)^(.*?)\n\*\*\1\*\*', r'\1', text, flags=re.MULTILINE)
# Clean up
tags
text = re.sub(r'', '\n', text)
# Remove excessive newlines
text = re.sub(r'\n\s*\n', '\n\n', text)
# Process line by line to handle bullet points and bold text
lines = text.split('\n')
cleaned_lines = []
for line in lines:
line = line.strip()
if not line:
cleaned_lines.append(line)
continue
# Check if line starts with a single asterisk (potential bullet point)
if line.lstrip().startswith('*'):
# Skip if it starts with double asterisks
if line.lstrip().startswith('**'):
cleaned_lines.append(line)
continue
# Count asterisks that are not part of bold text markers
# First, temporarily replace bold text markers
temp_line = re.sub(r'\*\*.*?\*\*', '', line) # Remove double-asterisk patterns
temp_line = re.sub(r'\*[^\*]+\*', '', temp_line) # Remove single-asterisk patterns
# If there's exactly one asterisk left, it's a bullet point
if temp_line.count('*') == 1:
content = line.replace('*', '', 1).strip()
cleaned_lines.append(f'* {content}')
else:
cleaned_lines.append(line)
else:
cleaned_lines.append(line)
return '\n'.join(cleaned_lines).strip()
def add_section_content(self, doc, section_name, content):
"""Add a section with proper formatting"""
# Add section heading
heading = doc.add_heading(section_name.upper(), level=1)
heading.alignment = WD_ALIGN_PARAGRAPH.LEFT
# Clean and process the content
content = self.clean_content(content)
lines = content.split('\n')
for line in lines:
line = line.strip()
if not line:
continue
# Check for bullet point line
is_bullet = line.startswith('* ') and not line.startswith('** ')
if is_bullet:
# Create bullet point paragraph
bullet_paragraph = doc.add_paragraph(style='Bullet Point')
bullet_paragraph.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
bullet_paragraph.paragraph_format.left_indent = Inches(0.5)
bullet_paragraph.paragraph_format.first_line_indent = Inches(-0.25)
# Add bullet character
bullet_paragraph.add_run('âĸ ')
# Add the rest of the line with formatting
content = line[2:].strip()
self.add_formatted_text(bullet_paragraph, content)
else:
# Regular paragraph
p = doc.add_paragraph()
p.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
self.add_formatted_text(p, line)
def create_word_document(self, title, author, sections_content):
"""Create and return a formatted Word document"""
doc = Document()
self.setup_document_styles(doc)
# Title section
title_paragraph = doc.add_paragraph()
title_paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
title_run = title_paragraph.add_run("CASE BREAKDOWN")
title_run.font.size = Pt(16)
title_run.bold = True
# Case study name and author
case_name_paragraph = doc.add_paragraph()
case_name_paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
case_name_run = case_name_paragraph.add_run(title)
case_name_run.font.size = Pt(14)
case_name_run.italic = True
author_paragraph = doc.add_paragraph()
author_paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
author_run = author_paragraph.add_run(author)
author_run.font.size = Pt(12)
# Separator line
separator = doc.add_paragraph()
separator.alignment = WD_ALIGN_PARAGRAPH.CENTER
separator_run = separator.add_run('_' * 50)
# Add TOC
toc_heading = doc.add_heading('TABLE OF CONTENTS', level=1)
toc_heading.alignment = WD_ALIGN_PARAGRAPH.CENTER
self.add_toc(doc)
doc.add_page_break()
# Add sections
for section_name, content in sections_content.items():
self.add_section_content(doc, section_name, content)
doc.add_paragraph() # Add spacing between sections
return doc
# Helper functions for Word document
def create_element(name):
return OxmlElement(name)
def create_attribute(element, name, value):
element.set(qn(name), value)
#---------------------------- Case Breakdown Generator ----------------------------#
class CaseMetadata(BaseModel):
title: str = Field(description="The title of the case study")
author: str = Field(description="The author(s) of the case study")
class SectionContent(BaseModel):
content: str = Field(description="Generated content for the section")
review: str = Field(description="Review of the content with score and feedback")
class CaseBreakdownCrew:
def __init__(self, api_key):
self.api_key = api_key
self.llm = LLM(
model='gemini/gemini-2.0-flash',
api_key=self.api_key,
provider="gemini"
)
def create_metadata_agent(self):
return Agent(
role="Metadata Analyzer",
goal="Extract title and author information from document content",
backstory="""You specialize in analyzing document content to identify key metadata
such as titles, authors, and other publication information. You have a keen eye for
identifying the most important and relevant document metadata, even when it's not
explicitly labeled.""",
llm=LLM(
model='gemini/gemini-2.0-flash',
api_key=self.api_key,
provider="gemini"
),
verbose=True
)
def create_content_generator_agent(self):
return Agent(
role="Case Study Content Generator",
goal="Generate comprehensive case analysis content based on section requirements",
backstory="""You are an expert business analyst specializing in case study analysis.
You excel at breaking down complex business cases into structured, insightful content
that highlights key learning points, strategies, and insights. You have extensive experience
in business education and know how to create content that is valuable for teaching and learning.""",
llm=self.llm,
verbose=True
)
def create_content_reviewer_agent(self):
return Agent(
role="Content Quality Reviewer",
goal="Evaluate and score content for quality, relevance, and depth",
backstory="""You are a seasoned academic reviewer with years of experience evaluating
business case studies and educational content. You have a strong understanding of what makes
effective case study material and can provide constructive feedback to improve content quality.
You carefully analyze content for relevance, clarity, depth, and educational value.""",
llm=self.llm,
verbose=True
)
def create_metadata_task(self, text):
return Task(
description=f"""
Analyze the extracted text and identify the case study title and author(s).
Look for information typically found at the beginning of a document, such as:
1. The case study or article title
2. The author name(s)
Return the identified title and author in the following format:
Title: [the title]
Author: [the author(s)]
If you cannot find this information with certainty, use "Untitled Case Study" for the title
and "Unknown Author" for the author.
Text to analyze:
{text[:2000]}
""",
expected_output="Extracted metadata with title and author information",
agent=self.create_metadata_agent()
)
def create_section_task(self, section_name, prompt, text):
return Task(
description=f"""
Generate content for the '{section_name}' section of the case breakdown.
{prompt}
Formatting Requirements:
1. Use **bold** for important terms or concepts
2. For bullet points, start each line with "* " (asterisk followed by space)
3. For numbered lists, use "1. ", "2. " etc.
4. Use line breaks between paragraphs
5. Keep paragraphs focused and concise
Ensure the content is structured, well-organized, and follows proper formatting.
Text to analyze:
{text[:5000]}
""",
expected_output=f"A well-formatted {section_name} section",
agent=self.create_content_generator_agent()
)
def create_review_task(self, section_name, content):
return Task(
description=f"""
Review the content for the '{section_name}' section.
Score it from 1-10 based on:
1. Relevance to the section (0-3)
2. Clarity and coherence (0-3)
3. Depth of analysis (0-4)
Provide a structured review with:
1. Numerical score
2. Specific strengths
3. Areas for improvement
Content to review:
{content}
""",
expected_output=f"A review of the {section_name} section",
agent=self.create_content_reviewer_agent()
)
def extract_metadata(self, text):
metadata_task = self.create_metadata_task(text)
crew = Crew(
agents=[self.create_metadata_agent()],
tasks=[metadata_task],
process=Process.sequential,
verbose=False
)
result = crew.kickoff()
title = "Untitled Case Study"
author = "Unknown Author"
for line in result.raw.split('\n'):
if line.startswith('Title:'):
extracted_title = line.replace('Title:', '').strip()
if extracted_title and extracted_title != "[Untitled Case Study]":
title = extracted_title
elif line.startswith('Author:'):
extracted_author = line.replace('Author:', '').strip()
if extracted_author and extracted_author != "[Unknown Author]":
author = extracted_author
return title, author
def generate_section_content(self, text, section_name, section_prompt):
section_task = self.create_section_task(section_name, section_prompt, text)
crew = Crew(
agents=[self.create_content_generator_agent()],
tasks=[section_task],
process=Process.sequential,
verbose=False
)
result = crew.kickoff()
return result.raw
def review_content(self, content, section_name):
review_task = self.create_review_task(section_name, content)
crew = Crew(
agents=[self.create_content_reviewer_agent()],
tasks=[review_task],
process=Process.sequential,
verbose=False
)
result = crew.kickoff()
return result.raw
#---------------------------- Teaching Plan Generator ----------------------------#
class AgentTracker:
def __init__(self):
self.current_agent = ""
self.placeholder = None
def set_placeholder(self, placeholder):
self.placeholder = placeholder
def update_agent(self, agent_name):
self.current_agent = agent_name
if self.placeholder:
with self.placeholder:
st.write(f"đ¤ Agent in action: **{self.current_agent}**")
@tool
def extract_text(file_path: str) -> str:
"""
Extract text from a file based on its extension.
Args:
file_path (str): Path to the file
Returns:
str: Extracted text content
"""
try:
file_extension = file_path.split('.')[-1].lower()
if file_extension == 'pdf':
reader = PyPDF2.PdfReader(file_path)
text = ""
for page in reader.pages:
text += page.extract_text()
return text
elif file_extension == 'docx':
return docx2txt.process(file_path)
elif file_extension in ['ppt', 'pptx']:
presentation = Presentation(file_path)
text = ""
for slide in presentation.slides:
for shape in slide.shapes:
if hasattr(shape, "text"):
text += shape.text + "\n"
return text
else:
return f"Unsupported file format: {file_extension}"
except Exception as e:
return f"Error extracting text: {str(e)}"
def create_teaching_plan_crew(file_paths):
# Initialize LLM
my_llm = LLM(
model='gemini/gemini-2.0-flash',
api_key=os.environ.get("GEMINI_API_KEY"),
provider="gemini"
)
# Create agents with Gemini configuration
pdf_analyzer = Agent(
role='Case Study Analyzer',
goal='Extract key concepts, objectives, and data from case study files',
backstory='You are an expert in analyzing business case studies. Identify core themes, data points, and learning objectives.',
llm=my_llm,
tools=[extract_text],
verbose=True,
step_callback=lambda *args, **kwargs: tracker.update_agent("Case Study Analyzer")
)
plan_generator = Agent(
role='Teaching Plan Designer',
goal='Create a 2-hour lesson plan based on analyzed case study data',
backstory='You are an educator designing a structured lesson plan. Use the extracted case study data to outline activities, discussions, and assessments.',
llm=my_llm,
verbose=True,
step_callback=lambda *args, **kwargs: tracker.update_agent("Teaching Plan Designer")
)
reviewer = Agent(
role='Plan Reviewer',
goal='Ensure the lesson plan is engaging and aligned with learning objectives',
backstory='You are a curriculum reviewer. Verify the plan\'s clarity, alignment with objectives, and engagement level.',
llm=my_llm,
verbose=True,
step_callback=lambda *args, **kwargs: tracker.update_agent("Plan Reviewer")
)
final_reporter = Agent(
role='Teaching Plan Reporter',
goal='Ensure to incorporate the feedback from the reviewer agent and finalize the content for the teaching plan',
backstory=""" You are a Harvard Business School Teaching Plan Reporter with 20 years of Experience in teaching and curriculum development.
You are responsible for finalizing the content for the teaching plan and ensuring it is engaging and aligned with learning objectives.
You will use the feedback from the reviewer agent to make necessary revisions and finalize the content for the teaching plan.""",
llm=my_llm,
verbose=True,
step_callback=lambda *args, **kwargs: tracker.update_agent("Teaching Plan Reporter")
)
# Combine all file contents into one text
combined_file_path = file_paths[0] # Use the first file path for the analyzer to begin
# Define tasks
analyze_pdf = Task(
description=f"Extract and analyze the files at {', '.join(file_paths)} for key concepts and learning objectives.",
config={"file_path": combined_file_path},
expected_output="A summary of key concepts and learning objectives extracted from the files.",
agent=pdf_analyzer
)
generate_plan = Task(
description="Design a 2-hour lesson plan with introduction, analysis, group activity, and assessment.",
expected_output="A detailed 2-hour lesson plan with clear sections and activities.",
agent=plan_generator
)
review_plan = Task(
description="Review the lesson plan for clarity, alignment with objectives, and student engagement.",
expected_output="Feedback on the lesson plan's clarity, alignment, and engagement level.",
agent=reviewer
)
final_plan = Task(
description="Generate the final lesson plan based on the feedback.",
expected_output="""
You are also responsible for ensuring the plan is clear and concise.
- It should have the overall objective to start with.
- It should have a clear introduction
- It should have detailed lesson breakdowns with the time to be spent on each section and the title of the section Highlighting all the important concepts to be taught (you can use tables to highlight the concepts in a structured way)
- It should have one powerful visual aid which can be a table That can help in better understanding for the students
- It can have simple assessmentsthat enables class participation engagement in brainstorming activities and such that can help in better understanding of the concepts.
- It should have a clear conclusion that ties back to the overall objective.
- Overall Plan should be around 1300 - 1500 words.""",
agent=final_reporter
)
# Create crew
crew = Crew(
agents=[pdf_analyzer, plan_generator, reviewer, final_reporter],
tasks=[analyze_pdf, generate_plan, review_plan, final_plan],
process=Process.sequential,
verbose=True
)
return crew
#---------------------------- Board Plan Generator ----------------------------#
class BoardPlanAnalyzer:
def __init__(self):
api_key = os.environ.get('GEMINI_API_KEY')
if not api_key:
raise ValueError("Gemini API key not found")
self.llm = LLM(
model='gemini/gemini-2.0-flash',
api_key=api_key,
provider="gemini"
)
litellm.set_verbose = True
# Create agents
self.create_agents()
def create_agents(self):
"""Create specialized agents for different tasks"""
# PDF Processing Agent
self.pdf_processor = Agent(
role='PDF Processor',
goal='Extract and clean text content from PDF case studies',
backstory="""You are an expert at processing PDF documents and extracting
meaningful content. You ensure the text is properly formatted and ready
for analysis.""",
tools=[Tool(
name="extract_text",
func=self.extract_text_from_pdf,
description="Extracts text content from PDF files"
)],
allow_delegation=False,
llm=self.llm,
verbose=True
)
# Content Analysis Agent
self.analyzer = Agent(
role='Case Study Analyzer',
goal='Analyze case studies and identify key points for board plan',
backstory="""You are an expert business analyst skilled at analyzing case
studies and identifying crucial elements. You create clear, structured
analyses that highlight key insights.""",
tools=[Tool(
name="analyze_content",
func=self.analyze_case_study,
description="Analyzes case study and creates structured board plan"
)],
allow_delegation=False,
llm=self.llm,
verbose=True
)
def extract_text_from_pdf(self, pdf_content: bytes) -> str:
"""Extract text from PDF using PyPDF2"""
try:
# Create PDF reader object
pdf_file = io.BytesIO(pdf_content)
pdf_reader = PyPDF2.PdfReader(pdf_file)
# Extract text from all pages
text_content = []
for page in pdf_reader.pages:
text_content.append(page.extract_text())
# Combine all pages with proper spacing
return "\n\n".join(text_content)
except Exception as e:
raise Exception(f"PDF extraction error: {str(e)}")
def analyze_case_study(self, text: str) -> dict:
"""Analyze case study content using litellm with JSON response"""
messages = [
{
"role": "user",
"content": f"""Analyze this case study and create a structured board plan.
Case study: {text}
Create a detailed analysis with these exact sections:
1. Main concept/technology being discussed
2. Industry suitability and context
3. Benefits and impact
4. Key roles and perspectives
5. Implementation details
- Data requirements
- Scaling considerations
- Performance metrics
6. Next steps and recommendations
Also include risk assessment.
Format the response as a JSON object with this structure:
{{
"boards": [
{{
"title": "BOARD 1: [Title]",
"points": ["point 1", "point 2", "point 3"]
}},
// ... other boards
],
"risk_assessment": {{
"title": "WHAT IS THE RISK OF FAILURE?",
"points": ["risk 1", "risk 2"]
}}
}}"""
}
]
try:
response = litellm.completion(
model="gemini/gemini-2.0-flash",
messages=messages,
api_key=os.environ.get("GEMINI_API_KEY"),
provider="gemini",
response_format={"type": "json_object"}
)
# Extract and parse the JSON response
content = response.choices[0].message.content
return json.loads(content)
except Exception as e:
st.error(f"Analysis error: {str(e)}")
if 'response' in locals():
st.error("Raw response:")
st.code(response.choices[0].message.content)
raise
def process_case_study(self, pdf_content: bytes) -> dict:
"""Process the case study using Crew AI agents"""
try:
# First extract text
progress_text = st.empty()
progress_text.text("Extracting text from PDF...")
text_content = self.extract_text_from_pdf(pdf_content)
# Show extracted text for verification
with st.expander("View extracted text"):
st.text(text_content[:500] + "...")
# Then analyze content
progress_text.text("Analyzing content...")
result = self.analyze_case_study(text_content)
return result
except Exception as e:
raise Exception(f"Processing error: {str(e)}")
#---------------------------- Main App Interface ----------------------------#
# File upload section - shared across all generators
if st.session_state.uploaded_files is None:
uploaded_files = st.file_uploader(
"Upload case study files (PDF, DOCX, PPT, PPTX)",
accept_multiple_files=True,
type=['pdf', 'docx', 'ppt', 'pptx']
)
if uploaded_files:
st.session_state.uploaded_files = uploaded_files
# Process files only once and store results
with st.spinner("Processing uploaded files..."):
combined_text, first_file_text, temp_file_paths = process_files(uploaded_files)
st.session_state.combined_text = combined_text
st.session_state.first_file_text = first_file_text
st.session_state.temp_file_paths = temp_file_paths
# Show file upload summary
st.success(f"â
{len(uploaded_files)} file(s) uploaded and processed successfully")
for file in uploaded_files:
st.write(f"- {file.name}")
# Tabs for different generators
if st.session_state.uploaded_files:
# Use native streamlit tabs (no styling overrides)
tab1, tab2, tab3 = st.tabs([
"Case Breakdown Generator",
"Teaching Plan Generator",
"Board Plan Generator"
])
#------------------ Case Breakdown Generator Tab ------------------#
with tab1:
st.header("Case Breakdown Generator")
st.write("Generate a comprehensive breakdown of the case study with sections for teaching purposes.")
if not st.session_state.breakdown_generated:
if not api_key:
st.warning("â ī¸ Please enter an API key in the sidebar before proceeding.")
else:
# Initialize the breakdown generator
crew_manager = CaseBreakdownCrew(api_key)
# Extract metadata
with st.spinner("Extracting document metadata..."):
title, author = crew_manager.extract_metadata(st.session_state.first_file_text)
# Display extracted metadata with option to edit
st.subheader("Extracted Document Information")
title = st.text_input("Case Study Title:", title)
author = st.text_input("Author:", author)
# Initialize sections based on template
sections = {
"Case Synopsis": """ Summarize the case in 3â4 paragraphs of a total 300 words. Explain the company's background, the industry it operates in,
and the key challenge or strategic decision it faces. Discuss any turning points or dilemmas. Why is this case relevant for
business students?
Position in Course: In 1â2 sentences, describe which type of course this case is best suited for
(e.g., Operations Strategy, AI in Business, Global Supply Chain). What key topics does it help students understand""",
"Learning Objectives": """List 8â10 learning objectives for this case. A total of 300 words. What should students understand after analyzing this case? Focus on
leadership decisions, operational insights, AI adoption, or ethical concerns""",
"Teaching Strategies":
"""
Describe 8â10 ways an instructor can effectively teach this case. Should they use role-playing? A total of 350 words.
A structured debate? Analyzing real-world examples? How can students actively engage with the material? 1st point should be Approach and second point should be Objective
""",
"Suggested Teaching Plan":
"""
Outline a structured teaching plan for this case. What should be covered first? A total of 350 words.
When should student activities be introduced? How should the case discussion conclude?
""",
"Key Points and Insights":
"""
List 10 key insights students should take from this case. What makes this case unique? A total of 300 words.
What are the most important strategic, operational, or ethical considerations?
""",
"Further Insights":
"""
Provide additional insights that go beyond the case. How does this case relate to
larger business trends? What external factors (e.g., regulation, innovation, geopolitical forces) could impact the situation? A total of 400 words.
""",
"Discussion Questions & Answers":
"""
Create 8â10 discussion questions about the case. What are the key strategic dilemmas?
Where do trade-offs exist? How can students critically analyze the company's decisions? Provide concise answers. A total of 450 words.
""",
"Assignment Exercises":
"""
List 8â10 in-depth assignments that encourage strategic thinking, data analysis,
or real-world application. Include a mix of strategy proposals, financial analysis,
role-playing exercises, and ethical debates. Define the expected format
(e.g., business report, presentation, comparative analysis) and objective of each exercise. A total of 550- 600 words.
""",
"Automated Conversation":
"""
Write an AI-generated conversation between three personas relevant to the case. A total of 650- 700 words.
One should be an executive making a strategic decision, another should be an expert,
and the third should be skeptical or resistant. The conversation should explore the challenges, risks, and strategic importance of the case.
""",
"Case Suggestions":
"""
List 10 ways to make this case more interactive. Should students role-play as executives?
Simulate a crisis response? Conduct a competitive market analysis?
Suggest unique, hands-on ways to engage with the case. A total of 550 words.
"""
}
# Generate button
if st.button("Generate Case Breakdown", key="breakdown_button"):
# Create tabs for content and review
content_tab, review_tab = st.tabs(["Generated Content", "Content Review"])
# Generate and display content
sections_content = {}
reviews = {}
with st.spinner("Generating content... This may take several minutes."):
progress_bar = st.progress(0)
with content_tab:
for i, (section_name, prompt) in enumerate(sections.items()):
# Generate content using the CrewAI agents
st.info(f"Generating {section_name}...")
content = crew_manager.generate_section_content(st.session_state.combined_text, section_name, prompt)
sections_content[section_name] = content
# Generate review
review = crew_manager.review_content(content, section_name)
reviews[section_name] = review
# Display content in preview
st.subheader(section_name)
st.markdown(content)
# Update progress
progress_bar.progress((i + 1) / len(sections))
# Store generated content in session state
st.session_state.sections_content = sections_content
st.session_state.reviews = reviews
st.session_state.title = title
st.session_state.author = author
st.session_state.breakdown_generated = True
# Display reviews in review tab
with review_tab:
for section_name, review in reviews.items():
st.subheader(f"{section_name} Review")
st.markdown(review)
# Generate and store the document for later
doc_generator = DocumentGenerator()
doc = doc_generator.create_word_document(
title=title,
author=author,
sections_content=sections_content
)
# Save document to temporary file
with tempfile.NamedTemporaryFile(delete=False, suffix='.docx') as tmp_file:
doc.save(tmp_file.name)
st.session_state.doc_path = tmp_file.name
# Allow the user to download the document
with open(st.session_state.doc_path, 'rb') as file:
st.download_button(
label="đĨ Download Case Breakdown (DOCX)",
data=file,
file_name=f"{title.lower().replace(' ', '_')}_case_breakdown.docx",
mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
key="download_docx_button"
)
else:
# If we already have generated content, display it without regenerating
st.subheader("Extracted Document Information")
st.text_input("Case Study Title:", value=st.session_state.title, key="title_display", disabled=True)
st.text_input("Author:", value=st.session_state.author, key="author_display", disabled=True)
# Display the generated content in tabs
content_tab, review_tab = st.tabs(["Generated Content", "Content Review"])
with content_tab:
for section_name, content in st.session_state.sections_content.items():
st.subheader(section_name)
st.markdown(content)
with review_tab:
for section_name, review in st.session_state.reviews.items():
st.subheader(f"{section_name} Review")
st.markdown(review)
# Allow the user to download the document without regenerating
with open(st.session_state.doc_path, 'rb') as file:
st.download_button(
label="đĨ Download Case Breakdown (DOCX)",
data=file,
file_name=f"{st.session_state.title.lower().replace(' ', '_')}_case_breakdown.docx",
mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
key="download_docx_button"
)
#------------------ Teaching Plan Generator Tab ------------------#
with tab2:
st.header("Teaching Plan Generator")
st.write("Generate a comprehensive 2-hour teaching plan for the case study.")
if not st.session_state.teaching_plan_generated:
if not api_key:
st.warning("â ī¸ Please enter an API key in the sidebar before proceeding.")
else:
# Create a button to start generation
if st.button("Generate Teaching Plan", key="teaching_plan_button"):
try:
# Create placeholders for UI updates
progress_placeholder = st.empty()
agent_status_placeholder = st.empty()
# Create a tracker and set its placeholder
tracker = AgentTracker()
tracker.set_placeholder(agent_status_placeholder)
# Initialize progress bar
progress_bar = progress_placeholder.progress(0)
# Select LLM provider
llm_provider = "gemini"
# Update progress
progress_bar.progress(10)
st.info("đ Initializing crew and analyzing documents...")
# Create crew
crew = create_teaching_plan_crew(st.session_state.temp_file_paths, llm_provider)
# Update progress
progress_bar.progress(30)
st.info("đ Document analysis in progress...")
# Start the execution
start_time = time.time()
result = crew.kickoff(inputs={"file_path": st.session_state.temp_file_paths[0]})
result_text = str(result) # Convert CrewOutput to string
# Update progress
progress_bar.progress(90)
st.info("âī¸ Finalizing teaching plan...")
# Calculate execution time
execution_time = time.time() - start_time
# Complete progress
progress_bar.progress(100)
agent_status_placeholder.empty() # Clear the agent status
# Save results to session state
st.session_state.teaching_plan_execution_time = execution_time
st.session_state.teaching_plan_result = result_text
st.session_state.teaching_plan_generated = True
# Display the result
st.success(f"â
Teaching plan generated successfully in {execution_time:.2f} seconds!")
st.subheader("đ Generated Teaching Plan")
st.markdown(result_text)
# Provide download option
st.download_button(
label="đĨ Download Teaching Plan (Markdown)",
data=result_text,
file_name="teaching_plan.md",
mime="text/markdown",
)
except Exception as e:
st.error(f"â An error occurred during processing: {str(e)}")
# Show instructions
with st.expander("âšī¸ How it works"):
st.write("""
The Teaching Plan Generator creates a comprehensive 2-hour lesson plan with:
1. **Clear learning objectives** tied to the case study
2. **Structured timeline** with time allocations for each activity
3. **Engaging activities** for effective student learning
4. **Discussion questions** to promote critical thinking
5. **Assessment strategies** to measure understanding
The AI uses a team of specialized agents to analyze your case study, create a draft plan,
review it for quality, and finalize it into a polished teaching resource.
""")
else:
# Display the previously generated content
st.success(f"â
Teaching plan generated successfully in {st.session_state.teaching_plan_execution_time:.2f} seconds!")
st.subheader("đ Generated Teaching Plan")
st.markdown(st.session_state.teaching_plan_result)
# Provide download option
st.download_button(
label="đĨ Download Teaching Plan (Markdown)",
data=st.session_state.teaching_plan_result,
file_name="teaching_plan.md",
mime="text/markdown",
)
#------------------ Board Plan Generator Tab ------------------#
with tab3:
st.header("Board Plan Generator")
st.write("Generate a structured board plan analysis for the case study.")
if not st.session_state.board_plan_generated:
if not api_key:
st.warning("â ī¸ Please enter an API key in the sidebar before proceeding.")
else:
# Create a button to start generation
if st.button("Generate Board Plan", key="board_plan_button"):
try:
# Select LLM provider
llm_provider = "gemini"
# Initialize the board plan analyzer
analyzer = BoardPlanAnalyzer(llm_provider=llm_provider)
with st.spinner("Analyzing case study to generate board plan..."):
# Get content from first uploaded file
file = st.session_state.uploaded_files[0]
pdf_content = file.getvalue()
# Process the case study
analysis_result = analyzer.process_case_study(pdf_content)
# Store in session state
st.session_state.board_plan_result = analysis_result
st.session_state.board_plan_generated = True
# Generate markdown for download
markdown_content = "# Board Plan Analysis\n\n"
for board in analysis_result['boards']:
markdown_content += f"## {board['title']}\n\n"
for point in board['points']:
markdown_content += f"* {point}\n"
markdown_content += "\n"
if 'risk_assessment' in analysis_result:
markdown_content += f"## {analysis_result['risk_assessment']['title']}\n\n"
for point in analysis_result['risk_assessment']['points']:
markdown_content += f"* {point}\n"
st.session_state.board_plan_markdown = markdown_content
st.success("Board plan generated successfully!")
# Display the analysis results
st.subheader("Board Plan Analysis")
for board in analysis_result['boards']:
with st.expander(board['title'], expanded=True):
for point in board['points']:
st.markdown(f"âĸ {point}")
if 'risk_assessment' in analysis_result:
st.subheader("Risk Assessment")
for point in analysis_result['risk_assessment']['points']:
st.markdown(f"âĸ {point}")
# Provide download option
st.download_button(
label="đĨ Download Board Plan (Markdown)",
data=st.session_state.board_plan_markdown,
file_name="board_plan.md",
mime="text/markdown",
)
except Exception as e:
st.error(f"An error occurred: {str(e)}")
st.error("Please ensure the file is not encrypted and contains extractable text.")
# Show instructions
with st.expander("âšī¸ How it works"):
st.write("""
The Board Plan Generator creates a structured analysis with these components:
1. **Main concept/technology** being discussed in the case study
2. **Industry suitability and context** for application
3. **Benefits and impact** of implementing the solution
4. **Key roles and perspectives** from stakeholders
5. **Implementation details** including data requirements, scaling, and metrics
6. **Next steps and recommendations** for moving forward
7. **Risk assessment** to identify potential challenges
The generator provides a structured framework perfect for teaching, presentations,
or boardroom discussions.
""")
else:
# Display the previously generated content
st.success("Board plan generated successfully!")
# Display the analysis results
st.subheader("Board Plan Analysis")
for board in st.session_state.board_plan_result['boards']:
with st.expander(board['title'], expanded=True):
for point in board['points']:
st.markdown(f"âĸ {point}")
if 'risk_assessment' in st.session_state.board_plan_result:
st.subheader("Risk Assessment")
for point in st.session_state.board_plan_result['risk_assessment']['points']:
st.markdown(f"âĸ {point}")
# Provide download option
st.download_button(
label="đĨ Download Board Plan (Markdown)",
data=st.session_state.board_plan_markdown,
file_name="board_plan.md",
mime="text/markdown",
)
else:
# Display welcome message and instructions when no files are uploaded
st.markdown("""
## Welcome to the Case Study Analysis Suite
This application provides three powerful tools for analyzing case studies:
1. **Case Breakdown Generator**: Creates a comprehensive breakdown of the case with sections for teaching purposes, formatted as a DOCX document.
2. **Teaching Plan Generator**: Develops a 2-hour lesson plan with activities, discussions, and assessments based on the case study.
3. **Board Plan Generator**: Produces a structured board plan analysis with key insights and implementation details.
### Getting Started
1. Choose your API provider in the sidebar (Google Gemini or OpenAI)
2. Enter your API key
3. Upload one or more case study files in PDF, DOCX, PPT, or PPTX format
4. Select the generator tab you want to use
5. Click the generate button and wait for the results
Each generator produces downloadable content in an appropriate format for your use.
""")
# Footer
st.divider()
st.caption("Created with CrewAI, Streamlit, and Gemini âĸ Built by Arun Kashyap âĸ Š 2025")