app.py

import os
import gradio as gr
import openai
from langdetect import detect
import json

# Set up OpenAI API with your custom endpoint
openai.api_key = os.getenv("API_KEY")
openai.api_base = "https://api.groq.com/openai/v1"

# Import datasets from the Python files in your project
from company_profile import company_profile
from workforce import workforce
from financials import financials
from investors import investors
from products_services import products_services
from market_trends import market_trends
from partnerships_collaborations import partnerships_collaborations
from legal_compliance import legal_compliance
from customer_insights import customer_insights
from news_updates import news_updates
from social_media import social_media
from tech_stack import tech_stack

# Command handler for specific queries
def command_handler(user_input):
    if user_input.lower().startswith("define "):
        term = user_input[7:].strip()
        definitions = {
            "market analysis": (
                "Market analysis evaluates a business's position by studying competitors, trends, and customer behavior. "
                "It helps in crafting strategies for growth. 📊"
            ),
            "financials": (
                "Financial analysis examines profit margins, revenues, and expenses to determine fiscal health and sustainability. 💵"
            ),
            "investors": (
                "Investors provide capital in exchange for equity or debt, enabling business growth and scaling. 🏦"
            )
        }
        return definitions.get(term.lower(), "Definition not available. Let’s dive into your query!")
    return None

# Function to get the response from OpenAI with professionalism and energy
def get_groq_response(message, user_language, custom_data=None):
    try:
        # If custom data is available, include it in the AI prompt
        if custom_data:
            prompt = f"Use the following information for analysis: {custom_data}. Then answer the user's query: {message}"
        else:
            prompt = message

        response = openai.ChatCompletion.create(
            model="llama-3.1-70b-versatile",
            messages=[
                {
                    "role": "system",
                    "content": (
                        f"You are a professional and concise Private Market Analyst AI. Your task is to explain market trends, "
                        f"company insights, and investment strategies in a clear, impactful, and concise manner. "
                        f"Keep the responses brief yet informative, focusing on the key points. Always maintain professionalism. "                      
                        f"1. **Accuracy**: Provide reliable, data-backed insights based on market trends, company profiles, and financial data.\n"
                        f"2. **Real-Time Updates**: Continuously track and update insights from the latest company developments, financial reports, and market movements.\n"
                        f"3. **Customizable**: Offer tailored responses based on user preferences such as specific industries, risk levels, and deal types.\n"
                        f"4. **Confidentiality**: Ensure that all information and insights provided remain secure and confidential, respecting user privacy.\n"
                        f"5. **Explainability**: Provide clear, understandable, and actionable explanations for every AI-generated insight, ensuring users can easily follow the rationale behind the analysis.\n\n"
                        f"Your primary goal is to assist users by providing accurate, personalized, and actionable insights related to private markets. Always maintain professionalism and conciseness. Ensure that responses are easy to interpret, and avoid jargon whenever possible.\n\n"
                    )
                },
                {"role": "user", "content": prompt}
            ]
        )
        return response.choices[0].message["content"]
    except Exception as e:
        return f"Oops, looks like something went wrong! Error: {str(e)}"

# Function to format the response data in a readable and highlighted form
def format_response(data):
    if not data:
        return "No data available for this query."

    formatted_response = ""

    if isinstance(data, dict):
        formatted_response += "### Key Insights:\n\n"
        for key, value in data.items():
            if isinstance(value, dict):
                # For nested dictionaries, add a heading for the sub-keys
                formatted_response += f"**{key.capitalize()}**:\n"
                for sub_key, sub_value in value.items():
                    formatted_response += f"  - **{sub_key.capitalize()}**: {sub_value}\n"
            elif isinstance(value, list):
                # If the value is a list, show it as a bullet-point list
                formatted_response += f"**{key.capitalize()}**:\n"
                for idx, item in enumerate(value):
                    formatted_response += f"  - {item}\n"
            else:
                # For other types of data, simply display key-value pairs
                formatted_response += f"**{key.capitalize()}**: {value}\n"

    elif isinstance(data, list):
        formatted_response += "### Insights:\n\n" + "\n".join(f"{idx+1}. {item}" for idx, item in enumerate(data))
    else:
        formatted_response = f"### Key Insight:\n\n{data}"

    return formatted_response.strip()

# Function to handle the interaction and queries
def market_analysis_agent(user_input, history=[]):
    try:
        # Detect the language of the user's input
        detected_language = detect(user_input)
        user_language = "Hindi" if detected_language == "hi" else "English"
        
        # Handle special commands like "Define [term]"
        command_response = command_handler(user_input)
        if command_response:
            history.append((user_input, command_response))
            return history, history
        
        # Handle private market queries with datasets
        if "company" in user_input.lower():
            response = company_profile
        elif "financials" in user_input.lower():
            response = financials
        elif "investors" in user_input.lower():
            response = investors
        elif "products" in user_input.lower():
            response = products_services
        elif "news" in user_input.lower() or "updates" in user_input.lower():
            response = news_updates
        elif "legal" in user_input.lower() or "compliance" in user_input.lower():
            response = legal_compliance
        elif "social media" in user_input.lower() or "instagram" in user_input.lower() or "linkedin" in user_input.lower() or "twitter" in user_input.lower():
            response = social_media
        elif "workforce" in user_input.lower():
            response = workforce
        else:
            # Get dynamic AI response if query doesn't match predefined terms
            response = get_groq_response(user_input, user_language, custom_data=json.dumps(company_profile))

        # Format the response for easy readability and highlighting
        formatted_response = format_response(response)

        # Add some professional and engaging replies for the user
        cool_replies = [
    "Insightful observation. Let’s keep the momentum going. 📊",
    "Good question! Let’s extract deeper business insights. 📈",
    "You're on the right track — let’s refine the strategy further. 🔍",
    "Great focus. Let’s explore actionable opportunities. 💼",
    "Valuable input. Let’s build on this insight together. 🚀",
    "You're making smart moves. Let’s keep adding value. 💡",
    "Curiosity drives innovation — let’s keep pushing boundaries. 🔎",
    "Strategic thinking in action! Let’s continue refining. 🎯",
    "I see you're aiming for precision — let’s achieve clarity together. ⚙️",
    "Sharp question! Let’s identify the key drivers. 🔑",
    "You're thinking ahead. Let’s stay future-focused. 📅",
    "Business insights are coming together — let’s maximize value. 📚",
    "Making data-driven decisions? You’re spot on. 📊",
    "I like your approach. Let’s keep this analytical momentum. 🧠",
    "Big ideas require sharper analysis. Let’s keep refining. ✨",
    "You’re asking the right questions — let’s uncover the next steps. 🚦",
    "The numbers don’t lie — let’s make them work for us. 💸",
    "Smart query! Let’s turn it into actionable intelligence. 🔎",
    "Excellent business acumen. Let’s push further. 📈",
    "Your focus is commendable — let’s identify new opportunities. 💻",
    "Looks like you're identifying hidden value — let’s explore. 💎",
    "Another smart step toward actionable insights. Let’s keep moving. 🚀",
    "Strategic moves require sharp insights. Let’s build on this. 🛠️",
    "You’re driving a data-driven approach. Let’s keep up the pace. 📊",
    "Excellent thought process — let’s continue to optimize. 💼",
    "Financial insights require precision — let’s dive deeper. 💰",
    "Impressive thinking. Let’s sharpen the competitive advantage. ⚔️",
    "Every number tells a story — let’s ensure it works in your favor. 🖋️",
    "This shows strong foresight. Let’s unlock the next opportunity. 🔐",
    "Taking this step reflects your analytical mindset. Let’s continue. 📚",
    "Looks like a winning strategy. Let’s make it even stronger. 🏆"
]
        formatted_response += f"\n{cool_replies[hash(user_input) % len(cool_replies)]}"

        # Add to chat history
        history.append((user_input, formatted_response))
        return history, history

    except Exception as e:
        return [(user_input, f"Oops, something went wrong: {str(e)}")], history

def fetch_crypto_trends(symbol="BTC", market="USD", api_key="your_api_key_here"):
    url = f'https://www.alphavantage.co/query?function=DIGITAL_CURRENCY_DAILY&symbol={symbol}&market={market}&apikey={api_key}'
    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise exception for HTTP errors
        data = response.json()
        if "Time Series (Digital Currency Daily)" in data:
            trends = data["Time Series (Digital Currency Daily)"]
            latest_date = max(trends.keys())  # Get the most recent date
            latest_data = trends[latest_date]
            return {
                "date": latest_date,
                "open": latest_data["1a. open (USD)"],
                "high": latest_data["2a. high (USD)"],
                "low": latest_data["3a. low (USD)"],
                "close": latest_data["4a. close (USD)"],
                "volume": latest_data["5. volume"],
                "market_cap": latest_data["6. market cap (USD)"]
            }
        else:
            return "No cryptocurrency data available. Check your API key or query parameters."
    except Exception as e:
        return f"Error fetching cryptocurrency trends: {str(e)}"

# Gradio Interface setup
chat_interface = gr.Interface(
    fn=market_analysis_agent,  # Function for handling user interaction
    inputs=["text", "state"],  # Inputs: user message and chat history
    outputs=["chatbot", "state"],  # Outputs: chatbot messages and updated history
    live=False,  # Disable live responses; show after submit
    title="Private Market AI Agent",  # Title of the app
    description=(
        "Welcome to your professional Private Market Analyst AI Agent by Satyam! 📊\n\n"
        "Ask me anything about market trends, company profiles, financial analysis, investors, and more! "
        "I’ll provide you with concise insights that are informative and to the point, helping you make well-informed decisions. \n\n"
        "Let's break down market complexities with clarity. 🔍\n\n"
        "We Transform Data into Deal"
        
    )
)

# Launch the Gradio interface
if __name__ == "__main__":
    chat_interface.launch(share=True)