Hybrid GVFD Assistant with OAuth and AI integration

- Combines GVFD-specific functionality with HF template OAuth features
- Smart search and calculation handling for value factor queries
- AI responses with user's own HF token (user pays their own costs)
- Fallback to structured responses without sign-in
- Optimized for "value factor for X in Y country" queries
- Enhanced contextual AI responses when logged in

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

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

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,46 +1,40 @@
-# Global Value Factor Database Assistant
+---
+title: GVFD Explorer
+emoji: 🌍
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: 5.42.0
+app_file: app.py
+pinned: false
+short_description: AI-powered chat interface for exploring the Global Value Factor Database
+---
+
+# Global Value Factor Database Explorer
 
 An AI-enhanced interactive chatbot that allows users to explore and calculate with the Global Value Factor Database - a comprehensive dataset that converts environmental and social impacts into monetary values (USD).
 
 ## ✨ Features
 
 - 🤖 **AI-Enhanced Responses**: Local AI model provides intelligent, conversational responses
-- 🔍 **Search Value Factors**: Find specific value factors by category, country, or keywords  
-- 🧮 **Impact Calculations**: Calculate monetary impacts using value factors and impact quantities
-- 🌍 **Country Analysis**: Explore value factors specific to different countries
-- 📊 **Category Filtering**: Browse factors by environmental categories (air pollution, water, waste, etc.)
-- 💰 **Completely FREE**: Runs locally on Hugging Face infrastructure with no API costs
+- 🔍 **Smart Search**: "Value factor for CO2 emissions in Germany" 
+- 🧮 **Impact Calculations**: Calculate monetary impacts using value factors
+- 🌍 **Country Analysis**: Explore factors specific to different countries
+- 📊 **Category Filtering**: Browse factors by environmental categories
+- 💰 **Completely FREE**: Runs locally with no API costs
 
 ## Dataset
 
-This assistant uses the [Global Value Factor Database Refactor V2](https://huggingface.co/datasets/danielrosehl/Global-Value-Factor-Database-Refactor-V2) created by the International Foundation for Valuing Impacts (IFVI).
+Uses the [Global Value Factor Database Refactor V2](https://huggingface.co/datasets/danielrosehill/Global-Value-Factor-Database-Refactor-V2) from the International Foundation for Valuing Impacts (IFVI).
 
-The database covers:
-- 229 countries (205 with ISO codes)
-- Multiple environmental categories
-- Standardized monetary conversion factors
-- Precise decimal values for accurate calculations
+**Coverage**: 229 countries, multiple environmental categories, standardized monetary conversion factors.
 
-## Usage Examples
+## Example Queries
 
-- "Find air pollution value factors"
-- "Calculate impact for 100 tons with factor 185.50"
-- "Show value factors for Germany"
-- "Search water consumption factors"
+- "Value factor for CO2 emissions in Germany"
+- "Find air pollution factors for USA" 
+- "What's the water consumption factor in Japan?"
+- "Calculate impact for 50 tons with factor 125.75"
+- "Alternatives to methane factors if not available"
 
-## Technology Stack
-
-- **Frontend**: Gradio for interactive web interface
-- **Data Processing**: Pandas for data manipulation
-- **Dataset**: Hugging Face Datasets library
-- **Backend**: Python with efficient search and calculation algorithms
-
-## Categories Covered
-
-- Air pollution
-- Land use and conservation
-- Waste generation
-- Water consumption
-- Water pollution
-
-Perfect for researchers, sustainability professionals, ESG analysts, and anyone working with environmental impact assessment and monetization.
+Perfect for researchers, sustainability professionals, ESG analysts, and environmental impact assessment.

app.py

@@ -5,28 +5,24 @@ from datasets import load_dataset
 import json
 from typing import Dict, List, Any, Optional
 import re
-from transformers import pipeline
-import torch
+from huggingface_hub import InferenceClient
+
 
 class GVFDChatbot:
     def __init__(self):
         self.dataset = None
         self.df = None
-        self.ai_model = None
         self.load_data()
-        self.load_ai_model()
     
     def load_data(self):
         """Load the Global Value Factor Database from HuggingFace"""
         try:
-            # Try to load the dataset, handling potential CSV parsing issues
             self.dataset = load_dataset(
                 "danielrosehill/Global-Value-Factor-Database-Refactor-V2",
-                split='validation'  # Use validation split which seems to work
+                split='validation'
             )
             self.df = pd.DataFrame(self.dataset)
             print(f"Dataset loaded successfully with {len(self.df)} records")
-            print(f"Columns available: {list(self.df.columns)}")
         except Exception as e:
             print(f"Error loading dataset: {e}")
             # Create a sample dataset for testing
@@ -39,23 +35,6 @@ class GVFDChatbot:
             })
             print("Using sample dataset for testing")
     
-    def load_ai_model(self):
-        """Load local AI model for enhanced responses"""
-        try:
-            print("Loading local AI model...")
-            # Use a small, efficient model that runs locally
-            self.ai_model = pipeline(
-                "text-generation",
-                model="microsoft/DialoGPT-small",
-                tokenizer="microsoft/DialoGPT-small",
-                device_map="auto" if torch.cuda.is_available() else "cpu"
-            )
-            print("✅ Local AI model loaded successfully - completely FREE!")
-        except Exception as e:
-            print(f"⚠️ AI model loading failed: {e}")
-            print("Falling back to rule-based responses")
-            self.ai_model = None
-    
     def search_value_factors(self, query: str, category: str = "all") -> List[Dict]:
         """Search for value factors based on query and category"""
         if self.df is None or self.df.empty:
@@ -64,12 +43,10 @@ class GVFDChatbot:
         results = []
         query_lower = query.lower()
         
-        # Filter by category if specified
         df_filtered = self.df
         if category != "all" and 'category' in self.df.columns:
             df_filtered = self.df[self.df['category'].str.lower().str.contains(category.lower(), na=False)]
         
-        # Search across text columns
         text_columns = [col for col in df_filtered.columns if df_filtered[col].dtype == 'object']
         
         for _, row in df_filtered.iterrows():
@@ -83,9 +60,8 @@ class GVFDChatbot:
                 result['match_score'] = match_score
                 results.append(result)
         
-        # Sort by match score
         results.sort(key=lambda x: x['match_score'], reverse=True)
-        return results[:10]  # Return top 10 matches
+        return results[:10]
     
     def calculate_impact_value(self, impact_quantity: float, value_factor: float, country: str = "") -> Dict:
         """Calculate monetary impact value"""
@@ -101,259 +77,151 @@ class GVFDChatbot:
             "country": country,
             "calculation": f"{impact_quantity} × {value_factor} = ${monetary_impact:,.2f}"
         }
+
+
+# Initialize the chatbot
+gvfd_bot = GVFDChatbot()
+
+def respond(
+    message,
+    history: list[dict[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    hf_token: gr.OAuthToken,
+):
+    """Enhanced GVFD response with AI integration"""
+    # First, try to handle with GVFD-specific logic
+    message_lower = message.lower()
     
-    def get_country_factors(self, country: str) -> List[Dict]:
-        """Get all value factors for a specific country"""
-        if self.df is None or self.df.empty:
-            return []
-        
-        country_data = []
-        
-        # Search for country in relevant columns
-        country_columns = [col for col in self.df.columns if 'country' in col.lower() or 'iso' in col.lower()]
-        
-        for _, row in self.df.iterrows():
-            for col in country_columns:
-                if pd.notna(row[col]) and country.lower() in str(row[col]).lower():
-                    country_data.append(row.to_dict())
-                    break
-        
-        return country_data
+    # Handle calculations
+    if "calculate" in message_lower:
+        numbers = re.findall(r'\d+(?:\.\d+)?', message)
+        if len(numbers) >= 2:
+            try:
+                quantity = float(numbers[0])
+                factor = float(numbers[1])
+                result = gvfd_bot.calculate_impact_value(quantity, factor)
+                if "error" not in result:
+                    yield f"💰 **Impact Calculation**\n\n{result['calculation']}\n\n**Monetary Impact:** ${result['monetary_impact_usd']:,}"
+                    return
+            except:
+                pass
     
-    def generate_ai_response(self, message: str, context: str = "", search_results: List[Dict] = None) -> str:
-        """Generate AI-enhanced response using local model with contextualization"""
-        if not self.ai_model:
-            return None  # Fall back to rule-based
-        
-        try:
-            # Enhanced system context for value factor queries
-            system_context = """You are an expert assistant for the Global Value Factor Database (GVFD). 
-            Your role is to help users find value factors and provide guidance when exact matches aren't available.
-            
-            Key behaviors:
-            - When users ask for "value factor for X in Y country", first show what you found
-            - If no exact match, suggest similar factors, related categories, or nearby countries
-            - Explain what value factors represent and why they vary by location
-            - Guide users to alternative approaches when specific data isn't available
-            - Contextualize findings with explanations about environmental impact monetization"""
-            
-            # Build enhanced context
-            enhanced_context = context
-            if search_results:
-                if len(search_results) == 0:
-                    enhanced_context += "\n\nNo exact matches found. Suggest alternatives or related factors."
-                else:
-                    enhanced_context += f"\n\nFound {len(search_results)} matches. Help user understand the results and suggest related options."
-            
-            if enhanced_context:
-                prompt = f"{system_context}\n\nSearch results: {enhanced_context}\n\nUser query: {message}\n\nProvide a helpful response that contextualizes the findings and offers guidance:\nAssistant:"
-            else:
-                prompt = f"{system_context}\n\nUser query: {message}\n\nProvide helpful guidance about value factors:\nAssistant:"
-            
-            # Generate response
-            response = self.ai_model(
-                prompt,
-                max_length=len(prompt) + 200,  # More space for contextual responses
-                temperature=0.6,  # Slightly lower for more focused responses
-                do_sample=True,
-                pad_token_id=self.ai_model.tokenizer.eos_token_id
-            )
-            
-            # Extract just the assistant's response
-            full_text = response[0]['generated_text']
-            assistant_response = full_text.split("Assistant:")[-1].strip()
-            
-            # Clean up common AI artifacts
-            assistant_response = assistant_response.replace("User:", "").strip()
-            
-            return f"🤖 **AI Assistant:**\n\n{assistant_response}"
-            
-        except Exception as e:
-            print(f"AI generation error: {e}")
-            return None  # Fall back to rule-based
+    # Handle searches
+    elif any(keyword in message_lower for keyword in ["search", "find", "factor", "value factor for"]):
+        search_terms = message_lower
+        for word in ["search", "find", "factor", "value factor for"]:
+            search_terms = search_terms.replace(word, "")
+        search_terms = search_terms.strip()
+        
+        results = gvfd_bot.search_value_factors(search_terms)
+        
+        if results:
+            response = f"🔍 **Found {len(results)} value factors:**\n\n"
+            for i, result in enumerate(results[:3], 1):
+                key_fields = ['category', 'impact', 'value_factor', 'country', 'units']
+                shown = []
+                for field in key_fields:
+                    if field in result and pd.notna(result[field]):
+                        shown.append(f"{result[field]}")
+                response += f"**{i}.** " + " | ".join(shown[:3]) + "\n\n"
+            yield response
+            return
     
-    def process_chat_message(self, message: str, history: List[List[str]]) -> str:
-        """Process chat message and return response"""
-        message_lower = message.lower()
-        context = ""
-        
-        # Calculate impact value
-        if "calculate" in message_lower or "impact" in message_lower:
-            numbers = re.findall(r'\d+(?:\.\d+)?', message)
-            if len(numbers) >= 2:
-                try:
-                    quantity = float(numbers[0])
-                    factor = float(numbers[1])
-                    result = self.calculate_impact_value(quantity, factor)
-                    if "error" not in result:
-                        context = f"Calculated: {result['calculation']} = ${result['monetary_impact_usd']:,}"
-                        
-                        # Try AI-enhanced response
-                        ai_response = self.generate_ai_response(message, context)
-                        if ai_response:
-                            return ai_response
-                        
-                        # Fallback to basic response
-                        return f"💰 **Impact Calculation**\n\n{result['calculation']}\n\n**Monetary Impact:** ${result['monetary_impact_usd']:,}"
-                except:
-                    pass
-        
-        # Search for value factors (including "value factor for X in Y" queries)
-        elif any(keyword in message_lower for keyword in ["search", "find", "factor", "value factor for"]):
-            search_terms = message_lower
-            for word in ["search", "find", "factor", "value factor for"]:
-                search_terms = search_terms.replace(word, "")
-            search_terms = search_terms.strip()
-            
-            results = self.search_value_factors(search_terms)
-            
-            # Enhanced context for AI
-            if results:
-                context = f"Query: '{search_terms}' | Found {len(results)} matches"
-                for i, result in enumerate(results[:3]):
-                    context += f" | Match {i+1}: {result}"
-            else:
-                context = f"Query: '{search_terms}' | No exact matches found"
-            
-            # AI-enhanced response with results
-            ai_response = self.generate_ai_response(message, context, results)
-            if ai_response:
-                # Add structured data after AI response
-                if results:
-                    data_summary = f"\n\n📊 **Quick Reference:**\n"
-                    for i, result in enumerate(results[:3], 1):
-                        key_fields = ['category', 'impact', 'value_factor', 'country', 'units']
-                        shown = []
-                        for field in key_fields:
-                            if field in result and pd.notna(result[field]):
-                                shown.append(f"{result[field]}")
-                        data_summary += f"**{i}.** " + " | ".join(shown[:3]) + "\n"
-                    return ai_response + data_summary
-                return ai_response
-            
-            # Fallback to structured response
-            if results:
-                response = f"🔍 **Found {len(results)} value factors:**\n\n"
-                for i, result in enumerate(results[:5], 1):
-                    response += f"**{i}.** "
-                    key_fields = ['category', 'impact', 'value_factor', 'country', 'units']
-                    shown_fields = []
-                    
-                    for field in key_fields:
-                        if field in result and pd.notna(result[field]):
-                            shown_fields.append(f"{field.replace('_', ' ').title()}: {result[field]}")
-                    
-                    response += " | ".join(shown_fields[:3]) + "\n\n"
-                return response
-            else:
-                return "❌ No value factors found matching your search. Try different keywords or check spelling."
-        
-        # Country-specific queries (including "in [country]" patterns)
-        elif "country" in message_lower or " in " in message_lower:
-            # Extract country name more intelligently
-            words = message.split()
-            country_candidates = []
-            
-            # Look for "in [country]" patterns
-            if " in " in message_lower:
-                in_index = message_lower.split().index("in")
-                if in_index + 1 < len(words):
-                    country_candidates.append(words[in_index + 1])
-            
-            # Fallback to any capitalized words or country-like terms
-            for word in words:
-                if len(word) > 2 and (word[0].isupper() or word.lower() in ['usa', 'uk', 'us']):
-                    country_candidates.append(word)
-            
-            if country_candidates:
-                country = country_candidates[-1]  # Take the most likely candidate
-                results = self.get_country_factors(country)
-                
-                # Enhanced context for AI
-                context = f"Country query for '{country}' | Found {len(results)} factors"
-                if results:
-                    context += f" | Sample data: {results[:2]}"
-                else:
-                    context += " | No direct matches - suggest alternatives"
-                
-                # AI-enhanced response
-                ai_response = self.generate_ai_response(message, context, results)
-                if ai_response:
-                    return ai_response
+    # For general queries, use AI with GVFD context
+    if hf_token and hf_token.token:
+        try:
+            client = InferenceClient(token=hf_token.token, model="meta-llama/Llama-2-7b-chat-hf")
+            
+            # Enhanced system message for GVFD
+            enhanced_system = f"""{system_message}
+            
+            You are specifically helping with the Global Value Factor Database (GVFD). 
+            This database converts environmental impacts to USD values. Key categories include:
+            - Air pollution, Water consumption, Waste generation, Land use
+            - Covers 229 countries with standardized monetary conversion factors
+            
+            When users ask about value factors, provide helpful guidance and suggest alternatives if exact matches aren't found."""
+            
+            messages = [{"role": "system", "content": enhanced_system}]
+            messages.extend(history)
+            messages.append({"role": "user", "content": message})
+            
+            response = ""
+            for msg in client.chat_completion(
+                messages,
+                max_tokens=max_tokens,
+                stream=True,
+                temperature=temperature,
+                top_p=top_p,
+            ):
+                choices = msg.choices
+                token = ""
+                if len(choices) and choices[0].delta.content:
+                    token = choices[0].delta.content
+                response += token
+                yield response
                 
-                # Fallback
-                if results:
-                    return f"🌍 **Value factors for {country.title()}:**\n\nFound {len(results)} factors. Use 'search {country}' for detailed results."
-                else:
-                    return f"❌ No value factors found for {country.title()}. Try a different country name or check spelling."
-        
-        # General queries - try AI first
-        ai_response = self.generate_ai_response(message)
-        if ai_response:
-            return ai_response
-        
-        # Final fallback - help message
-        return """👋 **Welcome to the Global Value Factor Database Assistant!**
-
-🤖 **AI-Enhanced Responses** - Now with local AI for smarter conversations!
-
-I can help you with:
-
-🔍 **Search value factors:** "Find air pollution factors" or "Search water consumption"
-
-🧮 **Calculate impacts:** "Calculate impact for 100 units with factor 185.50"
-
-🌍 **Country data:** "Show factors for Germany" or "Country USA"
-
-📊 **Categories available:**
-- Air pollution
-- Land use and conservation  
-- Waste generation
-- Water consumption
-- Water pollution
-
-💡 **Example queries:**
-- "Value factor for CO2 emissions in Germany"
-- "Find air pollution factors for USA"
-- "What's the water consumption factor in Japan?"
-- "Calculate impact for 50 tons with factor 125.75"
-- "Alternatives to methane factors if not available"
+        except Exception as e:
+            yield f"⚠️ AI Error: {str(e)}"
+    else:
+        # Fallback response
+        yield """👋 **Welcome to the Global Value Factor Database Explorer!**
 
-✨ **Completely FREE** - AI runs locally on Hugging Face infrastructure!
+🔍 **Search**: "Find air pollution factors for USA"
+🧮 **Calculate**: "Calculate impact for 100 tons with factor 185.50"  
+🌍 **Explore**: "Value factor for CO2 emissions in Germany"
 
-What would you like to explore?"""
+💡 For enhanced AI responses, please sign in with your Hugging Face account."""
 
-# Initialize the chatbot
-chatbot = GVFDChatbot()
 
-# Create Gradio interface
-def chat_interface(message, history):
-    return chatbot.process_chat_message(message, history)
+# Create the interface with OAuth
+chatbot = gr.ChatInterface(
+    respond,
+    type="messages",
+    title="🌍 GVFD Explorer",
+    description="AI-powered exploration of the Global Value Factor Database. Search for environmental impact value factors, perform calculations, and get intelligent guidance.",
+    examples=[
+        "Value factor for CO2 emissions in Germany",
+        "Find air pollution factors for USA",
+        "Calculate impact for 100 tons with factor 185.50",
+        "What's the water consumption factor in Japan?"
+    ],
+    additional_inputs=[
+        gr.Textbox(
+            value="You are an expert assistant for the Global Value Factor Database, helping users find environmental impact value factors and perform calculations.", 
+            label="System message"
+        ),
+        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p"),
+    ],
+)
 
-# Create the Gradio app
-with gr.Blocks(title="Global Value Factor Database Assistant", theme=gr.themes.Soft()) as app:
-    gr.Markdown(
-        """
-        # 🌍 Global Value Factor Database Assistant
-        
-        Welcome to the interactive assistant for the Global Value Factor Database! This tool helps you explore environmental and social impact value factors that convert non-financial impacts into monetary values (USD).
-        
-        **Dataset:** [Global Value Factor Database Refactor V2](https://huggingface.co/datasets/danielrosehill/Global-Value-Factor-Database-Refactor-V2)
-        **Source:** International Foundation for Valuing Impacts (IFVI)
-        """
-    )
+with gr.Blocks(title="GVFD Explorer") as demo:
+    gr.Markdown("""
+    # 🌍 Global Value Factor Database Explorer
+    
+    **Dataset**: [Global Value Factor Database Refactor V2](https://huggingface.co/datasets/danielrosehill/Global-Value-Factor-Database-Refactor-V2)  
+    **Source**: International Foundation for Valuing Impacts (IFVI)  
+    **Coverage**: 229 countries, environmental impact monetization
+    """)
     
-    chatbot_interface = gr.ChatInterface(
-        chat_interface,
-        title="Chat with GVFD Assistant",
-        description="Ask questions about value factors, calculate environmental impacts, or explore data by country and category.",
-        examples=[
-            "Find air pollution value factors",
-            "Calculate impact for 100 tons with factor 185.50", 
-            "Show value factors for Germany",
-            "Search water consumption factors"
-        ]
-    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.LoginButton()
+            gr.Markdown("""
+            **Sign in for enhanced AI responses!**
+            
+            • Advanced contextual assistance
+            • Smart alternatives when data isn't found  
+            • Detailed explanations of value factors
+            """)
+        
+        with gr.Column(scale=4):
+            chatbot.render()
 
 if __name__ == "__main__":
-    app.launch()
+    demo.launch()

requirements.txt

@@ -2,7 +2,4 @@ gradio>=4.0.0
 pandas>=1.5.0
 numpy>=1.21.0
 datasets>=2.0.0
-huggingface_hub>=0.16.0
-transformers>=4.21.0
-torch>=1.9.0
-accelerate>=0.20.0
+huggingface_hub>=0.16.0