INTERN.ME - AI-Powered Internship Recommendation Engine

A national-level AI-driven web platform to fairly and efficiently match Indian students with the best-fit internships under the Indian Prime Minister's Internship Scheme.

🚀 Features

For Students

• AI-Powered Recommendations: Get personalized internship matches based on skills, preferences, and academic profile
• Resume Analysis: Upload resume and get AI-extracted skills and keywords
• Profile Completion: Gamified profile completion with progress tracking
• Smart Matching: Content-based and collaborative filtering for accurate recommendations
• Application Tracking: Track application status and get feedback

For Employers

• Talent Discovery: Find the best-fit students for your internships
• Advanced Filtering: Filter applications by skills, academic performance, and location
• Application Management: Manage applications, schedule interviews, and provide feedback
• Analytics Dashboard: Track application metrics and success rates
• Company Profile: Showcase company culture and internship programs

For Policy Makers

• Analytics Dashboard: Comprehensive insights into internship trends
• Skill Gap Analysis: Identify skill gaps in the Indian workforce
• Regional Insights: Analyze internship distribution across states and cities
• Success Metrics: Track placement rates and conversion statistics
• Policy Recommendations: Data-driven insights for policy decisions

🛠️ Technology Stack

Backend

• FastAPI: Modern Python web framework
• PostgreSQL: Robust relational database
• SQLAlchemy: Python SQL toolkit and ORM
• Redis: In-memory data structure store for caching
• TensorFlow: Machine learning framework
• scikit-learn: Machine learning library
• spaCy: Natural language processing library

Frontend

• React.js: Modern JavaScript library for building user interfaces
• Material-UI: React component library following Material Design
• Recharts: Composable charting library for React
• Axios: HTTP client for API requests

DevOps

• Docker: Containerization platform
• Docker Compose: Multi-container Docker application
• Nginx: Web server and reverse proxy
• AWS: Cloud deployment platform

📋 Prerequisites

• Docker and Docker Compose
• Node.js 18+ (for local development)
• Python 3.11+ (for local development)
• PostgreSQL 15+ (for local development)
• Redis 7+ (for local development)

🚀 Quick Start

Using Docker (Recommended)

1. Clone the repository

   git clone <repository-url>
   cd intern-me

2. Start the application

   docker-compose up -d

3. Access the application

   • Frontend: http://localhost:3000
   • Backend API: http://localhost:8000
   • API Documentation: http://localhost:8000/docs

Local Development

1. Backend Setup

   cd backend
   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate
   pip install -r requirements.txt
   python -m spacy download en_core_web_sm
   uvicorn main:app --reload

2. Frontend Setup

   cd frontend
   npm install
   npm start

3. Database Setup

   # Create PostgreSQL database
   createdb intern_me_db
   
   # Run migrations (when available)
   alembic upgrade head

📁 Project Structure

intern-me/
├── backend/
│   ├── main.py                 # FastAPI application entry point
│   ├── models/                 # Database models
│   ├── routers/                # API route handlers
│   ├── schemas/                # Pydantic models
│   ├── services/               # Business logic services
│   ├── core/                   # Core configuration and utilities
│   └── requirements.txt        # Python dependencies
├── frontend/
│   ├── src/
│   │   ├── components/         # Reusable React components
│   │   ├── pages/              # Page components
│   │   ├── contexts/           # React contexts
│   │   └── App.js              # Main React application
│   └── package.json            # Node.js dependencies
├── docker-compose.yml          # Docker Compose configuration
├── nginx.conf                  # Nginx configuration
└── README.md                   # Project documentation

🔧 Configuration

Environment Variables

Create a .env file in the backend directory:

# Database
DATABASE_URL=postgresql://intern_user:intern_pass@localhost:5432/intern_me_db

# JWT
SECRET_KEY=your-secret-key-change-in-production
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30

# Redis
REDIS_URL=redis://localhost:6379

# File Upload
UPLOAD_DIR=uploads
MAX_FILE_SIZE=10485760

# ML Models
MODEL_PATH=models
SPACY_MODEL=en_core_web_sm

🤖 AI Features

Recommendation Engine

• Content-Based Filtering: Matches students with internships based on skills and preferences
• Collaborative Filtering: Uses historical application data to improve recommendations
• Hybrid Approach: Combines both methods for optimal results
• Continuous Learning: Feedback loop improves recommendations over time

Resume Parsing

• NLP Processing: Extracts skills, education, and experience from resumes
• Skill Extraction: Identifies technical and soft skills
• Contact Information: Extracts email, phone, and location
• Project Recognition: Identifies projects and achievements

Analytics

• Trend Analysis: Tracks internship trends over time
• Skill Gap Analysis: Identifies gaps between demand and supply
• Regional Insights: Analyzes geographic distribution
• Success Metrics: Tracks placement rates and outcomes

📊 API Documentation

The API documentation is available at:

• Swagger UI: http://localhost:8000/docs
• ReDoc: http://localhost:8000/redoc

Key Endpoints

Authentication

• POST /api/auth/register - User registration
• POST /api/auth/login - User login
• GET /api/auth/me - Get current user

Students

• GET /api/students/profile - Get student profile
• PUT /api/students/profile - Update student profile
• POST /api/students/upload-resume - Upload and parse resume
• GET /api/students/recommendations - Get AI recommendations

Employers

• GET /api/employers/profile - Get employer profile
• PUT /api/employers/profile - Update employer profile
• GET /api/employers/applications - Get applications
• GET /api/employers/statistics - Get employer statistics

Internships

• GET /api/internships/ - List internships
• POST /api/internships/ - Create internship
• GET /api/internships/{id} - Get internship details
• PUT /api/internships/{id} - Update internship

Applications

• POST /api/applications/ - Apply for internship
• GET /api/applications/my-applications - Get user applications
• PUT /api/applications/{id}/status - Update application status

Analytics

• GET /api/analytics/dashboard - Get analytics dashboard
• GET /api/analytics/skill-gaps - Get skill gap analysis
• GET /api/analytics/placement-trends - Get placement trends
• GET /api/analytics/regional-analysis - Get regional analysis

🧪 Testing

Backend Tests

cd backend
pytest

Frontend Tests

cd frontend
npm test

🚀 Deployment

Production Deployment

1. Update environment variables for production
2. Set up SSL certificates
3. Configure production database
4. Deploy using Docker Compose

docker-compose -f docker-compose.prod.yml up -d

AWS Deployment

1. Create EC2 instance
2. Install Docker and Docker Compose
3. Clone repository
4. Configure environment variables
5. Deploy application

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

📞 Support

For support and questions:

• Email: support@intern.me
• Documentation: https://docs.intern.me
• Issues: https://github.com/intern-me/issues

🎯 Roadmap

Phase 1 (Current)

• ✅ Basic user authentication
• ✅ Student and employer profiles
• ✅ Internship posting and browsing
• ✅ AI recommendation engine
• ✅ Application management

Phase 2 (Next)

• 🔄 Advanced analytics dashboard
• 🔄 Mobile application
• 🔄 Video interview integration
• 🔄 Skill assessment tests
• 🔄 Certificate generation

Phase 3 (Future)

• 📋 AI-powered interview scheduling
• 📋 Blockchain-based certificate verification
• 📋 Integration with university systems
• 📋 Advanced ML models for matching
• 📋 Multi-language support

---

INTERN.ME - Empowering India's future workforce through AI-driven internship matching.