app.py

import gradio as gr
import requests
import os
import json
from typing import List, Dict
from datetime import datetime

# Groq API Configuration
API_URL = "https://api.groq.com/openai/v1/chat/completions"
API_KEY = os.getenv("GROQ_API_KEY")

print(f"🔑 API Key Found: {'Yes' if API_KEY else 'No'}")

# In-memory chat history storage
chat_history: List[Dict[str, str]] = []

def groq_with_memory(message: str, topic: str = "general", summarize: bool = False, max_history: int = 10) -> str:
    """Groq API call with chat history and optional summarization"""
    
    if not API_KEY:
        return "❌ No API Key found"
    
    if not message.strip():
        return "❌ Empty message"
    
    try:
        headers = {
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        }
        
        # Add current message to history with timestamp and topic
        chat_history.append({
            "role": "user",
            "content": message.strip(),
            "topic": topic,
            "timestamp": datetime.now().isoformat()
        })
        
        # Limit history to max_history messages
        recent_history = chat_history[-max_history:]
        
        # Prepare messages for API call
        messages = [{"role": msg["role"], "content": msg["content"]} for msg in recent_history]
        
        if summarize:
            summary_prompt = f"Summarize this conversation about '{topic}':\n\n"
            summary_prompt += "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_history])
            messages.append({"role": "user", "content": summary_prompt})
        
        payload = {
            "model": "llama-3.3-70b-versatile",
            "messages": messages,
            "max_tokens": 5000,
            "temperature": 0.7
        }
        
        response = requests.post(API_URL, headers=headers, json=payload, timeout=30)
        
        if response.status_code == 200:
            result = response.json()
            if "choices" in result and result["choices"]:
                response_content = result["choices"][0]["message"]["content"]
                chat_history.append({
                    "role": "assistant",
                    "content": response_content,
                    "topic": topic,
                    "timestamp": datetime.now().isoformat()
                })
                return response_content
            return f"❌ No choices in response: {result}"
        return f"❌ HTTP {response.status_code}: {response.text}"
            
    except Exception as e:
        return f"❌ Error: {str(e)}"

def clear_history():
    """Clear the chat history"""
    chat_history.clear()
    return "✅ Chat history cleared"

def view_history(topic: str = None):
    """View chat history with optional topic filter"""
    if not chat_history:
        return "❌ No chat history available"
    
    filtered = [msg for msg in chat_history if topic is None or msg["topic"] == topic]
    return "\n".join(
        f"[{msg['timestamp']}] {msg['role'].capitalize()}: {msg['content']}"
        for msg in filtered
    )

def manual_curl_example():
    """Generate example curl command"""
    if not API_KEY:
        return "❌ No API key available"
    return f"""curl -X POST "{API_URL}" \\
  -H "Authorization: Bearer {API_KEY}" \\
  -H "Content-Type: application/json" \\
  -d '{{"model": "llama3-8b-8192", "messages": [{{"role": "user", "content": "Hello"}}]}}'
"""

def process_message(message: str, topic: str, summarize: bool):
    """Process message and clear input"""
    response = groq_with_memory(message, topic, summarize)
    return response, ""

# Gradio Interface
with gr.Blocks(title="Groq Chat Debugger") as demo:
    gr.Markdown("## 💬 Groq API Chat Interface")
    
    with gr.Tab("Chat"):
        with gr.Row():
            with gr.Column():
                msg_input = gr.Textbox(
    label="Your Message", 
    value="", 
    placeholder="Tulis di sini..."
                )
                topic_input = gr.Textbox(
                    label="Topic", 
                    value="general"
                )
                summarize_cb = gr.Checkbox(label="Summarize conversation")
                send_btn = gr.Button("Send", variant="primary")
                
            with gr.Column():
                response_output = gr.Textbox(
                    label="Response", 
                    lines=10,
                    interactive=False
                )
        
        send_btn.click(
            process_message,
            inputs=[msg_input, topic_input, summarize_cb],
            outputs=[response_output, msg_input]
        )
    
    with gr.Tab("History"):
        history_topic = gr.Textbox(label="Filter by Topic")
        view_btn = gr.Button("View History")
        clear_btn = gr.Button("Clear History", variant="stop")
        history_output = gr.Textbox(label="Chat History", lines=10)
        
        view_btn.click(view_history, inputs=[history_topic], outputs=[history_output])
        clear_btn.click(clear_history, outputs=[history_output])
    
    with gr.Tab("API Tools"):
        gr.Markdown(f"""
        **API Status:** {'✅ Ready' if API_KEY else '❌ No API Key'}
        **Endpoint:** `{API_URL}`
        **Models:** `llama3-8b-8192`, `llama3-70b-8192`, `mixtral-8x7b-32768`
        """)
        
        curl_btn = gr.Button("Generate cURL Example")
        curl_output = gr.Code(label="cURL Command", language="shell")
        curl_btn.click(manual_curl_example, outputs=[curl_output])

if __name__ == "__main__":
    demo.launch(server_name="0.0.0.0", server_port=7860)