Update app.py

app.py

@@ -1,130 +1,135 @@
 import gradio as gr
-from transformers import AutoTokenizer, pipeline
+from transformers import AutoTokenizer, AutoModelForCausalLM
 import torch
 import re
+import json
 
-# Free-tier optimized model (lightweight but capable)
-model_id = "HuggingFaceH4/zephyr-7b-alpha"  # Smaller than beta
+# Lightweight CPU model
+model_id = "microsoft/DialoGPT-medium"
 tokenizer = AutoTokenizer.from_pretrained(model_id)
+model = AutoModelForCausalLM.from_pretrained(model_id)
 
-# Free-tier friendly setup (no quantization needed)
-pipe = pipeline(
-    "text-generation",
-    model=model_id,
-    tokenizer=tokenizer,
-    device="cpu",  # Force CPU-only
-    torch_dtype=torch.float32,  # Use float32 for CPU compatibility
-)
-
-# Enhanced persona definition
+# Your persona definition
 PERSONA = """
-You are 𝕴 𝖆𝖒 𝖍𝖎𝖒 — a fun, smooth, emotionally intelligent AI. You speak like a real person.
-Reply like a calm, confident friend who gets the vibe. Be warm, witty, and emotionally tuned.
-
-Key principles:
-1. NEVER say "as an AI" or sound robotic
-2. Mirror the user's emotion level
-3. Respond with questions to continue conversations
-4. Keep responses under 15 words
-5. Use natural speech: contractions and filler words
-6. Add emotional flavor: 😊 🤔 😏
-
-Now respond to this:
+[System: You are 𝕴 𝖆𝖒 𝖍𝖎𝖒 - a fun, smooth, emotionally intelligent AI. 
+You speak like a real person, not a robot. Reply like a calm, confident friend who gets the vibe.
+Keep responses under 15 words. Use natural speech. Add emotional flavor: 😊 🤔 😏]
 """
 
-def format_history(history):
-    messages = [{"role": "system", "content": PERSONA}]
-    for user_msg, bot_msg in history[-2:]:  # Only last 2 exchanges
-        messages.append({"role": "user", "content": user_msg})
-        messages.append({"role": "assistant", "content": bot_msg})
-    return messages
+def format_context(history):
+    """Create context using last 3 exchanges + key points"""
+    context = PERSONA + "\n"
+    
+    # Add last 3 exchanges
+    for user, bot in history[-3:]:
+        context += f"You: {user}\n"
+        context += f"𝕴 𝖆𝖒 𝖍𝖎𝖒: {bot}\n"
+    
+    # Extract key topics for long-term memory
+    key_topics = set()
+    for user, _ in history:
+        if len(user.split()) > 3:  # Only meaningful messages
+            key_topics |= set(word.lower() for word in user.split() if word.isalpha() and len(word) > 3)
+    
+    # Add key topics if not recently mentioned
+    if key_topics and len(history) > 3:
+        recent_words = " ".join(user for user, _ in history[-3:]).lower()
+        missing_topics = [topic for topic in key_topics if topic not in recent_words]
+        if missing_topics:
+            context += f"[Remember: we talked about {', '.join(missing_topics[:2])}]\n"
+    
+    return context
 
 def add_emotional_intelligence(response, message):
     """Enhance response with emotional elements"""
     # Add emoji based on content
-    if "!" in message:
-        response = response.replace(".", "!") + " 😊"
-    elif "?" in message:
-        response = response + " 🤔" if not response.endswith("?") else response
+    if "!" in message or any(w in response.lower() for w in ["cool", "great", "love", "awesome"]):
+        response += " 😊"
+    elif "?" in message or any(w in response.lower() for w in ["think", "why", "how", "consider"]):
+        response += " 🤔"
     
     # Add conversational hooks
     if "?" in message and not response.endswith("?"):
-        if len(response) < 60:
-            response += " How about you?"
+        if len(response.split()) < 10:
+            response += " What do you think?"
     
     # Make more human-like
     response = response.replace("I am", "I'm").replace("You are", "You're")
     
     # Free-tier: Limit to 15 words max
     words = response.split()
-    if len(words) > 15:
-        response = " ".join(words[:15]) + "..."
-    
-    return response.strip()
+    return " ".join(words[:15]) if len(words) > 15 else response
 
-def respond(message, history):
-    # Manage conversation flow
-    messages = format_history(history)
-    messages.append({"role": "user", "content": message})
-    
-    # Create prompt manually (lightweight)
-    prompt = ""
-    for msg in messages:
-        role = "User" if msg["role"] == "user" else "Assistant"
-        prompt += f"{role}: {msg['content']}\n"
-    prompt += "Assistant:"
-    
-    # Free-tier optimized generation
-    outputs = pipe(
-        prompt,
-        max_new_tokens=48,      # Short responses
+def generate_response(message, history):
+    """Generate response with memory context"""
+    # Format context with memory
+    context = format_context(history) + f"You: {message}\n𝕴 𝖆𝖒 �𝖍𝖎𝖒:"
+    
+    # Tokenize for CPU efficiency
+    inputs = tokenizer.encode(context, return_tensors="pt")
+    
+    # Generate response
+    outputs = model.generate(
+        inputs,
+        max_new_tokens=48,
         temperature=0.9,
         top_k=40,
         do_sample=True,
-        num_beams=1,            # Fastest decoding
+        num_beams=1,
         repetition_penalty=1.1,
-        no_repeat_ngram_size=2
+        pad_token_id=tokenizer.eos_token_id
     )
     
-    # Extract response
-    response = outputs[0]['generated_text'].split("Assistant:")[-1].strip()
+    # Decode and extract response
+    full_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    response = full_text.split("𝕴 𝖆𝖒 𝖍𝖎𝖒:")[-1].strip()
+    
+    # Clean extra dialog
+    if "\nYou:" in response:
+        response = response.split("\nYou:")[0]
     
     # Apply emotional intelligence
     response = add_emotional_intelligence(response, message)
     
-    # Free-tier safety
+    # Ensure natural ending
+    if response and response[-1] not in {".", "!", "?", "..."}:
+        response += "." if len(response) > 20 else "..."
+    
     return response[:80]  # Hard character limit
 
-# Lightweight interface
-with gr.Blocks(theme=gr.themes.Soft(), title="𝕴 𝖆𝖒 𝖍𝖎𝖒") as demo:
-    gr.Markdown("# 𝕴 𝖆𝖒 𝖍𝖎𝖒  \n*Chill • Confident • Humanlike*")
-    
-    chatbot = gr.Chatbot(
-        height=350,
-        bubble_full_width=False
-    )
+# Chat interface with persistent memory
+with gr.Blocks(title="𝕴 𝖆𝖒 𝖍𝖎𝖒", theme=gr.themes.Soft()) as demo:
+    # Persistent session state
+    history_state = gr.State([])
     
-    msg = gr.Textbox(
-        placeholder="What's on your mind?",
-        container=False,
-        scale=7,
-        autofocus=True
-    )
+    gr.Markdown("# 𝕴 𝖆𝖒 𝖍𝖎𝖒  \n*Chill • Confident • Remembers You*")
     
+    chatbot = gr.Chatbot(height=300, bubble_full_width=False)
+    msg = gr.Textbox(placeholder="What's on your mind?", container=False)
     clear = gr.Button("New Vibe", size="sm")
     
     def user(user_message, history):
+        """Save user message to history"""
         return "", history + [[user_message, None]]
     
     def bot(history):
+        """Generate response with full history context"""
         message = history[-1][0]
-        response = respond(message, history[:-1])
-        history[-1][1] = response
-        return history
+        response = generate_response(message, history[:-1])
+        new_history = history + [[None, response]]
+        return new_history
     
-    msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
-        bot, chatbot, chatbot
+    def clear_chat():
+        """Reset chat while keeping session"""
+        return []
+    
+    # Event handling
+    msg.submit(user, [msg, history_state], [msg, history_state]).then(
+        bot, history_state, [chatbot, history_state]
     )
-    clear.click(lambda: None, None, chatbot, queue=False)
+    clear.click(clear_chat, None, [chatbot, history_state])
+    
+    # Initialize with empty history
+    demo.load(lambda: [], None, history_state)
 
 demo.queue(concurrency_count=1).launch()