Upload 11 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AI Anytime
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,20 +1,231 @@
----
-title: KiemkeKhinhakinh
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+# YourCarbonFootprint - AI Agents powered Carbon Accounting Tool
+
+![Carbon Footprint](https://img.shields.io/badge/Carbon-Footprint-green)
+![Streamlit](https://img.shields.io/badge/Streamlit-FF4B4B?logo=streamlit&logoColor=white)
+![CrewAI](https://img.shields.io/badge/CrewAI-AI%20Agents-blue)
+![Groq](https://img.shields.io/badge/Groq-LLM-purple)
+
+A lightweight, multilingual carbon accounting and reporting tool for SMEs in Asia, with AI-powered insights and data entry.
+
+## 📋 Table of Contents
+
+- [Features](#-features)
+- [Architecture](#-architecture)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Usage](#-usage)
+- [AI Agents](#-ai-agents)
+- [Data Structure](#-data-structure)
+- [Contributing](#-contributing)
+- [License](#-license)
+
+## ✨ Features
+
+### Core Features
+- **Enterprise-Grade Data Entry**: Comprehensive form with business unit tracking, project categorization, facility details, and data quality indicators
+- **Dashboard Visualization**: Interactive charts and graphs for emissions data analysis
+- **AI-Powered Insights**: Specialized AI agents for various carbon accounting tasks
+- **Data Management**: CSV import/export, robust error handling, and automatic backups
+- **Multilingual Support**: Available in multiple languages
+
+### AI Agent Features
+| Agent | Role |
+|-------|------|
+| Data Entry Assistant | Helps users classify emissions, map to scopes, and validate data entries |
+| Report Summary Generator | Converts emission data into human-readable summaries |
+| Carbon Offset Advisor | Suggests verified offset options based on user profile and location |
+| Regulation Radar | Notifies users of upcoming compliance needs |
+| Emission Optimizer | Uses historical data to suggest reductions and savings |
+
+## 🏗 Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                       YourCarbonFootprint App                           │
+└───────────────────────────────────┬─────────────────────────────────────┘
+                                    │
+                ┌─────────────────────────────────────┐
+                │                                     │
+┌───────────────▼───────────────┐       ┌─────────────▼─────────────┐
+│      Frontend (Streamlit)     │       │      Backend Services     │
+│                               │       │                           │
+│  ┌─────────────────────────┐  │       │  ┌─────────────────────┐  │
+│  │    Navigation System    │  │       │  │   Data Management   │  │
+│  │  - Dashboard            │  │       │  │  - JSON Storage     │  │
+│  │  - Data Entry           │  │       │  │  - CSV Import       │  │
+│  │  - AI Insights          │  │       │  │  - Backup System    │  │
+│  │  - Settings             │  │       │  └─────────────────────┘  │
+│  └─────────────────────────┘  │       │                           │
+│                               │       │  ┌─────────────────────┐  │
+│  ┌─────────────────────────┐  │       │  │  AI Agent System    │  │
+│  │   Data Entry Module     │  │       │  │  - CrewAI Framework │  │
+│  │  - Enterprise Form      │◄─┼───────┼──┤  - Groq LLM         │  │
+│  │  - Validation           │  │       │  │  - Specialized      │  │
+│  │  - AI Suggestions       │  │       │  │    Agent Roles      │  │
+│  └─────────────────────────┘  │       │  └─────────────────────┘  │
+│                               │       │                           │
+│  ┌─────────────────────────┐  │       │  ┌─────────────────────┐  │
+│  │   Dashboard Module      │  │       │  │  Analytics Engine   │  │
+│  │  - Emissions Overview   │◄─┼───────┼──┤  - Data Processing  │  │
+│  │  - Charts & Graphs      │  │       │  │  - Calculations     │  │
+│  │  - Filtering            │  │       │  │  - Visualization    │  │
+│  └─────────────────────────┘  │       │  └─────────────────────┘  │
+└───────────────────────────────┘       └───────────────────────────┘
+```
+
+## 🚀 Installation
+
+### Prerequisites
+- Python 3.9+
+- Groq API key (for AI features)
+
+### Setup
+
+1. Clone the repository:
+```bash
+git clone https://github.com/AIAnytime/Your-Carbon-Footprint/tree/main.git
+cd Your-Carbon-Footprint/
+```
+
+2. Create and activate a virtual environment:
+```bash
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+```
+
+3. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+4. Create a `.env` file in the project root with your Groq API key:
+```
+GROQ_API_KEY=your_groq_api_key_here
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+- `GROQ_API_KEY`: Your Groq API key for AI agent functionality
+
+### Data Storage
+- Emissions data is stored in `data/emissions.json`
+- Company settings are stored in `data/settings.json`
+- Automatic backups are created for corrupted files with timestamped filenames
+
+## 📊 Usage
+
+### Running the Application
+
+```bash
+streamlit run app.py
+```
+
+### Navigation
+- **Dashboard**: View emissions data visualizations and analytics
+- **Data Entry**: Add new emission entries with enterprise-grade form
+- **AI Insights**: Access specialized AI agents for carbon accounting assistance
+- **Settings**: Configure company information and preferences
+
+### Data Entry Form
+The enhanced enterprise-grade data entry form includes:
+- Business unit and project tracking
+- Facility location and responsible person fields
+- Data quality indicators and verification status
+- AI-powered emission factor suggestions
+- Financial impact tracking (optional)
+
+### CSV Import/Export
+- Upload CSV files with emissions data
+- Download sample CSV template
+- Export emissions data as CSV or PDF reports
+
+## 🤖 AI Agents
+
+YourCarbonFootprint integrates five specialized AI agents using CrewAI and Groq LLM:
+
+1. **Data Entry Assistant**: Helps classify emissions and validate data entries
+2. **Report Summary Generator**: Creates human-readable summaries from emissions data
+3. **Carbon Offset Advisor**: Recommends verified carbon offset options
+4. **Regulation Radar**: Provides updates on compliance requirements
+5. **Emission Optimizer**: Suggests ways to reduce emissions based on historical data
+
+### AI Agent Implementation
+
+```python
+from crewai import Agent, Task, Crew, Process
+from crewai.llms import LLM
+
+# Initialize LLM
+llm = LLM(provider="groq", model="llama3-70b-8192")
+
+# Create an agent
+data_entry_assistant = Agent(
+    llm=llm,
+    role="Data Entry Assistant",
+    goal="Help users classify emissions, map to scopes, and validate data entries",
+    backstory="You are an expert in carbon accounting who helps users correctly categorize "
+             "their emissions data and ensure it's properly mapped to the right scope.",
+    allow_delegation=False,
+    verbose=False
+)
+
+# Create a task
+data_entry_task = Task(
+    description="Analyze the user's emission data and provide guidance on classification",
+    agent=data_entry_assistant
+)
+
+# Create and run a crew
+crew = Crew(
+    agents=[data_entry_assistant],
+    tasks=[data_entry_task],
+    verbose=False,
+    process=Process.sequential
+)
+
+result = crew.kickoff(inputs={"user_query": "How should I categorize my company's electricity usage?"})
+```
+
+## 📁 Data Structure
+
+### Emissions Data Format
+
+```json
+{
+  "date": "2025-01-15",
+  "business_unit": "Corporate",
+  "project": "Carbon Reduction Initiative",
+  "scope": "Scope 2",
+  "category": "Electricity",
+  "activity": "Office Electricity",
+  "country": "India",
+  "facility": "Mumbai HQ",
+  "responsible_person": "Rahul Sharma",
+  "quantity": 1000.0,
+  "unit": "kWh",
+  "emission_factor": 0.82,
+  "emissions_kgCO2e": 820.0,
+  "data_quality": "High",
+  "verification_status": "Internally Verified",
+  "notes": "Monthly electricity bill"
+}
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+---
+
+Built by AI Anytime with ❤️ for a sustainable future

ai_agents.py

@@ -0,0 +1,233 @@
+"""
+AI Agents for CarbonFootprint by GXS application.
+Uses CrewAI to create agents for various tasks.
+"""
+
+import os
+from dotenv import load_dotenv
+from crewai import Agent, Task, Crew, LLM
+__import__('pysqlite3')
+import sys
+sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+
+# Load environment variables
+load_dotenv()
+
+# Get Groq API key
+os.environ["GROQ_API_KEY"] = os.getenv("GROQ_API_KEY")
+
+# Initialize LLM
+def get_llm():
+    """Initialize and return the Groq LLM."""
+    return LLM(
+    model="groq/llama-3.3-70b-versatile",
+    temperature=0.7
+)
+
+# Create AI agents
+class CarbonFootprintAgents:
+    def __init__(self):
+        """Initialize the CarbonFootprintAgents class."""
+        self.llm = get_llm()
+        self._create_agents()
+    
+    def _create_agents(self):
+        """Create all the agents."""
+        # Data Entry Assistant
+        self.data_entry_assistant = Agent(
+            llm=self.llm,
+            role="Data Entry Assistant",
+            goal="Help users classify emissions, map to scopes, and validate data entries",
+            backstory="You are an expert in carbon accounting who helps users correctly categorize "
+                     "their emissions data and ensure it's properly mapped to the right scope. "
+                     "You understand the nuances of Scope 1, 2, and 3 emissions and can guide "
+                     "users to make accurate entries.",
+            allow_delegation=False,
+            verbose=False
+        )
+        
+        # Report Summary Generator
+        self.report_generator = Agent(
+            llm=self.llm,
+            role="Report Summary Generator",
+            goal="Convert emission data into human-readable summaries",
+            backstory="You are a skilled analyst who can take raw emissions data and transform it "
+                     "into clear, concise summaries that highlight key trends, areas of concern, "
+                     "and opportunities for improvement. You make complex data accessible to "
+                     "non-technical stakeholders.",
+            allow_delegation=False,
+            verbose=False
+        )
+        
+        # Carbon Offset Advisor
+        self.offset_advisor = Agent(
+            llm=self.llm,
+            role="Carbon Offset Advisor",
+            goal="Suggest verified offset options based on user profile and location",
+            backstory="You are a sustainability expert who understands the carbon offset market "
+                     "and can recommend high-quality, verified offset projects that align with "
+                     "the user's industry, values, and location. You help users navigate the "
+                     "complex world of carbon credits and offsets.",
+            allow_delegation=False,
+            verbose=False
+        )
+        
+        # Regulation Radar
+        self.regulation_radar = Agent(
+            llm=self.llm,
+            role="Regulation Radar",
+            goal="Notify users of upcoming compliance requirements",
+            backstory="You are a regulatory expert who tracks carbon-related regulations across "
+                     "different regions, with a focus on EU CBAM, Japan GX League, and Indonesia "
+                     "ETS/ETP. You help users understand what compliance requirements apply to "
+                     "them and how to prepare for upcoming changes.",
+            allow_delegation=False,
+            verbose=False
+        )
+        
+        # Emission Optimizer
+        self.emission_optimizer = Agent(
+            llm=self.llm,
+            role="Emission Optimizer",
+            goal="Use historical data to suggest reductions and savings",
+            backstory="You are a carbon reduction specialist who analyzes emissions data to "
+                     "identify patterns and opportunities for reduction. You provide practical, "
+                     "actionable recommendations that can help organizations reduce their "
+                     "carbon footprint while also saving costs.",
+            allow_delegation=False,
+            verbose=False
+        )
+    
+    def create_data_entry_task(self, data_description):
+        """Create a task for the Data Entry Assistant."""
+        return Task(
+            description=(
+                f"Analyze the following data and help classify it into the appropriate "
+                f"emission scope and category: {data_description}\n"
+                f"1. Determine if this is Scope 1, 2, or 3\n"
+                f"2. Suggest the most appropriate category\n"
+                f"3. Recommend an appropriate emission factor if possible\n"
+                f"4. Validate the data for completeness and accuracy"
+            ),
+            expected_output="A detailed classification of the emissions data with scope, "
+                           "category, and recommended emission factor.",
+            agent=self.data_entry_assistant
+        )
+    
+    def create_report_summary_task(self, emissions_data):
+        """Create a task for the Report Summary Generator."""
+        return Task(
+            description=(
+                f"Generate a comprehensive summary of the following emissions data: "
+                f"{emissions_data}\n"
+                f"1. Highlight key trends and patterns\n"
+                f"2. Identify the largest sources of emissions\n"
+                f"3. Compare performance across different time periods if data is available\n"
+                f"4. Suggest areas for potential improvement"
+            ),
+            expected_output="A clear, concise summary of the emissions data with key insights "
+                           "and recommendations.",
+            agent=self.report_generator
+        )
+    
+    def create_offset_advice_task(self, emissions_total, location, industry):
+        """Create a task for the Carbon Offset Advisor."""
+        return Task(
+            description=(
+                f"Recommend carbon offset options for an organization with the following profile:\n"
+                f"- Total emissions: {emissions_total} kgCO2e\n"
+                f"- Location: {location}\n"
+                f"- Industry: {industry}\n"
+                f"1. Suggest 3-5 verified offset projects that would be suitable\n"
+                f"2. Provide estimated costs for offsetting their emissions\n"
+                f"3. Explain the benefits and limitations of each option\n"
+                f"4. Recommend a balanced portfolio approach if appropriate"
+            ),
+            expected_output="A list of recommended carbon offset options with costs, benefits, "
+                           "and limitations for each.",
+            agent=self.offset_advisor
+        )
+    
+    def create_regulation_check_task(self, location, industry, export_markets):
+        """Create a task for the Regulation Radar."""
+        return Task(
+            description=(
+                f"Analyze the regulatory requirements for an organization with the following profile:\n"
+                f"- Location: {location}\n"
+                f"- Industry: {industry}\n"
+                f"- Export markets: {export_markets}\n"
+                f"1. Identify current compliance requirements related to carbon emissions\n"
+                f"2. Highlight upcoming regulatory changes in the next 1-2 years\n"
+                f"3. Assess the potential impact of these regulations on the organization\n"
+                f"4. Recommend preparation steps to ensure compliance"
+            ),
+            expected_output="A comprehensive overview of current and upcoming regulatory "
+                           "requirements with recommendations for compliance preparation.",
+            agent=self.regulation_radar
+        )
+    
+    def create_optimization_task(self, emissions_data):
+        """Create a task for the Emission Optimizer."""
+        return Task(
+            description=(
+                f"Analyze the following emissions data and identify opportunities for reduction: "
+                f"{emissions_data}\n"
+                f"1. Identify the top 3-5 sources of emissions that could be reduced\n"
+                f"2. Suggest practical measures to reduce emissions in each area\n"
+                f"3. Estimate potential emission reductions and cost savings where possible\n"
+                f"4. Prioritize recommendations based on impact and feasibility"
+            ),
+            expected_output="A prioritized list of emission reduction opportunities with "
+                           "estimated impacts and implementation guidance.",
+            agent=self.emission_optimizer
+        )
+    
+    def run_data_entry_crew(self, data_description):
+        """Run a crew with the Data Entry Assistant."""
+        task = self.create_data_entry_task(data_description)
+        crew = Crew(
+            agents=[self.data_entry_assistant],
+            tasks=[task],
+            verbose=False
+        )
+        return crew.kickoff()
+    
+    def run_report_summary_crew(self, emissions_data):
+        """Run a crew with the Report Summary Generator."""
+        task = self.create_report_summary_task(emissions_data)
+        crew = Crew(
+            agents=[self.report_generator],
+            tasks=[task],
+            verbose=False
+        )
+        return crew.kickoff()
+    
+    def run_offset_advice_crew(self, emissions_total, location, industry):
+        """Run a crew with the Carbon Offset Advisor."""
+        task = self.create_offset_advice_task(emissions_total, location, industry)
+        crew = Crew(
+            agents=[self.offset_advisor],
+            tasks=[task],
+            verbose=False
+        )
+        return crew.kickoff()
+    
+    def run_regulation_check_crew(self, location, industry, export_markets):
+        """Run a crew with the Regulation Radar."""
+        task = self.create_regulation_check_task(location, industry, export_markets)
+        crew = Crew(
+            agents=[self.regulation_radar],
+            tasks=[task],
+            verbose=False
+        )
+        return crew.kickoff()
+    
+    def run_optimization_crew(self, emissions_data):
+        """Run a crew with the Emission Optimizer."""
+        task = self.create_optimization_task(emissions_data)
+        crew = Crew(
+            agents=[self.emission_optimizer],
+            tasks=[task],
+            verbose=False
+        )
+        return crew.kickoff()

app.py

@@ -0,0 +1,1298 @@
+import streamlit as st
+import pandas as pd
+import os
+import json
+import shutil
+import time
+from datetime import datetime
+import plotly.express as px
+import plotly.graph_objects as go
+from dotenv import load_dotenv
+import base64
+from io import BytesIO
+
+
+# Load environment variables
+load_dotenv()
+
+# Ensure data directory exists
+os.makedirs('data', exist_ok=True)
+
+# Set page config for wide layout
+st.set_page_config(page_title="YourCarbonEmissions by GXS - Công cụ Kiểm kê Khí Nhà kính và Báo cáo KKKNK cho Doanh nghiệp SMEs", page_icon="🌍", layout="wide")
+
+# Initialize session state variables if they don't exist
+if 'language' not in st.session_state:
+    st.session_state.language = 'English'
+if 'emissions_data' not in st.session_state:
+    # Load data if exists, otherwise create empty dataframe
+    if os.path.exists('data/emissions.json'):
+        try:
+            with open('data/emissions.json', 'r') as f:
+                data = f.read().strip()
+                if data:  # Check if file is not empty
+                    try:
+                        st.session_state.emissions_data = pd.DataFrame(json.loads(data))
+                    except json.JSONDecodeError:
+                        # Create a backup of the corrupted file
+                        backup_file = f'data/emissions_backup_{int(time.time())}.json'
+                        shutil.copy('data/emissions.json', backup_file)
+                        st.warning(f"Corrupted emissions data file found. A backup has been created at {backup_file}")
+                        # Create empty dataframe
+                        st.session_state.emissions_data = pd.DataFrame(columns=[
+                            'date', 'scope', 'category', 'activity', 'quantity', 
+                            'unit', 'emission_factor', 'emissions_kgCO2e', 'notes'
+                        ])
+                else:
+                    # Empty file, create new DataFrame
+                    st.session_state.emissions_data = pd.DataFrame(columns=[
+                        'date', 'scope', 'category', 'activity', 'quantity', 
+                        'unit', 'emission_factor', 'emissions_kgCO2e', 'notes'
+                    ])
+        except Exception as e:
+            st.error(f"Error loading emissions data: {str(e)}")
+            # Create empty dataframe if loading fails
+            st.session_state.emissions_data = pd.DataFrame(columns=[
+                'date', 'scope', 'category', 'activity', 'quantity', 
+                'unit', 'emission_factor', 'emissions_kgCO2e', 'notes'
+            ])
+            # Make sure data directory exists
+            os.makedirs('data', exist_ok=True)
+    else:
+        st.session_state.emissions_data = pd.DataFrame(columns=[
+            'date', 'scope', 'category', 'activity', 'quantity', 
+            'unit', 'emission_factor', 'emissions_kgCO2e', 'notes'
+        ])
+        # Make sure data directory exists
+        os.makedirs('data', exist_ok=True)
+if 'theme' not in st.session_state:
+    st.session_state.theme = 'dark'
+if 'active_page' not in st.session_state:
+    st.session_state.active_page = "AI Insights"
+
+# Translation dictionary
+translations = {
+    'English': {
+        'title': 'YourCarbonEmissions by GXS',
+        'subtitle': 'Carbon Accounting & Reporting Tool for SMEs',
+        'dashboard': 'Dashboard',
+        'data_entry': 'Data Entry',
+        'reports': 'Reports',
+        'settings': 'Settings',
+        'about': 'About',
+        'scope1': 'Scope 1 (Direct Emissions)',
+        'scope2': 'Scope 2 (Indirect Emissions - Purchased Energy)',
+        'scope3': 'Scope 3 (Other Indirect Emissions)',
+        'date': 'Date',
+        'scope': 'Scope',
+        'category': 'Category',
+        'activity': 'Activity',
+        'quantity': 'Quantity',
+        'unit': 'Unit',
+        'emission_factor': 'Emission Factor',
+        'emissions': 'Emissions (kgCO2e)',
+        'notes': 'Notes',
+        'add_entry': 'Add Entry',
+        'upload_csv': 'Upload CSV',
+        'download_report': 'Download Report',
+        'total_emissions': 'Total Emissions',
+        'emissions_by_scope': 'Emissions by Scope',
+        'emissions_by_category': 'Emissions by Category',
+        'emissions_over_time': 'Emissions Over Time',
+        'language': 'Language',
+        'save': 'Save',
+        'cancel': 'Cancel',
+        'success': 'Success!',
+        'error': 'Error!',
+        'entry_added': 'Entry added successfully!',
+        'csv_uploaded': 'CSV uploaded successfully!',
+        'report_downloaded': 'Report downloaded successfully!',
+        'settings_saved': 'Settings saved successfully!',
+        'no_data': 'No data available.',
+        'welcome_message': 'Welcome to YourCarbonEmissions by GXS! Start by adding your emissions data or uploading a CSV file.',
+        'custom_category': 'Custom Category',
+        'custom_activity': 'Custom Activity',
+        'custom_unit': 'Custom Unit',
+        'entry_failed': 'Failed to add entry.'
+    },
+    'Vietnamese': {
+        'title': 'YourCarbonEmissions by GXS',
+        'subtitle': 'Công cụ Kiểm kê Khí Nhà kính và Báo cáo KKKNK cho Doanh nghiệp SMEs',
+        'dashboard': 'Dashboard',
+        'data_entry': 'Nhập Dữ liệu',
+        'reports': 'Các Báo cáo',
+        'settings': 'Cài đặt',
+        'about': 'Thông tin chung',
+        'scope1': 'Phạm vi 1 (Phát thải trực tiếp)',
+        'scope2': 'Phạm vi 2 (Phát thải gián tiếp - Mua Năng lượng)',
+        'scope3': 'Phạm vi 3 (Phát thải gián tiếp khác)',
+        'date': 'Ngày',
+        'scope': 'Phạm vi',
+        'category': 'Tiểu mục',
+        'activity': 'Hoạt động',
+        'quantity': 'Số lượng',
+        'unit': 'Đơn vị',
+        'emission_factor': 'Hệ số phát thải',
+        'emissions': 'Phát thải (kgCO2e)',
+        'notes': 'Ghi chú',
+        'add_entry': 'Thêm Đầu vào',
+        'upload_csv': 'Tải file CSV lên',
+        'download_report': 'Tải Báo cáo xuống',
+        'total_emissions': 'Tổng Phát thải',
+        'emissions_by_scope': 'Phát thải theo Phạm vi',
+        'emissions_by_category': 'Phát thải theo Tiểu mục',
+        'emissions_over_time': 'Phát thải qua thời gian',
+        'language': 'Ngôn ngữ',
+        'save': 'Lưu',
+        'cancel': 'Hủy bỏ',
+        'success': 'Thành công!',
+        'error': 'Lỗi!',
+        'entry_added': 'Dữ liệu đã được thêm!',
+        'csv_uploaded': 'CSV đã tải lên!',
+        'report_downloaded': 'Báo cáo đã được tải xuống!',
+        'settings_saved': 'Cài đặt đã được lưu!',
+        'no_data': 'Không có dữ liệu',
+        'welcome_message': 'Chào mừng Bạn đến YourCarbonEmissions by GXS! Bắt đầu bằng nhập dữ liệu phát thải của bạn hoặc tải file CSV lên',
+        'custom_category': 'Điều chỉnh Tiểu mục',
+        'custom_activity': 'Điều chỉnh Hoạt động',
+        'custom_unit': 'Điều chỉnh Đơn vị',
+        'entry_failed': 'Nhập Đầu vào thất bại'
+    }
+}
+
+# Function to get translated text
+def t(key):
+    lang = st.session_state.language
+    return translations.get(lang, {}).get(key, key)
+
+# Function to save emissions data
+def save_emissions_data():
+    try:
+        # Create data directory if it doesn't exist
+        os.makedirs('data', exist_ok=True)
+        
+        # Create a backup of the existing file if it exists
+        if os.path.exists('data/emissions.json'):
+            backup_path = 'data/emissions_backup.json'
+            try:
+                with open('data/emissions.json', 'r') as src, open(backup_path, 'w') as dst:
+                    dst.write(src.read())
+            except Exception:
+                # Continue even if backup fails
+                pass
+        
+        # Save data to JSON file with proper formatting
+        with open('data/emissions.json', 'w') as f:
+            if len(st.session_state.emissions_data) > 0:
+                json.dump(st.session_state.emissions_data.to_dict('records'), f, indent=2)
+            else:
+                # Write empty array if no data
+                f.write('[]')
+                
+        return True
+    except Exception as e:
+        st.error(f"Error saving data: {str(e)}")
+        return False
+
+# Function to add new emission entry
+def add_emission_entry(date, business_unit, project, scope, category, activity, country, facility, responsible_person, quantity, unit, emission_factor, data_quality, verification_status, notes):
+    """Add a new emission entry to the emissions data."""
+    try:
+        # Calculate emissions
+        emissions_kgCO2e = float(quantity) * float(emission_factor)
+        
+        # Create new entry
+        new_entry = pd.DataFrame([{
+            'date': date.strftime('%Y-%m-%d'),
+            'business_unit': business_unit,
+            'project': project,
+            'scope': scope,
+            'category': category,
+            'activity': activity,
+            'country': country,
+            'facility': facility,
+            'responsible_person': responsible_person,
+            'quantity': float(quantity),
+            'unit': unit,
+            'emission_factor': float(emission_factor),
+            'emissions_kgCO2e': emissions_kgCO2e,
+            'data_quality': data_quality,
+            'verification_status': verification_status,
+            'notes': notes
+        }])
+        
+        # Add to existing data
+        st.session_state.emissions_data = pd.concat([st.session_state.emissions_data, new_entry], ignore_index=True)
+        
+        # Save data and return success/failure
+        return save_emissions_data()
+    except Exception as e:
+        st.error(f"Error adding entry: {str(e)}")
+        return False
+
+def delete_emission_entry(index):
+    try:
+        # Make a copy of the current data
+        if len(st.session_state.emissions_data) > index:
+            # Drop the row at the specified index
+            st.session_state.emissions_data = st.session_state.emissions_data.drop(index).reset_index(drop=True)
+            
+            # Save data and return success/failure
+            return save_emissions_data()
+        else:
+            st.error("Invalid index for deletion")
+            return False
+    except Exception as e:
+        st.error(f"Error deleting entry: {str(e)}")
+        return False
+
+# Function to process uploaded CSV
+def process_csv(uploaded_file):
+    """Process uploaded CSV file and add to emissions data."""
+    try:
+        # Read CSV file
+        df = pd.read_csv(uploaded_file)
+        required_columns = ['date', 'scope', 'category', 'activity', 'quantity', 'unit', 'emission_factor']
+        
+        # Check if all required columns exist
+        if not all(col in df.columns for col in required_columns):
+            st.error(f"CSV must contain all required columns: {', '.join(required_columns)}")
+            return False
+        
+        # Validate data types
+        try:
+            # Convert quantity and emission_factor to float
+            df['quantity'] = df['quantity'].astype(float)
+            df['emission_factor'] = df['emission_factor'].astype(float)
+            
+            # Validate dates
+            df['date'] = pd.to_datetime(df['date']).dt.strftime('%Y-%m-%d')
+        except Exception as e:
+            st.error(f"Data validation error: {str(e)}")
+            return False
+        
+        # Calculate emissions if not provided
+        if 'emissions_kgCO2e' not in df.columns:
+            df['emissions_kgCO2e'] = df['quantity'] * df['emission_factor']
+        
+        # Add enterprise fields if not present
+        enterprise_fields = {
+            'business_unit': 'Corporate',
+            'project': 'Not Applicable',
+            'country': 'Vietnam',
+            'facility': '',
+            'responsible_person': '',
+            'data_quality': 'Medium',
+            'verification_status': 'Unverified',
+            'notes': ''
+        }
+        
+        # Add missing columns with default values
+        for field, default_value in enterprise_fields.items():
+            if field not in df.columns:
+                df[field] = default_value
+        
+        # Append to existing data
+        st.session_state.emissions_data = pd.concat([st.session_state.emissions_data, df], ignore_index=True)
+        
+        # Save data
+        if save_emissions_data():
+            st.success(f"Successfully added {len(df)} entries")
+            return True
+        else:
+            st.error("Failed to save data")
+            return False
+    except Exception as e:
+        st.error(f"Error processing CSV: {str(e)}")
+        return False
+
+# Function to generate PDF report
+def generate_report():
+    # Create a BytesIO object
+    buffer = BytesIO()
+    
+    # Create a simple CSV report for now
+    st.session_state.emissions_data.to_csv(buffer, index=False)
+    buffer.seek(0)
+    
+    return buffer
+
+# Custom CSS
+def local_css():
+    st.markdown('''
+    <style>
+    /* Remove default Streamlit styling */
+    #MainMenu {visibility: hidden;}
+    footer {visibility: hidden;}
+    
+    /* Base styling */
+    html, body, [class*="css"] {
+        font-family: 'Segoe UI', 'Roboto', sans-serif;
+    }
+    
+    /* Main content area */
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    
+    /* Sidebar styling - IMPORTANT: Override the dark background */
+    [data-testid="stSidebar"] {
+        background-color: #ffffff !important;
+    }
+    
+    [data-testid="stSidebar"] > div:first-child {
+        background-color: #ffffff !important;
+        padding: 2rem 1rem;
+    }
+    
+    /* Sidebar title */
+    [data-testid="stSidebar"] h1 {
+        color: #2E7D32;
+        font-size: 24px;
+        font-weight: 600;
+        margin-bottom: 0;
+    }
+    
+    /* Sidebar subtitle */
+    [data-testid="stSidebar"] p {
+        color: #555555;
+        font-size: 14px;
+    }
+    
+    /* Headings */
+    h1, h2, h3, h4, h5, h6 {
+        color: #2E7D32;
+        font-weight: 600;
+    }
+    
+    h1 {
+        font-size: 2rem;
+        margin-bottom: 1.5rem;
+    }
+    
+    h2 {
+        font-size: 1.5rem;
+        margin-top: 1.5rem;
+        margin-bottom: 1rem;
+    }
+    
+    h3 {
+        font-size: 1.2rem;
+        margin-top: 1.2rem;
+        margin-bottom: 0.8rem;
+    }
+    
+    /* Card styling */
+    div.stCard {
+        background-color: #ffffff;
+        border-radius: 8px;
+        padding: 1.5rem;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+        margin-bottom: 1.5rem;
+        border: none;
+    }
+    
+    /* Card styling */
+    .stCard {
+        background-color: white;
+        border-radius: 8px;
+        padding: 20px;
+        margin-bottom: 20px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+        border: 1px solid #f0f0f0;
+    }
+    
+    /* AI Insights card styling */
+    .stCard p {
+        margin-bottom: 10px;
+        line-height: 1.6;
+    }
+    
+    .stCard h1, .stCard h2, .stCard h3, .stCard h4 {
+        color: #2E7D32;
+        margin-top: 15px;
+        margin-bottom: 10px;
+    }
+    
+    .stCard ul, .stCard ol {
+        margin-left: 20px;
+        margin-bottom: 15px;
+    }
+    
+    .stCard table {
+        border-collapse: collapse;
+        width: 100%;
+        margin-bottom: 15px;
+    }
+    
+    .stCard th, .stCard td {
+        border: 1px solid #ddd;
+        padding: 8px;
+        text-align: left;
+    }
+    
+    .stCard th {
+        background-color: #f2f2f2;
+    }
+    
+    /* Metric cards */
+    .metric-card {
+        background-color: #ffffff;
+        border-radius: 8px;
+        padding: 1.5rem;
+        text-align: center;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.12), 0 1px 2px rgba(0,0,0,0.24);
+        border-left: 4px solid #2E7D32;
+        margin-bottom: 1rem;
+    }
+    
+    .metric-value {
+        font-size: 28px;
+        font-weight: bold;
+        margin: 0.5rem 0;
+        color: #2E7D32;
+    }
+    
+    .metric-label {
+        font-size: 14px;
+        color: #555555;
+        text-transform: uppercase;
+        letter-spacing: 1px;
+    }
+    
+    /* Buttons */
+    .stButton>button {
+        background-color: #2E7D32;
+        color: white;
+        border-radius: 4px;
+        border: none;
+        padding: 0.5rem 1rem;
+        font-size: 16px;
+        font-weight: 500;
+        transition: all 0.2s ease;
+    }
+    
+    .stButton>button:hover {
+        background-color: #388E3C;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+    }
+    
+    .stButton>button:focus {
+        box-shadow: 0 0 0 2px rgba(46, 125, 50, 0.5);
+    }
+    
+    /* Secondary buttons */
+    .stButton>button[kind="secondary"] {
+        background-color: #f8f9fa;
+        color: #2E7D32;
+        border: 1px solid #2E7D32;
+    }
+    
+    .stButton>button[kind="secondary"]:hover {
+        background-color: #f1f3f5;
+    }
+    
+    /* Tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 10px;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        background-color: #f8f9fa;
+        border-radius: 4px 4px 0px 0px;
+        padding: 10px 16px;
+        font-weight: 500;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background-color: #2E7D32 !important;
+        color: white !important;
+    }
+    
+    /* Info boxes */
+    .info-box {
+        background-color: #E3F2FD;
+        border-left: 4px solid #2196F3;
+        padding: 1rem;
+        border-radius: 4px;
+        margin: 1rem 0;
+    }
+    
+    .warning-box {
+        background-color: #FFF8E1;
+        border-left: 4px solid #FFC107;
+        padding: 1rem;
+        border-radius: 4px;
+        margin: 1rem 0;
+    }
+    
+    /* Footer */
+    .footer {
+        text-align: center;
+        padding: 1rem;
+        color: #555555;
+        font-size: 12px;
+        margin-top: 2rem;
+        border-top: 1px solid #e9ecef;
+    }
+    
+    /* Form fields */
+    [data-baseweb="input"] {
+        border-radius: 4px;
+    }
+    
+    /* Selectbox */
+    [data-baseweb="select"] {
+        border-radius: 4px;
+    }
+    
+    /* Sidebar navigation buttons */
+    [data-testid="stSidebar"] .stButton>button {
+        width: 100%;
+        text-align: left;
+        background-color: transparent;
+        color: #333333;
+        border: none;
+        padding: 0.75rem 1rem;
+        margin-bottom: 0.5rem;
+        border-radius: 4px;
+        font-weight: normal;
+        display: flex;
+        align-items: center;
+    }
+    
+    [data-testid="stSidebar"] .stButton>button:hover {
+        background-color: #f1f3f5;
+        box-shadow: none;
+    }
+    
+    /* Active navigation button */
+    [data-testid="stSidebar"] .stButton>button.active {
+        background-color: #E8F5E9;
+        border-left: 4px solid #2E7D32;
+        font-weight: 500;
+    }
+    
+    /* Divider */
+    hr {
+        margin: 1.5rem 0;
+        border: 0;
+        border-top: 1px solid #e9ecef;
+    }
+    
+    /* Dataframe styling */
+    .dataframe {
+        border-collapse: collapse;
+        width: 100%;
+        border: 1px solid #e9ecef;
+    }
+    
+    .dataframe th {
+        background-color: #f8f9fa;
+        color: #333333;
+        font-weight: 500;
+        text-align: left;
+        padding: 0.75rem;
+        border-bottom: 2px solid #e9ecef;
+    }
+    
+    .dataframe td {
+        padding: 0.75rem;
+        border-bottom: 1px solid #e9ecef;
+    }
+    
+    .dataframe tr:hover {
+        background-color: #f8f9fa;
+    }
+    </style>
+    ''', unsafe_allow_html=True)
+
+# Navigation component
+def render_navigation():
+    nav_items = [
+        {"icon": "📝", "label": "Data Entry (Nhập Dữ liệu", "id": "Data Entry"},
+        {"icon": "📊", "label": "Dashboard", "id": "Dashboard"},
+        {"icon": "🤖", "label": "AI Insights", "id": "AI Insights"},
+        {"icon": "⚙️", "label": "Settings (Cài đặt", "id": "Settings"}
+    ]
+    
+    st.markdown("### Navigation")
+    
+    for item in nav_items:
+        active_class = "active" if st.session_state.active_page == item["id"] else ""
+        if st.sidebar.button(
+            f"{item['icon']} {item['label']}", 
+            key=f"nav_{item['id']}",
+            help=f"Go to {item['label']}",
+            use_container_width=True
+        ):
+            st.session_state.active_page = item["id"]
+            st.rerun()
+
+# Metric card component
+def metric_card(title, value, description=None, icon=None, prefix="", suffix=""):
+    st.markdown(f'''
+    <div class="metric-card">
+        {f'<div style="font-size: 24px;">{icon}</div>' if icon else ''}
+        <div class="metric-label">{title}</div>
+        <div class="metric-value">{prefix}{value}{suffix}</div>
+        {f'<div style="color: #aaa; font-size: 12px;">{description}</div>' if description else ''}
+    </div>
+    ''', unsafe_allow_html=True)
+
+# Card component
+def card(content, title=None):
+    if title:
+        st.markdown(f"<div class='stCard'><h3>{title}</h3>{content}</div>", unsafe_allow_html=True)
+    else:
+        st.markdown(f"<div class='stCard'>{content}</div>", unsafe_allow_html=True)
+
+# Apply custom CSS
+local_css()
+
+# Sidebar
+with st.sidebar:
+    st.markdown(f"<h1 style='margin-bottom: 0; font-size: 24px;'>{t('title')}</h1>", unsafe_allow_html=True)
+    st.markdown(f"<p style='margin-top: 0; color: #aaa; font-size: 12px;'>{t('subtitle')}</p>", unsafe_allow_html=True)
+    
+    st.divider()
+    
+    # Language selector
+    language = st.selectbox(t('language'), ['English', 'Vietnamese'])
+    if language != st.session_state.language:
+        st.session_state.language = language
+        st.rerun()
+    
+    st.divider()
+    
+    # Navigation
+    render_navigation()
+    
+    st.divider()
+    
+    # Footer
+    st.markdown(
+        "<div class='footer' style='color: #555555;'> Copyright©2025 Created by GXS Company Limited<br>Liên hệ: Nguyễn Sơn<br>Zalo: 0376076054 - Email: contact@p4cng.biz.vn</div>",
+        unsafe_allow_html=True
+    )
+
+# Main content
+if st.session_state.active_page == "Dashboard":
+    st.markdown(f"<h1> {t('dashboard')}</h1>", unsafe_allow_html=True)
+    
+    if len(st.session_state.emissions_data) == 0:
+        st.markdown(f"<div class='info-box'>{t('welcome_message')}</div>", unsafe_allow_html=True)
+    else:
+        # Calculate metrics
+        # Ensure emissions_kgCO2e is numeric
+        st.session_state.emissions_data['emissions_kgCO2e'] = pd.to_numeric(st.session_state.emissions_data['emissions_kgCO2e'], errors='coerce')
+        
+        # Replace NaN with 0
+        st.session_state.emissions_data['emissions_kgCO2e'].fillna(0, inplace=True)
+        
+        total_emissions = st.session_state.emissions_data['emissions_kgCO2e'].sum()
+        
+        # Display metrics
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            metric_card(
+                title=t('total_emissions'),
+                value=f"{total_emissions:.2f}",
+                suffix=" kgCO2e",
+                icon="🌍"
+            )
+        with col2:
+            if 'date' in st.session_state.emissions_data.columns:
+                st.session_state.emissions_data['date'] = pd.to_datetime(st.session_state.emissions_data['date'], errors='coerce')
+                if not st.session_state.emissions_data['date'].isnull().all():
+                    latest_date = st.session_state.emissions_data['date'].max().strftime('%Y-%m-%d')
+                else:
+                    latest_date = "No date data"
+                metric_card(
+                    title="Latest Entry",
+                    value=latest_date,
+                    icon="📅"
+                )
+        with col3:
+            entry_count = len(st.session_state.emissions_data)
+            metric_card(
+                title="Total Entries",
+                value=str(entry_count),
+                icon="📊"
+            )
+        
+        # Charts
+        st.markdown(f"<h2>{t('emissions_by_scope')}</h2>", unsafe_allow_html=True)
+        
+        # Check if there are any non-zero emissions before creating charts
+        if total_emissions > 0:
+            # Create scope data for pie chart
+            scope_data = st.session_state.emissions_data.groupby('scope')['emissions_kgCO2e'].sum().reset_index()
+            
+            # Only create chart if we have data with emissions
+            if not scope_data.empty and scope_data['emissions_kgCO2e'].sum() > 0:
+                fig1 = px.pie(
+                    scope_data, 
+                    values='emissions_kgCO2e', 
+                    names='scope', 
+                    color='scope', 
+                    color_discrete_map={'Scope 1': '#4CAF50', 'Scope 2': '#2196F3', 'Scope 3': '#FFC107'},
+                    hole=0.4
+                )
+                fig1.update_layout(
+                    margin=dict(t=0, b=0, l=0, r=0),
+                    legend=dict(orientation="h", yanchor="bottom", y=-0.2, xanchor="center", x=0.5),
+                    height=400
+                )
+                st.plotly_chart(fig1, use_container_width=True, config={'displayModeBar': False})
+            else:
+                st.info("No emissions data available for scope breakdown.")
+        else:
+            st.info("No emissions data available for scope breakdown.")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown(f"<h2>{t('emissions_by_category')}</h2>", unsafe_allow_html=True)
+            
+            if total_emissions > 0:
+                # Create category data for bar chart
+                category_data = st.session_state.emissions_data.groupby('category')['emissions_kgCO2e'].sum().reset_index()
+                category_data = category_data.sort_values('emissions_kgCO2e', ascending=False)
+                
+                # Only create chart if we have data with emissions
+                if not category_data.empty and category_data['emissions_kgCO2e'].sum() > 0:
+                    fig2 = px.bar(
+                        category_data, 
+                        x='category', 
+                        y='emissions_kgCO2e', 
+                        color='category',
+                        labels={'emissions_kgCO2e': 'Emissions (kgCO2e)', 'category': 'Category'}
+                    )
+                    fig2.update_layout(
+                        showlegend=False,
+                        margin=dict(t=0, b=0, l=0, r=0),
+                        height=400
+                    )
+                    st.plotly_chart(fig2, use_container_width=True, config={'displayModeBar': False})
+                else:
+                    st.info("No emissions data available for category breakdown.")
+            else:
+                st.info("No emissions data available for category breakdown.")
+        
+        with col2:
+            st.markdown(f"<h2>{t('emissions_over_time')}</h2>", unsafe_allow_html=True)
+            
+            if total_emissions > 0 and 'date' in st.session_state.emissions_data.columns:
+                # Convert date column to datetime
+                time_data = st.session_state.emissions_data.copy()
+                time_data['date'] = pd.to_datetime(time_data['date'], errors='coerce')
+                
+                # Filter out rows with invalid dates
+                time_data = time_data.dropna(subset=['date'])
+                
+                if not time_data.empty:
+                    # Create month column for aggregation
+                    time_data['month'] = time_data['date'].dt.strftime('%Y-%m')
+                    
+                    # Group by month and scope
+                    time_data = time_data.groupby(['month', 'scope'])['emissions_kgCO2e'].sum().reset_index()
+                    
+                    if len(time_data['month'].unique()) > 0:
+                        # Create line chart
+                        fig3 = px.line(
+                            time_data, 
+                            x='month', 
+                            y='emissions_kgCO2e', 
+                            color='scope', 
+                            markers=True,
+                            color_discrete_map={'Scope 1': '#4CAF50', 'Scope 2': '#2196F3', 'Scope 3': '#FFC107'},
+                            labels={'emissions_kgCO2e': 'Emissions (kgCO2e)', 'month': 'Month', 'scope': 'Scope'}
+                        )
+                        fig3.update_layout(
+                            margin=dict(t=0, b=0, l=0, r=0),
+                            xaxis_title="",
+                            yaxis_title="kgCO2e",
+                            legend_title="",
+                            height=400
+                        )
+                        st.plotly_chart(fig3, use_container_width=True, config={'displayModeBar': False})
+                    else:
+                        st.info("Not enough time data to show emissions over time.")
+                else:
+                    st.info("No valid date data available for time series chart.")
+            else:
+                st.info("No emissions data available for time series chart.")
+
+elif st.session_state.active_page == "Data Entry":
+    st.markdown(f"<h1> {t('data_entry')}</h1>", unsafe_allow_html=True)
+    
+    tabs = st.tabs([" Manual Entry", " CSV Upload"])
+    
+    with tabs[0]:
+        st.markdown("<h3>Add New Emission Entry (Nhập Dữ liệu phát thải mới)</h3>", unsafe_allow_html=True)
+        with st.form("emission_form", border=False):
+            col1, col2 = st.columns(2)
+            with col1:
+                date = st.date_input(t('date'), datetime.now(), help="Date when the emission occurred")
+                
+                # Add business unit field for enterprise tracking with tooltip
+                business_unit = st.selectbox(
+                    "Business Unit", 
+                    ["Corporate", "Manufacturing", "Sales", "R&D", "Logistics", "IT", "Other"],
+                    help="The business unit responsible for this emission"
+                )
+                if business_unit == "Other":
+                    business_unit = st.text_input("Custom Business Unit", placeholder="Enter business unit name")
+                
+                # Add project field for better categorization with tooltip
+                project = st.selectbox(
+                    "Project", 
+                    ["Not Applicable", "Carbon Reduction Initiative", "Sustainability Program", "Operational", "Other"],
+                    help="The project or initiative associated with this emission"
+                )
+                if project == "Other":
+                    project = st.text_input("Custom Project", placeholder="Enter project name")
+                
+                # Add scope selection with tooltip explaining each scope
+                scope = st.selectbox(
+                    t('scope'), 
+                    ['Scope 1', 'Scope 2', 'Scope 3'],
+                    help="Scope 1: Direct emissions from owned sources\nScope 2: Indirect emissions from purchased energy\nScope 3: All other indirect emissions in value chain"
+                )
+                category_options = {
+                    'Scope 1': ['Stationary Combustion', 'Mobile Combustion', 'Fugitive Emissions', 'Process Emissions', 'Other'],
+                    'Scope 2': ['Electricity', 'Steam', 'Heating', 'Cooling', 'Other'],
+                    'Scope 3': ['Purchased Goods and Services', 'Capital Goods', 'Fuel- and Energy-Related Activities', 'Upstream Transportation and Distribution', 'Waste Generated in Operations', 'Business Travel', 'Employee Commuting', 'Upstream Leased Assets', 'Downstream Transportation and Distribution', 'Processing of Sold Products', 'Use of Sold Products', 'End-of-Life Treatment of Sold Products', 'Downstream Leased Assets', 'Franchises', 'Investments', 'Other']
+                }
+                category = st.selectbox(
+                    t('category'), 
+                    category_options[scope],
+                    help="The category of emission source"
+                )
+                if category == 'Other':
+                    category = st.text_input(t('custom_category'), placeholder="Enter custom category")
+                
+                # Enhanced location tracking with facility details and tooltips
+                country_options = ['Vietnam', 'India', 'United States', 'United Kingdom', 'Japan', 'Indonesia', 'Other']
+                country = st.selectbox(
+                    "Country", 
+                    country_options,
+                    help="Country where the emission occurred"
+                )
+                if country == 'Other':
+                    country = st.text_input("Custom Country", placeholder="Enter country name")
+                
+                # Add facility/location field with tooltip
+                facility = st.text_input(
+                    "Facility/Location", 
+                    placeholder="e.g., Ho Chi Minh City HQ, Binh Duong Plant 2, etc.",
+                    help="Specific facility or location where the emission occurred"
+                )
+                
+                # Add responsible person field with tooltip
+                responsible_person = st.text_input(
+                    "Responsible Person", 
+                    placeholder="Person responsible for this emission source",
+                    help="Name of the person accountable for managing this emission source"
+                )
+            with col2:
+                activity_options = {
+                    'Stationary Combustion': ['Boiler', 'Furnace', 'Generator', 'Other'],
+                    'Mobile Combustion': ['Company Vehicle', 'Fleet Vehicle', 'Machinery', 'Other'],
+                    'Fugitive Emissions': ['Refrigerant Leak', 'SF6 Emissions', 'Other'],
+                    'Process Emissions': ['Cement Production', 'Chemical Production', 'Other'],
+                    'Electricity': ['Office Electricity', 'Manufacturing Electricity', 'Other'],
+                    'Steam': ['Industrial Steam', 'Heating Steam', 'Other'],
+                    'Heating': ['Office Heating', 'Industrial Heating', 'Other'],
+                    'Cooling': ['Office Cooling', 'Industrial Cooling', 'Other'],
+                    'Purchased Goods and Services': ['Raw Materials', 'Office Supplies', 'Other'],
+                    'Capital Goods': ['Equipment Purchase', 'Vehicle Purchase', 'Other'],
+                    'Fuel- and Energy-Related Activities': ['Upstream Fuel Production', 'Transmission Losses', 'Other'],
+                    'Upstream Transportation and Distribution': ['Supplier Transport', 'Inbound Logistics', 'Other'],
+                    'Waste Generated in Operations': ['Solid Waste', 'Wastewater', 'Other'],
+                    'Business Travel': ['Air Travel', 'Ground Travel', 'Hotel Stays', 'Other'],
+                    'Employee Commuting': ['Private Vehicle', 'Public Transport', 'Other'],
+                    'Upstream Leased Assets': ['Leased Equipment', 'Leased Vehicles', 'Other'],
+                    'Downstream Transportation and Distribution': ['Outbound Logistics', 'Customer Transport', 'Other'],
+                    'Processing of Sold Products': ['Intermediate Processing', 'Final Assembly', 'Other'],
+                    'Use of Sold Products': ['Product Operation', 'Energy Consumption', 'Other'],
+                    'End-of-Life Treatment of Sold Products': ['Recycling', 'Landfill', 'Other'],
+                    'Downstream Leased Assets': ['Leased Equipment', 'Leased Property', 'Other'],
+                    'Franchises': ['Franchise Operations', 'Franchise Energy Use', 'Other'],
+                    'Investments': ['Investment Emissions', 'Financed Emissions', 'Other'],
+                    'Other': ['Custom Activity', 'Other']
+                }
+                activity_key = category if category != 'Other' else 'Other'
+                activity_list = activity_options.get(activity_key, ['Custom Activity', 'Other'])
+                activity = st.selectbox(
+                    "Activity", 
+                    activity_options.get(category, ['Other']),
+                    help="Specific activity that generated the emissions"
+                )
+                if activity == 'Other':
+                    activity = st.text_input("Custom Activity", placeholder="Enter custom activity")
+                
+                # Add validation for quantity with tooltip
+                quantity = st.number_input(
+                    t('quantity'), 
+                    min_value=0.0, 
+                    format="%.2f",
+                    help="The amount of activity (e.g., kWh used, liters consumed, etc.)"
+                )
+                
+                # Enhanced unit selection with tooltip
+                unit_options = ['kWh', 'MWh', 'GJ', 'liter', 'gallon', 'kg', 'tonne', 'km', 'mile', 'hour', 'day', 'piece', 'USD', 'Other']
+                unit = st.selectbox(
+                    t('unit'), 
+                    unit_options,
+                    help="The unit of measurement for the quantity"
+                )
+                if unit == 'Other':
+                    unit = st.text_input(t('custom_unit'), placeholder="Enter custom unit")
+                    
+                # Emission factor auto-population based on country and category
+                emission_factors = {
+                    'India': {
+                        'Electricity': 0.82, 'Mobile Combustion': 2.31, 'Stationary Combustion': 1.85, 'Other': 0.0
+                    },
+                    'United States': {
+                        'Electricity': 0.42,
+                        'Mobile Combustion': 2.32,
+                        'Stationary Combustion': 2.01,
+                        'Business Travel': 0.12,
+                        'Employee Commuting': 0.15
+                    }
+                }
+                default_factor = emission_factors.get(country, {}).get(category, 0.0) if country != 'Other' else 0.0
+                
+                # Now that default_factor is defined, show AI suggestion
+                st.info(f"💡 AI Suggestion: Based on your selections, a typical emission factor for {category} in {country} would be around {default_factor:.4f} kgCO2e per unit.")
+                
+                emission_factor = st.number_input(
+                    t('emission_factor'), 
+                    min_value=0.0, 
+                    value=default_factor, 
+                    format="%.4f",
+                    help=f"Emission factor in kgCO2e per unit. Typical range: {max(0.1, default_factor*0.8):.4f} to {default_factor*1.2:.4f}"
+                )
+                
+                # Add data quality indicator with color-coded help
+                data_quality = st.select_slider(
+                    "Data Quality",
+                    options=["Low", "Medium", "High"],
+                    value="Medium",
+                    help="🔴 Low: Estimated or proxy data\n🟡 Medium: Calculated from bills or invoices\n🟢 High: Directly measured or metered data"
+                )
+                
+                # Add verification status with detailed help
+                verification_status = st.selectbox(
+                    "Verification Status",
+                    ["Unverified", "Internally Verified", "Third-Party Verified"],
+                    help="Unverified: No verification process applied\nInternally Verified: Checked by internal team\nThird-Party Verified: Validated by external auditor"
+                )
+                
+                # Enhanced notes field with better guidance
+                notes = st.text_area(
+                    t('notes'), 
+                    placeholder="Additional information, data sources, calculation methods, etc.",
+                    help="Include information about data sources, calculation methodology, assumptions made, and any other relevant context"
+                )
+                
+                # Add cost field for financial impact tracking (optional)
+                cost = st.number_input(
+                    "Cost (Optional)", 
+                    min_value=0.0, 
+                    value=0.0,
+                    format="%.2f",
+                    help="Optional: Associated cost in your local currency"
+                )
+                
+                # Add cost currency if cost is entered
+                if cost > 0:
+                    currency = st.selectbox(
+                        "Currency",
+                        ["VND", "USD", "EUR", "INR", "GBP", "JPY", "Other"],
+                        help="Currency for the entered cost"
+                    )
+            
+            # Form submission buttons
+            col1, col2 = st.columns([1, 1])
+            with col1:
+                submitted = st.form_submit_button(t('add_entry'), type="primary", use_container_width=True)
+            with col2:
+                clear = st.form_submit_button(t('clear_form'), type="secondary", use_container_width=True)
+            
+            if submitted:
+                # Basic validation
+                if quantity <= 0:
+                    st.error("Quantity must be greater than zero.")
+                elif not facility.strip():
+                    st.warning("Facility/Location is recommended for enterprise tracking.")
+                else:
+                    try:
+                        # Include cost in the entry if provided
+                        cost_value = cost if 'cost' in locals() and cost > 0 else 0.0
+                        currency_value = currency if 'currency' in locals() and cost > 0 else ""
+                        
+                        add_emission_entry(
+                            date, business_unit, project, scope, category, activity, country, facility,
+                            responsible_person, quantity, unit, emission_factor, data_quality, verification_status, notes
+                        )
+                        st.success(t('entry_added'))
+                        # Redirect to Dashboard after successful entry
+                        st.session_state.active_page = "Dashboard"
+                        st.rerun()
+                    except Exception as e:
+                        st.error(f"{t('entry_failed')} {str(e)}")
+    
+    # Show existing data table
+    if len(st.session_state.emissions_data) > 0:
+        st.markdown("<h3>Existing Emissions Data</h3>", unsafe_allow_html=True)
+        
+        # Create a copy of the dataframe with an action column
+        display_df = st.session_state.emissions_data.copy()
+        
+        # Add a column for the delete action
+        col1, col2 = st.columns([3, 1])
+        
+        with col1:
+            # Display the dataframe
+            st.dataframe(
+                display_df,
+                column_config={
+                    "date": st.column_config.DateColumn("Date"),
+                    "business_unit": st.column_config.TextColumn("Business Unit"),
+                    "project": st.column_config.TextColumn("Project"),
+                    "scope": st.column_config.TextColumn("Scope"),
+                    "category": st.column_config.TextColumn("Category"),
+                    "activity": st.column_config.TextColumn("Activity"),
+                    "country": st.column_config.TextColumn("Country"),
+                    "facility": st.column_config.TextColumn("Facility"),
+                    "responsible_person": st.column_config.TextColumn("Responsible Person"),
+                    "quantity": st.column_config.NumberColumn("Quantity", format="%.2f"),
+                    "unit": st.column_config.TextColumn("Unit"),
+                    "emission_factor": st.column_config.NumberColumn("Emission Factor", format="%.4f"),
+                    "emissions_kgCO2e": st.column_config.NumberColumn("Emissions (kgCO2e)", format="%.2f"),
+                    "data_quality": st.column_config.TextColumn("Data Quality"),
+                    "verification_status": st.column_config.TextColumn("Verification"),
+                    "notes": st.column_config.TextColumn("Notes"),
+                },
+                use_container_width=True,
+                hide_index=False
+            )
+        
+        with col2:
+            # Add delete functionality
+            st.markdown("### Delete Entry")
+            entry_to_delete = st.number_input("Select entry number to delete", min_value=0, 
+                                           max_value=len(display_df)-1 if len(display_df) > 0 else 0, 
+                                           step=1, 
+                                           help="Enter the index number of the entry you want to delete")
+            
+            if st.button("🗑️ Delete Selected Entry", type="primary"):
+                if delete_emission_entry(entry_to_delete):
+                    st.success(f"Entry {entry_to_delete} deleted successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"Failed to delete entry {entry_to_delete}")
+        
+    
+    with tabs[1]:
+        st.markdown("<h3>Upload CSV File</h3>", unsafe_allow_html=True)
+        
+        uploaded_file = st.file_uploader(t('upload_csv'), type='csv')
+        if uploaded_file is not None:
+            if process_csv(uploaded_file):
+                st.success(t('csv_uploaded'))
+                # Redirect to Dashboard after successful upload
+                st.session_state.active_page = "Dashboard"
+                st.rerun()
+            else:
+                st.error("Failed to process CSV file. Please check the format.")
+        
+        # Sample CSV download with enterprise-grade fields
+        sample_data = {
+            'date': ['2025-01-15', '2025-01-20'],
+            'business_unit': ['Corporate', 'Logistics'],
+            'project': ['Carbon Reduction Initiative', 'Operational'],
+            'scope': ['Scope 2', 'Scope 1'],
+            'category': ['Electricity', 'Mobile Combustion'],
+            'activity': ['Office Electricity', 'Company Vehicle'],
+            'country': ['Vietnam', 'United States'],
+            'facility': ['Hanoi HQ', 'Soc Son Distribution Center'],
+            'responsible_person': ['Nguyen Thuy Trang', 'Tran Quoc Hung'],
+            'quantity': [1000, 50],
+            'unit': ['kWh', 'liter'],
+            'emission_factor': [0.82, 2.31495],
+            'data_quality': ['High', 'Medium'],
+            'verification_status': ['Internally Verified', 'Unverified'],
+            'notes': ['Monthly electricity bill', 'Fleet vehicle fuel consumption']
+        }
+        sample_df = pd.DataFrame(sample_data)
+        csv = sample_df.to_csv(index=False).encode('utf-8')
+        
+        st.download_button(
+            label="Download Sample CSV",
+            data=csv,
+            file_name="sample_emissions.csv",
+            mime="text/csv",
+        )
+
+# Reports page removed - focusing on AI features only
+
+elif st.session_state.active_page == "Settings":
+    st.markdown(f"<h1> {t('settings')}</h1>", unsafe_allow_html=True)
+    
+    st.markdown("<h3>Company Information</h3>", unsafe_allow_html=True)
+        
+    # Company info form
+    with st.form("company_info_form"):
+        col1, col2 = st.columns(2)
+        with col1:
+            company_name = st.text_input("Company Name")
+            industry = st.text_input("Industry")
+            location = st.text_input("Location")
+        with col2:
+            contact_person = st.text_input("Contact Person")
+            email = st.text_input("Email")
+            phone = st.text_input("Phone")
+        
+        st.markdown("<h4>Export Markets</h4>", unsafe_allow_html=True)
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            eu_market = st.checkbox("European Union")
+        with col2:
+            japan_market = st.checkbox("Japan")
+        with col3:
+            unitedstates_market = st.checkbox("United States")
+        
+        submitted = st.form_submit_button("Save Settings")
+        if submitted:
+            st.success("Settings saved successfully!")
+
+elif st.session_state.active_page == "AI Insights":
+    st.markdown(f"<h1>🤖 AI Insights</h1>", unsafe_allow_html=True)
+    
+    # Import AI agents
+    from ai_agents import CarbonFootprintAgents
+    
+    # Initialize AI agents
+    if 'ai_agents' not in st.session_state:
+        st.session_state.ai_agents = CarbonFootprintAgents()
+    
+    # Create tabs for different AI insights
+    ai_tabs = st.tabs(["Data Assistant", "Report Summary", "Offset Advisor", "Regulation Radar", "Emission Optimizer"])
+    
+    with ai_tabs[0]:
+        st.markdown("<h3>Data Entry Assistant</h3>", unsafe_allow_html=True)
+        st.markdown("Get help with classifying emissions and mapping them to the correct scope.")
+        
+        data_description = st.text_area("Describe your emission activity", 
+                                      placeholder="Example: We use diesel generators for backup power at our office in Hai Phong. How should I categorize this?")
+        
+        if st.button("Get Assistance", key="data_assistant_btn"):
+            if data_description:
+                with st.spinner("AI assistant is analyzing your request..."):
+                    try:
+                        result = st.session_state.ai_agents.run_data_entry_crew(data_description)
+                        # Handle CrewOutput object by converting it to string
+                        result_str = str(result)
+                        st.markdown(f"<div class='stCard'>{result_str}</div>", unsafe_allow_html=True)
+                    except Exception as e:
+                        st.error(f"Error: {str(e)}. Please check your API key and try again.")
+            else:
+                st.warning("Please describe your emission activity first.")
+    
+    with ai_tabs[1]:
+        st.markdown("<h3>Report Summary Generator</h3>", unsafe_allow_html=True)
+        st.markdown("Generate a human-readable summary of your emissions data.")
+        
+        if len(st.session_state.emissions_data) == 0:
+            st.warning("No emissions data available. Please add data first.")
+        else:
+            if st.button("Generate Summary", key="report_summary_btn"):
+                with st.spinner("Generating report summary..."):
+                    try:
+                        # Convert DataFrame to string representation for the AI
+                        emissions_str = st.session_state.emissions_data.to_string()
+                        result = st.session_state.ai_agents.run_report_summary_crew(emissions_str)
+                        # Handle CrewOutput object by converting it to string
+                        result_str = str(result)
+                        st.markdown(f"<div class='stCard'>{result_str}</div>", unsafe_allow_html=True)
+                    except Exception as e:
+                        st.error(f"Error: {str(e)}. Please check your API key and try again.")
+    
+    with ai_tabs[2]:
+        st.markdown("<h3>Carbon Offset Advisor</h3>", unsafe_allow_html=True)
+        st.markdown("Get recommendations for verified carbon offset options based on your profile.")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            location = st.text_input("Location", placeholder="e.g., Bac Ninh, Vietnam")
+            industry = st.selectbox("Industry", ["Manufacturing", "Technology", "Agriculture", "Transportation", "Energy", "Services", "Other"])
+        
+        if len(st.session_state.emissions_data) == 0:
+            st.warning("No emissions data available. Please add data first.")
+        else:
+            total_emissions = st.session_state.emissions_data['emissions_kgCO2e'].sum()
+            st.markdown(f"<p>Total emissions to offset: <strong>{total_emissions:.2f} kgCO2e</strong></p>", unsafe_allow_html=True)
+            
+            if st.button("Get Offset Recommendations", key="offset_advisor_btn"):
+                if location:
+                    with st.spinner("Finding offset options..."):
+                        try:
+                            result = st.session_state.ai_agents.run_offset_advice_crew(total_emissions, location, industry)
+                            # Handle CrewOutput object by converting it to string
+                            result_str = str(result)
+                            st.markdown(f"<div class='stCard'>{result_str}</div>", unsafe_allow_html=True)
+                        except Exception as e:
+                            st.error(f"Error: {str(e)}. Please check your API key and try again.")
+                else:
+                    st.warning("Please enter your location.")
+    
+    with ai_tabs[3]:
+        st.markdown("<h3>Regulation Radar</h3>", unsafe_allow_html=True)
+        st.markdown("Get insights on current and upcoming carbon regulations relevant to your business.")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            location = st.text_input("Company Location", placeholder="e.g., Hanoi, Vietnam", key="reg_location")
+            industry = st.selectbox("Industry Sector", ["Manufacturing", "Technology", "Agriculture", "Transportation", "Energy", "Services", "Other"], key="reg_industry")
+        with col2:
+            export_markets = st.multiselect("Export Markets", ["European Union", "Japan", "United States", "China", "Middle East", "India", "Other"])
+        
+        if st.button("Check Regulations", key="regulation_radar_btn"):
+            if location and len(export_markets) > 0:
+                with st.spinner("Analyzing regulatory requirements..."):
+                    try:
+                        result = st.session_state.ai_agents.run_regulation_check_crew(location, industry, ", ".join(export_markets))
+                        # Handle CrewOutput object by converting it to string
+                        result_str = str(result)
+                        st.markdown(f"<div class='stCard'>{result_str}</div>", unsafe_allow_html=True)
+                    except Exception as e:
+                        st.error(f"Error: {str(e)}. Please check your API key and try again.")
+            else:
+                st.warning("Please enter your location and select at least one export market.")
+    
+    with ai_tabs[4]:
+        st.markdown("<h3>Emission Optimizer</h3>", unsafe_allow_html=True)
+        st.markdown("Get AI-powered recommendations to reduce your carbon footprint.")
+        
+        if len(st.session_state.emissions_data) == 0:
+            st.warning("No emissions data available. Please add data first.")
+        else:
+            if st.button("Generate Optimization Recommendations", key="emission_optimizer_btn"):
+                with st.spinner("Analyzing your emissions data..."):
+                    try:
+                        # Convert DataFrame to string representation for the AI
+                        emissions_str = st.session_state.emissions_data.to_string()
+                        result = st.session_state.ai_agents.run_optimization_crew(emissions_str)
+                        # Handle CrewOutput object by converting it to string
+                        result_str = str(result)
+                        st.markdown(f"<div class='stCard'>{result_str}</div>", unsafe_allow_html=True)
+                    except Exception as e:
+                        st.error(f"Error: {str(e)}. Please check your API key and try again.")
+    
+# About page removed - focusing on AI features only

config.py

@@ -0,0 +1,64 @@
+"""
+Configuration settings for CarbonFootprint by GXS application.
+"""
+
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Application settings
+APP_NAME = "CarbonFootprint by GXS"
+APP_VERSION = "1.0.0"
+APP_DESCRIPTION = "A lightweight, multilingual carbon accounting and reporting tool for SMEs in Asia"
+APP_AUTHOR = "Son Nguyen"
+APP_CONTACT = "sonncdx@gmail.com"
+
+# API keys
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+# Data settings
+DATA_DIR = "data"
+EMISSIONS_FILE = os.path.join(DATA_DIR, "emissions.json")
+COMPANY_INFO_FILE = os.path.join(DATA_DIR, "company_info.json")
+
+# Supported languages
+SUPPORTED_LANGUAGES = ["English", "Vietnamese"]
+
+# Emission scopes
+EMISSION_SCOPES = ["Scope 1", "Scope 2", "Scope 3"]
+
+# Scope descriptions
+SCOPE_DESCRIPTIONS = {
+    "Scope 1": "Direct emissions from owned or controlled sources",
+    "Scope 2": "Indirect emissions from the generation of purchased energy",
+    "Scope 3": "All other indirect emissions that occur in a company's value chain"
+}
+
+# Default units
+DEFAULT_UNITS = [
+    "kWh",
+    "MWh",
+    "liter",
+    "kg",
+    "tonne",
+    "km",
+    "passenger-km",
+    "cubic meter",
+    "square meter",
+    "hour",
+    "day",
+    "piece",
+    "USD"
+]
+
+# Regulatory frameworks
+REGULATORY_FRAMEWORKS = {
+    "EU CBAM": "EU Carbon Border Adjustment Mechanism",
+    "Japan GX League": "Japan Green Transformation League",
+    "Indonesia ETS/ETP": "Indonesia Emissions Trading System/Emissions Trading Program"
+}
+
+# Create data directory if it doesn't exist
+os.makedirs(DATA_DIR, exist_ok=True)

data_handler.py

@@ -0,0 +1,382 @@
+"""
+Data handler for CarbonFootprint by GXS application.
+Manages data import, export, and processing.
+"""
+
+import pandas as pd
+import json
+import os
+from datetime import datetime
+import csv
+from io import StringIO
+from fpdf import FPDF
+import matplotlib.pyplot as plt
+import seaborn as sns
+from emission_factors import get_emission_factor, get_categories, get_activities
+
+# Constants
+DATA_DIR = "data"
+EMISSIONS_FILE = os.path.join(DATA_DIR, "emissions.json")
+COMPANY_INFO_FILE = os.path.join(DATA_DIR, "company_info.json")
+
+# Ensure data directory exists
+os.makedirs(DATA_DIR, exist_ok=True)
+
+class DataHandler:
+    def __init__(self):
+        """Initialize the DataHandler class."""
+        self.load_emissions_data()
+        self.load_company_info()
+    
+    def load_emissions_data(self):
+        """Load emissions data from file."""
+        if os.path.exists(EMISSIONS_FILE):
+            with open(EMISSIONS_FILE, 'r') as f:
+                try:
+                    self.emissions_data = pd.DataFrame(json.load(f))
+                    # Convert date strings to datetime objects
+                    if 'date' in self.emissions_data.columns:
+                        self.emissions_data['date'] = pd.to_datetime(self.emissions_data['date'])
+                except json.JSONDecodeError:
+                    self.create_empty_emissions_data()
+        else:
+            self.create_empty_emissions_data()
+    
+    def create_empty_emissions_data(self):
+        """Create empty emissions dataframe."""
+        self.emissions_data = pd.DataFrame(columns=[
+            'date', 'scope', 'category', 'activity', 'quantity', 
+            'unit', 'emission_factor', 'emissions_kgCO2e', 'notes'
+        ])
+    
+    def load_company_info(self):
+        """Load company information from file."""
+        if os.path.exists(COMPANY_INFO_FILE):
+            with open(COMPANY_INFO_FILE, 'r') as f:
+                try:
+                    self.company_info = json.load(f)
+                except json.JSONDecodeError:
+                    self.create_empty_company_info()
+        else:
+            self.create_empty_company_info()
+    
+    def create_empty_company_info(self):
+        """Create empty company information."""
+        self.company_info = {
+            "name": "",
+            "industry": "",
+            "location": "",
+            "export_markets": [],
+            "contact_person": "",
+            "email": "",
+            "phone": "",
+            "address": "",
+            "registration_number": "",
+            "reporting_year": datetime.now().year
+        }
+    
+    def save_emissions_data(self):
+        """Save emissions data to file."""
+        # Convert datetime objects to strings
+        data_to_save = self.emissions_data.copy()
+        if 'date' in data_to_save.columns:
+            data_to_save['date'] = data_to_save['date'].dt.strftime('%Y-%m-%d')
+        
+        with open(EMISSIONS_FILE, 'w') as f:
+            json.dump(data_to_save.to_dict('records'), f, indent=2)
+    
+    def save_company_info(self):
+        """Save company information to file."""
+        with open(COMPANY_INFO_FILE, 'w') as f:
+            json.dump(self.company_info, f, indent=2)
+    
+    def add_emission_entry(self, date, scope, category, activity, quantity, unit, emission_factor, notes=""):
+        """
+        Add a new emission entry.
+        
+        Args:
+            date (datetime): Date of the emission
+            scope (str): Emission scope (Scope 1, Scope 2, or Scope 3)
+            category (str): Emission category
+            activity (str): Specific activity
+            quantity (float): Quantity of activity
+            unit (str): Unit of measurement
+            emission_factor (float): Emission factor
+            notes (str, optional): Additional notes
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            # Calculate emissions
+            emissions_kgCO2e = float(quantity) * float(emission_factor)
+            
+            # Create new entry
+            new_entry = pd.DataFrame([{
+                'date': pd.Timestamp(date),
+                'scope': scope,
+                'category': category,
+                'activity': activity,
+                'quantity': float(quantity),
+                'unit': unit,
+                'emission_factor': float(emission_factor),
+                'emissions_kgCO2e': emissions_kgCO2e,
+                'notes': notes
+            }])
+            
+            # Append to existing data
+            self.emissions_data = pd.concat([self.emissions_data, new_entry], ignore_index=True)
+            
+            # Save data
+            self.save_emissions_data()
+            
+            return True
+        except Exception as e:
+            print(f"Error adding emission entry: {str(e)}")
+            return False
+    
+    def import_csv(self, file_path_or_buffer):
+        """
+        Import emissions data from CSV.
+        
+        Args:
+            file_path_or_buffer: Path to CSV file or file-like object
+            
+        Returns:
+            tuple: (success, message)
+        """
+        try:
+            # Read CSV
+            df = pd.read_csv(file_path_or_buffer)
+            
+            # Check required columns
+            required_columns = ['date', 'scope', 'category', 'activity', 'quantity', 'unit', 'emission_factor']
+            missing_columns = [col for col in required_columns if col not in df.columns]
+            
+            if missing_columns:
+                return False, f"Missing required columns: {', '.join(missing_columns)}"
+            
+            # Convert date strings to datetime objects
+            df['date'] = pd.to_datetime(df['date'])
+            
+            # Calculate emissions if not provided
+            if 'emissions_kgCO2e' not in df.columns:
+                df['emissions_kgCO2e'] = df['quantity'].astype(float) * df['emission_factor'].astype(float)
+            
+            # Add notes column if not present
+            if 'notes' not in df.columns:
+                df['notes'] = ""
+            
+            # Append to existing data
+            self.emissions_data = pd.concat([self.emissions_data, df], ignore_index=True)
+            
+            # Save data
+            self.save_emissions_data()
+            
+            return True, f"Successfully imported {len(df)} entries"
+        except Exception as e:
+            return False, f"Error importing CSV: {str(e)}"
+    
+    def export_csv(self, file_path=None, start_date=None, end_date=None):
+        """
+        Export emissions data to CSV.
+        
+        Args:
+            file_path (str, optional): Path to save CSV file
+            start_date (datetime, optional): Start date for filtering
+            end_date (datetime, optional): End date for filtering
+            
+        Returns:
+            str or bool: CSV string if file_path is None, otherwise True if successful
+        """
+        try:
+            # Filter data by date range if specified
+            data = self.emissions_data.copy()
+            if start_date and end_date:
+                mask = (data['date'] >= pd.Timestamp(start_date)) & (data['date'] <= pd.Timestamp(end_date))
+                data = data.loc[mask]
+            
+            # Convert datetime objects to strings
+            if 'date' in data.columns:
+                data['date'] = data['date'].dt.strftime('%Y-%m-%d')
+            
+            if file_path:
+                # Save to file
+                data.to_csv(file_path, index=False)
+                return True
+            else:
+                # Return CSV string
+                csv_buffer = StringIO()
+                data.to_csv(csv_buffer, index=False)
+                return csv_buffer.getvalue()
+        except Exception as e:
+            print(f"Error exporting CSV: {str(e)}")
+            return False
+    
+    def generate_pdf_report(self, file_path=None, start_date=None, end_date=None):
+        """
+        Generate PDF report.
+        
+        Args:
+            file_path (str, optional): Path to save PDF file
+            start_date (datetime, optional): Start date for filtering
+            end_date (datetime, optional): End date for filtering
+            
+        Returns:
+            bytes or bool: PDF bytes if file_path is None, otherwise True if successful
+        """
+        try:
+            # Filter data by date range if specified
+            data = self.emissions_data.copy()
+            if start_date and end_date:
+                mask = (data['date'] >= pd.Timestamp(start_date)) & (data['date'] <= pd.Timestamp(end_date))
+                data = data.loc[mask]
+            
+            # Create PDF
+            pdf = FPDF()
+            pdf.add_page()
+            
+            # Set font
+            pdf.set_font("Arial", "B", 16)
+            
+            # Title
+            pdf.cell(0, 10, "Carbon Emissions Report", 0, 1, "C")
+            pdf.set_font("Arial", "", 12)
+            
+            # Company info
+            pdf.cell(0, 10, f"Company: {self.company_info['name']}", 0, 1)
+            pdf.cell(0, 10, f"Reporting Period: {start_date.strftime('%Y-%m-%d') if start_date else 'All'} to {end_date.strftime('%Y-%m-%d') if end_date else 'All'}", 0, 1)
+            pdf.cell(0, 10, f"Generated on: {datetime.now().strftime('%Y-%m-%d')}", 0, 1)
+            
+            # Summary
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Summary", 0, 1)
+            pdf.set_font("Arial", "", 12)
+            
+            total_emissions = data['emissions_kgCO2e'].sum()
+            pdf.cell(0, 10, f"Total Emissions: {total_emissions:.2f} kgCO2e", 0, 1)
+            
+            # Emissions by scope
+            scope_data = data.groupby('scope')['emissions_kgCO2e'].sum().reset_index()
+            pdf.ln(5)
+            pdf.cell(0, 10, "Emissions by Scope:", 0, 1)
+            for _, row in scope_data.iterrows():
+                pdf.cell(0, 10, f"{row['scope']}: {row['emissions_kgCO2e']:.2f} kgCO2e ({row['emissions_kgCO2e'] / total_emissions * 100:.1f}%)", 0, 1)
+            
+            # Emissions by category
+            category_data = data.groupby('category')['emissions_kgCO2e'].sum().reset_index()
+            pdf.ln(5)
+            pdf.cell(0, 10, "Top Categories:", 0, 1)
+            for _, row in category_data.nlargest(5, 'emissions_kgCO2e').iterrows():
+                pdf.cell(0, 10, f"{row['category']}: {row['emissions_kgCO2e']:.2f} kgCO2e ({row['emissions_kgCO2e'] / total_emissions * 100:.1f}%)", 0, 1)
+            
+            # Data table
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Emissions Data", 0, 1)
+            pdf.set_font("Arial", "B", 10)
+            
+            # Table header
+            col_widths = [25, 25, 30, 30, 20, 15, 25, 30]
+            headers = ['Date', 'Scope', 'Category', 'Activity', 'Quantity', 'Unit', 'Factor', 'Emissions (kgCO2e)']
+            
+            for i, header in enumerate(headers):
+                pdf.cell(col_widths[i], 10, header, 1)
+            pdf.ln()
+            
+            # Table data
+            pdf.set_font("Arial", "", 8)
+            for _, row in data.iterrows():
+                pdf.cell(col_widths[0], 10, row['date'].strftime('%Y-%m-%d') if isinstance(row['date'], pd.Timestamp) else str(row['date']), 1)
+                pdf.cell(col_widths[1], 10, str(row['scope']), 1)
+                pdf.cell(col_widths[2], 10, str(row['category']), 1)
+                pdf.cell(col_widths[3], 10, str(row['activity']), 1)
+                pdf.cell(col_widths[4], 10, f"{row['quantity']:.2f}", 1)
+                pdf.cell(col_widths[5], 10, str(row['unit']), 1)
+                pdf.cell(col_widths[6], 10, f"{row['emission_factor']:.4f}", 1)
+                pdf.cell(col_widths[7], 10, f"{row['emissions_kgCO2e']:.2f}", 1)
+                pdf.ln()
+            
+            if file_path:
+                # Save to file
+                pdf.output(file_path)
+                return True
+            else:
+                # Return PDF bytes
+                return pdf.output(dest='S').encode('latin1')
+        except Exception as e:
+            print(f"Error generating PDF report: {str(e)}")
+            return False
+    
+    def get_emissions_summary(self):
+        """
+        Get emissions summary statistics.
+        
+        Returns:
+            dict: Summary statistics
+        """
+        if len(self.emissions_data) == 0:
+            return {
+                "total_emissions": 0,
+                "scope_breakdown": {},
+                "category_breakdown": {},
+                "time_series": {}
+            }
+        
+        # Total emissions
+        total_emissions = self.emissions_data['emissions_kgCO2e'].sum()
+        
+        # Emissions by scope
+        scope_data = self.emissions_data.groupby('scope')['emissions_kgCO2e'].sum().to_dict()
+        
+        # Emissions by category
+        category_data = self.emissions_data.groupby('category')['emissions_kgCO2e'].sum().to_dict()
+        
+        # Time series data (monthly)
+        time_data = self.emissions_data.copy()
+        if 'date' in time_data.columns and len(time_data) > 0:
+            time_data['month'] = time_data['date'].dt.strftime('%Y-%m')
+            time_series = time_data.groupby(['month', 'scope'])['emissions_kgCO2e'].sum().reset_index()
+            time_series_dict = {}
+            for _, row in time_series.iterrows():
+                if row['month'] not in time_series_dict:
+                    time_series_dict[row['month']] = {}
+                time_series_dict[row['month']][row['scope']] = row['emissions_kgCO2e']
+        else:
+            time_series_dict = {}
+        
+        return {
+            "total_emissions": total_emissions,
+            "scope_breakdown": scope_data,
+            "category_breakdown": category_data,
+            "time_series": time_series_dict
+        }
+    
+    def get_filtered_data(self, start_date=None, end_date=None, scope=None, category=None):
+        """
+        Get filtered emissions data.
+        
+        Args:
+            start_date (datetime, optional): Start date for filtering
+            end_date (datetime, optional): End date for filtering
+            scope (str, optional): Scope for filtering
+            category (str, optional): Category for filtering
+            
+        Returns:
+            pandas.DataFrame: Filtered data
+        """
+        data = self.emissions_data.copy()
+        
+        # Apply filters
+        if start_date and end_date:
+            mask = (data['date'] >= pd.Timestamp(start_date)) & (data['date'] <= pd.Timestamp(end_date))
+            data = data.loc[mask]
+        
+        if scope:
+            data = data[data['scope'] == scope]
+        
+        if category:
+            data = data[data['category'] == category]
+        
+        return data

emission_factors.py

@@ -0,0 +1,172 @@
+"""
+Emission factors database for CarbonFootprint by GXS application.
+Based on DEFRA/IPCC datasets for common emission sources.
+"""
+
+# Emission factors by category (in kgCO2e per unit)
+EMISSION_FACTORS = {
+    # Scope 1 - Direct emissions
+    "Stationary Combustion": {
+        "Natural Gas": {"factor": 0.18316, "unit": "kWh"},
+        "Diesel": {"factor": 2.68787, "unit": "liter"},
+        "LPG": {"factor": 1.55537, "unit": "kg"},
+        "Coal": {"factor": 2.42287, "unit": "kg"},
+    },
+    "Mobile Combustion": {
+        "Petrol/Gasoline": {"factor": 2.31495, "unit": "liter"},
+        "Diesel": {"factor": 2.70553, "unit": "liter"},
+        "LPG": {"factor": 1.55537, "unit": "liter"},
+        "CNG": {"factor": 2.53721, "unit": "kg"},
+    },
+    "Refrigerants": {
+        "R-410A": {"factor": 2088.0, "unit": "kg"},
+        "R-134a": {"factor": 1430.0, "unit": "kg"},
+        "R-404A": {"factor": 3922.0, "unit": "kg"},
+        "R-407C": {"factor": 1774.0, "unit": "kg"},
+    },
+    
+    # Scope 2 - Indirect emissions from purchased energy
+    "Electricity": {
+        "Vietnam Grid": {"factor": 0.6592, "unit": "kWh"},
+        "India Grid": {"factor": 0.82, "unit": "kWh"},
+        "Indonesia Grid": {"factor": 0.87, "unit": "kWh"},
+        "Japan Grid": {"factor": 0.47, "unit": "kWh"},
+        "Solar Power": {"factor": 0.041, "unit": "kWh"},
+        "Wind Power": {"factor": 0.011, "unit": "kWh"},
+    },
+    "Steam": {
+        "Purchased Steam": {"factor": 0.19, "unit": "kg"},
+    },
+    "District Cooling": {
+        "District Cooling": {"factor": 0.12, "unit": "kWh"},
+    },
+    
+    # Scope 3 - Other indirect emissions
+    "Business Travel": {
+        "Short-haul Flight": {"factor": 0.15298, "unit": "passenger-km"},
+        "Long-haul Flight": {"factor": 0.19085, "unit": "passenger-km"},
+        "Train": {"factor": 0.03694, "unit": "passenger-km"},
+        "Bus": {"factor": 0.10471, "unit": "passenger-km"},
+        "Taxi": {"factor": 0.14549, "unit": "km"},
+    },
+    "Employee Commuting": {
+        "Car (Petrol/Gasoline)": {"factor": 0.17336, "unit": "km"},
+        "Car (Diesel)": {"factor": 0.16844, "unit": "km"},
+        "Motorcycle": {"factor": 0.11501, "unit": "km"},
+        "Bus": {"factor": 0.10471, "unit": "passenger-km"},
+        "Train/Metro": {"factor": 0.03694, "unit": "passenger-km"},
+    },
+    "Waste": {
+        "Landfill": {"factor": 0.45727, "unit": "kg"},
+        "Recycling": {"factor": 0.01042, "unit": "kg"},
+        "Composting": {"factor": 0.01042, "unit": "kg"},
+        "Incineration": {"factor": 0.01613, "unit": "kg"},
+    },
+    "Water": {
+        "Water Supply": {"factor": 0.344, "unit": "cubic meter"},
+        "Water Treatment": {"factor": 0.708, "unit": "cubic meter"},
+    },
+    "Purchased Goods & Services": {
+        "Paper": {"factor": 0.919, "unit": "kg"},
+        "Plastic": {"factor": 3.14, "unit": "kg"},
+        "Glass": {"factor": 0.85, "unit": "kg"},
+        "Metal": {"factor": 1.37, "unit": "kg"},
+        "Food": {"factor": 3.59, "unit": "kg"},
+    },
+}
+
+# Scope categories
+SCOPE_CATEGORIES = {
+    "Scope 1": [
+        "Stationary Combustion",
+        "Mobile Combustion",
+        "Refrigerants",
+        "Process Emissions",
+        "Fugitive Emissions"
+    ],
+    "Scope 2": [
+        "Electricity",
+        "Steam",
+        "District Cooling",
+        "District Heating"
+    ],
+    "Scope 3": [
+        "Business Travel",
+        "Employee Commuting",
+        "Waste",
+        "Water",
+        "Purchased Goods & Services",
+        "Capital Goods",
+        "Fuel and Energy-Related Activities",
+        "Upstream Transportation & Distribution",
+        "Downstream Transportation & Distribution",
+        "Use of Sold Products",
+        "End-of-Life Treatment of Sold Products",
+        "Leased Assets",
+        "Franchises",
+        "Investments"
+    ]
+}
+
+# Get emission factor for a specific activity
+def get_emission_factor(category, activity):
+    """
+    Get the emission factor for a specific activity within a category.
+    
+    Args:
+        category (str): The emission category
+        activity (str): The specific activity
+        
+    Returns:
+        dict: Dictionary containing factor and unit, or None if not found
+    """
+    if category in EMISSION_FACTORS and activity in EMISSION_FACTORS[category]:
+        return EMISSION_FACTORS[category][activity]
+    return None
+
+# Get all activities for a category
+def get_activities(category):
+    """
+    Get all activities for a specific category.
+    
+    Args:
+        category (str): The emission category
+        
+    Returns:
+        list: List of activities for the category, or empty list if category not found
+    """
+    if category in EMISSION_FACTORS:
+        return list(EMISSION_FACTORS[category].keys())
+    return []
+
+# Get all categories for a scope
+def get_categories(scope):
+    """
+    Get all categories for a specific scope.
+    
+    Args:
+        scope (str): The scope (Scope 1, Scope 2, or Scope 3)
+        
+    Returns:
+        list: List of categories for the scope, or empty list if scope not found
+    """
+    if scope in SCOPE_CATEGORIES:
+        return SCOPE_CATEGORIES[scope]
+    return []
+
+# Get unit for a specific activity
+def get_unit(category, activity):
+    """
+    Get the unit for a specific activity within a category.
+    
+    Args:
+        category (str): The emission category
+        activity (str): The specific activity
+        
+    Returns:
+        str: Unit for the activity, or None if not found
+    """
+    ef = get_emission_factor(category, activity)
+    if ef:
+        return ef["unit"]
+    return None

pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "yourcarbonfootprint"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "crewai>=0.140.0",
+    "crewai-tools>=0.49.0",
+    "langchain>=0.3.26",
+    "langchain-community>=0.3.27",
+    "langchain-core>=0.3.68",
+    "langchain-google-genai>=2.1.6",
+    "langchain-groq>=0.3.5",
+    "plotly>=6.2.0",
+    "python-dotenv>=1.1.1",
+    "streamlit>=1.46.1",
+    "xlsxwriter>=3.2.5",    
+]

report_generator.py

@@ -0,0 +1,314 @@
+"""
+Report generator for CarbonFootprint by GXS application.
+Generates PDF reports and visualizations.
+"""
+
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import plotly.express as px
+import plotly.graph_objects as go
+from fpdf import FPDF
+import os
+from datetime import datetime
+import base64
+from io import BytesIO
+
+class ReportGenerator:
+    def __init__(self, data_handler):
+        """Initialize the ReportGenerator class."""
+        self.data_handler = data_handler
+    
+    def generate_pdf_report(self, file_path=None, start_date=None, end_date=None, company_info=None):
+        """
+        Generate PDF report.
+        
+        Args:
+            file_path (str, optional): Path to save PDF file
+            start_date (datetime, optional): Start date for filtering
+            end_date (datetime, optional): End date for filtering
+            company_info (dict, optional): Company information
+            
+        Returns:
+            bytes or bool: PDF bytes if file_path is None, otherwise True if successful
+        """
+        try:
+            # Get filtered data
+            data = self.data_handler.get_filtered_data(start_date, end_date)
+            
+            if len(data) == 0:
+                return False, "No data available for the selected period."
+            
+            # Create PDF
+            pdf = FPDF()
+            pdf.add_page()
+            
+            # Set font
+            pdf.set_font("Arial", "B", 16)
+            
+            # Title
+            pdf.cell(0, 10, "Carbon Emissions Report", 0, 1, "C")
+            pdf.set_font("Arial", "", 12)
+            
+            # Company info
+            if company_info:
+                pdf.cell(0, 10, f"Company: {company_info.get('name', 'N/A')}", 0, 1)
+                pdf.cell(0, 10, f"Industry: {company_info.get('industry', 'N/A')}", 0, 1)
+                pdf.cell(0, 10, f"Location: {company_info.get('location', 'N/A')}", 0, 1)
+            
+            # Reporting period
+            pdf.cell(0, 10, f"Reporting Period: {start_date.strftime('%Y-%m-%d') if start_date else 'All'} to {end_date.strftime('%Y-%m-%d') if end_date else 'All'}", 0, 1)
+            pdf.cell(0, 10, f"Generated on: {datetime.now().strftime('%Y-%m-%d')}", 0, 1)
+            
+            # Summary
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Summary", 0, 1)
+            pdf.set_font("Arial", "", 12)
+            
+            total_emissions = data['emissions_kgCO2e'].sum()
+            pdf.cell(0, 10, f"Total Emissions: {total_emissions:.2f} kgCO2e", 0, 1)
+            
+            # Emissions by scope
+            scope_data = data.groupby('scope')['emissions_kgCO2e'].sum().reset_index()
+            pdf.ln(5)
+            pdf.cell(0, 10, "Emissions by Scope:", 0, 1)
+            for _, row in scope_data.iterrows():
+                pdf.cell(0, 10, f"{row['scope']}: {row['emissions_kgCO2e']:.2f} kgCO2e ({row['emissions_kgCO2e'] / total_emissions * 100:.1f}%)", 0, 1)
+            
+            # Emissions by category
+            category_data = data.groupby('category')['emissions_kgCO2e'].sum().reset_index()
+            pdf.ln(5)
+            pdf.cell(0, 10, "Top Categories:", 0, 1)
+            for _, row in category_data.nlargest(5, 'emissions_kgCO2e').iterrows():
+                pdf.cell(0, 10, f"{row['category']}: {row['emissions_kgCO2e']:.2f} kgCO2e ({row['emissions_kgCO2e'] / total_emissions * 100:.1f}%)", 0, 1)
+            
+            # Data table
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Emissions Data", 0, 1)
+            pdf.set_font("Arial", "B", 10)
+            
+            # Table header
+            col_widths = [25, 25, 30, 30, 20, 15, 25, 30]
+            headers = ['Date', 'Scope', 'Category', 'Activity', 'Quantity', 'Unit', 'Factor', 'Emissions (kgCO2e)']
+            
+            for i, header in enumerate(headers):
+                pdf.cell(col_widths[i], 10, header, 1)
+            pdf.ln()
+            
+            # Table data
+            pdf.set_font("Arial", "", 8)
+            for _, row in data.iterrows():
+                pdf.cell(col_widths[0], 10, row['date'].strftime('%Y-%m-%d') if isinstance(row['date'], pd.Timestamp) else str(row['date']), 1)
+                pdf.cell(col_widths[1], 10, str(row['scope']), 1)
+                pdf.cell(col_widths[2], 10, str(row['category']), 1)
+                pdf.cell(col_widths[3], 10, str(row['activity']), 1)
+                pdf.cell(col_widths[4], 10, f"{row['quantity']:.2f}", 1)
+                pdf.cell(col_widths[5], 10, str(row['unit']), 1)
+                pdf.cell(col_widths[6], 10, f"{row['emission_factor']:.4f}", 1)
+                pdf.cell(col_widths[7], 10, f"{row['emissions_kgCO2e']:.2f}", 1)
+                pdf.ln()
+            
+            # Compliance section
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Regulatory Compliance", 0, 1)
+            pdf.set_font("Arial", "", 12)
+            
+            pdf.cell(0, 10, "EU CBAM: This report can be used as supporting documentation for EU CBAM compliance.", 0, 1)
+            pdf.cell(0, 10, "Japan GX League: This report follows the GX League reporting format.", 0, 1)
+            pdf.cell(0, 10, "Indonesia ETS/ETP: This report can be used for Indonesia ETS/ETP compliance.", 0, 1)
+            
+            # Recommendations
+            pdf.ln(10)
+            pdf.set_font("Arial", "B", 14)
+            pdf.cell(0, 10, "Recommendations", 0, 1)
+            pdf.set_font("Arial", "", 12)
+            
+            pdf.cell(0, 10, "1. Focus on reducing emissions from the top categories identified in this report.", 0, 1)
+            pdf.cell(0, 10, "2. Consider implementing energy efficiency measures for Scope 2 emissions.", 0, 1)
+            pdf.cell(0, 10, "3. Explore renewable energy options to reduce your carbon footprint.", 0, 1)
+            pdf.cell(0, 10, "4. Engage with suppliers to address Scope 3 emissions in your value chain.", 0, 1)
+            
+            if file_path:
+                # Save to file
+                pdf.output(file_path)
+                return True, "Report generated successfully."
+            else:
+                # Return PDF bytes
+                return pdf.output(dest='S').encode('latin1'), "Report generated successfully."
+        except Exception as e:
+            return False, f"Error generating PDF report: {str(e)}"
+    
+    def create_scope_pie_chart(self, data):
+        """
+        Create pie chart of emissions by scope.
+        
+        Args:
+            data (pandas.DataFrame): Emissions data
+            
+        Returns:
+            plotly.graph_objects.Figure: Pie chart figure
+        """
+        scope_data = data.groupby('scope')['emissions_kgCO2e'].sum().reset_index()
+        fig = px.pie(
+            scope_data, 
+            values='emissions_kgCO2e', 
+            names='scope',
+            color='scope',
+            color_discrete_map={
+                'Scope 1': '#4CAF50', 
+                'Scope 2': '#2196F3', 
+                'Scope 3': '#FFC107'
+            },
+            title='Emissions by Scope'
+        )
+        fig.update_layout(
+            legend_title="Scope",
+            font=dict(size=12),
+            margin=dict(t=50, b=20, l=20, r=20)
+        )
+        return fig
+    
+    def create_category_bar_chart(self, data):
+        """
+        Create bar chart of emissions by category.
+        
+        Args:
+            data (pandas.DataFrame): Emissions data
+            
+        Returns:
+            plotly.graph_objects.Figure: Bar chart figure
+        """
+        category_data = data.groupby('category')['emissions_kgCO2e'].sum().reset_index()
+        category_data = category_data.sort_values('emissions_kgCO2e', ascending=False)
+        fig = px.bar(
+            category_data, 
+            x='category', 
+            y='emissions_kgCO2e',
+            color='category',
+            title='Emissions by Category'
+        )
+        fig.update_layout(
+            xaxis_title="Category",
+            yaxis_title="Emissions (kgCO2e)",
+            legend_title="Category",
+            font=dict(size=12),
+            margin=dict(t=50, b=100, l=50, r=20),
+            xaxis_tickangle=-45
+        )
+        return fig
+    
+    def create_time_series_chart(self, data):
+        """
+        Create time series chart of emissions over time.
+        
+        Args:
+            data (pandas.DataFrame): Emissions data
+            
+        Returns:
+            plotly.graph_objects.Figure: Line chart figure
+        """
+        if 'date' not in data.columns or len(data) == 0:
+            # Create empty figure if no data
+            fig = go.Figure()
+            fig.update_layout(
+                title='Emissions Over Time',
+                xaxis_title="Month",
+                yaxis_title="Emissions (kgCO2e)",
+                font=dict(size=12),
+                margin=dict(t=50, b=50, l=50, r=20)
+            )
+            return fig
+        
+        # Group by month and scope
+        time_data = data.copy()
+        time_data['month'] = pd.to_datetime(time_data['date']).dt.strftime('%Y-%m')
+        time_data = time_data.groupby(['month', 'scope'])['emissions_kgCO2e'].sum().reset_index()
+        
+        fig = px.line(
+            time_data, 
+            x='month', 
+            y='emissions_kgCO2e',
+            color='scope',
+            markers=True,
+            title='Emissions Over Time'
+        )
+        fig.update_layout(
+            xaxis_title="Month",
+            yaxis_title="Emissions (kgCO2e)",
+            legend_title="Scope",
+            font=dict(size=12),
+            margin=dict(t=50, b=50, l=50, r=20)
+        )
+        return fig
+    
+    def create_activity_treemap(self, data):
+        """
+        Create treemap of emissions by scope, category, and activity.
+        
+        Args:
+            data (pandas.DataFrame): Emissions data
+            
+        Returns:
+            plotly.graph_objects.Figure: Treemap figure
+        """
+        fig = px.treemap(
+            data,
+            path=['scope', 'category', 'activity'],
+            values='emissions_kgCO2e',
+            color='scope',
+            color_discrete_map={
+                'Scope 1': '#4CAF50', 
+                'Scope 2': '#2196F3', 
+                'Scope 3': '#FFC107'
+            },
+            title='Emissions Breakdown'
+        )
+        fig.update_layout(
+            margin=dict(t=50, b=20, l=20, r=20),
+            font=dict(size=12)
+        )
+        return fig
+    
+    def create_monthly_comparison_chart(self, data):
+        """
+        Create bar chart comparing emissions by month.
+        
+        Args:
+            data (pandas.DataFrame): Emissions data
+            
+        Returns:
+            plotly.graph_objects.Figure: Bar chart figure
+        """
+        if 'date' not in data.columns or len(data) == 0:
+            # Create empty figure if no data
+            fig = go.Figure()
+            fig.update_layout(
+                title='Monthly Emissions Comparison',
+                xaxis_title="Month",
+                yaxis_title="Emissions (kgCO2e)",
+                font=dict(size=12),
+                margin=dict(t=50, b=50, l=50, r=20)
+            )
+            return fig
+        
+        # Group by month
+        monthly_data = data.copy()
+        monthly_data['month'] = pd.to_datetime(monthly_data['date']).dt.strftime('%Y-%m')
+        monthly_data = monthly_data.groupby('month')['emissions_kgCO2e'].sum().reset_index()
+        
+        fig = px.bar(
+            monthly_data,
+            x='month',
+            y='emissions_kgCO2e',
+            title='Monthly Emissions Comparison'
+        )
+        fig.update_layout(
+            xaxis_title="Month",
+            yaxis_title="Emissions (kgCO2e)",
+            font=dict(size=12),
+            margin=dict(t=50, b=50, l=50, r=20)
+        )
+        return fig

requirements.txt

@@ -1,3 +1,14 @@
-altair
-pandas
-streamlit
+streamlit
+python-dotenv
+crewai
+crewai_tools
+pandas
+plotly
+matplotlib
+seaborn
+fpdf
+langchain_groq
+faiss-cpu
+gunicorn
+chromadb
+pysqlite3-binary