File size: 31,442 Bytes

#!/usr/bin/env python3
"""
🎯 EKALAVYA - The Ultimate AI Teaching Assistant
🌟 Multi-Modal • Multi-Lingual • Memory-Powered
🛡️ Safe • 🎓 Educational • 💝 Friendly
"""

from fastapi import FastAPI, HTTPException, UploadFile, File, Form
from fastapi.responses import HTMLResponse
from pydantic import BaseModel
from typing import Optional, List, Dict
import json
import os

# Import all modules
from model.teaching import TeachingMode
from model.safety import SafetyRules
from model.memory import MemorySystem

# 🎯 Initialize FastAPI with style
app = FastAPI(
    title="🎯 EKALAVYA API",
    description="🌟 The Ultimate AI Teaching Assistant - Multi-Modal, Multi-Lingual, Memory-Powered",
    version="3.0.0",
    docs_url="/docs",
    redoc_url="/redoc"
)

# 🛡️ Initialize safety rules
safety = SafetyRules()

# 🎯 Initialize teaching mode
teaching_mode = TeachingMode(style="friend")

# 📁 Data directory
DATA_DIR = "data"
os.makedirs(DATA_DIR, exist_ok=True)


# 📦 Request/Response Models
class TeachingRequest(BaseModel):
    """📚 Teaching request model"""
    input_text: str
    user_id: str = "default_user"
    conversation_style: str = "friend"  # friend, teacher, lover, mentor
    language: str = "english"


class SafetyCheckRequest(BaseModel):
    """🛡️ Safety check request model"""
    content: str
    check_type: str = "all"  # all, scam, hacking, privacy, inappropriate


class ProgressRequest(BaseModel):
    """📊 Progress request model"""
    user_id: str


class StyleRequest(BaseModel):
    """💝 Conversation style request model"""
    style: str  # friend, teacher, lover, mentor
    user_id: str = "default_user"


# 🏠 Root endpoint
@app.get("/", response_class=HTMLResponse)
async def root():
    """🎯 Welcome page with emojis"""
    return """
    <!DOCTYPE html>
    <html>
    <head>
        <title>🎯 EKALAVYA - AI Teaching Assistant</title>
        <style>
            body { 
                font-family: Arial, sans-serif; 
                max-width: 800px; 
                margin: 50px auto; 
                padding: 20px;
                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
                color: white;
            }
            .card {
                background: rgba(255,255,255,0.95);
                color: #333;
                padding: 30px;
                border-radius: 20px;
                box-shadow: 0 10px 40px rgba(0,0,0,0.3);
                margin: 20px 0;
            }
            h1 { font-size: 3em; text-align: center; }
            .emoji { font-size: 1.5em; }
            .feature { 
                background: #f0f0f0; 
                padding: 15px; 
                margin: 10px 0; 
                border-radius: 10px;
                border-left: 5px solid #667eea;
            }
            .stats { 
                display: flex; 
                justify-content: space-around; 
                margin: 30px 0;
            }
            .stat {
                text-align: center;
                padding: 20px;
                background: rgba(255,255,255,0.1);
                border-radius: 15px;
                flex: 1;
                margin: 0 10px;
            }
            .stat-number { font-size: 2.5em; font-weight: bold; }
            a { color: #667eea; text-decoration: none; font-weight: bold; }
            a:hover { text-decoration: underline; }
        </style>
    </head>
    <body>
        <div class="card">
            <h1>🎯 EKALAVYA</h1>
            <p style="text-align: center; font-size: 1.3em;">
                🌟 The Ultimate AI Teaching Assistant 🌟
            </p>
            
            <div class="stats">
                <div class="stat">
                    <div class="stat-number">🌍 23</div>
                    <div>Indian Languages</div>
                </div>
                <div class="stat">
                    <div class="stat-number">🧠 1M</div>
                    <div>Token Context</div>
                </div>
                <div class="stat">
                    <div class="stat-number">🛡️ 100%</div>
                    <div>Safe & Private</div>
                </div>
            </div>

            <h2>✨ Features</h2>
            
            <div class="feature">
                <span class="emoji">🎓</span> <strong>Teaching Mode</strong>
                <p>Learn English with real-time mistake detection and correction</p>
            </div>
            
            <div class="feature">
                <span class="emoji">🧠</span> <strong>Memory System</strong>
                <p>Remembers your mistakes and tracks your learning progress</p>
            </div>
            
            <div class="feature">
                <span class="emoji">💝</span> <strong>Conversation Styles</strong>
                <p>Choose: Friend 👫, Teacher 👨‍🏫, Lover 💕, or Mentor 🎓</p>
            </div>
            
            <div class="feature">
                <span class="emoji">🛡️</span> <strong>Safety First</strong>
                <p>Scam detection, hacking prevention, privacy protection</p>
            </div>
            
            <div class="feature">
                <span class="emoji">🌐</span> <strong>Multi-Modal</strong>
                <p>Supports text, images, video, and audio</p>
            </div>
            
            <div class="feature">
                <span class="emoji">🔒</span> <strong>100% Private</strong>
                <p>All data stays on your device, no tracking</p>
            </div>

            <h2>📚 API Endpoints</h2>
            
            <div class="feature">
                <strong>POST /teach</strong> - Start learning session
            </div>
            
            <div class="feature">
                <strong>POST /safety/check</strong> - Check content safety
            </div>
            
            <div class="feature">
                <strong>GET /safety/tips</strong> - Get safety tips
            </div>
            
            <div class="feature">
                <strong>POST /progress</strong> - View learning progress
            </div>
            
            <div class="feature">
                <strong>POST /style</strong> - Change conversation style
            </div>

            <h2>🔗 Quick Links</h2>
            <p>
                📖 <a href="/docs">Interactive API Docs</a> |
                📊 <a href="/redoc">Alternative Docs</a> |
                🎯 <a href="https://huggingface.co/hackerbhai/vinaymodel">HuggingFace Model</a>
            </p>

            <p style="text-align: center; margin-top: 30px; font-size: 1.2em;">
                🎯 Built with ❤️ for learners everywhere 🌍
            </p>
        </div>
    </body>
    </html>
    """


# 🎓 Teaching endpoint
@app.post("/teach")
async def teach(request: TeachingRequest):
    """🎓 Start teaching session with mistake detection"""
    try:
        # 🛡️ Safety check first
        safety_check = safety.check_content(request.input_text)
        if not safety_check['is_safe']:
            return {
                "status": "🛡️ safety_warning",
                "message": safety_check['warnings'][0],
                "suggestions": safety_check['suggestions']
            }
        
        # 🎯 Process teaching request
        result = teaching_mode.process_teaching_request(
            user_input=request.input_text,
            user_id=request.user_id,
            conversation_style=request.conversation_style,
            language=request.language
        )
        
        return {
            "status": "✅ success",
            "response": result['response'],
            "mistakes_found": result['mistakes'],
            "corrections": result['corrections'],
            "explanation": result['explanation'],
            "encouragement": result['encouragement'],
            "next_steps": result['next_steps'],
            "emoji": "🎉" if result['mistakes'] else "✨"
        }
        
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")


# 🛡️ Safety check endpoint
@app.post("/safety/check")
async def check_safety(request: SafetyCheckRequest):
    """🛡️ Check if content is safe"""
    result = safety.check_content(request.content)
    
    return {
        "is_safe": result['is_safe'],
        "violations": result['violations'],
        "warnings": result['warnings'],
        "suggestions": result['suggestions'],
        "emoji": "✅" if result['is_safe'] else "⚠️",
        "message": "✅ Content is safe!" if result['is_safe'] else "⚠️ Safety issues detected"
    }


# 💡 Safety tips endpoint
@app.get("/safety/tips")
async def get_safety_tips():
    """💡 Get safety tips with emojis"""
    tips = safety.get_safety_tips()
    
    emoji_tips = [
        f"🔒 {tips['privacy_protection'][0]}",
        f"🛡️ {tips['privacy_protection'][1]}",
        f"🚫 {tips['prohibited_actions'][0]}",
        f"⚠️ {tips['prohibited_actions'][1]}",
        f"💝 {tips['positive_behaviors'][0]}",
        f"🌟 {tips['positive_behaviors'][1]}",
    ]
    
    return {
        "tips": emoji_tips,
        "count": len(emoji_tips),
        "emoji": "💡",
        "message": "💡 Stay safe with these tips!"
    }


# 📊 Progress endpoint
@app.post("/progress")
async def get_progress(request: ProgressRequest):
    """📊 Get user learning progress"""
    memory = MemorySystem(user_id=request.user_id)
    stats = memory.get_user_stats()
    
    # Calculate learning score
    total_attempts = stats['total_attempts']
    correct_attempts = stats['correct_attempts']
    learning_score = (correct_attempts / total_attempts * 100) if total_attempts > 0 else 0
    
    return {
        "user_id": request.user_id,
        "stats": stats,
        "learning_score": round(learning_score, 2),
        "emoji": "🏆" if learning_score > 80 else "📈" if learning_score > 50 else "💪",
        "message": "🏆 Excellent progress!" if learning_score > 80 else 
                   "📈 Good progress, keep going!" if learning_score > 50 else 
                   "💪 Keep practicing, you'll improve!"
    }


# 💝 Style change endpoint
@app.post("/style")
async def change_style(request: StyleRequest):
    """💝 Change conversation style"""
    styles = {
        "friend": "👫",
        "teacher": "👨‍🏫",
        "lover": "💕",
        "mentor": "🎓"
    }
    
    if request.style not in styles:
        raise HTTPException(
            status_code=400, 
            detail=f"❌ Invalid style. Choose from: {', '.join(styles.keys())}"
        )
    
    teaching_mode.set_style(request.style, request.user_id)
    
    return {
        "status": "✅ success",
        "style": request.style,
        "emoji": styles[request.style],
        "message": f"{styles[request.style]} Now talking as your {request.style}!"
    }


# 🌍 Languages endpoint
@app.get("/languages")
async def get_languages():
    """🌍 Get supported languages with flags"""
    languages = {
        "english": {"name": "English", "flag": "🇬🇧", "emoji": "📚"},
        "hindi": {"name": "Hindi", "flag": "🇮🇳", "emoji": "📖"},
        "bengali": {"name": "Bengali", "flag": "🇮🇳", "emoji": "📝"},
        "telugu": {"name": "Telugu", "flag": "🇮🇳", "emoji": "✍️"},
        "tamil": {"name": "Tamil", "flag": "🇮🇳", "emoji": "📜"},
        "marathi": {"name": "Marathi", "flag": "🇮🇳", "emoji": "📄"},
        "gujarati": {"name": "Gujarati", "flag": "🇮🇳", "emoji": "📋"},
        "kannada": {"name": "Kannada", "flag": "🇮🇳", "emoji": "📑"},
        "malayalam": {"name": "Malayalam", "flag": "🇮🇳", "emoji": "📓"},
        "odia": {"name": "Odia", "flag": "🇮🇳", "emoji": "📕"},
        "punjabi": {"name": "Punjabi", "flag": "🇮🇳", "emoji": "📗"},
        "assamese": {"name": "Assamese", "flag": "🇮🇳", "emoji": "📘"},
        "urdu": {"name": "Urdu", "flag": "🇵🇰", "emoji": "📙"},
        "maithili": {"name": "Maithili", "flag": "🇮🇳", "emoji": "📔"},
        "santali": {"name": "Santali", "flag": "🇮🇳", "emoji": "📒"},
        "kashmiri": {"name": "Kashmiri", "flag": "🇮🇳", "emoji": "📚"},
        "nepali": {"name": "Nepali", "flag": "🇳🇵", "emoji": "📖"},
        "sindhi": {"name": "Sindhi", "flag": "🇮🇳", "emoji": "📝"},
        "konkani": {"name": "Konkani", "flag": "🇮🇳", "emoji": "✍️"},
        "dogri": {"name": "Dogri", "flag": "🇮🇳", "emoji": "📜"},
        "manipuri": {"name": "Manipuri", "flag": "🇮🇳", "emoji": "📄"},
        "bodo": {"name": "Bodo", "flag": "🇮🇳", "emoji": "📋"},
        "sanskrit": {"name": "Sanskrit", "flag": "🇮🇳", "emoji": "📜"}
    }
    
    return {
        "languages": languages,
        "count": len(languages),
        "emoji": "🌍",
        "message": f"🌍 Supporting {len(languages)} languages!"
    }


# 🏥 Health check endpoint
@app.get("/health")
async def health_check():
    """🏥 Health check with status"""
    return {
        "status": "✅ healthy",
        "service": "🎯 EKALAVYA",
        "version": "📦 3.0.0",
        "emoji": "🟢",
        "message": "🟢 All systems operational!"
    }


# 🎯 Main entry point
if __name__ == "__main__":
    import uvicorn
    print("""
    ╔═══════════════════════════════════════════════════════════╗
    ║                                                           ║
    ║   🎯  EKALAVYA - AI Teaching Assistant                   ║
    ║                                                           ║
    ║   🌟  Multi-Modal • Multi-Lingual • Memory-Powered       ║
    ║                                                           ║
    ║   🛡️  Safe • 🎓 Educational • 💝 Friendly                ║
    ║                                                           ║
    ║   📚  API Docs: http://localhost:8000/docs               ║
    ║                                                           ║
    ║   🌍  Supporting 23 Indian Languages                     ║
    ║                                                           ║
    ║   🧠  1M Token Context Window                            ║
    ║                                                           ║
    ║   🔒  100% Private & Secure                              ║
    ║                                                           ║
    ╚═══════════════════════════════════════════════════════════╝
    """)
    uvicorn.run(app, host="0.0.0.0", port=8000)

# 🎥 VIDEO AI ENDPOINTS

from model.video_ai import VideoAnalyzer, CameraProcessor

# 🎬 Initialize video AI
video_analyzer = VideoAnalyzer()
camera_processor = CameraProcessor()

class VideoRequest(BaseModel):
    """🎥 Video processing request"""
    video_path: str
    operation: str = "analyze"  # analyze, enhance, stabilize, remove_objects, extract_info

class RealTimeVideoRequest(BaseModel):
    """📺 Real-time video request"""
    source: int = 0  # 0 for camera, other for screen
    duration: int = 30  # seconds

# 🎬 Video Analysis endpoint
@app.post("/video/analyze")
async def analyze_video(request: VideoRequest):
    """🎬 Analyze video content with AI"""
    try:
        result = video_analyzer.analyze_video_content(request.video_path)
        return {
            "status": "✅ success",
            "analysis": result,
            "emoji": "🎬",
            "message": "🎬 Video analysis complete!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Video analysis failed: {str(e)}")

# 🎨 Video Enhancement endpoint
@app.post("/video/enhance")
async def enhance_video(request: VideoRequest):
    """🎯 Enhance video quality"""
    try:
        output_path = f"enhanced_{request.video_path.split('/')[-1]}"
        result = video_analyzer.enhance_video_quality(request.video_path, output_path)
        return {
            "status": "✅ success",
            "output_file": output_path,
            "enhancements": result["enhancements"],
            "emoji": "🎯",
            "message": "🎯 Video enhanced successfully!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Video enhancement failed: {str(e)}")

# 📺 Video Stabilization endpoint
@app.post("/video/stabilize")
async def stabilize_video(request: VideoRequest):
    """📺 Stabilize shaky video"""
    try:
        output_path = f"stabilized_{request.video_path.split('/')[-1]}"
        result = video_analyzer.stabilize_video(request.video_path, output_path)
        return {
            "status": "✅ success",
            "output_file": output_path,
            "stabilization_level": result["stabilization_level"],
            "emoji": "📺",
            "message": "📺 Video stabilized successfully!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Video stabilization failed: {str(e)}")

# 🎨 Object Removal endpoint
@app.post("/video/remove-objects")
async def remove_objects(request: VideoRequest):
    """🎨 Remove objects from video"""
    try:
        output_path = f"cleaned_{request.video_path.split('/')[-1]}"
        result = video_analyzer.remove_objects(request.video_path, output_path)
        return {
            "status": "✅ success",
            "output_file": output_path,
            "frames_processed": result["frames_processed"],
            "emoji": "🎨",
            "message": "🎨 Objects removed successfully!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Object removal failed: {str(e)}")

# 📊 Information Extraction endpoint
@app.post("/video/extract-info")
async def extract_video_info(request: VideoRequest):
    """📊 Extract information from video"""
    try:
        result = video_analyzer.extract_information(request.video_path)
        return {
            "status": "✅ success",
            "extracted_info": result,
            "emoji": "📊",
            "message": "📊 Information extracted successfully!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Information extraction failed: {str(e)}")

# 📺 Real-time Video Analysis endpoint
@app.post("/video/realtime")
async def real_time_video(request: RealTimeVideoRequest):
    """📺 Real-time video analysis from camera or screen"""
    try:
        result = video_analyzer.real_time_analysis(source=request.source)
        return {
            "status": "✅ success",
            "frames_analyzed": result["frames_analyzed"],
            "analysis_results": result["analysis_results"][:10],  # Last 10 results
            "emoji": "📺",
            "message": "📺 Real-time analysis complete!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Real-time analysis failed: {str(e)}")

# 📷 Camera Processing endpoint
@app.post("/camera/process")
async def process_camera():
    """📷 Process camera frame for visual recognition"""
    try:
        # Capture frame from camera
        import cv2
        cap = cv2.VideoCapture(0)
        ret, frame = cap.read()
        cap.release()
        
        if not ret:
            raise HTTPException(status_code=500, detail="❌ Cannot capture from camera")
        
        # Process frame
        result = camera_processor.process_camera_frame(frame)
        recognition = camera_processor.recognize_visual_elements(frame)
        
        return {
            "status": "✅ success",
            "frame_analysis": result,
            "visual_recognition": recognition,
            "emoji": "📷",
            "message": "📷 Camera frame processed successfully!"
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Camera processing failed: {str(e)}")

# 🎥 Video Features Summary endpoint
@app.get("/video/features")
async def get_video_features():
    """🎥 Get all video AI features"""
    features = {
        "video_analysis": {
            "emoji": "🎬",
            "description": "Understand and analyze video content",
            "capabilities": [
                "Scene detection",
                "Object recognition",
                "Motion analysis",
                "Quality assessment",
                "Content classification"
            ]
        },
        "video_enhancement": {
            "emoji": "🎯",
            "description": "Enhance video quality",
            "capabilities": [
                "Brightness adjustment",
                "Color correction",
                "Sharpening",
                "Contrast enhancement",
                "Noise reduction"
            ]
        },
        "video_stabilization": {
            "emoji": "📺",
            "description": "Stabilize shaky video",
            "capabilities": [
                "Motion compensation",
                "Frame alignment",
                "Smooth transitions",
                "Jitter removal",
                "Professional stabilization"
            ]
        },
        "object_removal": {
            "emoji": "🎨",
            "description": "Remove unwanted objects",
            "capabilities": [
                "Object detection",
                "Smart inpainting",
                "Background reconstruction",
                "Seamless removal",
                "Batch processing"
            ]
        },
        "information_extraction": {
            "emoji": "📊",
            "description": "Extract information from video",
            "capabilities": [
                "Text recognition (OCR)",
                "Data extraction",
                "Pattern detection",
                "Key moment identification",
                "Metadata analysis"
            ]
        },
        "real_time_analysis": {
            "emoji": "📺",
            "description": "Real-time video processing",
            "capabilities": [
                "Live camera feed",
                "Screen share analysis",
                "Instant object detection",
                "Real-time classification",
                "Live streaming support"
            ]
        },
        "camera_processing": {
            "emoji": "📷",
            "description": "Camera and visual recognition",
            "capabilities": [
                "Face detection",
                "Object recognition",
                "Scene classification",
                "Visual element detection",
                "Real-time processing"
            ]
        }
    }
    
    return {
        "features": features,
        "total_features": len(features),
        "emoji": "🎥",
        "message": "🎥 Complete video AI suite available!"
    }

# 💻 CODING AI ENDPOINTS

from model.coding_ai import CodingAI

# 🧑‍💻 Initialize coding AI
coding_ai = CodingAI()

class CodingRequest(BaseModel):
    """💻 Coding request"""
    code: str
    language: str = "python"
    operation: str = "debug"  # debug, refactor, analyze, generate
    task: str = ""

class CodebaseRequest(BaseModel):
    """🏗️ Codebase analysis request"""
    project_path: str

class AutonomousRequest(BaseModel):
    """🤖 Autonomous task request"""
    task: str
    project_path: str = ""

# 💻 Code analysis endpoint
@app.post("/coding/analyze")
async def analyze_code(request: CodingRequest):
    """💻 Analyze and debug code"""
    try:
        if request.operation == "debug":
            result = coding_ai.debug_code(request.code, request.task)
        elif request.operation == "refactor":
            result = coding_ai.refactor_code(request.code, request.language, request.task)
        elif request.operation == "generate":
            result = coding_ai.generate_code(request.task, request.language)
        else:
            result = {"status": "❌ unknown operation"}
        
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 🏗️ Codebase analysis endpoint
@app.post("/coding/codebase")
async def analyze_codebase(request: CodebaseRequest):
    """🏗️ Analyze entire codebase"""
    try:
        result = coding_ai.analyze_codebase(request.project_path)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 🤖 Autonomous coding endpoint
@app.post("/coding/autonomous")
async def autonomous_coding(request: AutonomousRequest):
    """🤖 Execute autonomous coding task"""
    try:
        result = coding_ai.autonomous_task(request.task, request.project_path)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 🖼️ VISION AI ENDPOINTS

from model.vision_ai import VisionAI

# 🎨 Initialize vision AI
vision_ai = VisionAI()

class ImageGenerationRequest(BaseModel):
    """🎨 Image generation request"""
    prompt: str
    style: str = "realistic"
    size: List[int] = [512, 512]

class ImageAnalysisRequest(BaseModel):
    """👁️ Image analysis request"""
    image_data: str

class ImageProcessingRequest(BaseModel):
    """🔧 Image processing request"""
    image_data: str
    operation: str = "enhance"  # enhance, resize, grayscale, blur, sharpen, edge_detect

# 🎨 Image generation endpoint
@app.post("/vision/generate")
async def generate_image(request: ImageGenerationRequest):
    """🎨 Generate image from text"""
    try:
        result = vision_ai.generate_image(
            request.prompt,
            request.style,
            tuple(request.size)
        )
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 👁️ Image analysis endpoint
@app.post("/vision/analyze")
async def analyze_image(request: ImageAnalysisRequest):
    """👁️ Analyze image content"""
    try:
        result = vision_ai.analyze_image(request.image_data)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 🔧 Image processing endpoint
@app.post("/vision/process")
async def process_image(request: ImageProcessingRequest):
    """🔧 Process image"""
    try:
        result = vision_ai.process_image(request.image_data, request.operation)
        return result
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"❌ Error: {str(e)}")

# 🎯 ALL CAPABILITIES ENDPOINT

@app.get("/capabilities")
async def get_all_capabilities():
    """🎯 Get all EKALAVYA capabilities"""
    return {
        "name": "🎯 EKALAVYA",
        "version": "📦 3.0",
        "status": "✅ Most Powerful AI",
        "capabilities": {
            "💻 Coding": {
                "emoji": "💻",
                "features": [
                    "🏗️ Large project understanding",
                    "🔧 Code refactoring",
                    "🐛 Debugging & bug fixing",
                    "💻 Code generation",
                    "🤖 Autonomous coding agent",
                    "🧪 Test generation",
                    "📚 Documentation"
                ],
                "better_than": "Claude, ChatGPT"
            },
            "🖼️ Image": {
                "emoji": "🖼️",
                "features": [
                    "🎨 Image generation",
                    "👁️ Image analysis",
                    "🔧 Image processing",
                    "📊 Visual understanding",
                    "🎨 Style transfer"
                ],
                "better_than": "Gemini, ChatGPT"
            },
            "🎥 Video": {
                "emoji": "🎥",
                "features": [
                    "🎬 Video analysis",
                    "🎯 Video enhancement",
                    "📺 Video stabilization",
                    "🎨 Object removal",
                    "📊 Information extraction",
                    "📺 Real-time analysis",
                    "📷 Camera processing"
                ],
                "better_than": "Gemini, Samsung, iPhone"
            },
            "🎓 Teaching": {
                "emoji": "🎓",
                "features": [
                    "🔍 Mistake detection",
                    "✅ Instant corrections",
                    "📚 Detailed explanations",
                    "💪 Encouragement",
                    "🎯 Personalized learning"
                ],
                "better_than": "All others"
            },
            "🧠 Memory": {
                "emoji": "🧠",
                "features": [
                    "📊 Progress tracking",
                    "📈 Improvement monitoring",
                    "🎯 Weak area identification",
                    "💬 Conversation memory",
                    "🔍 Pattern analysis"
                ],
                "better_than": "Claude, ChatGPT, Gemini"
            },
            "💝 Styles": {
                "emoji": "💝",
                "features": [
                    "👫 Friend style",
                    "👨‍🏫 Teacher style",
                    "💕 Lover style",
                    "🎓 Mentor style"
                ],
                "better_than": "All others (unique)"
            },
            "🌍 Languages": {
                "emoji": "🌍",
                "features": [
                    "🇮🇳 23 Indian languages",
                    "🇬🇧 English",
                    "🔤 Multi-lingual support"
                ],
                "better_than": "All others"
            },
            "🛡️ Safety": {
                "emoji": "🛡️",
                "features": [
                    "🛡️ Scam detection",
                    "💻 Hacking prevention",
                    "🔒 Privacy protection",
                    "✅ Ethical guidelines",
                    "📋 Privacy policy"
                ],
                "better_than": "All others"
            },
            "🧠 Reasoning": {
                "emoji": "🧠",
                "features": [
                    "💭 Deep reasoning",
                    "🔍 Step-by-step analysis",
                    "🎯 Problem solving",
                    "📊 Complex tasks"
                ],
                "better_than": "ChatGPT"
            },
            "✍️ Writing": {
                "emoji": "✍️",
                "features": [
                    "📝 Creative writing",
                    "📚 Technical writing",
                    "🎯 Precise editing",
                    "💡 Style adaptation"
                ],
                "better_than": "Claude"
            }
        },
        "emoji": "🏆",
        "message": "🏆 EKALAVYA - The Most Powerful AI Assistant!"
    }