Update app.py

app.py

@@ -1,155 +1,411 @@
 """
-Test script for Event Tags Generator API
+Event Tags Generator - AI Chatbot for automatic tag generation
+Generates relevant tags, keywords, and categories from event information
 """
 
-import requests
-import json
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+import os
+from huggingface_hub import InferenceClient
 import uvicorn
+# Initialize FastAPI
+app = FastAPI(
+    title="Event Tags Generator API",
+    description="AI-powered automatic tag generation for events using LLM",
+    version="1.0.0"
+)
 
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-def test_generate_tags():
-    """Test single event tag generation"""
+# Hugging Face token
+hf_token = os.getenv("HUGGINGFACE_TOKEN")
+if hf_token:
+    print("✓ Hugging Face token configured")
+else:
+    print("⚠ Warning: No HUGGINGFACE_TOKEN found. Set it in environment variable.")
+
+
+# Pydantic models
+class EventTagsRequest(BaseModel):
+    event_name: str
+    category: str
+    short_description: str
+    detailed_description: str
+    max_tags: Optional[int] = 10
+    language: Optional[str] = "vi"  # vi = Vietnamese, en = English
+    hf_token: Optional[str] = None
+
+
+class EventTagsResponse(BaseModel):
+    event_name: str
+    generated_tags: List[str]
+    primary_category: str
+    secondary_categories: List[str]
+    keywords: List[str]
+    hashtags: List[str]
+    target_audience: List[str]
+    sentiment: str
+    confidence_score: float
+    generation_time: str
+    model_used: str
+
+
+@app.get("/")
+async def root():
+    """API Information"""
+    return {
+        "status": "running",
+        "service": "Event Tags Generator API",
+        "version": "1.0.0",
+        "description": "Generate tags, keywords, categories automatically from event info",
+        "endpoints": {
+            "POST /generate-tags": {
+                "description": "Generate tags from event information",
+                "request_body": {
+                    "event_name": "string - Tên sự kiện",
+                    "category": "string - Danh mục (âm nhạc, thể thao, công nghệ...)",
+                    "short_description": "string - Mô tả ngắn (1-2 câu)",
+                    "detailed_description": "string - Mô tả chi tiết",
+                    "max_tags": "integer (optional, default: 10) - Số lượng tags tối đa",
+                    "language": "string (optional, default: 'vi') - Ngôn ngữ output",
+                    "hf_token": "string (optional) - Hugging Face token"
+                },
+                "response": {
+                    "generated_tags": "array - Danh sách tags",
+                    "primary_category": "string - Danh mục chính",
+                    "secondary_categories": "array - Danh mục phụ",
+                    "keywords": "array - Keywords SEO",
+                    "hashtags": "array - Social media hashtags",
+                    "target_audience": "array - Đối tượng mục tiêu",
+                    "sentiment": "string - Cảm xúc (positive/neutral/negative)",
+                    "confidence_score": "float - Độ tin cậy (0-1)"
+                },
+                "example": {
+                    "request": {
+                        "event_name": "Vietnam Music Festival 2025",
+                        "category": "Âm nhạc",
+                        "short_description": "Lễ hội âm nhạc quốc tế lớn nhất Việt Nam",
+                        "detailed_description": "Sự kiện quy tụ các nghệ sĩ nổi tiếng trong nước và quốc tế..."
+                    },
+                    "response": {
+                        "generated_tags": ["âm nhạc", "festival", "concert", "việt nam", "quốc tế"],
+                        "hashtags": ["#VietnamMusicFest", "#MusicFestival2025", "#LiveMusic"]
+                    }
+                }
+            }
+        },
+        "usage": "POST /generate-tags with event information in JSON body"
+    }
+
+
+def build_powerful_prompt(
+    event_name: str,
+    category: str,
+    short_desc: str,
+    detailed_desc: str,
+    max_tags: int,
+    language: str
+) -> str:
+    """
+    Build a powerful, structured prompt for LLM to generate high-quality tags
+    """
     
-    print("=" * 60)
-    print("Testing Event Tags Generator")
-    print("=" * 60)
+    lang_instruction = "in Vietnamese" if language == "vi" else "in English"
     
-    # Test data
-    event_data = {
-        "event_name": "Vietnam Music Festival 2025",
-        "category": "Âm nhạc",
-        "short_description": "Lễ hội âm nhạc quốc tế lớn nhất Việt Nam năm 2025",
-        "detailed_description": """
-        Vietnam Music Festival 2025 là sự kiện âm nhạc đỉnh cao quy tụ các nghệ sĩ 
-        nổi tiếng trong nước và quốc tế. Sự kiện diễn ra trong 3 ngày với hơn 50 
-        nghệ sĩ tham gia, từ nhạc pop, rock, EDM đến acoustic. Đặc biệt có sự góp 
-        mặt của các DJ hàng đầu thế giới. Không gian festival rộng 10,000m2 tại 
-        trung tâm Hà Nội với hệ thống âm thanh ánh sáng hiện đại. Dự kiến thu hút 
-        hơn 30,000 khán giả mỗi ngày.
-        """,
-        "max_tags": 12,
-        "language": "vi"
+    prompt = f"""You are an expert AI system specialized in event marketing, SEO, and content categorization. Your task is to analyze event information and generate comprehensive, relevant tags and metadata.
+**EVENT INFORMATION:**
+• Event Name: {event_name}
+• Primary Category: {category}
+• Short Description: {short_desc}
+• Detailed Description: {detailed_desc}
+**YOUR TASK:**
+Analyze the event information above and generate the following {lang_instruction}:
+1. **TAGS** ({max_tags} tags maximum):
+   - Generate specific, relevant, searchable tags
+   - Include event type, theme, activities, location references
+   - Mix broad and specific tags for better discoverability
+   - Use lowercase, single words or short phrases
+   - Example format: âm nhạc, festival, concert, outdoor, hà nội
+2. **PRIMARY CATEGORY** (1 category):
+   - The main category that best describes this event
+   - Choose from: Âm nhạc, Thể thao, Công nghệ, Nghệ thuật, Ẩm thực, Giáo dục, Kinh doanh, Du lịch, Giải trí, Khác
+3. **SECONDARY CATEGORIES** (2-3 categories):
+   - Additional relevant categories
+   - Help with cross-categorization
+4. **KEYWORDS** (5-8 keywords):
+   - SEO-optimized keywords for search engines
+   - Include long-tail keywords
+   - Example: "lễ hội âm nhạc hà nội", "concert quốc tế việt nam"
+5. **HASHTAGS** (5-7 hashtags):
+   - Social media friendly hashtags
+   - Mix of popular and unique hashtags
+   - Example: #VietnamMusicFest, #LiveMusic, #HanoiEvents
+6. **TARGET AUDIENCE** (2-4 audience groups):
+   - Who would be interested in this event?
+   - Example: Giới trẻ, Gia đình, Dân văn phòng, Sinh viên
+7. **SENTIMENT** (one word):
+   - Overall emotion/feeling: positive, neutral, or negative
+   - Based on event description tone
+**OUTPUT FORMAT (JSON-like structure):**
+TAGS: tag1, tag2, tag3, ...
+PRIMARY_CATEGORY: category_name
+SECONDARY_CATEGORIES: cat1, cat2, cat3
+KEYWORDS: keyword1, keyword2, keyword3, ...
+HASHTAGS: #tag1, #tag2, #tag3, ...
+TARGET_AUDIENCE: audience1, audience2, audience3
+SENTIMENT: positive/neutral/negative
+**IMPORTANT GUIDELINES:**
+- Be specific and relevant to the event
+- Use terms people would actually search for
+- Balance between popular and niche terms
+- Consider SEO and social media best practices
+- Keep tags concise and meaningful
+- Generate output {lang_instruction}
+Now, analyze the event and generate the metadata:"""
+
+    return prompt
+
+
+def parse_llm_response(response_text: str, max_tags: int) -> dict:
+    """
+    Parse LLM response into structured format
+    Handles various response formats robustly
+    """
+    
+    result = {
+        "generated_tags": [],
+        "primary_category": "",
+        "secondary_categories": [],
+        "keywords": [],
+        "hashtags": [],
+        "target_audience": [],
+        "sentiment": "neutral"
     }
     
-    print("\n📤 REQUEST:")
-    print(json.dumps(event_data, indent=2, ensure_ascii=False))
+    lines = response_text.strip().split('\n')
     
-    try:
-        # Call API
-        response = requests.post(
-            f"{BASE_URL}/generate-tags",
-            json=event_data,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        if response.status_code == 200:
-            result = response.json()
-            
-            print("\n✅ SUCCESS!")
-            print("\n📥 RESPONSE:")
-            print(json.dumps(result, indent=2, ensure_ascii=False))
-            
-            print("\n" + "=" * 60)
-            print("GENERATED METADATA:")
-            print("=" * 60)
-            
-            print(f"\n🏷️  TAGS ({len(result['generated_tags'])} tags):")
-            for tag in result['generated_tags']:
-                print(f"   • {tag}")
-            
-            print(f"\n📁 PRIMARY CATEGORY: {result['primary_category']}")
-            
-            if result['secondary_categories']:
-                print(f"\n📂 SECONDARY CATEGORIES:")
-                for cat in result['secondary_categories']:
-                    print(f"   • {cat}")
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
             
-            if result['keywords']:
-                print(f"\n🔍 SEO KEYWORDS:")
-                for kw in result['keywords']:
-                    print(f"   • {kw}")
-            
-            if result['hashtags']:
-                print(f"\n#️⃣  HASHTAGS:")
-                for ht in result['hashtags']:
-                    print(f"   • {ht}")
-            
-            if result['target_audience']:
-                print(f"\n👥 TARGET AUDIENCE:")
-                for aud in result['target_audience']:
-                    print(f"   • {aud}")
-            
-            print(f"\n😊 SENTIMENT: {result['sentiment']}")
-            print(f"💯 CONFIDENCE: {result['confidence_score']}")
-            print(f"⏱️  GENERATION TIME: {result['generation_time']}")
-            print(f"🤖 MODEL USED: {result['model_used']}")
-            
-        else:
-            print(f"\n❌ ERROR: {response.status_code}")
-            print(response.text)
-            
-    except requests.exceptions.ConnectionError:
-        print("\n❌ ERROR: Cannot connect to API")
-        print("Make sure the server is running: python event_tags_generator.py")
-    except Exception as e:
-        print(f"\n❌ ERROR: {str(e)}")
+        # Parse TAGS
+        if line.upper().startswith('TAGS:'):
+            tags_text = line.split(':', 1)[1].strip()
+            tags = [t.strip().lower() for t in tags_text.split(',') if t.strip()]
+            result["generated_tags"] = tags[:max_tags]
+        
+        # Parse PRIMARY_CATEGORY
+        elif line.upper().startswith('PRIMARY_CATEGORY:'):
+            result["primary_category"] = line.split(':', 1)[1].strip()
+        
+        # Parse SECONDARY_CATEGORIES
+        elif line.upper().startswith('SECONDARY_CATEGORIES:'):
+            cats_text = line.split(':', 1)[1].strip()
+            result["secondary_categories"] = [c.strip() for c in cats_text.split(',') if c.strip()]
+        
+        # Parse KEYWORDS
+        elif line.upper().startswith('KEYWORDS:'):
+            kw_text = line.split(':', 1)[1].strip()
+            result["keywords"] = [k.strip() for k in kw_text.split(',') if k.strip()]
+        
+        # Parse HASHTAGS
+        elif line.upper().startswith('HASHTAGS:'):
+            ht_text = line.split(':', 1)[1].strip()
+            hashtags = [h.strip() for h in ht_text.split(',') if h.strip()]
+            # Ensure hashtags start with #
+            result["hashtags"] = [h if h.startswith('#') else f"#{h}" for h in hashtags]
+        
+        # Parse TARGET_AUDIENCE
+        elif line.upper().startswith('TARGET_AUDIENCE:'):
+            aud_text = line.split(':', 1)[1].strip()
+            result["target_audience"] = [a.strip() for a in aud_text.split(',') if a.strip()]
+        
+        # Parse SENTIMENT
+        elif line.upper().startswith('SENTIMENT:'):
+            sentiment = line.split(':', 1)[1].strip().lower()
+            if sentiment in ['positive', 'neutral', 'negative']:
+                result["sentiment"] = sentiment
+    
+    return result
 
 
-def test_batch_generation():
-    """Test batch event tag generation"""
+@app.post("/generate-tags", response_model=EventTagsResponse)
+async def generate_tags(request: EventTagsRequest):
+    """
+    Generate comprehensive tags and metadata for an event
     
-    print("\n\n" + "=" * 60)
-    print("Testing Batch Tag Generation")
-    print("=" * 60)
+    This endpoint uses advanced LLM prompting to generate:
+    - Relevant tags for searchability
+    - Category classification
+    - SEO keywords
+    - Social media hashtags
+    - Target audience identification
+    - Sentiment analysis
     
-    events = [
-        {
-            "event_name": "Tech Summit Vietnam 2025",
-            "category": "Công nghệ",
-            "short_description": "Hội nghị công nghệ lớn nhất Đông Nam Á",
-            "detailed_description": "Sự kiện quy tụ các chuyên gia AI, Blockchain, Cloud Computing từ Google, Microsoft, Amazon...",
-            "max_tags": 10,
-            "language": "vi"
-        },
-        {
-            "event_name": "Food Festival Saigon",
-            "category": "Ẩm thực",
-            "short_description": "Lễ hội ẩm thực đường phố Sài Gòn",
-            "detailed_description": "Khám phá hơn 100 món ăn đường phố đặc trưng của Sài Gòn với các đầu bếp nổi tiếng...",
-            "max_tags": 8,
-            "language": "vi"
-        }
-    ]
+    **Input:**
+    - event_name: Name of the event
+    - category: Primary category (music, sports, tech, etc.)
+    - short_description: Brief 1-2 sentence description
+    - detailed_description: Full event description with details
     
-    print(f"\n📤 Generating tags for {len(events)} events...")
+    **Output:**
+    - Structured metadata ready for use in event management system
+    - All fields optimized for search and discovery
+    """
     
     try:
-        response = requests.post(
-            f"{BASE_URL}/generate-tags/batch",
-            json=events,
-            headers={"Content-Type": "application/json"}
+        start_time = datetime.utcnow()
+        
+        # Get token
+        token = request.hf_token or hf_token
+        
+        if not token:
+            raise HTTPException(
+                status_code=401,
+                detail="HUGGINGFACE_TOKEN required. Set environment variable or pass in request body."
+            )
+        
+        # Build powerful prompt
+        prompt = build_powerful_prompt(
+            event_name=request.event_name,
+            category=request.category,
+            short_desc=request.short_description,
+            detailed_desc=request.detailed_description,
+            max_tags=request.max_tags,
+            language=request.language
         )
         
-        if response.status_code == 200:
-            result = response.json()
-            print(f"\n✅ Batch completed!")
-            print(f"   Total: {result['total']}")
-            print(f"   Successful: {result['successful']}")
-            print(f"   Failed: {result['failed']}")
-            
-            for item in result['results']:
-                if item['success']:
-                    print(f"\n✓ {item['event_name']}")
-                    print(f"   Tags: {', '.join(item['data']['generated_tags'][:5])}...")
-                else:
-                    print(f"\n✗ {item['event_name']}")
-                    print(f"   Error: {item['error']}")
-        else:
-            print(f"\n❌ ERROR: {response.status_code}")
-            print(response.text)
-            
+        # Initialize HF client
+        client = InferenceClient(token=token)
+        
+        # Try multiple models for best results
+        models_to_try = [
+            "microsoft/Phi-3-mini-4k-instruct",
+            "mistralai/Mistral-7B-Instruct-v0.3",
+            "HuggingFaceH4/zephyr-7b-beta",
+            "meta-llama/Llama-3.2-3B-Instruct"
+        ]
+        
+        llm_response = ""
+        model_used = ""
+        last_error = None
+        
+        for model_name in models_to_try:
+            try:
+                print(f"Trying model: {model_name}")
+                
+                # Generate with LLM
+                llm_response = client.text_generation(
+                    prompt,
+                    model=model_name,
+                    max_new_tokens=800,
+                    temperature=0.7,
+                    top_p=0.9,
+                    do_sample=True,
+                    return_full_text=False
+                )
+                
+                if llm_response and len(llm_response.strip()) > 50:
+                    model_used = model_name
+                    print(f"✓ Success with {model_name}")
+                    break
+                    
+            except Exception as model_error:
+                print(f"✗ Failed with {model_name}: {str(model_error)}")
+                last_error = model_error
+                continue
+        
+        # Check if generation succeeded
+        if not llm_response or len(llm_response.strip()) < 50:
+            raise HTTPException(
+                status_code=500,
+                detail=f"All models failed. Last error: {str(last_error)}\n\nPlease check:\n1. Token has correct permissions\n2. Token is valid and not expired\n3. Try regenerating token"
+            )
+        
+        # Parse LLM response into structured format
+        parsed_result = parse_llm_response(llm_response, request.max_tags)
+        
+        # Calculate confidence score (basic heuristic)
+        confidence = 0.0
+        if parsed_result["generated_tags"]:
+            confidence += 0.3
+        if parsed_result["primary_category"]:
+            confidence += 0.2
+        if parsed_result["keywords"]:
+            confidence += 0.2
+        if parsed_result["hashtags"]:
+            confidence += 0.15
+        if parsed_result["target_audience"]:
+            confidence += 0.15
+        
+        end_time = datetime.utcnow()
+        generation_time = (end_time - start_time).total_seconds()
+        
+        # Build response
+        return EventTagsResponse(
+            event_name=request.event_name,
+            generated_tags=parsed_result["generated_tags"],
+            primary_category=parsed_result["primary_category"],
+            secondary_categories=parsed_result["secondary_categories"],
+            keywords=parsed_result["keywords"],
+            hashtags=parsed_result["hashtags"],
+            target_audience=parsed_result["target_audience"],
+            sentiment=parsed_result["sentiment"],
+            confidence_score=round(confidence, 2),
+            generation_time=f"{generation_time:.2f}s",
+            model_used=model_used.split('/')[-1] if model_used else "unknown"
+        )
+        
+    except HTTPException:
+        raise
     except Exception as e:
-        print(f"\n❌ ERROR: {str(e)}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Error generating tags: {str(e)}"
+        )
+
+
+@app.post("/generate-tags/batch")
+async def generate_tags_batch(events: List[EventTagsRequest]):
+    """
+    Batch generate tags for multiple events
+    
+    Useful for bulk processing or migrating existing events
+    """
+    results = []
+    
+    for event in events:
+        try:
+            result = await generate_tags(event)
+            results.append({
+                "event_name": event.event_name,
+                "success": True,
+                "data": result
+            })
+        except Exception as e:
+            results.append({
+                "event_name": event.event_name,
+                "success": False,
+                "error": str(e)
+            })
+    
+    return {
+        "total": len(events),
+        "successful": sum(1 for r in results if r["success"]),
+        "failed": sum(1 for r in results if not r["success"]),
+        "results": results
+    }