Update app.py

app.py

@@ -1,183 +1,267 @@
 import streamlit as st
-from transformers import pipeline
-import pandas as pd
+import os
+from groq import Groq
 from typing import List, Dict
 import json
-import plotly.express as px
 from datetime import datetime
+import time
 
-# Initialize sentiment analysis pipeline
+# Initialize Groq client
 @st.cache_resource
-def load_model():
-    return pipeline("sentiment-analysis")
+def get_groq_client():
+    return Groq(api_key=st.secrets["groq_api_key"])
 
-class GraicieAnalyzer:
+class ContentAnalysisAgent:
     def __init__(self):
-        """Initialize the analyzer"""
-        self.sentiment_pipeline = load_model()
+        """Initialize the agent with Groq client"""
+        self.client = get_groq_client()
+        self.system_prompt = """You are an expert social media content analyzer with deep understanding of engagement, 
+        audience psychology, and content optimization. Analyze content step by step using a systematic approach."""
         
+    def _think(self, thought_process: str) -> None:
+        """Display agent's thinking process"""
+        with st.expander("🤔 Agent's Thought Process", expanded=False):
+            st.write(thought_process)
+    
+    def _get_llm_response(self, messages: List[Dict]) -> str:
+        """Get response from Groq LLM"""
+        try:
+            response = self.client.chat.completions.create(
+                messages=messages,
+                model="llama3-8b-8192",
+                temperature=0.7,
+                max_tokens=1024,
+            )
+            return response.choices[0].message.content
+        except Exception as e:
+            st.error(f"Error in LLM processing: {str(e)}")
+            return None
+
+    def _create_analysis_prompt(self, text: str) -> str:
+        """Create a detailed analysis prompt with agentic thinking"""
+        return f"""Let's analyze this social media post step by step:
+
+POST: {text}
+
+Think through the following aspects:
+
+1. CONTENT STRUCTURE ANALYSIS
+- Examine length, formatting, and organization
+- Identify key message components
+- Note special characters and emoji usage
+
+2. AUDIENCE PSYCHOLOGY
+- Who is the target audience?
+- What emotional triggers are present?
+- What call-to-actions exist?
+
+3. ENGAGEMENT POTENTIAL
+- Analyze hook effectiveness
+- Evaluate storytelling elements
+- Assess viral potential
+
+4. STYLE AND TONE
+- Determine primary content style
+- Identify emotional undertones
+- Evaluate brand voice consistency
+
+5. OPTIMIZATION OPPORTUNITIES
+- Identify areas for improvement
+- Suggest engagement boosters
+- Note potential risks or concerns
+
+Return a JSON structured response with:
+{
+    "style": "primary posting style",
+    "tones": ["list of detected tones"],
+    "rating": "1-5 rating for content appropriateness",
+    "engagement_score": "0-100 engagement potential",
+    "analysis": {
+        "strengths": ["list of strong points"],
+        "improvements": ["areas to enhance"],
+        "audience_fit": "target audience match score"
+    }
+}"""
+
     def analyze_post(self, post_text: str) -> Dict:
-        """Analyze a single post and return all metrics"""
-        # Get base sentiment
-        sentiment_result = self.sentiment_pipeline(post_text)[0]
+        """Perform comprehensive post analysis"""
+        # First thinking phase - Initial Assessment
+        self._think("🔍 Phase 1: Initial Assessment\nAnalyzing post structure and basic elements...")
+        
+        # Create conversation with system prompt and analysis request
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "user", "content": self._create_analysis_prompt(post_text)}
+        ]
         
-        # Determine style based on post characteristics
-        style = self._determine_style(post_text)
+        # Get initial analysis
+        with st.spinner("🤖 Analyzing content..."):
+            analysis_response = self._get_llm_response(messages)
+            
+        if not analysis_response:
+            return None
+            
+        # Parse JSON response
+        try:
+            analysis_result = json.loads(analysis_response)
+        except json.JSONDecodeError:
+            st.error("Error parsing LLM response")
+            return None
+            
+        # Second thinking phase - Refinement
+        self._think("🎯 Phase 2: Refinement\nRefining analysis and generating specific recommendations...")
         
-        # Determine tone based on content
-        tones = self._determine_tone(post_text, sentiment_result)
+        # Get specific recommendations
+        recommendation_prompt = f"""Based on the initial analysis of this post:
+        {post_text}
         
-        # Calculate rating
-        rating = self._calculate_rating(post_text)
+        Provide 3 specific, actionable recommendations to improve engagement."""
         
-        return {
-            "post": post_text,
-            "style": style,
-            "tones": tones,
-            "rating": rating,
-            "sentiment": sentiment_result["label"],
-            "confidence": f"{sentiment_result['score']:.2%}"
-        }
-    
-    def _determine_style(self, text: str) -> str:
-        """Determine post style based on characteristics"""
-        text_lower = text.lower()
+        messages.append({"role": "user", "content": recommendation_prompt})
+        recommendations = self._get_llm_response(messages)
         
-        if "!" in text or "?" in text or "😱" in text or "🤯" in text:
-            return "Hooking"
-        elif len(text.split()) <= 10:
-            return "Short & Sweet"
-        elif text.count('🏆') > 0 or text.count('📈') > 0:
-            return "Audience-focused"
-        elif text.count('😊') > 0 or "i feel" in text_lower or "just" in text_lower:
-            return "Authentic"
-        elif text.count('📸') > 0 or text.count('😍') > 0:
-            return "Visually appealing"
-        elif "?" in text or "what do you think" in text_lower:
-            return "Controversial"
-        else:
-            return "Storytelling"
+        if recommendations:
+            analysis_result["recommendations"] = recommendations
+            
+        return analysis_result
 
-    def _determine_tone(self, text: str, sentiment: Dict) -> List[str]:
-        """Determine post tone"""
-        tones = []
-        text_lower = text.lower()
+class GraicieApp:
+    def __init__(self):
+        self.agent = ContentAnalysisAgent()
         
-        if sentiment["label"] == "POSITIVE":
-            tones.append("Optimistic")
-        else:
-            tones.append("Pessimistic")
+    def display_header(self):
+        st.title("🤖 Project Graicie - Advanced Content Analyzer")
+        st.markdown("""
+        ### Powered by LLaMA 3 & Agentic AI
+        Get deep, AI-powered insights into your social media content using advanced language models.
+        """)
+    
+    def display_example_posts(self):
+        examples = {
+            "Viral Post": "🚀 HUGE ANNOUNCEMENT! After months of work, my online course is finally LIVE! 🎉\n"
+                         "Learn how I grew from 0 to 100K followers in 6 months! Early bird pricing ends tomorrow! 💫\n"
+                         "#socialmedia #digitalmarketing #success",
             
-        if "?" in text:
-            tones.append("Curious")
-        if "!" in text:
-            tones.append("Assertive")
-        if any(word in text_lower for word in ["learn", "guide", "how to", "tips"]):
-            tones.append("Informative")
-        if any(emoji in text for emoji in ["😂", "😆", "🤣"]):
-            tones.append("Entertaining")
+            "Personal Story": "Sometimes life throws you curveballs... Today I faced my biggest fear and went "
+                            "skydiving! 🪂 Swipe to see my reaction! Remember: growth happens outside your comfort zone 💕\n"
+                            "#personalgrowth #motivation",
             
-        return tones
-
-    def _calculate_rating(self, text: str) -> int:
-        """Calculate content rating"""
-        text_lower = text.lower()
-        # Simple rating system based on content markers
-        rating = 1  # Start with family-friendly
+            "Educational": "🧠 5 Python Tips You Didn't Know:\n1. List comprehensions\n2. f-strings\n3. Walrus operator\n"
+                          "4. Context managers\n5. Lambda functions\nSave this for later! 💡\n#coding #programming"
+        }
         
-        sensitive_words = ["damn", "hell", "stupid", "idiot"]
-        very_sensitive_words = ["fuck", "shit", "ass"]
-        adult_themes = ["drunk", "sex", "nsfw", "18+"]
+        st.subheader("📱 Try an Example Post")
+        selected_example = st.selectbox("Select an example post:", list(examples.keys()))
         
-        if any(word in text_lower for word in sensitive_words):
-            rating = max(rating, 2)
-        if any(word in text_lower for word in very_sensitive_words):
-            rating = max(rating, 4)
-        if any(word in text_lower for word in adult_themes):
-            rating = max(rating, 5)
-            
-        return rating
-
-def main():
-    # Set page config
-    st.set_page_config(
-        page_title="Project Graicie - Social Media Content Analyzer",
-        page_icon="📱",
-        layout="wide"
-    )
-    
-    # Title and description
-    st.title("🤖 Project Graicie")
-    st.markdown("""
-    ### AI-Powered Social Media Content Analysis
-    Analyze your social media content to understand its style, tone, and appropriateness. 
-    Get insights to improve your social media presence!
-    """)
+        if selected_example:
+            st.text_area("Example Post", examples[selected_example], height=100, disabled=True)
+            if st.button("Analyze Example", use_container_width=True):
+                self.analyze_and_display(examples[selected_example])
     
-    # Initialize analyzer
-    analyzer = GraicieAnalyzer()
+    def display_results(self, results: Dict):
+        if not results:
+            return
+            
+        # Display main metrics
+        col1, col2, col3, col4 = st.columns(4)
+        with col1:
+            st.metric("Style", results["style"])
+        with col2:
+            st.metric("Engagement Score", f"{results['engagement_score']}/100")
+        with col3:
+            st.metric("Content Rating", f"{results['rating']}/5")
+        with col4:
+            st.metric("Audience Fit", results["analysis"]["audience_fit"])
+            
+        # Display tones
+        st.subheader("📊 Content Tones")
+        for tone in results["tones"]:
+            st.markdown(f"<span style='background-color: #e6f3ff; padding: 5px 10px; "
+                      f"margin: 5px; border-radius: 15px;'>{tone}</span>", unsafe_allow_html=True)
+            
+        # Display strengths and improvements
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("💪 Strengths")
+            for strength in results["analysis"]["strengths"]:
+                st.markdown(f"✅ {strength}")
+                
+        with col2:
+            st.subheader("🎯 Areas to Improve")
+            for improvement in results["analysis"]["improvements"]:
+                st.markdown(f"📌 {improvement}")
+                
+        # Display recommendations
+        if "recommendations" in results:
+            st.subheader("🚀 Specific Recommendations")
+            st.markdown(results["recommendations"])
     
-    # Create columns for better layout
-    col1, col2 = st.columns([2, 1])
+    def analyze_and_display(self, text: str):
+        results = self.agent.analyze_post(text)
+        if results:
+            self.display_results(results)
     
-    with col1:
-        # Input area
-        st.subheader("📝 Content Analysis")
-        post_text = st.text_area(
-            "Enter your social media post here:",
-            height=150,
-            placeholder="Type or paste your post content here..."
-        )
+    def run(self):
+        self.display_header()
         
-        if st.button("🔍 Analyze Content", use_container_width=True):
-            if post_text:
-                with st.spinner("Analyzing your content..."):
-                    # Get analysis
-                    result = analyzer.analyze_post(post_text)
-                    
-                    # Display results in an organized way
-                    st.success("Analysis Complete!")
-                    
-                    # Create three columns for results
-                    res_col1, res_col2, res_col3 = st.columns(3)
-                    
-                    with res_col1:
-                        st.metric("Style", result["style"])
-                        
-                    with res_col2:
-                        st.metric("Sentiment", f"{result['sentiment']} ({result['confidence']})")
-                        
-                    with res_col3:
-                        st.metric("Content Rating", f"{result['rating']}/5")
-                    
-                    # Show tones
-                    st.subheader("📊 Detected Tones")
-                    tone_html = " ".join([f'<span style="background-color: #e6f3ff; padding: 5px 10px; margin: 5px; border-radius: 15px;">{tone}</span>' for tone in result["tones"]])
-                    st.markdown(f"<div style='margin-top: 10px;'>{tone_html}</div>", unsafe_allow_html=True)
+        # Main content area
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            self.display_example_posts()
+            
+            st.subheader("📝 Analyze Your Post")
+            user_post = st.text_area(
+                "Enter your post content:",
+                height=150,
+                placeholder="Type or paste your content here..."
+            )
+            
+            if st.button("🔍 Analyze My Post", use_container_width=True):
+                if user_post:
+                    self.analyze_and_display(user_post)
+                else:
+                    st.warning("Please enter some content to analyze!")
                     
-            else:
-                st.warning("Please enter some content to analyze!")
-    
-    with col2:
-        # Tips and information
-        st.subheader("💡 Tips")
-        st.info("""
-        **For better results:**
-        - Write naturally
-        - Include relevant emojis
-        - Add hashtags if relevant
-        - Keep your audience in mind
-        """)
+        with col2:
+            st.subheader("💡 Pro Tips")
+            st.info("""
+            **Content That Works:**
+            1. Tell authentic stories
+            2. Use relevant hashtags
+            3. Include call-to-actions
+            4. Add visual elements
+            5. Engage with questions
+            """)
+            
+            st.markdown("### 📊 Optimal Post Elements")
+            st.markdown("""
+            - Length: 80-150 characters
+            - Hashtags: 3-5 relevant tags
+            - Emojis: 2-3 key emojis
+            - CTA: One clear action
+            """)
         
-        # Rating guide
-        st.subheader("📋 Rating Guide")
-        st.markdown("""
-        1️⃣ Family-friendly  
-        2️⃣ Minor concerns  
-        3️⃣ Teen-appropriate  
-        4️⃣ Mature content  
-        5️⃣ Adult/Sensitive content
-        """)
+        # Footer
+        st.markdown(
+            """
+            <div style='position: fixed; bottom: 0; width: 100%; background-color: #f0f2f6; 
+            padding: 10px; text-align: center;'>
+                <p style='margin: 0; color: #666;'>
+                    Powered by LLaMA 3 & Groq | Made with ❤️ by Project Graicie Team | 
+                    © 2024 Project Graicie
+                </p>
+            </div>
+            """,
+            unsafe_allow_html=True
+        )
 
 if __name__ == "__main__":
-    main()
+    st.set_page_config(
+        page_title="Project Graicie - AI Content Analyzer",
+        page_icon="🤖",
+        layout="wide"
+    )
+    
+    app = GraicieApp()
+    app.run()