Integrate OpenRouter AI API for enhanced data analysis

- Add OpenRouter ChatOpenAI integration with Microsoft Phi-4 model
- Replace keyword-based responses with intelligent LLM-powered analysis
- Add proper prompt templating for data analysis questions
- Implement fallback error handling for API unavailability
- Configure environment variable support for OPENROUTER_API_KEY

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

app.py

@@ -6,12 +6,48 @@ import plotly.express as px
 import plotly.graph_objects as go
 from dash import Dash, html, dcc, Input, Output, State, callback_context
 import dash_bootstrap_components as dbc
+from typing import Optional
+from dotenv import load_dotenv
+from pydantic import Field, SecretStr
 
 # Fixed Langchain imports (using langchain-community)
 from langchain_community.embeddings import HuggingFaceEmbeddings
 from langchain_community.vectorstores import FAISS
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.schema import Document
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from langchain_core.utils.utils import secret_from_env
+from langchain.chains import LLMChain
+
+# Load environment variables
+load_dotenv()
+
+class ChatOpenRouter(ChatOpenAI):
+    openai_api_key: Optional[SecretStr] = Field(
+        alias="api_key", default_factory=lambda: secret_from_env("OPENROUTER_API_KEY", default=None)
+    )
+    
+    @property
+    def lc_secrets(self) -> dict[str, str]:
+        return {"openai_api_key": "OPENROUTER_API_KEY"}
+
+    def __init__(self,
+                 openai_api_key: Optional[str] = None,
+                 **kwargs):
+        openai_api_key = openai_api_key or os.environ.get("OPENROUTER_API_KEY")
+        super().__init__(base_url="https://openrouter.ai/api/v1", openai_api_key=openai_api_key, **kwargs)
+
+# Initialize OpenRouter model
+openrouter_model = ChatOpenRouter(
+    model_name="microsoft/phi-4-reasoning-plus",
+    temperature=0.3,
+    max_tokens=1500,
+    top_p=0.9,
+    frequency_penalty=0.0,    
+    presence_penalty=0.0, 
+    streaming=False        
+)
 
 # Initialize Dash app
 app = Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP])
@@ -177,80 +213,75 @@ def create_vector_store(df):
         return False
 
 def get_ai_response(question, df):
-    """Get AI response using RAG"""
+    """Get AI response using OpenRouter LLM and RAG"""
     global vector_store
     
     if vector_store is None:
         return "Please upload data first to enable AI features."
     
     try:
-        # Simple keyword-based responses for demo
-        question_lower = question.lower()
+        # Create data context for the LLM
+        data_context = f"""
+Dataset Information:
+- Shape: {df.shape[0]} rows × {df.shape[1]} columns
+- Columns: {', '.join(df.columns)}
+- Data Types: {df.dtypes.to_dict()}
+- Missing Values: {df.isnull().sum().to_dict()}
+
+Sample Data (first 5 rows):
+{df.head().to_string()}
+
+Summary Statistics:
+{df.describe().to_string()}
+        """
         
-        if "summary" in question_lower or "overview" in question_lower:
-            return f"""📊 **Data Summary**:
-            - **Shape**: {df.shape[0]} rows × {df.shape[1]} columns
-            - **Columns**: {', '.join(df.columns)}
-            - **Missing values**: {df.isnull().sum().sum()} total
-            - **Numeric columns**: {len(df.select_dtypes(include=['number']).columns)}
+        # Create a prompt template for data analysis
+        prompt_template = PromptTemplate(
+            input_variables=["question", "data_context"],
+            template="""
+You are a professional data analyst AI assistant. Based on the provided dataset information, answer the user's question with clear, actionable insights.
+
+Dataset Context:
+{data_context}
+
+User Question: {question}
+
+Please provide a helpful, accurate response with:
+1. Direct answer to the question
+2. Key insights or patterns you notice
+3. Recommendations or next steps if applicable
+
+Use emojis and markdown formatting to make your response engaging and easy to read.
             """
+        )
         
-        elif "correlation" in question_lower or "relationship" in question_lower:
-            numeric_cols = df.select_dtypes(include=['number']).columns
-            if len(numeric_cols) > 1:
-                corr = df[numeric_cols].corr()
-                # Find highest correlation
-                corr_vals = corr.abs().unstack().sort_values(ascending=False)
-                corr_vals = corr_vals[corr_vals < 1.0]  # Remove self-correlations
-                if not corr_vals.empty:
-                    top_corr = corr_vals.iloc[0]
-                    col1, col2 = corr_vals.index[0]
-                    return f"""🔗 **Correlation Analysis**:
-                    - Strongest relationship: **{col1}** and **{col2}** (r = {top_corr:.3f})
-                    - This suggests a {'strong' if top_corr > 0.7 else 'moderate' if top_corr > 0.5 else 'weak'} correlation
-                    """
-            return "No numeric columns found for correlation analysis."
+        # Create LLM chain
+        llm_chain = LLMChain(
+            llm=openrouter_model,
+            prompt=prompt_template
+        )
         
-        elif "missing" in question_lower or "null" in question_lower:
-            missing = df.isnull().sum()
-            missing = missing[missing > 0]
-            if missing.empty:
-                return "✅ **Great news!** No missing values found in your dataset."
-            else:
-                return f"""⚠️ **Missing Data Found**:
-                {missing.to_string()}
-                
-                **Recommendation**: Consider filling or removing missing values before analysis.
-                """
+        # Get response from OpenRouter
+        response = llm_chain.run(
+            question=question,
+            data_context=data_context
+        )
         
-        elif "recommend" in question_lower or "suggest" in question_lower:
-            suggestions = []
-            numeric_cols = df.select_dtypes(include=['number']).columns
-            categorical_cols = df.select_dtypes(include=['object']).columns
-            
-            if len(numeric_cols) >= 2:
-                suggestions.append("📈 Try scatter plots to explore relationships between numeric variables")
-            if len(categorical_cols) > 0 and len(numeric_cols) > 0:
-                suggestions.append("📊 Create bar charts to compare numeric values across categories")
-            if len(numeric_cols) > 0:
-                suggestions.append("📉 Use histograms to understand data distributions")
-            
-            return f"""💡 **Analysis Suggestions**:
-            {chr(10).join(['• ' + s for s in suggestions])}
-            """
+        return response
         
-        else:
-            return f"""🤖 **AI Assistant**: I can help you with:
-            - Data summaries and overviews
-            - Correlation and relationship analysis  
-            - Missing data detection
-            - Visualization recommendations
-            
-            Try asking: "What's the summary?" or "Any missing data?"
-            """
-            
     except Exception as e:
-        return f"Error processing question: {str(e)}"
+        # Fallback to basic responses if OpenRouter fails
+        print(f"OpenRouter error: {e}")
+        return f"""🤖 **AI Assistant** (Limited Mode): 
+        I encountered an issue with the AI service. Here's basic info about your data:
+        
+        📊 **Quick Summary**:
+        - Shape: {df.shape[0]} rows × {df.shape[1]} columns
+        - Columns: {', '.join(df.columns)}
+        - Missing values: {df.isnull().sum().sum()} total
+        
+        Please check your OPENROUTER_API_KEY configuration.
+        """
 
 def parse_contents(contents, filename):
     """Parse uploaded file contents"""