app.py

import gradio as gr
import requests
import json
import time
import os
from typing import List, Dict, Optional
import random
# Multiple free LLM API options
LLM_PROVIDERS = {
    "huggingface": {
        "url": "https://api-inference.huggingface.co/models/microsoft/DialoGPT-large",
        "headers": {"Authorization": f"Bearer {os.getenv('HF_TOKEN', '')}"},
        "free": True
    },
    "together": {
        "url": "https://api.together.xyz/inference",
        "model": "togethercomputer/RedPajama-INCITE-Chat-3B-v1",
        "headers": {"Authorization": f"Bearer {os.getenv('TOGETHER_API_KEY', '')}"},
        "free": True  # Has free tier
    },
    "replicate": {
        "model": "meta/llama-2-7b-chat",
        "free": True  # Has free tier
    },
    "groq": {
        "url": "https://api.groq.com/openai/v1/chat/completions",
        "model": "llama3-8b-8192",
        "headers": {"Authorization": f"Bearer {os.getenv('GROQ_API_KEY', '')}"},
        "free": True  # Very generous free tier
    }
}
# MCP Server for Ayurvedic knowledge
MCP_SERVER_URL = "https://your-mcp-server.hf.space/mcp"
# Global variables
user_profiles = {}
conversation_contexts = {}
class ConversationalAyurBot:
    """Truly conversational Ayurvedic chatbot using free LLMs"""
    
    def __init__(self):
        self.provider = "groq"  # Default to Groq (most reliable free option)
        self.context_window = []
        
    def get_ayurvedic_context(self, user_message: str, user_profile: Dict) -> str:
        """Get relevant Ayurvedic context from MCP or built-in knowledge"""
        try:
            # Try MCP server first
            payload = {
                "jsonrpc": "2.0",
                "id": int(time.time()),
                "method": "tools/call",
                "params": {
                    "name": "recommend_herbs",
                    "arguments": {
                        "condition": user_message,
                        "dosha": user_profile.get('constitution', '').lower() if user_profile.get('constitution', '').lower() not in ['unknown', ''] else None
                    }
                }
            }
            
            response = requests.post(MCP_SERVER_URL, json=payload, timeout=5)
            if response.status_code == 200:
                result = response.json()
                if "result" in result and "content" in result["result"]:
                    content = result["result"]["content"]
                    if content and len(content) > 0:
                        return content[0].get("text", "")
        except:
            pass
        
        # Fallback to curated knowledge snippets
        knowledge_snippets = [
            "Ayurveda emphasizes that like increases like and opposites balance. If you're feeling hot and irritated, cooling foods and practices help.",
            "The three doshas - Vata (air+space), Pitta (fire+water), and Kapha (earth+water) - govern all bodily functions.",
            "Agni, the digestive fire, is central to health. Strong agni means good digestion and immunity.",
            "Ama (toxins) accumulate when digestion is weak. Proper eating habits and detox help remove ama.",
            "Daily routines (dinacharya) aligned with natural cycles promote balance and prevent disease.",
            "Food is medicine in Ayurveda. The six tastes should be included in every meal for balance."
        ]
        return random.choice(knowledge_snippets)
    
    def call_groq_api(self, messages: List[Dict]) -> str:
        """Call Groq API (most reliable free option)"""
        try:
            import requests
            
            # You can get a free API key from https://console.groq.com/
            groq_api_key = os.getenv('GROQ_API_KEY') or 'your-groq-api-key-here'
            
            if groq_api_key == 'your-groq-api-key-here':
                return None  # No API key provided
            
            headers = {
                "Authorization": f"Bearer {groq_api_key}",
                "Content-Type": "application/json"
            }
            
            payload = {
                "model": "llama3-8b-8192",
                "messages": messages,
                "temperature": 0.7,
                "max_tokens": 512,
                "top_p": 0.9
            }
            
            response = requests.post(
                "https://api.groq.com/openai/v1/chat/completions",
                headers=headers,
                json=payload,
                timeout=10
            )
            
            if response.status_code == 200:
                result = response.json()
                return result["choices"][0]["message"]["content"]
                
        except Exception as e:
            print(f"Groq API error: {e}")
            return None
    
    def call_huggingface_api(self, prompt: str) -> str:
        """Call HuggingFace Inference API (free)"""
        try:
            hf_token = os.getenv('HF_TOKEN') or 'your-hf-token-here'
            
            if hf_token == 'your-hf-token-here':
                return None
            
            headers = {"Authorization": f"Bearer {hf_token}"}
            
            # Try different models
            models = [
                "microsoft/DialoGPT-large",
                "facebook/blenderbot-400M-distill",
                "microsoft/DialoGPT-medium"
            ]
            
            for model in models:
                try:
                    response = requests.post(
                        f"https://api-inference.huggingface.co/models/{model}",
                        headers=headers,
                        json={"inputs": prompt, "parameters": {"max_length": 200}},
                        timeout=10
                    )
                    
                    if response.status_code == 200:
                        result = response.json()
                        if isinstance(result, list) and len(result) > 0:
                            return result[0].get("generated_text", "").replace(prompt, "").strip()
                        elif isinstance(result, dict) and "generated_text" in result:
                            return result["generated_text"].replace(prompt, "").strip()
                except:
                    continue
                    
        except Exception as e:
            print(f"HuggingFace API error: {e}")
            return None
    
    def call_ollama_local(self, messages: List[Dict]) -> str:
        """Call local Ollama if available"""
        try:
            # Check if Ollama is running locally
            response = requests.post(
                "http://localhost:11434/api/chat",
                json={
                    "model": "llama2",  # or "mistral", "codellama"
                    "messages": messages,
                    "stream": False
                },
                timeout=10
            )
            
            if response.status_code == 200:
                return response.json()["message"]["content"]
                
        except:
            return None
    
    def generate_conversational_response(self, user_message: str, chat_history: List, user_profile: Dict) -> str:
        """Generate natural conversational response"""
        
        # Get Ayurvedic context
        ayur_context = self.get_ayurvedic_context(user_message, user_profile)
        
        # Build conversation context
        name = user_profile.get('name', 'friend')
        dosha = user_profile.get('constitution', 'unknown')
        concerns = user_profile.get('concerns', '')
        
        # Create system prompt for conversational AI
        system_prompt = f"""You are Dr. Ayur, a warm, wise, and conversational Ayurvedic doctor. You speak naturally like a caring friend who happens to be an expert in Ayurveda.
Your personality:
- Warm, empathetic, and genuinely caring
- Speaks naturally, not formally or robotically  
- Uses "Namaste" as greeting but then talks like a normal person
- Gives practical, actionable advice
- Admits when you need more information
- Asks follow-up questions to understand better
- Shares relevant stories or analogies when helpful
User info: {name}, constitution: {dosha}, concerns: {concerns}
Ayurvedic context for this conversation: {ayur_context}
Remember:
- Have a natural conversation, don't lecture
- Ask questions to understand their specific situation
- Give personalized advice based on their constitution
- Be encouraging and supportive
- Keep responses conversational length (2-4 sentences usually)
- Only give longer responses when explaining complex concepts"""
        # Build message history for API
        messages = [{"role": "system", "content": system_prompt}]
        
        # Add recent chat history
        if chat_history:
            for human_msg, ai_msg in chat_history[-3:]:  # Last 3 exchanges
                messages.append({"role": "user", "content": human_msg})
                messages.append({"role": "assistant", "content": ai_msg})
        
        # Add current message
        messages.append({"role": "user", "content": user_message})
        
        # Try different LLM providers
        response = None
        
        # 1. Try Groq (best free option)
        response = self.call_groq_api(messages)
        if response:
            return response
        
        # 2. Try local Ollama
        response = self.call_ollama_local(messages)
        if response:
            return response
        
        # 3. Try HuggingFace
        prompt = f"{system_prompt}\n\nUser: {user_message}\nDr. Ayur:"
        response = self.call_huggingface_api(prompt)
        if response:
            return response
        
        # 4. Fallback to intelligent template response
        return self.create_fallback_response(user_message, user_profile, ayur_context)
    
    def create_fallback_response(self, user_message: str, user_profile: Dict, context: str) -> str:
        """Create natural fallback response when APIs fail"""
        name = user_profile.get('name', 'friend')
        
        # Analyze user message for natural response
        msg_lower = user_message.lower()
        
        if any(word in msg_lower for word in ['hello', 'hi', 'hey', 'namaste']):
            return f"Namaste {name}! How are you feeling today? What's been on your mind health-wise?"
        
        elif any(word in msg_lower for word in ['thank', 'thanks']):
            return f"You're so welcome, {name}! I'm here whenever you need guidance. How else can I support your wellness journey?"
        
        elif any(word in msg_lower for word in ['stress', 'anxiety', 'worried']):
            return f"I can hear that you're dealing with some stress, {name}. That's really common, and Ayurveda has wonderful ways to help. Can you tell me more about what's been triggering this for you? Understanding the root cause helps me suggest the best approach."
        
        elif any(word in msg_lower for word in ['sleep', 'tired', 'insomnia']):
            return f"Sleep issues can be so frustrating, {name}. Let's figure this out together. Are you having trouble falling asleep, staying asleep, or both? And how's your evening routine looking these days?"
        
        elif any(word in msg_lower for word in ['diet', 'food', 'eat']):
            return f"Ah, food as medicine - one of my favorite topics, {name}! What's your current relationship with food like? Are you dealing with any digestive concerns, or are you looking to optimize your energy and health?"
        
        elif any(word in msg_lower for word in ['pain', 'hurt', 'ache']):
            return f"I'm sorry you're experiencing pain, {name}. Where exactly are you feeling this discomfort, and have you noticed any patterns - like times of day when it's worse or better?"
        
        else:
            responses = [
                f"That's a great question, {name}. Tell me a bit more about your situation so I can give you the most helpful guidance.",
                f"I'd love to help with that, {name}. Can you share some more details about what you're experiencing?",
                f"Interesting point, {name}. Let's explore this together - what made you think about this particular aspect of your health?"
            ]
            return random.choice(responses)
# Initialize the conversational bot
ayur_bot = ConversationalAyurBot()
def save_profile(name: str, age: int, constitution: str, concerns: str):
    """Save user profile"""
    if not name.strip():
        return "Please enter your name first!"
    
    profile = {
        "name": name.strip(),
        "age": age,
        "constitution": constitution,
        "concerns": concerns.strip()
    }
    
    user_profiles[name.lower()] = profile
    return f"Great! I've got your profile saved, {name}. Now our conversations will be much more personalized."
def get_user_profile() -> Dict:
    """Get the most recent user profile"""
    if user_profiles:
        return list(user_profiles.values())[-1]
    return {}
def chat_interface(message: str, history: List) -> tuple:
    """Main conversational interface"""
    if not message.strip():
        return "", history
    
    user_profile = get_user_profile()
    response = ayur_bot.generate_conversational_response(message.strip(), history, user_profile)
    history.append([message, response])
    
    return "", history
def test_llm_connections():
    """Test available LLM connections"""
    results = []
    
    # Test Groq
    groq_key = os.getenv('GROQ_API_KEY', 'your-groq-api-key-here')
    if groq_key != 'your-groq-api-key-here':
        try:
            test_response = ayur_bot.call_groq_api([
                {"role": "user", "content": "Hello"}
            ])
            if test_response:
                results.append("✅ Groq API: Connected")
            else:
                results.append("⚠️ Groq API: Available but failed test")
        except:
            results.append("❌ Groq API: Failed")
    else:
        results.append("⚠️ Groq API: No API key (add GROQ_API_KEY)")
    
    # Test HuggingFace
    hf_token = os.getenv('HF_TOKEN', 'your-hf-token-here')
    if hf_token != 'your-hf-token-here':
        results.append("✅ HuggingFace: Token available")
    else:
        results.append("⚠️ HuggingFace: No token (add HF_TOKEN)")
    
    # Test local Ollama
    try:
        response = requests.get("http://localhost:11434/api/tags", timeout=2)
        if response.status_code == 200:
            results.append("✅ Ollama: Running locally")
        else:
            results.append("❌ Ollama: Not responding")
    except:
        results.append("❌ Ollama: Not available")
    
    results.append("✅ Fallback responses: Always available")
    
    return "\n".join(results)
# Create the Gradio interface
with gr.Blocks(title="Dr. Ayur - Conversational AI", theme=gr.themes.Soft()) as app:
    
    gr.HTML("""
    <div style="text-align: center; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
                color: white; padding: 20px; border-radius: 10px; margin-bottom: 20px;">
        <h1>🕉️ Dr. Ayur - Conversational Ayurvedic AI</h1>
        <p>Have natural conversations about your health and wellness with an AI Ayurvedic doctor</p>
    </div>
    """)
    
    # API Key setup instructions
    with gr.Accordion("🔑 Setup Instructions (Click to expand)", open=False):
        gr.Markdown("""
        ## Get Free API Access for Better Conversations:
        
        **Option 1: Groq (Recommended - Very fast & generous free tier)**
        1. Go to [console.groq.com](https://console.groq.com/)
        2. Sign up for free
        3. Get your API key
        4. Add it as `GROQ_API_KEY` in your HuggingFace Space secrets
        
        **Option 2: HuggingFace Token**
        1. Go to [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
        2. Create a new token
        3. Add it as `HF_TOKEN` in your Space secrets
        
        **Option 3: Local Ollama (For local development)**
        1. Install [Ollama](https://ollama.ai/)
        2. Run `ollama pull llama2`
        3. The app will automatically detect it
        
        *Don't worry - the app works without API keys using intelligent fallback responses!*
        """)
    
    with gr.Row():
        with gr.Column(scale=3):
            chatbot = gr.Chatbot(
                height=500,
                placeholder="Start a natural conversation with Dr. Ayur about your health...",
                show_label=False
            )
            
            with gr.Row():
                msg_input = gr.Textbox(
                    placeholder="Just talk naturally - ask anything about your health, diet, stress, sleep...",
                    scale=4,
                    container=False
                )
                send_btn = gr.Button("Send", variant="primary", scale=1)
            
            clear_btn = gr.Button("Clear Conversation", variant="secondary")
            
        with gr.Column(scale=1):
            gr.Markdown("### 🔧 System Status")
            test_btn = gr.Button("🔌 Test LLM Connections")
            status_display = gr.Textbox(
                label="Connection Status",
                value="Click 'Test LLM Connections' to check available services",
                interactive=False,
                lines=6
            )
            
            gr.Markdown("### 👤 Tell me about yourself")
            with gr.Group():
                profile_name = gr.Textbox(label="Your name", placeholder="What should I call you?")
                profile_age = gr.Number(label="Age", value=30, minimum=1, maximum=120)
                profile_constitution = gr.Dropdown(
                    label="Your dosha (if you know it)",
                    choices=["I don't know", "Vata", "Pitta", "Kapha", "Mixed"],
                    value="I don't know"
                )
                profile_concerns = gr.Textbox(
                    label="What's on your mind health-wise?",
                    placeholder="e.g., stress, sleep issues, digestion...",
                    lines=2
                )
                save_btn = gr.Button("💾 Save My Info", variant="primary")
                profile_status = gr.Textbox(label="", interactive=False, show_label=False)
            
            gr.Markdown("### 💭 Conversation starters:")
            gr.Markdown("""
            - "I've been really stressed lately..."
            - "I'm having trouble sleeping"
            - "What foods should I eat for my body type?"
            - "I get anxious a lot, can Ayurveda help?"
            - "My digestion has been off"
            - "I want to start eating healthier"
            """)
    # Event handlers
    msg_input.submit(chat_interface, [msg_input, chatbot], [msg_input, chatbot])
    send_btn.click(chat_interface, [msg_input, chatbot], [msg_input, chatbot])
    clear_btn.click(lambda: [], outputs=[chatbot])
    
    test_btn.click(test_llm_connections, outputs=[status_display])
    save_btn.click(
        save_profile,
        [profile_name, profile_age, profile_constitution, profile_concerns],
        [profile_status]
    )
    gr.HTML("""
    <div style="text-align: center; margin-top: 20px; padding: 15px; 
                background: #000000; border-radius: 10px;">
        <p><strong>🌟 This is a truly conversational AI!</strong> It understands context, asks follow-up questions, and has natural conversations about your health.</p>
        <p><strong>Disclaimer:</strong> Dr. Ayur provides educational information only. Always consult qualified practitioners for medical concerns.</p>
    </div>
    """)
if __name__ == "__main__":
    app.launch(share=True)