app.py

import os
import json
import gradio as gr
from groq import Groq
import requests
from typing import Dict, Any
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class IbibioTranslationAgent:
    def __init__(self):
        self.groq_client = None
        self.tavily_api_key = None
        self.setup_apis()
        
        # Local Ibibio dictionary (basic fallback)
        self.local_dictionary = {
            "hello": "ndimesiere",
            "thank you": "sosongo",
            "good morning": "emesiere ntak",
            "good evening": "emesiere ekey",
            "yes": "ayi",
            "no": "mme",
            "water": "mmong",
            "food": "ndinyanga",
            "house": "ufok",
            "child": "akanamukoro"
        }
    
    def setup_apis(self):
        """Initialize API clients"""
        try:
            groq_api_key = os.getenv("GROQ_API_KEY")
            self.tavily_api_key = os.getenv("TAVILY_API_KEY")
            
            if groq_api_key:
                self.groq_client = Groq(api_key=groq_api_key)
                logger.info("Groq client initialized successfully")
            else:
                logger.warning("GROQ_API_KEY not found")
                
            if not self.tavily_api_key:
                logger.warning("TAVILY_API_KEY not found")
                
        except Exception as e:
            logger.error(f"Error setting up APIs: {e}")
    
    def search_web(self, query: str) -> str:
        """Search web using Tavily API"""
        if not self.tavily_api_key:
            return "Web search unavailable - API key not configured"
            
        try:
            url = "https://api.tavily.com/search"
            payload = {
                "api_key": self.tavily_api_key,
                "query": f"{query} Ibibio language translation",
                "search_depth": "basic",
                "include_answer": True,
                "max_results": 3
            }
            
            response = requests.post(url, json=payload, timeout=10)
            response.raise_for_status()
            
            data = response.json()
            if data.get("answer"):
                return data["answer"]
            elif data.get("results"):
                # Combine top results
                results = []
                for result in data["results"][:2]:
                    results.append(f"• {result.get('content', '')[:200]}")
                return "\n".join(results)
            else:
                return "No web results found"
                
        except Exception as e:
            logger.error(f"Web search error: {e}")
            return f"Web search failed: {str(e)}"
    
    def check_local_dictionary(self, query: str) -> str:
        """Check local dictionary for basic translations"""
        query_lower = query.lower().strip()
        
        # Direct lookup
        if query_lower in self.local_dictionary:
            return f"Local dictionary: '{query_lower}' in Ibibio is '{self.local_dictionary[query_lower]}'"
        
        # Partial matching
        for eng, ibibio in self.local_dictionary.items():
            if eng in query_lower or query_lower in eng:
                return f"Local dictionary match: '{eng}' in Ibibio is '{ibibio}'"
        
        return None
    
    def groq_reasoning(self, query: str, web_results: str = None, local_result: str = None) -> str:
        """Use Groq for intelligent reasoning about translation"""
        if not self.groq_client:
            return "Groq API not available"
        
        try:
            # Build context
            context_parts = []
            if local_result:
                context_parts.append(f"Local dictionary result: {local_result}")
            if web_results and "unavailable" not in web_results.lower():
                context_parts.append(f"Web search results: {web_results}")
            
            context = "\n".join(context_parts) if context_parts else "No additional context available"
            
            prompt = f"""You are an expert in Ibibio language translation. The user asked: "{query}"

Available information:
{context}

Your task:
1. If this is asking for Ibibio translation, provide the most accurate translation possible
2. If you have conflicting information, explain which source seems more reliable
3. If you don't have enough information, be honest about limitations
4. Always format your response clearly for the user

Provide a helpful, accurate response:"""

            response = self.groq_client.chat.completions.create(
                model="llama-3.3-70b-versatile",
                messages=[
                    {"role": "system", "content": "You are a helpful Ibibio language translation assistant."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=300,
                temperature=0.3
            )
            
            return response.choices[0].message.content.strip()
            
        except Exception as e:
            logger.error(f"Groq reasoning error: {e}")
            return f"AI reasoning failed: {str(e)}"
    
    def translate_online(self, query: str) -> Dict[str, Any]:
        """Main translation function that combines all methods"""
        try:
            logger.info(f"Processing query: {query}")
            
            # Step 1: Check local dictionary
            local_result = self.check_local_dictionary(query)
            
            # Step 2: Search web for additional context
            web_results = self.search_web(query)
            
            # Step 3: Use Groq for intelligent reasoning
            ai_response = self.groq_reasoning(query, web_results, local_result)
            
            # Compile response
            response = {
                "query": query,
                "ai_response": ai_response,
                "local_dictionary": local_result,
                "web_search": web_results if "unavailable" not in web_results.lower() else None,
                "status": "success"
            }
            
            return response
            
        except Exception as e:
            logger.error(f"Translation error: {e}")
            return {
                "query": query,
                "error": str(e),
                "status": "error"
            }

# Initialize the agent
agent = IbibioTranslationAgent()

def translate_interface(query: str) -> str:
    """Gradio interface function"""
    if not query.strip():
        return "Please enter a translation query."
    
    result = agent.translate_online(query)
    
    if result["status"] == "error":
        return f"❌ Error: {result['error']}"
    
    # Format response for display
    response_parts = []
    
    if result.get("ai_response"):
        response_parts.append(f"🤖 **AI Translation:**\n{result['ai_response']}")
    
    if result.get("local_dictionary"):
        response_parts.append(f"\n📚 **Local Dictionary:**\n{result['local_dictionary']}")
    
    if result.get("web_search"):
        response_parts.append(f"\n🔍 **Web Research:**\n{result['web_search'][:300]}...")
        
    return "\n\n".join(response_parts) if response_parts else "No translation found."

def api_interface(query: str) -> str:
    """API-style interface that returns JSON"""
    result = agent.translate_online(query)
    return json.dumps(result, indent=2)

# Create Gradio interface
with gr.Blocks(title="Ibi-Voice Translation Backend", theme=gr.themes.Soft()) as app:
    gr.Markdown("""
    # 🎯 Ibi-Voice Translation Backend
    
    **JR Digital Insights** - AI-powered Ibibio translation service
    
    This backend combines:
    - 🧠 **Groq LLaMA3** for intelligent reasoning
    - 🔍 **Tavily Search** for real-time web lookup
    - 📚 **Local Dictionary** for common phrases
    """)
    
    with gr.Tab("🎯 Translation Interface"):
        with gr.Row():
            with gr.Column():
                query_input = gr.Textbox(
                    label="Enter your translation query",
                    placeholder="e.g., 'What is God is good in Ibibio?'",
                    lines=2
                )
                translate_btn = gr.Button("🚀 Translate", variant="primary")
            
            with gr.Column():
                translation_output = gr.Markdown(
                    label="Translation Result",
                    value="Enter a query to get started..."
                )
        
        # Examples
        gr.Examples(
            examples=[
                ["What is 'God is good' in Ibibio?"],
                ["How do you say 'thank you' in Ibibio?"],
                ["Translate 'good morning' to Ibibio"],
                ["What does 'sosongo' mean in English?"]
            ],
            inputs=query_input
        )
    
    with gr.Tab("🔧 API Format"):
        gr.Markdown("### For developers: Raw JSON API response")
        api_query = gr.Textbox(label="API Query", placeholder="Enter query for JSON response")
        api_btn = gr.Button("Get JSON Response")
        api_output = gr.Code(label="JSON Response", language="json")
        
        api_btn.click(api_interface, inputs=api_query, outputs=api_output)
    
    with gr.Tab("📋 Setup Instructions"):
        gr.Markdown("""
        ### 🔑 Required Environment Variables
        
        To use this backend, set these in your Hugging Face Space settings:
        
        ```bash
        GROQ_API_KEY=your_groq_api_key_here
        TAVILY_API_KEY=your_tavily_api_key_here
        ```
        
        ### 🌐 API Endpoint
        
        Once deployed, your frontend can call:
        ```
        POST https://your-username-ibi-voice-backend.hf.space/api/predict
        ```
        
        ### 🔗 Integration with Your Frontend
        
        ```javascript
        async function translateOnline(query) {
            const response = await fetch('https://your-space-url.hf.space/api/predict', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    data: [query],
                    fn_index: 0
                })
            });
            const result = await response.json();
            return result.data[0];
        }
        ```
        """)
    
    # Connect the interface
    translate_btn.click(translate_interface, inputs=query_input, outputs=translation_output)

# Launch the app
if __name__ == "__main__":
    app.launch(server_name="0.0.0.0", server_port=7860)