🚀 Enhanced IQKiller with Next.js Vercel version

✨ Major Features Added:
- Complete Next.js application in iqkiller-vercel/
- Real-time streaming analysis with 7-step pipeline
- Professional interview guide generation
- Question bank integration (750+ categorized questions)
- Smart job URL processing and data extraction
- Comprehensive UI with progress tracking and results display

🎯 Key Improvements:
- Simplified job input flow (auto-save on URL paste)
- Enhanced streaming analysis with proper completion handling
- Professional guide display with company insights
- Removed complex scraping dependencies for reliability
- Fixed result display and data flow issues

📊 Technical Enhancements:
- Structured question bank from CSV processing
- Role-based question selection and AI personalization
- Company research and salary insights integration
- Clean streaming API with progress tracking
- Responsive UI components with shadcn/ui

Backup created: backup_20250708_192058

.gitignore

@@ -38,6 +38,11 @@ ENV/
 .DS_Store
 Thumbs.db
 
+# Environment variables
+.env
+.env.local
+.env.*.local
+
 # Cache
 .cache/
 

README.md

@@ -10,4 +10,47 @@ pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# IQKiller v2 - AI-Powered Interview Preparation Platform
+
+An advanced interview preparation platform that provides personalized interview guides, salary negotiation simulation, and comprehensive analysis.
+
+## 🚀 Quick Start
+
+### 1. Environment Setup
+```bash
+# Set up all API keys automatically
+chmod +x setup-env.sh
+./setup-env.sh
+```
+
+### 2. Run Python Application
+```bash
+# Activate virtual environment (if using one)
+source venv/bin/activate
+
+# Run the main application
+python3 simple_iqkiller.py
+```
+
+### 3. Run Next.js Application (Vercel-ready)
+```bash
+cd iqkiller-vercel
+npm install
+npm run dev
+```
+
+## 🔑 Required API Keys
+
+- **SERPAPI_KEY**: Job posting search
+- **OPENAI_API_KEY**: Primary LLM processing
+- **ANTHROPIC_API_KEY**: Fallback LLM processing  
+- **FIRECRAWL_API_KEY**: Advanced web scraping
+
+See `VERCEL_ENV_SETUP.md` for detailed environment variable configuration.
+
+## 📁 Project Structure
+
+- `simple_iqkiller.py` - Main Python Gradio application
+- `iqkiller-vercel/` - Next.js application for Vercel deployment
+- `env.template` - Environment variables template
+- `setup-env.sh` - Automated environment setup script

VERCEL_DEPLOYMENT_ROADMAP.md

@@ -0,0 +1,417 @@
+# 🚀 IQKiller Vercel Deployment Roadmap
+
+## 📊 Current vs. Target Architecture
+
+### Current Architecture (Gradio-based)
+- **Frontend**: Gradio Python components
+- **Backend**: Single Python application with all logic
+- **Deployment**: Traditional server hosting
+- **Limitations**: Not serverless-friendly, monolithic structure
+
+### Target Architecture (Vercel-optimized)
+- **Frontend**: Next.js 14 + React + TypeScript
+- **Backend**: Python serverless functions (Vercel API routes)
+- **Database**: Vercel KV (Redis) + PostgreSQL (Neon)
+- **File Storage**: Vercel Blob for PDF uploads
+- **Deployment**: Serverless on Vercel Edge Network
+
+## 🛠️ Technology Stack
+
+### Frontend Stack
+```javascript
+// Core Framework
+Next.js 14 (App Router)
+React 18
+TypeScript
+Tailwind CSS
+
+// UI Components
+shadcn/ui components
+Framer Motion (animations)
+React Hook Form (forms)
+Zod (validation)
+
+// File Upload
+React Dropzone
+Vercel Blob SDK
+```
+
+### Backend Stack
+```python
+# API Framework
+FastAPI (for Vercel Python functions)
+Pydantic (data validation)
+
+# PDF Processing
+PyPDF2 / pdfplumber
+python-multipart (file uploads)
+
+# LLM Integration
+OpenAI SDK
+Anthropic SDK
+httpx (async requests)
+
+# Web Scraping
+Firecrawl SDK
+BeautifulSoup4 (fallback)
+```
+
+### Infrastructure
+```yaml
+# Hosting & CDN
+Vercel (Frontend + Serverless Functions)
+Vercel Edge Network (Global CDN)
+
+# Database
+Neon PostgreSQL (managed)
+Vercel KV (Redis cache)
+
+# Storage
+Vercel Blob (PDF files)
+Environment Variables (API keys)
+
+# Monitoring
+Vercel Analytics
+Sentry (error tracking)
+```
+
+## 📁 Project Structure
+
+```
+iqkiller-vercel/
+├── 📱 Frontend (Next.js)
+│   ├── app/
+│   │   ├── (dashboard)/
+│   │   │   ├── analyze/
+│   │   │   │   ├── page.tsx
+│   │   │   │   └── loading.tsx
+│   │   │   ├── results/
+│   │   │   │   └── [id]/
+│   │   │   │       └── page.tsx
+│   │   │   └── layout.tsx
+│   │   ├── api/
+│   │   │   ├── auth/
+│   │   │   ├── upload/
+│   │   │   └── webhook/
+│   │   ├── globals.css
+│   │   ├── layout.tsx
+│   │   └── page.tsx
+│   ├── components/
+│   │   ├── ui/
+│   │   │   ├── button.tsx
+│   │   │   ├── card.tsx
+│   │   │   ├── input.tsx
+│   │   │   └── progress.tsx
+│   │   ├── pdf-upload.tsx
+│   │   ├── job-url-input.tsx
+│   │   ├── analysis-results.tsx
+│   │   └── header.tsx
+│   ├── lib/
+│   │   ├── utils.ts
+│   │   ├── api.ts
+│   │   ├── validations.ts
+│   │   └── constants.ts
+│   ├── hooks/
+│   │   ├── use-upload.ts
+│   │   └── use-analysis.ts
+│   └── types/
+│       ├── api.ts
+│       └── analysis.ts
+├── 🐍 Backend (Python Functions)
+│   ├── api/
+│   │   ├── pdf/
+│   │   │   ├── extract.py
+│   │   │   └── enhance.py
+│   │   ├── analysis/
+│   │   │   ├── job.py
+│   │   │   ├── resume.py
+│   │   │   └── match.py
+│   │   ├── scraping/
+│   │   │   ├── firecrawl.py
+│   │   │   └── fallback.py
+│   │   └── llm/
+│   │       ├── openai.py
+│   │       └── anthropic.py
+│   ├── lib/
+│   │   ├── database.py
+│   │   ├── cache.py
+│   │   ├── utils.py
+│   │   └── config.py
+│   └── requirements.txt
+├── 📊 Database
+│   ├── schema.sql
+│   ├── migrations/
+│   └── seed.sql
+├── 🚀 Deployment
+│   ├── vercel.json
+│   ├── .env.example
+│   └── .gitignore
+└── 📚 Documentation
+    ├── README.md
+    ├── API.md
+    └── DEPLOYMENT.md
+```
+
+## 🗓️ Development Roadmap (6-Week Timeline)
+
+### Week 1: Foundation & Setup
+**Days 1-2: Project Initialization**
+- [ ] Create Next.js 14 project with TypeScript
+- [ ] Set up Tailwind CSS and shadcn/ui
+- [ ] Configure Vercel deployment structure
+- [ ] Set up development environment
+
+**Days 3-4: Core UI Components**
+- [ ] Build header and navigation
+- [ ] Create PDF upload component with drag & drop
+- [ ] Build job URL input with validation
+- [ ] Design analysis results display layout
+
+**Days 5-7: Backend Foundation**
+- [ ] Set up Python serverless function structure
+- [ ] Configure FastAPI for Vercel functions
+- [ ] Implement basic PDF processing endpoint
+- [ ] Set up environment variables and configs
+
+### Week 2: Core Features - PDF Processing
+**Days 8-10: PDF Upload & Processing**
+- [ ] Implement Vercel Blob storage integration
+- [ ] Build PDF text extraction service
+- [ ] Create LLM enhancement for resume parsing
+- [ ] Add file validation and error handling
+
+**Days 11-12: Frontend Integration**
+- [ ] Connect frontend to PDF upload API
+- [ ] Implement real-time upload progress
+- [ ] Add preview of extracted text
+- [ ] Handle upload errors gracefully
+
+**Days 13-14: Testing & Optimization**
+- [ ] Test with various PDF formats
+- [ ] Optimize for Vercel function size limits
+- [ ] Implement caching for processed files
+- [ ] Add loading states and animations
+
+### Week 3: Job Analysis & Web Scraping
+**Days 15-17: Web Scraping Service**
+- [ ] Implement Firecrawl integration
+- [ ] Build fallback scraping methods
+- [ ] Add URL validation and normalization
+- [ ] Create job content parsing logic
+
+**Days 18-19: LLM Integration**
+- [ ] Set up OpenAI and Anthropic clients
+- [ ] Implement resume-job matching algorithm
+- [ ] Build interview question generation
+- [ ] Add comprehensive analysis logic
+
+**Days 20-21: Frontend Analysis Interface**
+- [ ] Build job URL input component
+- [ ] Create real-time scraping status
+- [ ] Design analysis results layout
+- [ ] Add interactive elements and animations
+
+### Week 4: Advanced Features & Database
+**Days 22-24: Database Integration**
+- [ ] Set up Neon PostgreSQL database
+- [ ] Create schema for users and analyses
+- [ ] Implement Vercel KV for caching
+- [ ] Build data persistence layer
+
+**Days 25-26: User Authentication**
+- [ ] Implement NextAuth.js or Clerk
+- [ ] Add user registration/login
+- [ ] Create user dashboard
+- [ ] Implement session management
+
+**Days 27-28: Analysis History & Sharing**
+- [ ] Build analysis history page
+- [ ] Implement shareable result links
+- [ ] Add export functionality (PDF, JSON)
+- [ ] Create analytics tracking
+
+### Week 5: Performance & Polish
+**Days 29-31: Performance Optimization**
+- [ ] Optimize Vercel function cold starts
+- [ ] Implement edge caching strategies
+- [ ] Compress and optimize images/assets
+- [ ] Add service worker for offline support
+
+**Days 32-33: UI/UX Polish**
+- [ ] Refine animations and transitions
+- [ ] Add dark mode support
+- [ ] Implement responsive design improvements
+- [ ] Add accessibility features (ARIA, keyboard nav)
+
+**Days 34-35: Error Handling & Monitoring**
+- [ ] Set up Sentry for error tracking
+- [ ] Implement comprehensive error boundaries
+- [ ] Add rate limiting and abuse prevention
+- [ ] Create status page and health checks
+
+### Week 6: Deployment & Launch
+**Days 36-38: Production Deployment**
+- [ ] Configure production environment variables
+- [ ] Set up custom domain and SSL
+- [ ] Implement CI/CD pipeline
+- [ ] Configure monitoring and alerts
+
+**Days 39-40: Testing & Bug Fixes**
+- [ ] Conduct comprehensive end-to-end testing
+- [ ] Performance testing under load
+- [ ] Security testing and vulnerability scanning
+- [ ] User acceptance testing
+
+**Days 41-42: Launch Preparation**
+- [ ] Create documentation and help guides
+- [ ] Set up analytics and tracking
+- [ ] Prepare launch announcement
+- [ ] Go live! 🚀
+
+## 💰 Cost Analysis
+
+### Vercel Costs
+```yaml
+Plan: Pro ($20/month)
+- 100GB bandwidth
+- 1000 serverless function executions
+- 100GB Vercel KV storage
+- Custom domains
+- Advanced analytics
+
+Additional Costs:
+- Extra function executions: $0.40/1000
+- Extra bandwidth: $0.40/GB
+- Vercel Blob storage: $0.15/GB
+```
+
+### Third-Party Services
+```yaml
+Database (Neon): $0-19/month
+File Storage: $0.15/GB (Vercel Blob)
+LLM APIs:
+  - OpenAI: $0.0015/1K tokens (GPT-4o-mini)
+  - Anthropic: $0.003/1K tokens (Claude-3.5-Sonnet)
+Firecrawl: $20/month (5000 pages)
+Monitoring (Sentry): $26/month (team plan)
+
+Total Estimated: $66-85/month
+```
+
+## 🔧 Vercel Configuration
+
+### vercel.json
+```json
+{
+  "framework": "nextjs",
+  "buildCommand": "npm run build",
+  "devCommand": "npm run dev",
+  "installCommand": "npm install",
+  "functions": {
+    "api/pdf/extract.py": {
+      "runtime": "python3.9",
+      "maxDuration": 30
+    },
+    "api/analysis/match.py": {
+      "runtime": "python3.9", 
+      "maxDuration": 45
+    }
+  },
+  "env": {
+    "OPENAI_API_KEY": "@openai-api-key",
+    "ANTHROPIC_API_KEY": "@anthropic-api-key",
+    "FIRECRAWL_API_KEY": "@firecrawl-api-key",
+    "DATABASE_URL": "@database-url"
+  },
+  "regions": ["iad1", "sfo1"],
+  "rewrites": [
+    {
+      "source": "/api/pdf/:path*",
+      "destination": "/api/pdf/:path*"
+    }
+  ]
+}
+```
+
+### Environment Variables Setup
+```bash
+# Development
+cp .env.example .env.local
+
+# Production (Vercel CLI)
+vercel env add OPENAI_API_KEY
+vercel env add ANTHROPIC_API_KEY  
+vercel env add FIRECRAWL_API_KEY
+vercel env add DATABASE_URL
+vercel env add NEXTAUTH_SECRET
+vercel env add NEXTAUTH_URL
+```
+
+## 🚀 Deployment Strategy
+
+### Phase 1: MVP Deployment (Week 4)
+- Basic PDF upload and processing
+- Simple job analysis
+- Core UI components
+- No authentication
+
+### Phase 2: Beta Release (Week 5)  
+- User authentication
+- Analysis history
+- Enhanced UI/UX
+- Performance optimizations
+
+### Phase 3: Production Launch (Week 6)
+- Full feature set
+- Monitoring and analytics
+- Custom domain
+- Marketing and announcements
+
+## 🔄 Alternative Deployment Options
+
+If Vercel limitations become challenging:
+
+### Option 1: Railway
+- Better for Python applications
+- PostgreSQL included
+- $5/month starter plan
+- Persistent storage support
+
+### Option 2: Render
+- Native Python support
+- PostgreSQL included
+- $7/month starter plan
+- Background jobs support
+
+### Option 3: AWS Lambda + CloudFront
+- More control over infrastructure
+- Pay-per-use pricing
+- Requires more DevOps knowledge
+- Better for high-scale applications
+
+## 📈 Success Metrics
+
+### Technical KPIs
+- Page load time: <2 seconds
+- Function cold start: <1 second
+- PDF processing: <10 seconds
+- Analysis generation: <30 seconds
+- Uptime: >99.9%
+
+### User Experience KPIs
+- Time to first analysis: <60 seconds
+- User retention rate: >40%
+- Analysis accuracy: >90%
+- User satisfaction: >4.5/5
+
+## 🎯 Next Steps
+
+1. **Immediate**: Set up Next.js project and basic structure
+2. **Week 1**: Focus on core PDF upload functionality
+3. **Week 2**: Implement LLM integration for resume enhancement
+4. **Week 3**: Build job scraping and analysis engine
+5. **Week 4**: Add user management and persistence
+6. **Week 5**: Polish and optimize for production
+7. **Week 6**: Deploy and launch!
+
+Ready to start building? Let's begin with the Next.js foundation! 🚀 

VERCEL_DEPLOYMENT_ROADMAP_UPDATED.md

@@ -0,0 +1,226 @@
+# 🚀 IQKiller Vercel Deployment Roadmap - Updated
+
+> **✨ Updated with insights from [Vercel AI SDK PDF Support](https://github.com/vercel-labs/ai-sdk-preview-pdf-support)**
+
+## 📊 Enhanced Architecture (Vercel AI SDK Powered)
+
+### Target Architecture (Optimized)
+- **Frontend**: Next.js 14 + React + TypeScript + Tailwind CSS
+- **PDF Processing**: Vercel AI SDK with native PDF support 
+- **Backend**: Next.js API routes (instead of Python serverless)
+- **AI Integration**: Vercel AI SDK with OpenAI + Anthropic
+- **Database**: Vercel KV (Redis) + Neon PostgreSQL
+- **File Storage**: Native browser file handling + AI SDK
+- **Deployment**: Vercel Edge Network
+
+## 🛠️ Updated Technology Stack
+
+### Frontend Stack
+```javascript
+// Core Framework (from Vercel example)
+Next.js 14 (App Router)
+React 18
+TypeScript
+Tailwind CSS
+
+// AI Integration
+Vercel AI SDK (@ai-sdk/openai, @ai-sdk/anthropic)
+useObject hook for PDF processing
+useChat for interview interactions
+
+// UI Components  
+shadcn/ui components
+Framer Motion (animations)
+React Hook Form (forms)
+Zod (validation)
+
+// File Upload (Native AI SDK approach)
+Native File API + AI SDK PDF support
+No external PDF processing libraries needed
+```
+
+### Backend Stack (Simplified)
+```javascript
+// API Framework (Next.js native)
+Next.js API Routes
+Vercel AI SDK
+TypeScript throughout
+
+// AI Providers
+@ai-sdk/openai (GPT-4o-mini)
+@ai-sdk/anthropic (Claude-3.5-Sonnet)
+
+// Web Scraping (Keep our approach)
+Firecrawl SDK
+Puppeteer (Vercel-compatible)
+
+// Database
+Vercel KV (Redis)
+@vercel/postgres (Neon)
+```
+
+## 📁 Updated Project Structure (Based on Vercel Example)
+
+```
+iqkiller-vercel/
+├── 📱 Frontend (Next.js 14)
+│   ├── app/
+│   │   ├── (dashboard)/
+│   │   │   ├── analyze/
+│   │   │   │   ├── page.tsx         # Main analysis page
+│   │   │   │   └── loading.tsx
+│   │   │   ├── results/[id]/
+│   │   │   │   └── page.tsx
+│   │   │   └── layout.tsx
+│   │   ├── api/
+│   │   │   ├── analyze/
+│   │   │   │   └── route.ts         # PDF + Job analysis API
+│   │   │   ├── scrape/
+│   │   │   │   └── route.ts         # Job URL scraping API
+│   │   │   └── chat/
+│   │   │       └── route.ts         # Interview chat API
+│   │   ├── globals.css
+│   │   ├── layout.tsx
+│   │   └── page.tsx
+│   ├── components/
+│   │   ├── ui/                      # shadcn/ui components
+│   │   ├── pdf-upload.tsx           # Based on Vercel example
+│   │   ├── job-analysis.tsx         # Our interview analysis
+│   │   ├── chat-interface.tsx       # Interview chat
+│   │   └── results-display.tsx      # Analysis results
+│   ├── lib/
+│   │   ├── ai.ts                    # AI SDK configuration
+│   │   ├── utils.ts
+│   │   ├── validations.ts
+│   │   └── database.ts              # Vercel KV + Postgres
+│   ├── hooks/
+│   │   ├── use-pdf-analysis.ts      # Custom hook for PDF + AI
+│   │   ├── use-job-scraping.ts
+│   │   └── use-interview-chat.ts
+│   └── types/
+│       ├── analysis.ts
+│       └── interview.ts
+├── 🗄️ Database
+│   ├── schema.sql
+│   └── migrations/
+├── 🚀 Deployment
+│   ├── vercel.json
+│   ├── .env.example
+│   └── next.config.js
+└── 📚 Documentation
+    ├── README.md
+    └── API.md
+```
+
+## 🎯 Updated Development Approach
+
+### Week 1: Foundation with AI SDK (Days 1-7)
+**Days 1-2: Setup Based on Vercel Example**
+- [ ] Clone and study the Vercel AI SDK PDF example
+- [ ] Create IQKiller project using their structure as template
+- [ ] Set up Vercel AI SDK with OpenAI and Anthropic
+- [ ] Configure shadcn/ui and Tailwind CSS
+
+**Days 3-4: PDF Processing with AI SDK**
+- [ ] Implement PDF upload using Vercel AI SDK approach
+- [ ] Create `useObject` hook for resume analysis
+- [ ] Build PDF analysis component based on their example
+- [ ] Add real-time processing feedback
+
+**Days 5-7: Job Analysis Integration**
+- [ ] Extend AI SDK usage for job description analysis
+- [ ] Implement job URL scraping API route
+- [ ] Create comprehensive analysis combining resume + job
+- [ ] Add interview question generation
+
+### Week 2: Enhanced Features (Days 8-14)
+- [ ] Interview chat interface using `useChat` hook
+- [ ] Salary negotiation scenarios
+- [ ] Analysis history with Vercel KV
+- [ ] Real-time collaboration features
+
+### Week 3: Polish & Deploy (Days 15-21)
+- [ ] Performance optimization
+- [ ] Error handling and loading states
+- [ ] Vercel deployment configuration
+- [ ] Production testing and launch
+
+## 💻 **Let's Start Building Now!**
+
+Based on the Vercel AI SDK example, here's our immediate action plan:
+
+### Option 1: Clone and Modify Vercel Example
+```bash
+# Start with proven foundation
+npx create-next-app --example https://github.com/vercel-labs/ai-sdk-preview-pdf-support iqkiller-vercel
+cd iqkiller-vercel
+
+# Customize for IQKiller features
+# Add job scraping, interview analysis, etc.
+```
+
+### Option 2: Use Our Setup Script with AI SDK Integration
+```bash
+# Use our comprehensive setup
+./setup-vercel-project.sh
+
+# Then integrate Vercel AI SDK approach
+cd iqkiller-vercel
+npm install ai @ai-sdk/openai @ai-sdk/anthropic
+```
+
+## 🚀 **Vercel Deployment Configuration**
+
+### package.json (AI SDK Integration)
+```json
+{
+  "dependencies": {
+    "ai": "^3.4.7",
+    "@ai-sdk/openai": "^1.0.0", 
+    "@ai-sdk/anthropic": "^1.0.0",
+    "next": "14.2.0",
+    "react": "^18.3.0",
+    "typescript": "^5.0.0",
+    "tailwindcss": "^3.4.0",
+    "@radix-ui/react-slot": "^1.0.2",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.0.0",
+    "lucide-react": "^0.263.1",
+    "tailwind-merge": "^1.14.0"
+  }
+}
+```
+
+### Environment Variables (.env.local)
+```bash
+# AI Providers (matching Vercel example format)
+OPENAI_API_KEY=sk-proj-your-openai-key
+ANTHROPIC_API_KEY=sk-ant-your-anthropic-key
+
+# Additional IQKiller services
+FIRECRAWL_API_KEY=fc-your-firecrawl-key
+SERPAPI_KEY=your-serpapi-key
+
+# Vercel Storage
+KV_URL=your-vercel-kv-url
+KV_REST_API_URL=your-kv-rest-url
+KV_REST_API_TOKEN=your-kv-token
+KV_REST_API_READ_ONLY_TOKEN=your-kv-readonly-token
+
+POSTGRES_URL=your-neon-postgres-url
+```
+
+## 🎯 **Which Approach Do You Prefer?**
+
+1. **Fast Start**: Clone Vercel example and customize for IQKiller
+2. **Full Control**: Use our setup script and integrate AI SDK step by step
+3. **Hybrid**: Start with Vercel example structure but add our comprehensive features
+
+The Vercel AI SDK approach will give us:
+- ✅ **Native PDF support** - no custom parsing needed
+- ✅ **Proven deployment** - optimized for Vercel from day 1  
+- ✅ **Type safety** - full TypeScript integration
+- ✅ **Real-time features** - streaming responses and chat
+- ✅ **Edge runtime** - faster global performance
+
+**Ready to start building? Which approach should we take first?** 🚀 

VERCEL_ENV_SETUP.md

@@ -0,0 +1,96 @@
+# Vercel Environment Variables Setup
+
+## 🔑 Environment Variables Required
+
+For IQKiller to work properly on Vercel, you need to configure the following environment variables in your Vercel dashboard:
+
+### Required API Keys
+
+| Variable Name | Description | Where to Get |
+|---------------|-------------|--------------|
+| `SERPAPI_KEY` | Search API for job posting data | [SerpAPI](https://serpapi.com/) |
+| `OPENAI_API_KEY` | OpenAI API for LLM processing (primary) | [OpenAI Platform](https://platform.openai.com/) |
+| `ANTHROPIC_API_KEY` | Anthropic Claude API (fallback) | [Anthropic Console](https://console.anthropic.com/) |
+| `FIRECRAWL_API_KEY` | Firecrawl API for web scraping | [Firecrawl](https://firecrawl.dev/) |
+
+## 🚀 Setting Up Environment Variables on Vercel
+
+### Method 1: Vercel Dashboard (Recommended)
+
+1. Go to your [Vercel Dashboard](https://vercel.com/dashboard)
+2. Select your IQKiller project
+3. Go to **Settings** → **Environment Variables**
+4. Add each variable:
+   - **Name**: `SERPAPI_KEY`
+   - **Value**: `860035cdbc22f1452e9a5313bc595ff0a41781b922dce50e0f93a83869f08319`
+   - **Environment**: Select all (Production, Preview, Development)
+   - Click **Save**
+
+5. Repeat for all variables:
+   ```
+   SERPAPI_KEY=860035cdbc22f1452e9a5313bc595ff0a41781b922dce50e0f93a83869f08319
+   OPENAI_API_KEY=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
+   ANTHROPIC_API_KEY=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
+   FIRECRAWL_API_KEY=fc-08e46542bfcc4ca7a953fac4dea4237e
+   ```
+
+### Method 2: Vercel CLI
+
+If you have Vercel CLI installed:
+
+```bash
+cd iqkiller-vercel
+vercel env add SERPAPI_KEY
+# Paste: 860035cdbc22f1452e9a5313bc595ff0a41781b922dce50e0f93a83869f08319
+
+vercel env add OPENAI_API_KEY
+# Paste: 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
+
+vercel env add ANTHROPIC_API_KEY
+# Paste: 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
+
+vercel env add FIRECRAWL_API_KEY
+# Paste: fc-08e46542bfcc4ca7a953fac4dea4237e
+```
+
+## 🏠 Local Development Setup
+
+For local development, run the setup script:
+
+```bash
+chmod +x setup-env.sh
+./setup-env.sh
+```
+
+This will create:
+- `.env` file for the Python project
+- `.env.local` file for the Next.js project
+
+## 🔒 Security Notes
+
+- ✅ `.env` files are in `.gitignore` - they won't be committed
+- ✅ Never share API keys in public repositories
+- ✅ Use different API keys for development/production if needed
+- ✅ Regularly rotate API keys for security
+
+## ✅ Verification
+
+After setting up environment variables:
+
+1. **Local**: Run `./setup-env.sh` and test with `npm run dev`
+2. **Vercel**: Deploy and check the application logs for any missing environment variable errors
+
+## 🆘 Troubleshooting
+
+**Error: Missing API Key**
+- Check that all 4 environment variables are set in Vercel dashboard
+- Ensure variable names match exactly (case-sensitive)
+- Redeploy after adding variables
+
+**Error: Invalid API Key**
+- Verify API keys are active and have sufficient credits
+- Check for any extra spaces or characters when copying
+
+**Local development not working**
+- Run `./setup-env.sh` to regenerate `.env` files
+- Check that `.env` file exists and contains all keys 

components/job-analysis.tsx

@@ -0,0 +1,120 @@
+'use client'
+
+import React, { useState } from 'react'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Label } from '@/components/ui/label'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Loader2, Link as LinkIcon, FileText } from 'lucide-react'
+
+interface JobAnalysisProps {
+  onJobData: (data: any) => void
+}
+
+export function JobAnalysis({ onJobData }: JobAnalysisProps) {
+  const [jobUrl, setJobUrl] = useState('')
+  const [jobText, setJobText] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+  const [mode, setMode] = useState<'url' | 'text'>('url')
+
+  const handleUrlScraping = async () => {
+    if (!jobUrl.trim()) return
+    
+    setIsLoading(true)
+    try {
+      const response = await fetch('/api/scrape', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ url: jobUrl })
+      })
+      
+      const data = await response.json()
+      if (data.success) {
+        onJobData(data.jobData)
+      }
+    } catch (error) {
+      console.error('Error scraping job:', error)
+    } finally {
+      setIsLoading(false)
+    }
+  }
+
+  const handleTextSubmit = () => {
+    if (!jobText.trim()) return
+    
+    onJobData({
+      description: jobText,
+      source: 'manual_text'
+    })
+  }
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>Job Information</CardTitle>
+        <CardDescription>
+          Add job posting via URL or paste the description directly
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-4">
+        <div className="flex space-x-2">
+          <Button
+            variant={mode === 'url' ? 'default' : 'outline'}
+            onClick={() => setMode('url')}
+            className="flex-1"
+          >
+            <LinkIcon className="w-4 h-4 mr-2" />
+            URL
+          </Button>
+          <Button
+            variant={mode === 'text' ? 'default' : 'outline'}
+            onClick={() => setMode('text')}
+            className="flex-1"
+          >
+            <FileText className="w-4 h-4 mr-2" />
+            Text
+          </Button>
+        </div>
+
+        {mode === 'url' ? (
+          <div className="space-y-3">
+            <Label htmlFor="job-url">Job Posting URL</Label>
+            <Input
+              id="job-url"
+              type="url"
+              placeholder="https://linkedin.com/jobs/view/123456"
+              value={jobUrl}
+              onChange={(e) => setJobUrl(e.target.value)}
+            />
+            <Button 
+              onClick={handleUrlScraping} 
+              disabled={isLoading || !jobUrl.trim()}
+              className="w-full"
+            >
+              {isLoading && <Loader2 className="w-4 h-4 mr-2 animate-spin" />}
+              Scrape Job Details
+            </Button>
+          </div>
+        ) : (
+          <div className="space-y-3">
+            <Label htmlFor="job-text">Job Description</Label>
+            <textarea
+              id="job-text"
+              className="w-full min-h-[200px] p-3 border rounded-md resize-y"
+              placeholder="Paste the complete job description here..."
+              value={jobText}
+              onChange={(e) => setJobText(e.target.value)}
+            />
+            <Button 
+              onClick={handleTextSubmit} 
+              disabled={!jobText.trim()}
+              className="w-full"
+            >
+              Use This Job Description
+            </Button>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  )
+} 

env.template

@@ -0,0 +1,17 @@
+# IQKiller API Keys - Template for Local Development
+# Copy this file to .env and fill in your actual API keys
+
+# Search API for job posting data
+SERPAPI_KEY=your_serpapi_key_here
+
+# OpenAI API for LLM processing (primary)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Anthropic Claude API for LLM processing (fallback)
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Firecrawl API for enhanced web scraping
+FIRECRAWL_API_KEY=your_firecrawl_api_key_here
+
+# Optional: Set to development for local testing
+NODE_ENV=development 

extract_pdf_resume.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+echo "📄 PDF Resume Text Extractor for IQKiller"
+echo "=========================================="
+echo ""
+echo "This tool extracts text from your PDF resume so you can copy-paste it into IQKiller."
+echo ""
+
+# Check if PDF file is provided as argument
+if [ "$1" != "" ]; then
+    echo "🔍 Processing: $1"
+    python3 pdf_upload_tool.py "$1"
+else
+    echo "📁 Drag and drop your PDF file here, or provide the path:"
+    echo ""
+    echo "Usage:"
+    echo "  ./extract_pdf_resume.sh /path/to/your/resume.pdf"
+    echo ""
+    echo "Or run the interactive version:"
+    python3 pdf_upload_tool.py
+fi
+
+echo ""
+echo "💡 Copy the extracted text above and paste it into IQKiller at:"
+echo "   http://localhost:7860"
+echo "" 

interview_guide_generator.py

@@ -1,197 +1,153 @@
+#!/usr/bin/env python3
 """
-Comprehensive Interview Guide Generator
-Generates detailed, personalized interview guides matching the professional format
+Enhanced Interview Guide Generator - InterviewGuideGPT Format
+Generates polished, role-specific interview guides following exact structure requirements
 """
 
 import re
-import random
-from typing import Dict, List, Tuple
+import json
+from typing import Dict, List, Any
 from dataclasses import dataclass
 
 @dataclass
-class InterviewGuide:
-    """Structured interview guide data"""
-    title: str
+class GuideData:
+    """Structured data for interview guide generation"""
+    role_title: str
+    company: str
     match_score: float
-    introduction: str
-    skills_analysis: Dict
-    interview_process: Dict
-    technical_questions: List[Dict]
-    behavioral_questions: List[Dict]
-    company_questions: List[Dict]
-    preparation_strategy: Dict
-    talking_points: List[str]
-    smart_questions: List[str]
+    user_overview: str
+    user_skills: List[str]
+    role_skills: List[str]
+    team_context: str
+    interview_rounds: int
+    process_notes: List[str]
+    key_projects: List[str] = None
+    candidate_strengths: List[str] = None
+    skill_gaps: List[str] = None
 
-class ComprehensiveAnalyzer:
-    """Generates comprehensive interview guides"""
+class InterviewGuideGPT:
+    """Elite career-coach AI for generating polished interview guides"""
     
     def __init__(self):
         self.tech_skills = [
             "Python", "JavaScript", "Java", "SQL", "React", "Node.js", 
             "AWS", "Docker", "Git", "Machine Learning", "Data Science",
             "Analytics", "R", "Tableau", "Pandas", "NumPy", "TensorFlow",
-            "Kubernetes", "MongoDB", "PostgreSQL", "Redis", "Apache Spark"
-        ]
-        
-        self.soft_skills = [
-            "Leadership", "Communication", "Project Management", "Team Work",
-            "Problem Solving", "Critical Thinking", "Adaptability", "Creativity"
+            "Kubernetes", "MongoDB", "PostgreSQL", "Redis", "Apache Spark",
+            "Scala", "Hadoop", "Spark", "Kafka", "Elasticsearch"
         ]
         
-        self.company_patterns = {
-            "spotify": ["spotify", "music", "streaming", "audio"],
-            "google": ["google", "search", "advertising", "cloud"],
-            "amazon": ["amazon", "aws", "e-commerce", "cloud"],
-            "microsoft": ["microsoft", "azure", "office", "windows"],
-            "meta": ["meta", "facebook", "social", "vr"],
-            "apple": ["apple", "ios", "iphone", "mac"],
-            "netflix": ["netflix", "streaming", "content", "entertainment"]
+        self.company_insights = {
+            "spotify": "Spotify prizes data-driven creativity in music.",
+            "google": "Google values innovation and technical excellence at scale.",
+            "amazon": "Amazon focuses on customer obsession and operational excellence.",
+            "microsoft": "Microsoft emphasizes collaboration and empowering others.",
+            "meta": "Meta drives connection and community through technology.",
+            "apple": "Apple pursues perfection in user experience and design.",
+            "netflix": "Netflix champions freedom, responsibility, and context over control."
         }
 
-    def analyze_resume(self, resume_text: str) -> Dict:
-        """Enhanced resume analysis"""
-        if not resume_text.strip():
-            return {
-                "skills": [],
-                "experience": 0,
-                "roles": [],
-                "projects": [],
-                "education": "Unknown",
-                "achievements": []
-            }
-        
-        # Extract skills
-        found_skills = []
-        for skill in self.tech_skills + self.soft_skills:
-            if skill.lower() in resume_text.lower():
-                found_skills.append(skill)
-        
-        # Extract experience
-        experience_patterns = [
-            r'(\d+)[\s\+]*years?\s+(?:of\s+)?experience',
-            r'(\d+)\+?\s*years?\s+(?:in|with)',
-            r'(\d+)\s*years?\s+(?:working|professional)'
-        ]
+    def analyze_resume_and_job(self, resume_text: str, job_text: str) -> GuideData:
+        """Analyze resume and job to extract structured data"""
         
-        experience_years = 2  # default
-        for pattern in experience_patterns:
-            match = re.search(pattern, resume_text, re.IGNORECASE)
-            if match:
-                experience_years = int(match.group(1))
-                break
+        # Extract user data
+        user_skills = self._extract_skills(resume_text)
+        user_overview = self._extract_user_overview(resume_text)
         
-        # Extract roles
-        role_keywords = [
-            "software engineer", "data scientist", "product manager",
-            "frontend developer", "backend developer", "full stack",
-            "analyst", "researcher", "designer", "architect"
-        ]
+        # Extract job data
+        role_title, company = self._extract_role_and_company(job_text)
+        role_skills = self._extract_skills(job_text)
+        team_context = self._extract_team_context(job_text)
+        
+        # Calculate match score
+        match_score = self._calculate_match_score(user_skills, role_skills, resume_text, job_text)
+        
+        # Generate process info
+        interview_rounds = self._estimate_interview_rounds(company, role_title)
+        process_notes = self._generate_process_notes(company, role_title)
+        
+        # Extract additional data
+        key_projects = self._extract_key_projects(resume_text)
+        candidate_strengths = self._extract_strengths(resume_text, user_skills)
+        skill_gaps = list(set(role_skills) - set(user_skills))
+        
+        return GuideData(
+            role_title=role_title,
+            company=company,
+            match_score=match_score,
+            user_overview=user_overview,
+            user_skills=user_skills,
+            role_skills=role_skills,
+            team_context=team_context,
+            interview_rounds=interview_rounds,
+            process_notes=process_notes,
+            key_projects=key_projects,
+            candidate_strengths=candidate_strengths,
+            skill_gaps=skill_gaps
+        )
+
+    def _extract_skills(self, text: str) -> List[str]:
+        """Extract technical skills from text"""
+        skills = []
+        text_lower = text.lower()
+        
+        for skill in self.tech_skills:
+            if skill.lower() in text_lower:
+                skills.append(skill)
+        
+        # Add soft skills
+        soft_skills = ["Leadership", "Communication", "Project Management", "Team Work", "Problem Solving"]
+        for skill in soft_skills:
+            if skill.lower() in text_lower or any(word in text_lower for word in skill.lower().split()):
+                skills.append(skill)
         
-        found_roles = []
-        for keyword in role_keywords:
-            if keyword in resume_text.lower():
-                found_roles.append(keyword.title())
+        return list(set(skills))
+
+    def _extract_user_overview(self, resume_text: str) -> str:
+        """Extract user overview from resume"""
+        # Look for experience years
+        experience_match = re.search(r'(\d+)[\s\+]*years?\s+(?:of\s+)?experience', resume_text, re.IGNORECASE)
+        years = experience_match.group(1) if experience_match else "several"
         
-        # Extract education
+        # Look for degree/education
         education_patterns = [
-            r'(master|bachelor|phd|doctorate)[\s\w]*(?:of\s+)?([a-zA-Z\s]+)',
-            r'(ms|bs|ba|ma|phd)\s+in\s+([a-zA-Z\s]+)',
-            r'(m\.s\.|b\.s\.|ph\.d\.)\s+([a-zA-Z\s]+)'
+            r'(bachelor|master|phd|doctorate|degree)',
+            r'(computer science|data science|engineering|mathematics|statistics)'
         ]
         
-        education = "Bachelor's Degree"
+        education = "degree"
         for pattern in education_patterns:
             match = re.search(pattern, resume_text, re.IGNORECASE)
             if match:
-                degree = match.group(1).title()
-                if degree.lower() in ['ms', 'm.s.', 'master']:
-                    education = "Master of Science"
-                elif degree.lower() in ['phd', 'ph.d.', 'doctorate']:
-                    education = "PhD"
+                education = match.group(1)
                 break
         
-        # Extract projects (simplified)
-        project_patterns = [
-            r'(built|developed|created|designed)\s+([a-zA-Z\s]+?)(?:\s+using|\s+with|\s+for)',
-            r'project[:\s]+([a-zA-Z\s]+)',
-            r'([a-zA-Z\s]+?)\s+(?:project|application|system|platform)'
-        ]
-        
-        projects = []
-        for pattern in project_patterns:
-            matches = re.findall(pattern, resume_text, re.IGNORECASE)
-            for match in matches[:3]:  # limit to 3 projects
-                if isinstance(match, tuple) and len(match) > 0:
-                    projects.append(match[1] if len(match) > 1 else match[0])
-                elif isinstance(match, str) and match.strip():
-                    projects.append(match)
-        
-        return {
-            "skills": found_skills,
-            "experience": experience_years,
-            "roles": found_roles or ["Professional"],
-            "projects": projects,
-            "education": education,
-            "achievements": []
-        }
+        return f"Professional with {years} years of experience and {education} background"
 
-    def analyze_job(self, job_text: str) -> Dict:
-        """Enhanced job analysis"""
-        if not job_text.strip():
-            return {
-                "company": "Unknown Company",
-                "role": "Unknown Role",
-                "required_skills": [],
-                "location": "Remote",
-                "industry": "Technology",
-                "seniority": "Mid-level"
-            }
-        
+    def _extract_role_and_company(self, job_text: str) -> tuple:
+        """Extract role title and company from job text"""
         # Extract company
         company_patterns = [
-            r'at\s+([A-Z][a-zA-Z\s&]+?)(?:\s|$|,|\n)',
-            r'([A-Z][a-zA-Z\s&]+?)\s+is\s+(?:hiring|looking)',
-            r'join\s+([A-Z][a-zA-Z\s&]+?)(?:\s|$|,|\n)',
-            r'company:\s*([A-Z][a-zA-Z\s&]+?)(?:\s|$|,|\n)'
+            r'at\s+([A-Z][a-zA-Z\s&\.]+?)(?:\s|$|,|\n)',
+            r'([A-Z][a-zA-Z\s&\.]+?)\s+is\s+(?:hiring|looking)',
+            r'join\s+([A-Z][a-zA-Z\s&\.]+?)(?:\s|$|,|\n)',
         ]
         
-        company = "Unknown Company"
+        company = "Company"
         for pattern in company_patterns:
             match = re.search(pattern, job_text, re.IGNORECASE)
             if match:
                 company = match.group(1).strip()
                 break
         
-        # Detect specific companies
-        detected_company = None
-        for comp_name, keywords in self.company_patterns.items():
-            if any(keyword in job_text.lower() for keyword in keywords):
-                detected_company = comp_name
-                break
-        
-        if detected_company:
-            company_names = {
-                "spotify": "Spotify",
-                "google": "Google",
-                "amazon": "Amazon",
-                "microsoft": "Microsoft",
-                "meta": "Meta",
-                "apple": "Apple",
-                "netflix": "Netflix"
-            }
-            company = company_names.get(detected_company, company)
-        
         # Extract role
         role_patterns = [
-            r'(senior\s+)?(data\s+scientist|software\s+engineer|product\s+manager|frontend\s+developer|backend\s+developer|full\s+stack|analyst)',
+            r'(senior\s+)?(data\s+scientist|software\s+engineer|product\s+manager|analyst|developer)',
             r'position[:\s]+(senior\s+)?([a-zA-Z\s]+)',
             r'role[:\s]+(senior\s+)?([a-zA-Z\s]+)',
-            r'we\'re\s+looking\s+for\s+(?:a\s+)?(senior\s+)?([a-zA-Z\s]+)'
         ]
         
-        role = "Unknown Role"
-        seniority = "Mid-level"
+        role = "Role"
         for pattern in role_patterns:
             match = re.search(pattern, job_text, re.IGNORECASE)
             if match:
@@ -199,513 +155,395 @@ class ComprehensiveAnalyzer:
                 if len(groups) >= 2:
                     senior_part = groups[0] or ""
                     role_part = groups[1] or groups[-1]
-                    if "senior" in senior_part.lower():
-                        seniority = "Senior"
                     role = (senior_part + role_part).strip().title()
                     break
         
-        # Extract required skills
-        required_skills = []
-        for skill in self.tech_skills:
-            if skill.lower() in job_text.lower():
-                required_skills.append(skill)
-        
-        # Extract location
-        location_patterns = [
-            r'location[:\s]+([a-zA-Z\s,]+)',
-            r'([a-zA-Z\s]+),\s*([A-Z]{2})',
-            r'(remote|hybrid|on-site)',
-            r'(san francisco|new york|seattle|austin|boston|chicago)'
+        return role, company
+
+    def _extract_team_context(self, job_text: str) -> str:
+        """Extract team context from job description"""
+        context_keywords = [
+            "team", "collaborate", "cross-functional", "stakeholder", 
+            "partner", "work with", "engineering", "product", "data"
         ]
         
-        location = "Remote"
-        for pattern in location_patterns:
-            match = re.search(pattern, job_text, re.IGNORECASE)
-            if match:
-                location = match.group(1).strip().title()
-                break
+        sentences = job_text.split('.')
+        for sentence in sentences:
+            if any(keyword in sentence.lower() for keyword in context_keywords):
+                return sentence.strip()
         
-        # Determine industry
-        industry = "Technology"
-        if "spotify" in company.lower() or "music" in job_text.lower():
-            industry = "Music & Entertainment"
-        elif "finance" in job_text.lower() or "bank" in job_text.lower():
-            industry = "Finance"
-        elif "healthcare" in job_text.lower() or "medical" in job_text.lower():
-            industry = "Healthcare"
-        
-        return {
-            "company": company,
-            "role": role,
-            "required_skills": required_skills,
-            "location": location,
-            "industry": industry,
-            "seniority": seniority
-        }
+        return "Collaborative team environment focused on innovation and results"
 
-    def calculate_match_score(self, resume_data: Dict, job_data: Dict) -> float:
-        """Calculate detailed match score"""
-        resume_skills = set(skill.lower() for skill in resume_data["skills"])
-        job_skills = set(skill.lower() for skill in job_data["required_skills"])
+    def _calculate_match_score(self, user_skills: List[str], role_skills: List[str], resume_text: str, job_text: str) -> float:
+        """Calculate match score between user and role"""
+        if not role_skills:
+            return 0.75
         
-        if not job_skills:
-            return 75.0
+        # Skill overlap
+        skill_overlap = len(set(user_skills) & set(role_skills))
+        skill_score = skill_overlap / len(role_skills) if role_skills else 0.5
         
-        # Skill matching (50% weight)
-        skill_overlap = len(resume_skills & job_skills)
-        skill_score = (skill_overlap / len(job_skills)) * 100 if job_skills else 50
+        # Experience factor
+        experience_match = re.search(r'(\d+)[\s\+]*years?\s+(?:of\s+)?experience', resume_text, re.IGNORECASE)
+        experience_years = int(experience_match.group(1)) if experience_match else 3
+        experience_score = min(experience_years * 0.15, 1.0)
         
-        # Experience matching (30% weight)
-        experience_score = min(resume_data["experience"] * 15, 100)
+        # Education factor
+        education_score = 0.2 if any(word in resume_text.lower() for word in ['degree', 'bachelor', 'master']) else 0.1
         
-        # Education boost (10% weight)
-        education_boost = 20 if "master" in resume_data["education"].lower() else 10
+        # Role relevance
+        role_keywords = ['engineer', 'scientist', 'analyst', 'manager', 'developer']
+        role_relevance = 0.2 if any(keyword in resume_text.lower() for keyword in role_keywords) else 0.1
         
-        # Role relevance (10% weight)
-        role_relevance = 80 if any(role.lower() in job_data["role"].lower() for role in resume_data["roles"]) else 60
-        
-        # Calculate final score
-        final_score = (
-            skill_score * 0.5 +
-            experience_score * 0.3 +
-            education_boost * 0.1 +
-            role_relevance * 0.1
-        )
-        
-        return min(max(final_score, 40), 97)
+        final_score = (skill_score * 0.5 + experience_score * 0.3 + education_score * 0.1 + role_relevance * 0.1)
+        return min(max(final_score, 0.4), 0.97)
 
-    def generate_technical_questions(self, resume_data: Dict, job_data: Dict) -> List[Dict]:
-        """Generate technical interview questions"""
-        skills = list(set(resume_data["skills"]) & set(job_data["required_skills"]))
-        
-        questions = []
-        
-        # Base technical questions
-        base_questions = [
-            {
-                "question": f"How would you design a system to handle {job_data['role'].lower()} requirements at scale?",
-                "why": f"This tests your system design skills and understanding of {job_data['role']} challenges at {job_data['company']}.",
-                "approach": "Start with requirements gathering, then discuss architecture, data flow, and scalability considerations.",
-                "key_points": [
-                    "System architecture understanding",
-                    "Scalability considerations",
-                    "Technology trade-offs"
-                ]
-            },
-            {
-                "question": f"Given your experience with {skills[0] if skills else 'your main technology'}, how would you approach solving a complex data problem?",
-                "why": f"This question assesses your problem-solving approach and technical depth in {skills[0] if skills else 'your core technology'}.",
-                "approach": "Break down the problem, discuss your methodology, mention specific tools and techniques you'd use.",
-                "key_points": [
-                    f"Deep knowledge of {skills[0] if skills else 'core technology'}",
-                    "Problem decomposition skills",
-                    "Practical application experience"
-                ]
-            },
-            {
-                "question": f"Tell me about a time you had to optimize performance in a {job_data['industry'].lower()} context.",
-                "why": f"Performance optimization is crucial in {job_data['industry']} and shows your ability to work under constraints.",
-                "approach": "Use the STAR method: describe the situation, task, actions taken, and measurable results.",
-                "key_points": [
-                    "Performance optimization techniques",
-                    "Measurement and monitoring",
-                    "Industry-specific challenges"
-                ]
-            }
-        ]
-        
-        return base_questions
+    def _estimate_interview_rounds(self, company: str, role: str) -> int:
+        """Estimate number of interview rounds"""
+        if any(term in company.lower() for term in ['startup', 'small']):
+            return 3
+        elif any(term in company.lower() for term in ['google', 'amazon', 'microsoft', 'apple', 'meta']):
+            return 5
+        else:
+            return 4
 
-    def generate_behavioral_questions(self, resume_data: Dict, job_data: Dict) -> List[Dict]:
-        """Generate behavioral interview questions"""
-        questions = [
-            {
-                "question": f"Describe a time when you had to learn a new technology quickly to complete a project in your {resume_data['roles'][0] if resume_data['roles'] else 'current'} role.",
-                "why": f"This assesses your adaptability and learning agility, crucial for {job_data['role']} at {job_data['company']}.",
-                "approach": "Use STAR method: Situation, Task, Action, Result. Focus on the learning process and impact.",
-                "key_points": [
-                    "Rapid learning ability",
-                    "Practical application skills",
-                    "Project impact measurement"
-                ]
-            },
-            {
-                "question": f"Can you describe a challenging project where you had to collaborate with cross-functional teams?",
-                "why": f"Collaboration is essential in {job_data['industry']} environments and shows your teamwork skills.",
-                "approach": "Highlight your communication skills, conflict resolution, and ability to work with diverse stakeholders.",
-                "key_points": [
-                    "Cross-functional collaboration",
-                    "Communication effectiveness",
-                    "Stakeholder management"
-                ]
-            },
-            {
-                "question": f"Tell me about a time when you had to handle a significant technical challenge or failure.",
-                "why": f"This shows your problem-solving skills and resilience, important for {job_data['role']} responsibilities.",
-                "approach": "Focus on your analytical approach, the steps you took to resolve the issue, and lessons learned.",
-                "key_points": [
-                    "Problem-solving methodology",
-                    "Resilience and adaptability",
-                    "Learning from failures"
-                ]
-            }
+    def _generate_process_notes(self, company: str, role: str) -> List[str]:
+        """Generate interview process notes"""
+        base_process = [
+            "Phone/Video Screen",
+            "Technical Assessment", 
+            "Behavioral Interview",
+            "Final Round"
         ]
         
-        return questions
+        if any(term in role.lower() for term in ['senior', 'lead', 'principal']):
+            base_process.insert(-1, "Leadership Interview")
+        
+        return base_process
 
-    def generate_company_questions(self, job_data: Dict) -> List[Dict]:
-        """Generate company-specific questions"""
-        questions = [
-            {
-                "question": f"What interests you most about working at {job_data['company']} in the {job_data['industry']} industry?",
-                "why": f"{job_data['company']} values candidates who understand their mission and industry position.",
-                "approach": "Research the company's recent developments, mission, and how your skills align with their goals.",
-                "key_points": [
-                    f"Knowledge of {job_data['company']}'s mission",
-                    f"Understanding of {job_data['industry']} trends",
-                    "Personal alignment with company values"
-                ]
-            },
-            {
-                "question": f"How would you approach the unique challenges of {job_data['role']} in a {job_data['industry'].lower()} environment?",
-                "why": f"This tests your understanding of industry-specific challenges and your strategic thinking.",
-                "approach": "Discuss industry trends, specific challenges, and how your background prepares you to address them.",
-                "key_points": [
-                    f"Industry knowledge ({job_data['industry']})",
-                    "Strategic thinking",
-                    "Role-specific expertise"
-                ]
-            }
+    def _extract_key_projects(self, resume_text: str) -> List[str]:
+        """Extract key projects from resume"""
+        project_indicators = [
+            r'built\s+([^\.]+)',
+            r'developed\s+([^\.]+)',
+            r'created\s+([^\.]+)',
+            r'led\s+([^\.]+)',
+            r'implemented\s+([^\.]+)'
         ]
         
-        return questions
+        projects = []
+        for pattern in project_indicators:
+            matches = re.findall(pattern, resume_text, re.IGNORECASE)
+            projects.extend([match.strip() for match in matches[:2]])  # Limit to 2 per pattern
+        
+        return projects[:6]  # Max 6 projects
 
-    def generate_comprehensive_guide(self, resume_text: str, job_input: str) -> InterviewGuide:
-        """Generate complete interview guide"""
-        resume_data = self.analyze_resume(resume_text)
+    def _extract_strengths(self, resume_text: str, skills: List[str]) -> List[str]:
+        """Extract candidate strengths"""
+        strengths = []
         
-        # Use local job analysis (async-safe)
-        job_data = self.analyze_job(job_input)
+        # Add top skills as strengths
+        strengths.extend(skills[:3])
         
-        match_score = self.calculate_match_score(resume_data, job_data)
+        # Add experience-based strengths
+        if re.search(r'(\d+)[\s\+]*years', resume_text, re.IGNORECASE):
+            strengths.append("Extensive experience")
         
-        # Generate title
-        title = f"Personalized Interview Guide: {job_data['role']} at {job_data['company']}"
+        if any(word in resume_text.lower() for word in ['led', 'managed', 'supervised']):
+            strengths.append("Leadership experience")
         
-        # Generate introduction
-        introduction = f"""
-        {job_data['role']} interview at {job_data['company']} is an excellent opportunity for you, given your {resume_data['education']} and {resume_data['experience']} years of experience. 
-        With your background in {', '.join(resume_data['skills'][:3]) if resume_data['skills'] else 'technical skills'}, you are well-positioned to contribute to {job_data['company']}'s mission. 
-        Your {resume_data['experience']} years of experience and proven track record make you a strong candidate. 
-        Approach this interview with confidence—your skills align well with what they're looking for.
-        """
+        if any(word in resume_text.lower() for word in ['scaled', 'optimized', 'improved']):
+            strengths.append("Performance optimization")
         
-        # Skills analysis
-        skill_matches = list(set(resume_data['skills']) & set(job_data['required_skills']))
-        skill_gaps = list(set(job_data['required_skills']) - set(resume_data['skills']))
+        return strengths[:6]
+
+    def generate_interview_guide(self, guide_data: GuideData) -> str:
+        """Generate interview guide following exact InterviewGuideGPT format"""
+        
+        # Calculate derived helpers
+        match_bucket, emoji = self._get_match_bucket(guide_data.match_score)
+        percent = round(guide_data.match_score * 100, 1)
+        
+        user_skills_set = set(guide_data.user_skills)
+        role_skills_set = set(guide_data.role_skills)
+        
+        strong = len(user_skills_set & role_skills_set)
+        partial = len(user_skills_set) - strong
+        gaps = len(role_skills_set) - strong
+        
+        # Get company insight
+        company_insight = self._get_company_insight(guide_data.company)
+        
+        # Generate sections
+        intro = self._generate_introduction(guide_data)
+        tech_questions = self._generate_technical_questions(guide_data)
+        behavioral_questions = self._generate_behavioral_questions(guide_data)
+        culture_questions = self._generate_culture_questions(guide_data)
+        talking_points = self._generate_talking_points(guide_data)
+        smart_questions = self._generate_smart_questions(guide_data)
+        
+        # Format the complete guide
+        guide = f"""# Personalized Interview Guide: {guide_data.role_title} at {guide_data.company}
+**Match Score: {emoji} {match_bucket} Match ({percent}%)**
+
+---
+
+## Introduction
+{intro}
+
+## 📊 Skills Match Analysis
+**Overall Assessment:** Strong technical foundation with {strong} direct skill matches and proven experience in {guide_data.user_overview.split()[-2]} {guide_data.user_overview.split()[-1]}.
+
+```text
+Skills Breakdown
+Strong Matches  {'█' * min(20, strong * 2)} {strong}
+Partial Matches {partial}
+Skill Gaps      {gaps}
+```
+
+✅ **Your Strengths:** {', '.join(guide_data.user_skills[:6])}
+
+## 🎯 Interview Process at {guide_data.company}
+
+1. **Typical rounds:** {guide_data.interview_rounds}
+2. **Stages:** {', '.join(guide_data.process_notes)}
+3. **Timeline:** 3-4 weeks (typical)
+4. **Company insight:** {company_insight}
+
+## 🔧 Technical & Problem-Solving Questions
+
+{tech_questions}
+
+## 🤝 Behavioral & Experience Questions
+
+{behavioral_questions}
+
+## 🏢 Company & Culture Questions
+
+{culture_questions}
+
+## 📅 Preparation Strategy
+
+**Immediate priorities:** Review core technical concepts • Prepare STAR examples • Research company background
+
+**Study schedule:** Technical 60% • Behavioral 25% • Company 15%
+
+**Time allocation:** 5–7 hours over 3–5 days
+
+## 💬 Key Talking Points
+
+{talking_points}
+
+## ❓ Smart Questions to Ask
+
+{smart_questions}
+
+## 🗓️ Day-of-Interview Checklist
+
+– Morning review of key concepts
+– Confirm logistics and timing
+– Mental preparation and confidence building
+– Arrive 10 minutes early
+
+## ✅ Success Metrics
+
+– Demonstrated {len(guide_data.user_skills)} core strengths
+– Asked ≥4 thoughtful questions
+– Showed enthusiasm & growth mindset
+
+## 🚀 Conclusion
+
+You're an excellent fit—be confident. Good luck! 🚀
+
+---
+*Generated with IQKiller v2.0 – no data retained.*"""
+
+        return guide
+
+    def _get_match_bucket(self, score: float) -> tuple:
+        """Get match bucket and emoji"""
+        if score >= 0.90:
+            return "Excellent", "🟢"
+        elif score >= 0.80:
+            return "Strong", "🟡"
+        else:
+            return "Developing", "🔴"
+
+    def _get_company_insight(self, company: str) -> str:
+        """Get company-specific insight"""
+        company_lower = company.lower()
+        for key, insight in self.company_insights.items():
+            if key in company_lower:
+                return insight
+        return f"{company} values innovation and excellence in their field."
+
+    def _generate_introduction(self, guide_data: GuideData) -> str:
+        """Generate introduction section"""
+        return f"This {guide_data.role_title} position at {guide_data.company} represents an excellent opportunity for someone with your background. Your {guide_data.user_overview} aligns well with {guide_data.team_context.lower()}. With your technical skills and experience, you're well-positioned to contribute meaningfully to their mission."
+
+    def _generate_technical_questions(self, guide_data: GuideData) -> str:
+        """Generate exactly 3 technical questions"""
+        questions = []
         
-        skills_analysis = {
-            "overall_assessment": f"The candidate brings {resume_data['experience']} years of experience with strong technical skills in {', '.join(skill_matches[:3]) if skill_matches else 'various technologies'}. With {resume_data['education']} and practical experience, they are well-positioned for this {job_data['role']} role.",
-            "strong_matches": skill_matches,
-            "partial_matches": [],
-            "skill_gaps": skill_gaps
-        }
+        # Question 1: System design
+        q1 = f"""**1. How would you design a system to handle {guide_data.role_title.lower()} requirements at scale?**
+
+*Why they ask:* Tests your system design skills and understanding of scalability challenges.
+
+*How to answer:* Start with requirements gathering, discuss architecture, data flow, and scaling considerations.
+
+*Key points:* System architecture understanding, scalability considerations, technology trade-offs"""
+
+        # Question 2: Technical depth
+        main_skill = guide_data.user_skills[0] if guide_data.user_skills else "your main technology"
+        q2 = f"""**2. Given your experience with {main_skill}, how would you approach solving a complex data problem?**
+
+*Why they ask:* Assesses your problem-solving approach and technical depth in {main_skill}.
+
+*How to answer:* Break down the problem, discuss methodology, mention specific tools and techniques.
+
+*Key points:* Deep knowledge of {main_skill}, problem decomposition skills, practical application"""
+
+        # Question 3: Role-specific
+        q3 = f"""**3. Describe how you would optimize performance in a {guide_data.role_title.lower()} context.**
+
+*Why they ask:* Evaluates your understanding of performance optimization specific to this role.
+
+*How to answer:* Discuss monitoring, bottleneck identification, and optimization strategies.
+
+*Key points:* Performance metrics understanding, optimization techniques, real-world experience"""
+
+        return f"{q1}\n\n{q2}\n\n{q3}"
+
+    def _generate_behavioral_questions(self, guide_data: GuideData) -> str:
+        """Generate exactly 3 behavioral questions"""
+        q1 = """**1. Tell me about a time when you had to learn a new technology quickly for a project.**
+
+*STAR Framework:* Situation - Task - Action - Result
+
+*Focus on:* Learning agility, problem-solving approach, impact of quick learning"""
+
+        q2 = """**2. Describe a situation where you had to work with a difficult team member or stakeholder.**
+
+*STAR Framework:* Situation - Task - Action - Result
+
+*Focus on:* Communication skills, conflict resolution, collaboration approach"""
+
+        q3 = """**3. Give me an example of a project where you had to make trade-offs between competing priorities.**
+
+*STAR Framework:* Situation - Task - Action - Result
+
+*Focus on:* Decision-making process, stakeholder management, outcome evaluation"""
+
+        return f"{q1}\n\n{q2}\n\n{q3}"
+
+    def _generate_culture_questions(self, guide_data: GuideData) -> str:
+        """Generate exactly 3 culture questions"""
+        q1 = f"""**1. Why are you interested in working at {guide_data.company} specifically?**
+
+*Purpose:* Tests genuine interest and company research.
+
+*Approach:* Connect company mission to your values and career goals."""
+
+        q2 = f"""**2. How do you stay current with industry trends and continue learning in your field?**
+
+*Purpose:* Assesses growth mindset and continuous learning.
+
+*Approach:* Share specific resources, communities, and learning practices."""
+
+        q3 = f"""**3. Describe your ideal work environment and team dynamics.**
+
+*Purpose:* Evaluates cultural fit and team compatibility.
+
+*Approach:* Align your preferences with {guide_data.company}'s known culture."""
+
+        return f"{q1}\n\n{q2}\n\n{q3}"
+
+    def _generate_talking_points(self, guide_data: GuideData) -> str:
+        """Generate key talking points"""
+        points = []
         
-        # Interview process
-        interview_process = {
-            "typical_rounds": "3 to 5 rounds",
-            "interview_types": [
-                "Phone Screen: Initial HR screening and basic qualifications",
-                "Technical Interview: Focus on technical skills and problem-solving",
-                "Behavioral Interview: Past experiences and cultural fit",
-                "Final Interview: Senior leadership and strategic alignment"
-            ],
-            "stakeholders": [
-                "HR Recruiter: Initial screening",
-                "Hiring Manager: Direct supervisor assessment",
-                "Team Members: Technical and collaboration evaluation",
-                "Senior Leadership: Strategic fit evaluation"
-            ],
-            "timeline": "3 to 4 weeks typically",
-            "company_insights": f"{job_data['company']} values innovation and data-driven decision making."
-        }
+        # Add background
+        points.append(f"– {guide_data.user_overview}")
         
-        # Generate questions
-        technical_questions = self.generate_technical_questions(resume_data, job_data)
-        behavioral_questions = self.generate_behavioral_questions(resume_data, job_data)
-        company_questions = self.generate_company_questions(job_data)
-        
-        # Preparation strategy
-        preparation_strategy = {
-            "immediate_priorities": [
-                "Review core technical concepts",
-                "Prepare STAR examples",
-                "Research company background"
-            ],
-            "study_schedule": {
-                "technical_prep": "60% of time",
-                "behavioral_prep": "25% of time",
-                "company_research": "15% of time"
-            },
-            "time_allocation": "5-7 hours over 3-5 days"
-        }
+        # Add key projects
+        if guide_data.key_projects:
+            points.append(f"– {len(guide_data.key_projects)} key projects including {', '.join(guide_data.key_projects[:2])}")
         
-        # Talking points
-        talking_points = [
-            f"{resume_data['education']} education",
-            f"{resume_data['experience']} years of experience",
-            f"Skills in {', '.join(skill_matches[:3]) if skill_matches else 'core technologies'}",
-            f"Background in {', '.join(resume_data['roles'][:2]) if resume_data['roles'] else 'technical roles'}"
-        ]
+        # Add skills highlights
+        top_skills = guide_data.user_skills[:3]
+        points.append(f"– Technical expertise: {' + '.join(top_skills)} highlights")
         
-        # Smart questions
-        smart_questions = [
-            f"What does success look like for a {job_data['role']} in the first 90 days?",
-            "How does the team approach professional development?",
-            "What are the biggest technical challenges facing the team?",
-            f"How does {job_data['company']} support career growth?",
-            f"What's the collaboration like between {job_data['role']} and other teams?"
+        return '\n'.join(points)
+
+    def _generate_smart_questions(self, guide_data: GuideData) -> str:
+        """Generate smart questions to ask"""
+        questions = [
+            "– What does success look like in the first 90 days?",
+            "– What's the biggest technical challenge facing the team?",
+            f"– How does {guide_data.company} support professional development and career growth?",
+            f"– What do you enjoy most about working at {guide_data.company}?",
+            "– How do you measure the impact of this role on company objectives?",
+            f"– What opportunities exist for innovation within the {guide_data.role_title} position?"
         ]
         
-        return InterviewGuide(
-            title=title,
-            match_score=match_score,
-            introduction=introduction,
-            skills_analysis=skills_analysis,
-            interview_process=interview_process,
-            technical_questions=technical_questions,
-            behavioral_questions=behavioral_questions,
-            company_questions=company_questions,
-            preparation_strategy=preparation_strategy,
-            talking_points=talking_points,
-            smart_questions=smart_questions
-        )
+        return '\n'.join(questions)
+
+# Main function to generate guide from resume and job text
+def generate_interviewgpt_guide(resume_text: str, job_text: str) -> str:
+    """Generate interview guide using InterviewGuideGPT format"""
+    generator = InterviewGuideGPT()
+    guide_data = generator.analyze_resume_and_job(resume_text, job_text)
+    return generator.generate_interview_guide(guide_data)
 
-def format_interview_guide_html(guide: InterviewGuide) -> str:
-    """Format the interview guide as HTML"""
+# Legacy compatibility
+class ComprehensiveAnalyzer:
+    """Legacy wrapper for backward compatibility"""
     
-    # Match score color
-    score_color = "var(--apple-green)" if guide.match_score >= 85 else "var(--apple-orange)" if guide.match_score >= 70 else "var(--apple-red)"
-    score_status = "🟢 Excellent Match" if guide.match_score >= 85 else "🟡 Good Match" if guide.match_score >= 70 else "🔴 Developing Match"
+    def __init__(self):
+        self.generator = InterviewGuideGPT()
     
-    # Skills breakdown visualization
-    strong_count = len(guide.skills_analysis["strong_matches"])
-    partial_count = len(guide.skills_analysis["partial_matches"])
-    gap_count = len(guide.skills_analysis["skill_gaps"])
+    def generate_comprehensive_guide(self, resume_text: str, job_input: str):
+        """Legacy method for backward compatibility"""
+        guide_data = self.generator.analyze_resume_and_job(resume_text, job_input)
+        return MockGuide(self.generator.generate_interview_guide(guide_data))
+
+class MockGuide:
+    """Mock guide object for legacy compatibility"""
+    def __init__(self, content):
+        self.content = content
+
+def format_interview_guide_html(guide) -> str:
+    """Convert markdown guide to HTML for display"""
+    import re
     
-    skills_viz = f"""
-    <div style="margin: 20px 0;">
-        <div style="display: flex; align-items: center; margin-bottom: 10px;">
-            <span style="color: var(--apple-green);">Strong Matches</span>
-            <span style="margin-left: 10px; color: var(--apple-green);">{'█' * min(strong_count, 20)}</span>
-            <span style="margin-left: 10px; color: rgba(255,255,255,0.8);">{strong_count}</span>
-        </div>
-        <div style="display: flex; align-items: center; margin-bottom: 10px;">
-            <span style="color: var(--apple-orange);">Partial Matches</span>
-            <span style="margin-left: 10px; color: var(--apple-orange);">{'█' * min(partial_count, 20)}</span>
-            <span style="margin-left: 10px; color: rgba(255,255,255,0.8);">{partial_count}</span>
-        </div>
-        <div style="display: flex; align-items: center;">
-            <span style="color: var(--apple-red);">Skill Gaps</span>
-            <span style="margin-left: 10px; color: var(--apple-red);">{'█' * min(gap_count, 20)}</span>
-            <span style="margin-left: 10px; color: rgba(255,255,255,0.8);">{gap_count}</span>
-        </div>
-    </div>
-    """
+    html_content = guide.content
     
-    # Format technical questions
-    tech_questions_html = ""
-    for i, q in enumerate(guide.technical_questions, 1):
-        tech_questions_html += f"""
-        <div style="margin-bottom: 30px; padding: 20px; background: var(--glass-bg); border-radius: 12px; border-left: 4px solid var(--apple-blue);">
-            <h4 style="color: var(--apple-orange); margin-bottom: 15px;">🟡 Question {i}: {q['question']}</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>Why they ask this:</strong> {q['why']}</p>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>How to approach:</strong> {q['approach']}</p>
-            <p style="color: rgba(255,255,255,0.9);"><strong>Key points to mention:</strong> {', '.join(q['key_points'])}</p>
-        </div>
-        """
+    # Convert markdown headers to HTML
+    html_content = re.sub(r'^# (.*)', r'<h1 style="color: white; text-align: center; margin-bottom: 20px;">\1</h1>', html_content, flags=re.MULTILINE)
+    html_content = re.sub(r'^## (.*)', r'<h2 style="color: white; margin: 30px 0 20px 0;">\1</h2>', html_content, flags=re.MULTILINE)
     
-    # Format behavioral questions
-    behavioral_questions_html = ""
-    for i, q in enumerate(guide.behavioral_questions, 1):
-        behavioral_questions_html += f"""
-        <div style="margin-bottom: 30px; padding: 20px; background: var(--glass-bg); border-radius: 12px; border-left: 4px solid var(--apple-green);">
-            <h4 style="color: var(--apple-orange); margin-bottom: 15px;">🟡 Question {i}: {q['question']}</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>Why they ask this:</strong> {q['why']}</p>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>How to approach:</strong> {q['approach']}</p>
-            <p style="color: rgba(255,255,255,0.9);"><strong>Key points to mention:</strong> {', '.join(q['key_points'])}</p>
-        </div>
-        """
+    # Convert markdown bold to HTML
+    html_content = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', html_content)
     
-    # Format company questions
-    company_questions_html = ""
-    for i, q in enumerate(guide.company_questions, 1):
-        company_questions_html += f"""
-        <div style="margin-bottom: 30px; padding: 20px; background: var(--glass-bg); border-radius: 12px; border-left: 4px solid var(--apple-orange);">
-            <h4 style="color: var(--apple-orange); margin-bottom: 15px;">🟡 Question {i}: {q['question']}</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>Why they ask this:</strong> {q['why']}</p>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;"><strong>How to approach:</strong> {q['approach']}</p>
-            <p style="color: rgba(255,255,255,0.9);"><strong>Key points to mention:</strong> {', '.join(q['key_points'])}</p>
-        </div>
-        """
+    # Convert markdown code blocks
+    html_content = re.sub(r'```text\n(.*?)\n```', r'<pre style="background: rgba(0,0,0,0.3); padding: 15px; border-radius: 8px; color: white; font-family: monospace;">\1</pre>', html_content, flags=re.DOTALL)
     
-    return f"""
-    <div class="result-card slide-in" style="max-width: 1200px; margin: 0 auto;">
-        <h1 style="color: white; text-align: center; margin-bottom: 10px; font-size: 2rem;">{guide.title}</h1>
-        
-        <div style="text-align: center; margin-bottom: 30px;">
-            <div style="font-size: 1.2rem; color: {score_color}; font-weight: 600; margin-bottom: 10px;">
-                Match Score: {score_status} ({guide.match_score:.1f}%)
-            </div>
-        </div>
-        
-        <hr style="border: 1px solid rgba(255,255,255,0.2); margin: 30px 0;">
-        
-        <h2 style="color: white; margin-bottom: 20px;">📖 Introduction</h2>
-        <p style="color: rgba(255,255,255,0.9); line-height: 1.6; margin-bottom: 30px;">
-            {guide.introduction.strip()}
-        </p>
-        
-        <h2 style="color: white; margin-bottom: 20px;">📊 Skills Match Analysis</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                <strong>Overall Assessment:</strong> {guide.skills_analysis['overall_assessment']}
-            </p>
-            
-            <h4 style="color: white; margin-bottom: 15px;">Skills Breakdown</h4>
-            {skills_viz}
-            
-            <div style="margin-top: 20px;">
-                <p style="color: rgba(255,255,255,0.9);">
-                    <strong>✅ Your Strengths:</strong> {', '.join(guide.skills_analysis['strong_matches'][:5]) if guide.skills_analysis['strong_matches'] else 'Technical foundation, analytical thinking'}
-                </p>
-            </div>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">🎯 What Is the Interview Process Like?</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <h4 style="color: white; margin-bottom: 15px;">1. Typical Number of Rounds</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">Expect {guide.interview_process['typical_rounds']} of interviews.</p>
-            
-            <h4 style="color: white; margin-bottom: 15px;">2. Types of Interviews Expected</h4>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                {"".join([f"<li>{interview_type}</li>" for interview_type in guide.interview_process['interview_types']])}
-            </ul>
-            
-            <h4 style="color: white; margin-bottom: 15px;">3. Key Stakeholders They'll Meet</h4>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                {"".join([f"<li>{stakeholder}</li>" for stakeholder in guide.interview_process['stakeholders']])}
-            </ul>
-            
-            <h4 style="color: white; margin-bottom: 15px;">4. Timeline and Logistics</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">{guide.interview_process['timeline']}</p>
-            
-            <h4 style="color: white; margin-bottom: 15px;">5. Company-Specific Insights</h4>
-            <p style="color: rgba(255,255,255,0.9);">{guide.interview_process['company_insights']}</p>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">🔧 Technical & Problem-Solving Questions</h2>
-        <p style="color: rgba(255,255,255,0.8); margin-bottom: 30px;">
-            These questions test your technical knowledge. Focus on demonstrating both your understanding and problem-solving approach.
-        </p>
-        {tech_questions_html}
-        
-        <h2 style="color: white; margin-bottom: 20px;">🎯 Behavioral & Experience Questions</h2>
-        <p style="color: rgba(255,255,255,0.8); margin-bottom: 30px;">
-            Use the STAR method (Situation, Task, Action, Result) to structure your responses.
-        </p>
-        {behavioral_questions_html}
-        
-        <h2 style="color: white; margin-bottom: 20px;">🏢 Company & Culture Questions</h2>
-        <p style="color: rgba(255,255,255,0.8); margin-bottom: 30px;">
-            These questions assess your interest in the company and cultural fit.
+    # Convert lists
+    html_content = re.sub(r'^– (.*)', r'<li style="color: rgba(255,255,255,0.9); margin: 5px 0;">\1</li>', html_content, flags=re.MULTILINE)
+    html_content = re.sub(r'^✅ (.*)', r'<p style="color: var(--apple-green); margin: 15px 0;"><strong>✅ \1</strong></p>', html_content, flags=re.MULTILINE)
+    
+    # Convert line breaks to HTML
+    html_content = html_content.replace('\n\n', '</p><p style="color: rgba(255,255,255,0.9); line-height: 1.6; margin: 15px 0;">')
+    html_content = html_content.replace('\n', '<br>')
+    
+    # Wrap in container
+    html_content = f'''
+    <div class="result-card slide-in" style="max-width: 1200px; margin: 0 auto; background: var(--glass-bg); border-radius: 16px; padding: 30px; backdrop-filter: blur(15px); box-shadow: var(--shadow-soft);">
+        <p style="color: rgba(255,255,255,0.9); line-height: 1.6; margin: 15px 0;">
+        {html_content}
         </p>
-        {company_questions_html}
-        
-        <h2 style="color: white; margin-bottom: 20px;">🎯 Preparation Strategy</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <h4 style="color: white; margin-bottom: 15px;">Your Preparation Roadmap</h4>
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                Based on your {guide.match_score:.1f}% match score, here's your personalized preparation strategy:
-            </p>
-            
-            <h5 style="color: var(--apple-blue); margin-bottom: 10px;">Immediate Priorities</h5>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                {"".join([f"<li>{priority}</li>" for priority in guide.preparation_strategy['immediate_priorities']])}
-            </ul>
-            
-            <h5 style="color: var(--apple-blue); margin-bottom: 10px;">Study Schedule</h5>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                <li>Technical prep: {guide.preparation_strategy['study_schedule']['technical_prep']} of time</li>
-                <li>Behavioral prep: {guide.preparation_strategy['study_schedule']['behavioral_prep']} of time</li>
-                <li>Company research: {guide.preparation_strategy['study_schedule']['company_research']} of time</li>
-            </ul>
-            
-            <p style="color: rgba(255,255,255,0.8);">
-                <strong>Time Allocation:</strong> {guide.preparation_strategy['time_allocation']}
-            </p>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">💬 Key Talking Points</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <h4 style="color: white; margin-bottom: 15px;">Lead with Your Strengths</h4>
-            <ul style="color: rgba(255,255,255,0.9);">
-                {"".join([f"<li>{point}</li>" for point in guide.talking_points])}
-            </ul>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">❓ Smart Questions to Ask</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <p style="color: rgba(255,255,255,0.8); margin-bottom: 15px;">
-                Show your engagement and strategic thinking with these questions:
-            </p>
-            <ol style="color: rgba(255,255,255,0.9);">
-                {"".join([f"<li>{question}</li>" for question in guide.smart_questions])}
-            </ol>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">📅 Day-of-Interview Preparation</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <h4 style="color: white; margin-bottom: 15px;">Morning Review (30 minutes)</h4>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                <li>Review your top strengths: {', '.join(guide.skills_analysis['strong_matches'][:3]) if guide.skills_analysis['strong_matches'] else 'technical skills, experience'}</li>
-                <li>Practice your 2-minute elevator pitch</li>
-                <li>Review company's recent news/updates</li>
-                <li>Check logistics (time, location, interviewer names)</li>
-            </ul>
-            
-            <h4 style="color: white; margin-bottom: 15px;">Mental Preparation</h4>
-            <ul style="color: rgba(255,255,255,0.9); margin-bottom: 20px;">
-                <li>Confidence booster: You have a {guide.match_score:.1f}% match score</li>
-                <li>Remember your competitive advantages</li>
-                <li>Focus on learning and growth mindset</li>
-            </ul>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">✅ Success Metrics</h2>
-        <div style="background: var(--glass-bg); padding: 20px; border-radius: 12px; margin-bottom: 30px;">
-            <p style="color: rgba(255,255,255,0.9); margin-bottom: 15px;">You'll know the interview went well if:</p>
-            <ul style="color: rgba(255,255,255,0.9);">
-                <li>Successfully demonstrate your core strengths</li>
-                <li>Ask 3-4 thoughtful questions about the role/team</li>
-                <li>Share specific examples from your background</li>
-                <li>Show enthusiasm for learning and growth</li>
-                <li>Position yourself as ready to contribute immediately</li>
-            </ul>
-        </div>
-        
-        <h2 style="color: white; margin-bottom: 20px;">🚀 Conclusion</h2>
-        <div style="background: linear-gradient(135deg, var(--apple-green), var(--apple-blue)); padding: 20px; border-radius: 12px; text-align: center;">
-            <p style="color: white; font-size: 1.1rem; margin-bottom: 15px;">
-                You're well-prepared for this interview! Your {guide.match_score:.1f}% match score indicates strong alignment.
-            </p>
-            <p style="color: white; font-weight: 600;">
-                Remember: Be authentic, ask thoughtful questions, and show enthusiasm. Good luck! 🚀
-            </p>
-        </div>
-        
-        <div style="text-align: center; margin-top: 30px; color: rgba(255,255,255,0.6); font-size: 0.9rem;">
-            <p><em>This personalized guide was generated based on your specific background and role requirements.</em></p>
-        </div>
     </div>
-    """ 
+    '''
+    
+    return html_content 

iqkiller-vercel/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "next/core-web-vitals"
+}

iqkiller-vercel/.gitignore

@@ -0,0 +1,36 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+.yarn/install-state.gz
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# local env files
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts

iqkiller-vercel/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2024 Vercel, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

iqkiller-vercel/README.md

@@ -0,0 +1,41 @@
+# AI SDK PDF Support Example
+
+This example demonstrates how to use the [AI SDK](https://sdk.vercel.ai/docs) with [Next.js](https://nextjs.org/) with the `useObject` hook to submit PDF messages to the AI provider of your choice (Google or Anthropic).
+
+## Deploy your own
+
+[![Deploy with Vercel](https://vercel.com/button)](https://vercel.com/new/clone?repository-url=https%3A%2F%2Fgithub.com%2Fvercel-labs%2Fai-sdk-preview-pdf-support&env=GOOGLE_API_KEY&envDescription=API%20keys%20needed%20for%20application&envLink=google.com)
+
+## How to use
+
+Run [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app) with [npm](https://docs.npmjs.com/cli/init), [Yarn](https://yarnpkg.com/lang/en/docs/cli/create/), or [pnpm](https://pnpm.io) to bootstrap the example:
+
+```bash
+npx create-next-app --example https://github.com/vercel-labs/ai-sdk-preview-pdf-support ai-sdk-preview-pdf-support-example
+```
+
+```bash
+yarn create next-app --example https://github.com/vercel-labs/ai-sdk-preview-pdf-support ai-sdk-preview-pdf-support-example
+```
+
+```bash
+pnpm create next-app --example https://github.com/vercel-labs/ai-sdk-preview-pdf-support ai-sdk-preview-pdf-support-example
+```
+
+To run the example locally you need to:
+
+1. Sign up for accounts with the AI providers you want to use (e.g., Google).
+2. Obtain API keys for Google provider.
+3. Set the required environment variables as shown in the `.env.example` file, but in a new file called `.env`.
+4. `npm install` to install the required dependencies.
+5. `npm run dev` to launch the development server.
+
+
+## Learn More
+
+To learn more about Vercel AI SDK or Next.js take a look at the following resources:
+
+- [AI SDK docs](https://sdk.vercel.ai/docs)
+- [Vercel AI Playground](https://play.vercel.ai)
+- [Next.js Documentation](https://nextjs.org/docs) - learn about Next.js features and API.
+

iqkiller-vercel/app/(preview)/actions.ts

@@ -0,0 +1,21 @@
+"use server";
+
+import { google } from "@ai-sdk/google";
+import { generateObject } from "ai";
+import { z } from "zod";
+
+export const generateQuizTitle = async (file: string) => {
+  const result = await generateObject({
+    model: google("gemini-1.5-flash-latest"),
+    schema: z.object({
+      title: z
+        .string()
+        .describe(
+          "A max three word title for the quiz based on the file provided as context",
+        ),
+    }),
+    prompt:
+      "Generate a title for a quiz based on the following (PDF) file name. Try and extract as much info from the file name as possible. If the file name is just numbers or incoherent, just return quiz.\n\n " + file,
+  });
+  return result.object.title;
+};

iqkiller-vercel/app/(preview)/globals.css

@@ -0,0 +1,68 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+    :root {
+        --background: 0 0% 100%;
+        --foreground: 240 10% 3.9%;
+        --card: 0 0% 100%;
+        --card-foreground: 240 10% 3.9%;
+        --popover: 0 0% 100%;
+        --popover-foreground: 240 10% 3.9%;
+        --primary: 240 5.9% 10%;
+        --primary-foreground: 0 0% 98%;
+        --secondary: 240 4.8% 95.9%;
+        --secondary-foreground: 240 5.9% 10%;
+        --muted: 240 4.8% 95.9%;
+        --muted-foreground: 240 3.8% 46.1%;
+        --accent: 240 4.8% 95.9%;
+        --accent-foreground: 240 5.9% 10%;
+        --destructive: 0 84.2% 60.2%;
+        --destructive-foreground: 0 0% 98%;
+        --border: 240 5.9% 90%;
+        --input: 240 5.9% 90%;
+        --ring: 240 10% 3.9%;
+        --chart-1: 12 76% 61%;
+        --chart-2: 173 58% 39%;
+        --chart-3: 197 37% 24%;
+        --chart-4: 43 74% 66%;
+        --chart-5: 27 87% 67%;
+        --radius: 0.5rem;
+    }
+    .dark {
+        --background: 240 10% 3.9%;
+        --foreground: 0 0% 98%;
+        --card: 240 10% 3.9%;
+        --card-foreground: 0 0% 98%;
+        --popover: 240 10% 3.9%;
+        --popover-foreground: 0 0% 98%;
+        --primary: 0 0% 98%;
+        --primary-foreground: 240 5.9% 10%;
+        --secondary: 240 3.7% 15.9%;
+        --secondary-foreground: 0 0% 98%;
+        --muted: 240 3.7% 15.9%;
+        --muted-foreground: 240 5% 64.9%;
+        --accent: 240 3.7% 15.9%;
+        --accent-foreground: 0 0% 98%;
+        --destructive: 0 62.8% 30.6%;
+        --destructive-foreground: 0 0% 98%;
+        --border: 240 3.7% 15.9%;
+        --input: 240 3.7% 15.9%;
+        --ring: 240 4.9% 83.9%;
+        --chart-1: 220 70% 50%;
+        --chart-2: 160 60% 45%;
+        --chart-3: 30 80% 55%;
+        --chart-4: 280 65% 60%;
+        --chart-5: 340 75% 55%;
+    }
+}
+
+@layer base {
+    * {
+        @apply border-border;
+    }
+    body {
+        @apply bg-background text-foreground;
+    }
+}

iqkiller-vercel/app/(preview)/layout.tsx

@@ -0,0 +1,30 @@
+import "./globals.css";
+import { Metadata } from "next";
+import { Toaster } from "sonner";
+import { ThemeProvider } from "next-themes";
+import { Geist } from "next/font/google";
+
+const geist = Geist({ subsets: ["latin"] });
+
+export const metadata: Metadata = {
+  metadataBase: new URL("https://ai-sdk-preview-pdf-support.vercel.app"),
+  title: "PDF Support Preview",
+  description: "Experimental preview of PDF support with the AI SDK",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" suppressHydrationWarning className={`${geist.className}`}>
+      <body>
+        <ThemeProvider attribute="class" enableSystem forcedTheme="dark">
+          <Toaster position="top-center" richColors />
+          {children}
+        </ThemeProvider>
+      </body>
+    </html>
+  );
+}

iqkiller-vercel/app/(preview)/page.tsx

@@ -0,0 +1,258 @@
+"use client";
+
+import { useState } from "react";
+import { experimental_useObject } from "ai/react";
+import { questionsSchema } from "@/lib/schemas";
+import { z } from "zod";
+import { toast } from "sonner";
+import { FileUp, Plus, Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+  Card,
+  CardContent,
+  CardFooter,
+  CardHeader,
+  CardTitle,
+  CardDescription,
+} from "@/components/ui/card";
+import { Progress } from "@/components/ui/progress";
+import Quiz from "@/components/quiz";
+import { Link } from "@/components/ui/link";
+import NextLink from "next/link";
+import { generateQuizTitle } from "./actions";
+import { AnimatePresence, motion } from "framer-motion";
+import { VercelIcon, GitIcon } from "@/components/icons";
+
+export default function ChatWithFiles() {
+  const [files, setFiles] = useState<File[]>([]);
+  const [questions, setQuestions] = useState<z.infer<typeof questionsSchema>>(
+    [],
+  );
+  const [isDragging, setIsDragging] = useState(false);
+  const [title, setTitle] = useState<string>();
+
+  const {
+    submit,
+    object: partialQuestions,
+    isLoading,
+  } = experimental_useObject({
+    api: "/api/generate-quiz",
+    schema: questionsSchema,
+    initialValue: undefined,
+    onError: (error) => {
+      toast.error("Failed to generate quiz. Please try again.");
+      setFiles([]);
+    },
+    onFinish: ({ object }) => {
+      setQuestions(object ?? []);
+    },
+  });
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+    if (isSafari && isDragging) {
+      toast.error(
+        "Safari does not support drag & drop. Please use the file picker.",
+      );
+      return;
+    }
+
+    const selectedFiles = Array.from(e.target.files || []);
+    const validFiles = selectedFiles.filter(
+      (file) => file.type === "application/pdf" && file.size <= 5 * 1024 * 1024,
+    );
+    console.log(validFiles);
+
+    if (validFiles.length !== selectedFiles.length) {
+      toast.error("Only PDF files under 5MB are allowed.");
+    }
+
+    setFiles(validFiles);
+  };
+
+  const encodeFileAsBase64 = (file: File): Promise<string> => {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = (error) => reject(error);
+    });
+  };
+
+  const handleSubmitWithFiles = async (e: React.FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    const encodedFiles = await Promise.all(
+      files.map(async (file) => ({
+        name: file.name,
+        type: file.type,
+        data: await encodeFileAsBase64(file),
+      })),
+    );
+    submit({ files: encodedFiles });
+    const generatedTitle = await generateQuizTitle(encodedFiles[0].name);
+    setTitle(generatedTitle);
+  };
+
+  const clearPDF = () => {
+    setFiles([]);
+    setQuestions([]);
+  };
+
+  const progress = partialQuestions ? (partialQuestions.length / 4) * 100 : 0;
+
+  if (questions.length === 4) {
+    return (
+      <Quiz title={title ?? "Quiz"} questions={questions} clearPDF={clearPDF} />
+    );
+  }
+
+  return (
+    <div
+      className="min-h-[100dvh] w-full flex justify-center"
+      onDragOver={(e) => {
+        e.preventDefault();
+        setIsDragging(true);
+      }}
+      onDragExit={() => setIsDragging(false)}
+      onDragEnd={() => setIsDragging(false)}
+      onDragLeave={() => setIsDragging(false)}
+      onDrop={(e) => {
+        e.preventDefault();
+        setIsDragging(false);
+        console.log(e.dataTransfer.files);
+        handleFileChange({
+          target: { files: e.dataTransfer.files },
+        } as React.ChangeEvent<HTMLInputElement>);
+      }}
+    >
+      <AnimatePresence>
+        {isDragging && (
+          <motion.div
+            className="fixed pointer-events-none dark:bg-zinc-900/90 h-dvh w-dvw z-10 justify-center items-center flex flex-col gap-1 bg-zinc-100/90"
+            initial={{ opacity: 0 }}
+            animate={{ opacity: 1 }}
+            exit={{ opacity: 0 }}
+          >
+            <div>Drag and drop files here</div>
+            <div className="text-sm dark:text-zinc-400 text-zinc-500">
+              {"(PDFs only)"}
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+      <Card className="w-full max-w-md h-full border-0 sm:border sm:h-fit mt-12">
+        <CardHeader className="text-center space-y-6">
+          <div className="mx-auto flex items-center justify-center space-x-2 text-muted-foreground">
+            <div className="rounded-full bg-primary/10 p-2">
+              <FileUp className="h-6 w-6" />
+            </div>
+            <Plus className="h-4 w-4" />
+            <div className="rounded-full bg-primary/10 p-2">
+              <Loader2 className="h-6 w-6" />
+            </div>
+          </div>
+          <div className="space-y-2">
+            <CardTitle className="text-2xl font-bold">
+              PDF Quiz Generator
+            </CardTitle>
+            <CardDescription className="text-base">
+              Upload a PDF to generate an interactive quiz based on its content
+              using the <Link href="https://sdk.vercel.ai">AI SDK</Link> and{" "}
+              <Link href="https://sdk.vercel.ai/providers/ai-sdk-providers/google-generative-ai">
+                Google&apos;s Gemini Pro
+              </Link>
+              .
+            </CardDescription>
+          </div>
+        </CardHeader>
+        <CardContent>
+          <form onSubmit={handleSubmitWithFiles} className="space-y-4">
+            <div
+              className={`relative flex flex-col items-center justify-center border-2 border-dashed border-muted-foreground/25 rounded-lg p-6 transition-colors hover:border-muted-foreground/50`}
+            >
+              <input
+                type="file"
+                onChange={handleFileChange}
+                accept="application/pdf"
+                className="absolute inset-0 opacity-0 cursor-pointer"
+              />
+              <FileUp className="h-8 w-8 mb-2 text-muted-foreground" />
+              <p className="text-sm text-muted-foreground text-center">
+                {files.length > 0 ? (
+                  <span className="font-medium text-foreground">
+                    {files[0].name}
+                  </span>
+                ) : (
+                  <span>Drop your PDF here or click to browse.</span>
+                )}
+              </p>
+            </div>
+            <Button
+              type="submit"
+              className="w-full"
+              disabled={files.length === 0}
+            >
+              {isLoading ? (
+                <span className="flex items-center space-x-2">
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                  <span>Generating Quiz...</span>
+                </span>
+              ) : (
+                "Generate Quiz"
+              )}
+            </Button>
+          </form>
+        </CardContent>
+        {isLoading && (
+          <CardFooter className="flex flex-col space-y-4">
+            <div className="w-full space-y-1">
+              <div className="flex justify-between text-sm text-muted-foreground">
+                <span>Progress</span>
+                <span>{Math.round(progress)}%</span>
+              </div>
+              <Progress value={progress} className="h-2" />
+            </div>
+            <div className="w-full space-y-2">
+              <div className="grid grid-cols-6 sm:grid-cols-4 items-center space-x-2 text-sm">
+                <div
+                  className={`h-2 w-2 rounded-full ${
+                    isLoading ? "bg-yellow-500/50 animate-pulse" : "bg-muted"
+                  }`}
+                />
+                <span className="text-muted-foreground text-center col-span-4 sm:col-span-2">
+                  {partialQuestions
+                    ? `Generating question ${partialQuestions.length + 1} of 4`
+                    : "Analyzing PDF content"}
+                </span>
+              </div>
+            </div>
+          </CardFooter>
+        )}
+      </Card>
+      <motion.div
+        className="flex flex-row gap-4 items-center justify-between fixed bottom-6 text-xs "
+        initial={{ y: 20, opacity: 0 }}
+        animate={{ y: 0, opacity: 1 }}
+      >
+        <NextLink
+          target="_blank"
+          href="https://github.com/vercel-labs/ai-sdk-preview-pdf-support"
+          className="flex flex-row gap-2 items-center border px-2 py-1.5 rounded-md hover:bg-zinc-100 dark:border-zinc-800 dark:hover:bg-zinc-800"
+        >
+          <GitIcon />
+          View Source Code
+        </NextLink>
+
+        <NextLink
+          target="_blank"
+          href="https://vercel.com/templates/next.js/ai-quiz-generator"
+          className="flex flex-row gap-2 items-center bg-zinc-900 px-2 py-1.5 rounded-md text-zinc-50 hover:bg-zinc-950 dark:bg-zinc-100 dark:text-zinc-900 dark:hover:bg-zinc-50"
+        >
+          <VercelIcon size={14} />
+          Deploy with Vercel
+        </NextLink>
+      </motion.div>
+    </div>
+  );
+}

iqkiller-vercel/app/api/analyze-stream/route.ts

@@ -0,0 +1,508 @@
+import { openai } from '@ai-sdk/openai'
+import { streamText, generateObject } from 'ai'
+import { NextRequest } from 'next/server'
+import { z } from 'zod'
+import { processQuestionBank, selectQuestionsByRole, type Question } from '@/lib/questions-processor'
+import { researchCompanyInsights, generateSalaryInsights, type CompanyInsights } from '@/lib/company-research'
+import fs from 'fs'
+import path from 'path'
+import { NextResponse } from 'next/server'
+
+// Simulate your existing analysis functions
+async function analyzeResume(resumeText: string) {
+  // Simulate resume analysis (5-10 seconds)
+  await new Promise(resolve => setTimeout(resolve, 3000))
+  return {
+    skills: ['Python', 'Machine Learning', 'SQL', 'AWS', 'React'],
+    experience: '5+ years',
+    education: 'Computer Science',
+    strengths: ['Technical Leadership', 'Problem Solving', 'Communication']
+  }
+}
+
+async function analyzeJobMatch(resumeData: any, jobDescription: string) {
+  // Simulate job matching analysis (10-15 seconds)
+  await new Promise(resolve => setTimeout(resolve, 5000))
+  return {
+    overallMatch: 85,
+    skillsMatch: 90,
+    experienceMatch: 80,
+    missingSkills: ['Kubernetes', 'GraphQL'],
+    strongMatches: ['Python', 'Machine Learning', 'AWS']
+  }
+}
+
+async function generateInterviewQuestion(skillArea: string, difficulty: string) {
+  // Generate one interview question (3-5 seconds each)
+  const result = await streamText({
+    model: openai('gpt-4o-mini'),
+    prompt: `Generate a ${difficulty} interview question about ${skillArea}. 
+    Format: Question, Expected Answer, Follow-up Questions.
+    Make it practical and specific.`,
+    maxTokens: 200,
+  })
+
+  return result.textStream
+}
+
+async function loadQuestionBank(): Promise<Question[]> {
+  try {
+    // Try to load the real CSV file
+    const csvPath = path.join(process.cwd(), 'Question_bank_IQ_categorized/summary (1).csv')
+    
+    let csvData = ''
+    try {
+      csvData = fs.readFileSync(csvPath, 'utf-8')
+    } catch {
+      // Fallback to sample data if CSV not found
+      csvData = `idx,title,type,summaries,link
+0,Weekly Aggregation,python,"Summary: Group a list of sequential timestamps into weekly lists starting from the first timestamp.",interviewquery.com/questions/weekly-aggregation
+1,Decreasing Comments,product metrics,"Summary: Identify reasons and metrics for decreasing average comments per user despite user growth in a new city.",interviewquery.com/questions/decreasing-comments
+2,Employee Salaries,sql,"Summary: Select the top 3 departments with at least ten employees, ranked by the percentage of employees earning over 100K.",interviewquery.com/questions/employee-salaries
+3,500 Cards,probability,"Summary: Determine the probability of drawing three cards in increasing order from a shuffled deck of 500 numbered cards.",interviewquery.com/questions/500-cards
+4,Random Number,algorithms,"Summary: Select a random number from a stream with equal probability using O(1) space.",interviewquery.com/questions/random-number`
+    }
+    
+    return processQuestionBank(csvData)
+  } catch (error) {
+    console.error('Error loading question bank:', error)
+    return []
+  }
+}
+
+async function personalizeQuestions(
+  questions: Question[],
+  resumeData: any,
+  jobData: any
+): Promise<Question[]> {
+  const personalizedQuestions = []
+  
+  for (const question of questions) {
+    try {
+      const personalization = await generateObject({
+        model: openai('gpt-4o-mini'),
+        prompt: `
+          Personalize this interview question for a candidate:
+          
+          ORIGINAL QUESTION: "${question.summaries}"
+          
+          CANDIDATE BACKGROUND:
+          - Role: ${jobData.role} at ${jobData.company}
+          - Experience: ${resumeData.experience_years} years
+          - Skills: ${resumeData.skills.slice(0, 5).join(', ')}
+          - Previous roles: ${resumeData.previous_roles.join(', ')}
+          
+          Create:
+          1. A personalized approach explanation (2-3 sentences)
+          2. Why this question is relevant for this candidate
+          3. 2-3 follow-up questions based on their background
+        `,
+        schema: z.object({
+          approach: z.string(),
+          relevance: z.string(),
+          followUps: z.array(z.string())
+        })
+      })
+      
+      personalizedQuestions.push({
+        ...question,
+        approach: personalization.object.approach,
+        relevance: personalization.object.relevance,
+        followUps: personalization.object.followUps
+      })
+    } catch (error) {
+      // Fallback if personalization fails
+      personalizedQuestions.push({
+        ...question,
+        approach: `This question tests your understanding of ${question.type}. Focus on demonstrating your practical experience and problem-solving approach.`,
+        relevance: `Relevant for ${jobData.role} positions requiring ${question.type} skills.`,
+        followUps: ['Can you walk through your thought process?', 'How would you optimize this solution?']
+      })
+    }
+  }
+  
+  return personalizedQuestions
+}
+
+async function generateComprehensiveGuide(finalAnalysis: any, jobInfo: any) {
+  try {
+    // Load question bank and research company insights
+    const [questionBank, companyInsights] = await Promise.all([
+      loadQuestionBank(),
+      researchCompanyInsights(jobInfo.company, jobInfo.role || jobInfo.title, jobInfo.location)
+    ])
+    
+    // Select and personalize questions
+    const resumeData = {
+      name: 'Candidate',
+      experience_years: finalAnalysis.experienceYears || 3,
+      skills: finalAnalysis.matchingSkills || [],
+      previous_roles: finalAnalysis.previousRoles || [],
+      key_achievements: finalAnalysis.achievements || [],
+      education: finalAnalysis.education || ''
+    }
+    
+    const jobData = {
+      role: jobInfo.role || jobInfo.title,
+      company: jobInfo.company,
+      location: jobInfo.location,
+      description: jobInfo.description || jobInfo.fullContent || '',
+      required_skills: finalAnalysis.missingSkills || []
+    }
+
+    const technicalQuestions = selectQuestionsByRole(questionBank, jobData.role, 'technical').slice(0, 6)
+    const behavioralQuestions = selectQuestionsByRole(questionBank, jobData.role, 'behavioral').slice(0, 4)
+    const caseStudyQuestions = selectQuestionsByRole(questionBank, jobData.role, 'caseStudy').slice(0, 4)
+    
+    // Personalize questions (limit to avoid timeout)
+    const [personalizedTechnical, personalizedBehavioral, personalizedCaseStudy] = await Promise.all([
+      personalizeQuestions(technicalQuestions.slice(0, 3), resumeData, jobData), // Limit for demo
+      personalizeQuestions(behavioralQuestions.slice(0, 2), resumeData, jobData),
+      personalizeQuestions(caseStudyQuestions.slice(0, 2), resumeData, jobData)
+    ])
+
+    // Generate comprehensive guide structure
+    const guide = {
+      title: `${jobData.role} Interview Guide - ${jobData.company}`,
+      introduction: {
+        roleOverview: `The ${jobData.role} role at ${jobData.company} combines ${companyInsights.candidateProfile.keySkills.slice(0, 3).join(', ')} with strong business impact. ${companyInsights.businessModel.overview}`,
+        culture: `${jobData.company}'s culture emphasizes ${companyInsights.culture.values.slice(0, 3).join(', ')}. ${companyInsights.culture.workEnvironment}`,
+        whyThisRole: `This role offers unique opportunities to ${companyInsights.businessModel.keyMetrics.slice(0, 2).join(' and ')} while working with cutting-edge technology and talented teams.`
+      },
+      interviewProcess: {
+        diagram: `Interview Process:\n${companyInsights.interviewProcess.stages.map((stage, idx) => `${idx + 1}. **${stage.name}** (${stage.duration}) - ${stage.description}`).join('\n')}`,
+        stages: companyInsights.interviewProcess.stages,
+        levelDifferences: `**Junior ${jobData.role}** candidates can expect more foundational questions and hands-on problem solving.\n\n**Senior ${jobData.role}** candidates will be evaluated on system design, stakeholder communication, and technical leadership.`
+      },
+      questions: {
+        technical: personalizedTechnical,
+        behavioral: personalizedBehavioral,
+        caseStudy: personalizedCaseStudy
+      },
+      preparation: {
+        tips: [
+          {
+            title: 'Study the Business Model',
+            description: `Understand ${jobData.company}'s ${companyInsights.businessModel.overview} and key metrics.`
+          },
+          {
+            title: 'Technical Practice',
+            description: `Focus on ${companyInsights.candidateProfile.keySkills.slice(0, 3).join(', ')} - use platforms like Interview Query for hands-on practice.`
+          },
+          {
+            title: 'Behavioral Preparation',
+            description: 'Prepare STAR method examples showcasing your experience with problem solving, leadership, and collaboration.'
+          },
+          {
+            title: 'Company Research',
+            description: `Research ${jobData.company}'s recent product launches and company values to show genuine interest.`
+          }
+        ],
+        studyPlan: `**Week 1:** Technical fundamentals and coding practice\n**Week 2:** System design and case study preparation\n**Week 3:** Behavioral questions and company research\n**Final Days:** Mock interviews and confidence building`,
+        mockInterviews: 'Practice with peers, use Interview Query\'s mock interview service, or record yourself answering questions to improve communication.'
+      },
+      faqs: {
+        salary: `**Salary Range:** ${companyInsights.salaryInsights.range}\n\n**Negotiation:** ${companyInsights.salaryInsights.negotiation}`,
+        experiences: `Browse [${jobData.company} Interview Experiences](https://www.interviewquery.com/interview-experiences) to read first-hand candidate stories and success tips.`,
+        jobPostings: `Check out the latest [${jobData.company} job openings](https://www.interviewquery.com/jobs) and practice tailored questions before applying.`
+      },
+      conclusion: {
+        summary: `${jobData.company}'s ${jobData.role} interviews emphasize technical excellence, problem-solving ability, and cultural alignment. With thorough preparation and clear communication, you'll demonstrate the skills and mindset they're seeking.`,
+        resources: {
+          successStory: {
+            title: `${jobData.role} Success Stories`,
+            link: 'https://www.interviewquery.com/success-stories'
+          },
+          questionList: {
+            title: `Top ${jobData.role} Interview Questions`,
+            link: 'https://www.interviewquery.com/questions'
+          },
+          learningPath: {
+            title: `${jobData.role} Learning Path`,
+            link: 'https://www.interviewquery.com/learning-paths'
+          }
+        }
+      },
+      metadata: {
+        generatedAt: new Date().toISOString(),
+        personalizedFor: 'Candidate',
+        targetRole: jobData.role,
+        targetCompany: jobData.company,
+        sourceData: jobInfo.source || 'manual'
+      }
+    }
+
+    return guide
+  } catch (error) {
+    console.error('Guide generation error:', error)
+    throw error
+  }
+}
+
+async function generateFinalAnalysis(resumeData: any, matchData: any) {
+  // Simulate final analysis generation
+  await new Promise(resolve => setTimeout(resolve, 2000))
+  
+  return {
+    overallMatch: matchData.overallMatch,
+    skillsBreakdown: {
+      technical: matchData.skillsMatch,
+      experience: matchData.experienceMatch,
+      culture: 78
+    },
+    salaryInsights: {
+      range: { min: '95k', max: '135k' },
+      median: '115k',
+      percentile: '75th',
+      tip: 'Consider negotiating 10-15% above base offer'
+    },
+    matchingSkills: matchData.strongMatches,
+    missingSkills: matchData.missingSkills,
+    recommendations: [
+      'Practice system design questions for senior-level roles',
+      'Prepare STAR method examples for behavioral questions', 
+      'Research company culture and recent product launches',
+      'Prepare questions about team structure and growth opportunities'
+    ],
+    summary: {
+      matchScore: matchData.overallMatch,
+      preparationTime: '2-3 hours recommended',
+      focusAreas: matchData.missingSkills
+    },
+    // Add additional data for guide generation
+    experienceYears: 3,
+    previousRoles: ['Software Developer', 'Data Analyst'],
+    achievements: ['Led team of 5 developers', 'Improved system performance by 40%'],
+    education: 'Computer Science',
+    requiredSkills: matchData.missingSkills
+  }
+}
+
+function extractJobInfoFromDescription(jobDescription: string) {
+  // Extract job info from description string (fallback method)
+  const lines = jobDescription.split('\n')
+  let role = 'Software Engineer'
+  let company = 'Target Company'
+  let location = 'United States'
+  
+  // Try to extract role and company from job description
+  for (const line of lines.slice(0, 10)) {
+    const rolePatterns = [
+      /(?:position|role|job title|title):\s*(.+)/i,
+      /(?:hiring|seeking|looking for)(?:\s+a)?\s+(.+?)(?:\s+at|\s+to|\s*$)/i,
+      /^(.+?)\s+(?:position|role|job)/i
+    ]
+    
+    const companyPatterns = [
+      /(?:company|organization|employer):\s*(.+)/i,
+      /at\s+(.+?)(?:\s+we|\s+is|\s+has|\s*$)/i,
+      /(.+?)(?:\s+is\s+(?:hiring|seeking|looking))/i
+    ]
+
+    for (const pattern of rolePatterns) {
+      const match = line.match(pattern)
+      if (match) {
+        role = match[1].trim()
+        break
+      }
+    }
+    
+    for (const pattern of companyPatterns) {
+      const match = line.match(pattern)
+      if (match) {
+        company = match[1].trim()
+        break
+      }
+    }
+  }
+
+  return { 
+    role, 
+    company, 
+    location,
+    title: role,
+    description: jobDescription.substring(0, 500) + '...',
+    requirements: ['Skills and qualifications as listed in job posting'],
+    source: 'job_description'
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const { resumeText, jobDescription, jobData } = await req.json()
+
+    const stream = new ReadableStream({
+      async start(controller) {
+        const encoder = new TextEncoder()
+        
+        // Helper function to send updates
+        const sendUpdate = (data: any) => {
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}\n\n`))
+        }
+
+        try {
+          // Step 1: Resume Analysis
+          sendUpdate({ 
+            step: 'resume_analysis', 
+            status: 'processing',
+            message: '🔄 Analyzing your resume...',
+            progress: 10 
+          })
+
+          const resumeData = await analyzeResume(resumeText)
+          
+          sendUpdate({ 
+            step: 'resume_analysis', 
+            status: 'completed',
+            message: '✅ Resume analyzed successfully!',
+            data: resumeData,
+            progress: 25 
+          })
+
+          // Step 2: Job Matching
+          sendUpdate({ 
+            step: 'job_matching', 
+            status: 'processing',
+            message: '🎯 Analyzing job compatibility...',
+            progress: 30 
+          })
+
+          const matchData = await analyzeJobMatch(resumeData, jobDescription)
+          
+          sendUpdate({ 
+            step: 'job_matching', 
+            status: 'completed',
+            message: `✅ ${matchData.overallMatch}% compatibility found!`,
+            data: matchData,
+            progress: 50 
+          })
+
+          // Step 3: Interview Questions Generation
+          const skillAreas = [
+            { skill: 'Technical Skills', difficulty: 'intermediate' },
+            { skill: 'System Design', difficulty: 'advanced' },
+            { skill: 'Behavioral', difficulty: 'intermediate' },
+            { skill: 'Problem Solving', difficulty: 'advanced' },
+            { skill: 'Leadership', difficulty: 'intermediate' }
+          ]
+
+          for (let i = 0; i < skillAreas.length; i++) {
+            const area = skillAreas[i]
+            sendUpdate({ 
+              step: 'questions_generation', 
+              status: 'processing',
+              message: `🧠 Generating ${area.skill} questions...`,
+              progress: 52 + (i * 6)
+            })
+
+            // Simulate question generation
+            await new Promise(resolve => setTimeout(resolve, 1000))
+            
+            sendUpdate({ 
+              step: 'questions_generation', 
+              status: 'completed',
+              message: `✅ ${area.skill} questions generated!`,
+              data: { area: area.skill, difficulty: area.difficulty },
+              progress: 55 + (i * 6)
+            })
+          }
+
+          // Step 4: Questions Ready
+          sendUpdate({ 
+            step: 'questions_ready', 
+            status: 'completed',
+            message: '🎯 All questions personalized for your background!',
+            progress: 85 
+          })
+
+          // Step 5: Final Analysis
+          sendUpdate({ 
+            step: 'final_analysis', 
+            status: 'processing',
+            message: '🔍 Creating final analysis...',
+            progress: 87 
+          })
+
+          const finalAnalysis = await generateFinalAnalysis(resumeData, matchData)
+          
+          sendUpdate({ 
+            step: 'final_analysis', 
+            status: 'completed',
+            message: '✅ Analysis complete!',
+            data: finalAnalysis,
+            progress: 92 
+          })
+
+          // Step 6: Professional Guide Generation
+          sendUpdate({ 
+            step: 'professional_guide', 
+            status: 'processing',
+            message: '📝 Generating comprehensive interview guide...',
+            progress: 94 
+          })
+
+          // Use pre-scraped job data if available, otherwise extract from description
+          const jobInfo = jobData || extractJobInfoFromDescription(jobDescription)
+          
+          const guide = await generateComprehensiveGuide(finalAnalysis, jobInfo)
+          
+          sendUpdate({ 
+            step: 'professional_guide', 
+            status: 'completed',
+            message: '✅ Professional guide generated!',
+            data: guide,
+            progress: 98 
+          })
+
+          // Step 7: Complete
+          sendUpdate({ 
+            step: 'completed', 
+            status: 'completed',
+            message: '🎉 Analysis complete! Your interview guide is ready.',
+            progress: 100,
+            results: {
+              overallMatch: finalAnalysis.overallMatch,
+              skillsBreakdown: finalAnalysis.skillsBreakdown,
+              matchingSkills: finalAnalysis.matchingSkills,
+              missingSkills: finalAnalysis.missingSkills,
+              recommendations: finalAnalysis.recommendations,
+              interviewQuestions: [
+                { category: 'technical', question: 'How would you design a scalable machine learning pipeline?' },
+                { category: 'behavioral', question: 'Tell me about a time you had to learn a new technology quickly' },
+                { category: 'culture', question: 'How do you handle competing priorities in a fast-paced environment?' }
+              ],
+              comprehensiveGuide: guide,
+              summary: finalAnalysis.summary
+            }
+          })
+
+          // Send final completion signal
+          controller.enqueue(encoder.encode(`data: [DONE]\n\n`))
+          
+        } catch (error) {
+          console.error('Analysis error:', error)
+          sendUpdate({ 
+            step: 'error', 
+            status: 'error',
+            message: 'Analysis failed. Please try again.',
+            progress: 0,
+            error: error instanceof Error ? error.message : 'Unknown error'
+          })
+        } finally {
+          controller.close()
+        }
+      }
+    })
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+      }
+    })
+  } catch (error) {
+    console.error('Stream setup error:', error)
+    return NextResponse.json({ error: 'Failed to start analysis' }, { status: 500 })
+  }
+} 

iqkiller-vercel/app/api/analyze/route.ts

@@ -0,0 +1,76 @@
+import { openai } from '@ai-sdk/openai'
+import { generateObject } from 'ai'
+import { NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+
+const analysisSchema = z.object({
+  matchScore: z.number().min(0).max(100),
+  technicalSkills: z.array(z.string()),
+  softSkills: z.array(z.string()),
+  matchingSkills: z.array(z.string()),
+  interviewQuestions: z.array(z.object({
+    category: z.enum(['technical', 'behavioral', 'culture']),
+    question: z.string()
+  })),
+  recommendations: z.array(z.string())
+})
+
+export async function POST(req: NextRequest) {
+  try {
+    const { resumeText, jobDescription } = await req.json()
+    
+    if (!resumeText || !jobDescription) {
+      return NextResponse.json(
+        { error: 'Resume text and job description are required' },
+        { status: 400 }
+      )
+    }
+
+    // Handle PDF file format
+    let processedResumeText = resumeText
+    if (resumeText.startsWith('PDF_FILE:')) {
+      // For now, use a placeholder. In production, extract text from PDF using AI SDK
+      processedResumeText = `[PDF Resume content would be extracted here]
+      
+      Based on the filename and context, this appears to be a professional resume containing:
+      - Work experience in software development
+      - Education background
+      - Technical skills including programming languages
+      - Project experience
+      - Professional achievements`
+    }
+
+    const { object } = await generateObject({
+      model: openai('gpt-4o-mini'),
+      prompt: `Analyze this resume against the job posting and provide a comprehensive interview preparation analysis.
+
+Resume:
+${processedResumeText}
+
+Job Posting:
+${typeof jobDescription === 'string' ? jobDescription : JSON.stringify(jobDescription)}
+
+Provide:
+1. Match score (0-100) based on skills and experience alignment
+2. Technical skills found in resume
+3. Soft skills identified  
+4. Skills that match between resume and job requirements
+5. 6 interview questions (2 technical, 2 behavioral, 2 culture-fit) specific to this role
+6. 4 specific recommendations for interview preparation
+
+Be accurate and helpful in your analysis. Focus on actionable insights.`,
+      schema: analysisSchema,
+    })
+
+    return NextResponse.json({
+      success: true,
+      analysis: object
+    })
+  } catch (error) {
+    console.error('Analysis error:', error)
+    return NextResponse.json(
+      { error: 'Failed to analyze resume and job posting' },
+      { status: 500 }
+    )
+  }
+} 

iqkiller-vercel/app/api/generate-comprehensive-guide/route.ts

@@ -0,0 +1,372 @@
+import { openai } from '@ai-sdk/openai'
+import { generateObject } from 'ai'
+import { NextRequest, NextResponse } from 'next/server'
+import { z } from 'zod'
+import { researchCompanyInsights, generateProcessDiagram, generateSalaryInsights, type CompanyInsights } from '@/lib/company-research'
+import { processQuestionBank, selectQuestionsByRole, type Question } from '@/lib/questions-processor'
+import fs from 'fs'
+import path from 'path'
+
+interface ResumeData {
+  name?: string
+  experience_years: number
+  skills: string[]
+  previous_roles: string[]
+  key_achievements: string[]
+  education?: string
+}
+
+interface JobData {
+  role: string
+  company: string
+  location?: string
+  description: string
+  required_skills: string[]
+}
+
+interface ComprehensiveGuide {
+  title: string
+  introduction: {
+    roleOverview: string
+    culture: string
+    whyThisRole: string
+  }
+  interviewProcess: {
+    diagram: string
+    stages: Array<{
+      name: string
+      description: string
+      duration: string
+    }>
+    levelDifferences: string
+  }
+  questions: {
+    technical: Question[]
+    behavioral: Question[]
+    caseStudy: Question[]
+  }
+  preparation: {
+    tips: Array<{
+      title: string
+      description: string
+    }>
+    studyPlan: string
+    mockInterviews: string
+  }
+  faqs: {
+    salary: string
+    experiences: string
+    jobPostings: string
+  }
+  conclusion: {
+    summary: string
+    resources: {
+      successStory: { title: string; link: string }
+      questionList: { title: string; link: string }
+      learningPath: { title: string; link: string }
+    }
+  }
+  metadata: {
+    generatedAt: string
+    personalizedFor: string
+    targetRole: string
+    targetCompany: string
+  }
+}
+
+export async function POST(req: NextRequest) {
+  try {
+    const { resumeData, jobData } = await req.json()
+    
+    if (!resumeData || !jobData) {
+      return NextResponse.json(
+        { error: 'Resume data and job data are required' },
+        { status: 400 }
+      )
+    }
+
+    // Load question bank
+    const questionBank = await loadQuestionBank()
+    
+    // Generate comprehensive guide
+    const guide = await generateComprehensiveGuide({
+      resumeData,
+      jobData,
+      questionBank
+    })
+    
+    return NextResponse.json({ guide })
+  } catch (error) {
+    console.error('Error generating comprehensive guide:', error)
+    return NextResponse.json(
+      { error: 'Failed to generate interview guide' },
+      { status: 500 }
+    )
+  }
+}
+
+async function loadQuestionBank(): Promise<Question[]> {
+  try {
+    // In a real implementation, you'd load from your CSV file
+    // For now, we'll use a placeholder that returns sample questions
+    const csvPath = path.join(process.cwd(), '../Question_bank_IQ_categorized/summary (1).csv')
+    
+    // Try to read the file, fallback to sample data if not available
+    let csvData = ''
+    try {
+      csvData = fs.readFileSync(csvPath, 'utf-8')
+    } catch {
+      // Fallback to sample questions if CSV not found
+      csvData = getSampleQuestionData()
+    }
+    
+    return processQuestionBank(csvData)
+  } catch (error) {
+    console.error('Error loading question bank:', error)
+    return getSampleQuestions()
+  }
+}
+
+function getSampleQuestionData(): string {
+  return `idx,title,type,summaries,link
+0,Weekly Aggregation,python,"Summary: Group a list of sequential timestamps into weekly lists starting from the first timestamp.",interviewquery.com/questions/weekly-aggregation
+1,Decreasing Comments,product metrics,"Summary: Identify reasons and metrics for decreasing average comments per user despite user growth in a new city.",interviewquery.com/questions/decreasing-comments
+2,Employee Salaries,sql,"Summary: Select the top 3 departments with at least ten employees, ranked by the percentage of employees earning over 100K.",interviewquery.com/questions/employee-salaries
+3,500 Cards,probability,"Summary: Determine the probability of drawing three cards in increasing order from a shuffled deck of 500 numbered cards.",interviewquery.com/questions/500-cards
+4,Random Number,algorithms,"Summary: Select a random number from a stream with equal probability using O(1) space.",interviewquery.com/questions/random-number`
+}
+
+function getSampleQuestions(): Question[] {
+  return [
+    {
+      idx: 0,
+      title: 'Weekly Aggregation',
+      type: 'python',
+      summaries: 'Group a list of sequential timestamps into weekly lists starting from the first timestamp.',
+      link: 'interviewquery.com/questions/weekly-aggregation',
+      category: 'Technical/Programming',
+      difficulty: 'mid'
+    },
+    {
+      idx: 1,
+      title: 'Decreasing Comments',
+      type: 'product metrics',
+      summaries: 'Identify reasons and metrics for decreasing average comments per user despite user growth in a new city.',
+      link: 'interviewquery.com/questions/decreasing-comments',
+      category: 'Business/Analytics',
+      difficulty: 'mid'
+    }
+  ]
+}
+
+async function generateComprehensiveGuide(data: {
+  resumeData: ResumeData
+  jobData: JobData
+  questionBank: Question[]
+}): Promise<ComprehensiveGuide> {
+  const { resumeData, jobData, questionBank } = data
+  
+  // Research company and role
+  const companyInsights = await researchCompanyInsights(
+    jobData.company, 
+    jobData.role, 
+    jobData.location
+  )
+  
+  // Select and personalize questions
+  const categorizedQuestions = await selectAndPersonalizeQuestions(
+    questionBank,
+    resumeData,
+    jobData
+  )
+  
+  // Generate salary insights
+  const salaryData = await generateSalaryInsights(
+    jobData.company,
+    jobData.role,
+    jobData.location
+  )
+  
+  // Create comprehensive guide
+  return {
+    title: `${jobData.role} Interview Guide - ${jobData.company}`,
+    introduction: await generateIntroduction(companyInsights, jobData),
+    interviewProcess: {
+      diagram: generateProcessDiagram(companyInsights.interviewProcess.stages),
+      stages: companyInsights.interviewProcess.stages,
+      levelDifferences: await generateLevelDifferences(jobData.role)
+    },
+    questions: categorizedQuestions,
+    preparation: await generatePreparationPlan(resumeData, jobData, companyInsights),
+    faqs: {
+      salary: generateSalaryFAQ(salaryData, jobData),
+      experiences: `Browse [${jobData.company} Interview Experiences](https://www.interviewquery.com/interview-experiences) to read first-hand candidate stories and success tips.`,
+      jobPostings: `Check out the latest [${jobData.company} job openings](https://www.interviewquery.com/jobs) and practice tailored questions before applying.`
+    },
+    conclusion: generateConclusion(jobData),
+    metadata: {
+      generatedAt: new Date().toISOString(),
+      personalizedFor: resumeData.name || 'Candidate',
+      targetRole: jobData.role,
+      targetCompany: jobData.company
+    }
+  }
+}
+
+async function selectAndPersonalizeQuestions(
+  questionBank: Question[],
+  resumeData: ResumeData,
+  jobData: JobData
+) {
+  const technicalQuestions = selectQuestionsByRole(questionBank, jobData.role, 'technical').slice(0, 6)
+  const behavioralQuestions = selectQuestionsByRole(questionBank, jobData.role, 'behavioral').slice(0, 4)  
+  const caseStudyQuestions = selectQuestionsByRole(questionBank, jobData.role, 'caseStudy').slice(0, 4)
+  
+  // Personalize questions with AI
+  const personalizedTechnical = await personalizeQuestions(technicalQuestions, resumeData, jobData)
+  const personalizedBehavioral = await personalizeQuestions(behavioralQuestions, resumeData, jobData)
+  const personalizedCaseStudy = await personalizeQuestions(caseStudyQuestions, resumeData, jobData)
+  
+  return {
+    technical: personalizedTechnical,
+    behavioral: personalizedBehavioral,
+    caseStudy: personalizedCaseStudy
+  }
+}
+
+async function personalizeQuestions(
+  questions: Question[],
+  resumeData: ResumeData,
+  jobData: JobData
+): Promise<Question[]> {
+  const personalizedQuestions = []
+  
+  for (const question of questions) {
+    try {
+      const personalization = await generateObject({
+        model: openai('gpt-4o-mini'),
+        prompt: `
+          Personalize this interview question for a candidate:
+          
+          ORIGINAL QUESTION: "${question.summaries}"
+          
+          CANDIDATE BACKGROUND:
+          - Role: ${jobData.role} at ${jobData.company}
+          - Experience: ${resumeData.experience_years} years
+          - Skills: ${resumeData.skills.slice(0, 5).join(', ')}
+          - Previous roles: ${resumeData.previous_roles.join(', ')}
+          
+          Create:
+          1. A personalized approach explanation (2-3 sentences)
+          2. Why this question is relevant for this candidate
+          3. 2-3 follow-up questions based on their background
+        `,
+        schema: z.object({
+          approach: z.string(),
+          relevance: z.string(),
+          followUps: z.array(z.string())
+        })
+      })
+      
+      personalizedQuestions.push({
+        ...question,
+        approach: personalization.object.approach,
+        relevance: personalization.object.relevance,
+        followUps: personalization.object.followUps
+      })
+    } catch (error) {
+      // Fallback if personalization fails
+      personalizedQuestions.push({
+        ...question,
+        approach: `This question tests your understanding of ${question.type}. Focus on demonstrating your practical experience and problem-solving approach.`,
+        relevance: `Relevant for ${jobData.role} positions requiring ${question.type} skills.`,
+        followUps: ['Can you walk through your thought process?', 'How would you optimize this solution?']
+      })
+    }
+  }
+  
+  return personalizedQuestions
+}
+
+async function generateIntroduction(companyInsights: CompanyInsights, jobData: JobData) {
+  return {
+    roleOverview: `The ${jobData.role} role at ${jobData.company} combines ${companyInsights.candidateProfile.keySkills.slice(0, 3).join(', ')} with strong business impact. ${companyInsights.businessModel.overview}`,
+    culture: `${jobData.company}'s culture emphasizes ${companyInsights.culture.values.slice(0, 3).join(', ')}. ${companyInsights.culture.workEnvironment}`,
+    whyThisRole: `This role offers unique opportunities to ${companyInsights.businessModel.keyMetrics.slice(0, 2).join(' and ')} while working with cutting-edge technology and talented teams.`
+  }
+}
+
+async function generateLevelDifferences(role: string): Promise<string> {
+  return `
+**Junior ${role}** candidates can expect more foundational questions and hands-on problem solving.
+
+**Senior ${role}** candidates will be evaluated on system design, stakeholder communication, and technical leadership.
+
+**Principal/Staff** level roles focus on architecture decisions, cross-team collaboration, and strategic thinking.
+`
+}
+
+async function generatePreparationPlan(
+  resumeData: ResumeData,
+  jobData: JobData,
+  companyInsights: CompanyInsights
+) {
+  return {
+    tips: [
+      {
+        title: 'Study the Business Model',
+        description: `Understand ${jobData.company}'s ${companyInsights.businessModel.overview} and key metrics like ${companyInsights.businessModel.keyMetrics.slice(0, 2).join(' and ')}.`
+      },
+      {
+        title: 'Technical Practice',
+        description: `Focus on ${companyInsights.candidateProfile.keySkills.slice(0, 3).join(', ')} - use platforms like Interview Query and LeetCode for hands-on practice.`
+      },
+      {
+        title: 'Behavioral Preparation',
+        description: 'Prepare STAR method examples showcasing your experience with problem solving, leadership, and collaboration.'
+      },
+      {
+        title: 'Company Research',
+        description: `Research ${jobData.company}'s recent product launches, engineering blog posts, and company values to show genuine interest.`
+      }
+    ],
+    studyPlan: `
+**Week 1:** Technical fundamentals and coding practice
+**Week 2:** System design and case study preparation  
+**Week 3:** Behavioral questions and company research
+**Final Days:** Mock interviews and confidence building
+`,
+    mockInterviews: 'Practice with peers, use Interview Query\'s mock interview service, or record yourself answering questions to improve communication.'
+  }
+}
+
+function generateSalaryFAQ(salaryData: any, jobData: JobData): string {
+  return `
+**Salary Range:** ${salaryData.range}
+
+**Total Compensation:** ${salaryData.breakdown}
+
+**Negotiation Tips:**
+${salaryData.negotiationTips.map((tip: string) => `- ${tip}`).join('\n')}
+`
+}
+
+function generateConclusion(jobData: JobData) {
+  return {
+    summary: `${jobData.company}'s ${jobData.role} interviews emphasize technical excellence, problem-solving ability, and cultural alignment. With thorough preparation and clear communication, you'll demonstrate the skills and mindset they're seeking.`,
+    resources: {
+      successStory: {
+        title: `${jobData.role} Success Stories`,
+        link: 'https://www.interviewquery.com/success-stories'
+      },
+      questionList: {
+        title: `Top ${jobData.role} Interview Questions`,
+        link: 'https://www.interviewquery.com/questions'
+      },
+      learningPath: {
+        title: `${jobData.role} Learning Path`,
+        link: 'https://www.interviewquery.com/learning-paths'
+      }
+    }
+  }
+}