Upload 3 files

src/Pages/1_Search.py

@@ -0,0 +1,384 @@
+import streamlit as st
+import wikipedia
+import re
+import requests
+from PIL import Image
+import io
+
+# Page configuration
+st.set_page_config(page_title="🔍 Search Car Info", layout="centered")
+st.title("🔍 Search Car Info")
+
+# Enhanced Wikipedia Functions
+def fetch_single_car_info(car_name):
+    """Enhanced function to fetch car info with better error handling and data extraction"""
+    try:
+        # Try different search variations for better results
+        search_variations = [
+            car_name,
+            f"{car_name} car",
+            f"{car_name} automobile",
+            f"{car_name} vehicle",
+            car_name.replace(" ", "_")
+        ]
+        
+        for variation in search_variations:
+            try:
+                # Get Wikipedia page
+                page = wikipedia.page(variation)
+                
+                # Get enhanced summary with more sentences
+                summary = wikipedia.summary(variation, sentences=12)
+                
+                # Clean summary from references
+                clean_summary = re.sub(r'\[\d+\]', '', summary)
+                clean_summary = re.sub(r'\([^)]*\)', '', clean_summary)  # Remove parenthetical references
+                
+                # Get the best quality image
+                image_url = None
+                if page.images:
+                    # Filter for car-related images and common formats
+                    for img in page.images[:5]:  # Check first 5 images
+                        if any(ext in img.lower() for ext in ['.jpg', '.jpeg', '.png', '.webp']):
+                            # Avoid common non-car images
+                            if not any(avoid in img.lower() for avoid in ['commons-logo', 'wiki', 'edit-icon', 'flag']):
+                                image_url = img
+                                break
+                
+                # Extract additional info from content
+                content = page.content
+                
+                # Extract specifications if available
+                specs = extract_specifications(content)
+                
+                # Extract infobox data if available
+                infobox_data = extract_infobox_data(content)
+                
+                return {
+                    'summary': clean_summary,
+                    'image_url': image_url,
+                    'page_url': page.url,
+                    'title': page.title,
+                    'specifications': specs,
+                    'infobox': infobox_data,
+                    'full_content': content[:2000]  # First 2000 chars for additional info
+                }
+                
+            except wikipedia.exceptions.DisambiguationError as e:
+                # Handle disambiguation by trying the most relevant option
+                for option in e.options[:3]:  # Try first 3 options
+                    if any(keyword in option.lower() for keyword in ['car', 'automobile', 'vehicle', car_name.lower()]):
+                        try:
+                            page = wikipedia.page(option)
+                            summary = wikipedia.summary(option, sentences=10)
+                            clean_summary = re.sub(r'\[\d+\]', '', summary)
+                            image_url = page.images[0] if page.images else None
+                            
+                            specs = extract_specifications(page.content)
+                            infobox_data = extract_infobox_data(page.content)
+                            
+                            return {
+                                'summary': clean_summary,
+                                'image_url': image_url,
+                                'page_url': page.url,
+                                'title': page.title,
+                                'specifications': specs,
+                                'infobox': infobox_data,
+                                'full_content': page.content[:2000]
+                            }
+                        except:
+                            continue
+            except wikipedia.exceptions.PageError:
+                continue
+            except Exception as e:
+                continue
+        
+        return None
+    except Exception as e:
+        return None
+
+def extract_specifications(content):
+    """Extract car specifications from Wikipedia content"""
+    specs = {}
+    
+    # Common specification patterns
+    spec_patterns = {
+        'Engine': r'[Ee]ngine[:\s]*([^\n.]+)',
+        'Power': r'[Pp]ower[:\s]*([^\n.]+)',
+        'Torque': r'[Tt]orque[:\s]*([^\n.]+)',
+        'Top Speed': r'[Tt]op [Ss]peed[:\s]*([^\n.]+)',
+        'Acceleration': r'0[-–]60[:\s]*([^\n.]+)|0[-–]100[:\s]*([^\n.]+)',
+        'Fuel Economy': r'[Ff]uel [Ee]conomy[:\s]*([^\n.]+)|[Mm]ileage[:\s]*([^\n.]+)',
+        'Length': r'[Ll]ength[:\s]*([^\n.]+)',
+        'Width': r'[Ww]idth[:\s]*([^\n.]+)',
+        'Height': r'[Hh]eight[:\s]*([^\n.]+)',
+        'Wheelbase': r'[Ww]heelbase[:\s]*([^\n.]+)',
+        'Weight': r'[Ww]eight[:\s]*([^\n.]+)|[Cc]urb [Ww]eight[:\s]*([^\n.]+)'
+    }
+    
+    for spec_name, pattern in spec_patterns.items():
+        matches = re.findall(pattern, content, re.IGNORECASE)
+        if matches:
+            # Get the first non-empty match
+            for match in matches:
+                if isinstance(match, tuple):
+                    match = next((m for m in match if m), '')
+                if match and len(match.strip()) > 0:
+                    specs[spec_name] = match.strip()[:100]  # Limit length
+                    break
+    
+    return specs
+
+def extract_infobox_data(content):
+    """Extract infobox-style data from Wikipedia content"""
+    infobox = {}
+    
+    # Look for common car infobox patterns
+    infobox_patterns = {
+        'Manufacturer': r'[Mm]anufacturer[:\s]*([^\n.]+)',
+        'Production': r'[Pp]roduction[:\s]*([^\n.]+)',
+        'Assembly': r'[Aa]ssembly[:\s]*([^\n.]+)',
+        'Designer': r'[Dd]esigner[:\s]*([^\n.]+)',
+        'Body Style': r'[Bb]ody [Ss]tyle[:\s]*([^\n.]+)',
+        'Layout': r'[Ll]ayout[:\s]*([^\n.]+)',
+        'Platform': r'[Pp]latform[:\s]*([^\n.]+)',
+        'Related': r'[Rr]elated[:\s]*([^\n.]+)',
+        'Predecessor': r'[Pp]redecessor[:\s]*([^\n.]+)',
+        'Successor': r'[Ss]uccessor[:\s]*([^\n.]+)'
+    }
+    
+    for key, pattern in infobox_patterns.items():
+        matches = re.findall(pattern, content, re.IGNORECASE)
+        if matches:
+            infobox[key] = matches[0].strip()[:150]  # Limit length
+    
+    return infobox
+
+def fetch_versions(query):
+    """Enhanced function to fetch car versions with better filtering"""
+    try:
+        # Get more search results
+        results = wikipedia.search(query, results=15)
+        
+        # Enhanced filtering for car-related results
+        car_keywords = ['car', 'automobile', 'vehicle', 'motor', 'auto', 'sedan', 'suv', 'hatchback', 'coupe', 'convertible']
+        brand_keywords = ['toyota', 'honda', 'ford', 'bmw', 'mercedes', 'audi', 'volkswagen', 'nissan', 'hyundai', 'kia', 'mazda', 'subaru', 'lexus', 'acura', 'infiniti', 'tata', 'maruti', 'mahindra', 'bajaj']
+        
+        filtered_results = []
+        query_lower = query.lower()
+        
+        for result in results:
+            result_lower = result.lower()
+            
+            # Include if it contains the query or car-related keywords
+            if (query_lower in result_lower or 
+                any(keyword in result_lower for keyword in car_keywords) or
+                any(brand in result_lower for brand in brand_keywords)):
+                
+                # Exclude irrelevant results
+                if not any(exclude in result_lower for exclude in ['biography', 'politician', 'actor', 'singer', 'company', 'corporation']):
+                    filtered_results.append(result)
+        
+        # Sort by relevance (prefer results with years, exact matches first)
+        def sort_key(x):
+            score = 0
+            x_lower = x.lower()
+            
+            # Exact query match gets highest score
+            if query_lower == x_lower:
+                score += 1000
+            elif query_lower in x_lower:
+                score += 500
+            
+            # Results with years get higher score
+            if re.search(r'\d{4}', x):
+                score += 100
+            
+            # Car-specific terms get higher score
+            for keyword in car_keywords:
+                if keyword in x_lower:
+                    score += 50
+            
+            return score
+        
+        sorted_versions = sorted(filtered_results, key=sort_key, reverse=True)
+        return sorted_versions[:8]  # Return top 8 results
+        
+    except Exception as e:
+        return []
+
+def validate_image_url(url):
+    """Validate if image URL is accessible"""
+    try:
+        response = requests.head(url, timeout=5)
+        return response.status_code == 200
+    except:
+        return False
+
+def display_car_info(car_data, car_name):
+    """Display car information in an organized way"""
+    if not car_data:
+        return False
+    
+    st.success(f"✅ Found information about **{car_data['title']}**")
+    
+    # Main content layout
+    if car_data['image_url']:
+        col1, col2 = st.columns([2, 1])
+    else:
+        col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        # Summary section
+        st.markdown("### 📄 Summary")
+        st.write(car_data['summary'])
+        
+        # Specifications section
+        if car_data['specifications']:
+            st.markdown("### 🔧 Specifications")
+            spec_cols = st.columns(2)
+            spec_items = list(car_data['specifications'].items())
+            
+            for i, (key, value) in enumerate(spec_items):
+                with spec_cols[i % 2]:
+                    st.write(f"**{key}:** {value}")
+        
+        # Wikipedia link
+        if car_data['page_url']:
+            st.markdown(f"[🔗 Read full article on Wikipedia]({car_data['page_url']})")
+    
+    with col2:
+        # Image section
+        if car_data['image_url']:
+            st.markdown("### 🖼️ Image")
+            try:
+                st.image(car_data['image_url'], caption=car_data['title'], use_column_width=True)
+            except:
+                st.info("Image could not be loaded")
+        
+        # Infobox data
+        if car_data['infobox']:
+            st.markdown("### ℹ️ Quick Facts")
+            for key, value in list(car_data['infobox'].items())[:6]:  # Show max 6 items
+                st.write(f"**{key}:** {value}")
+    
+    return True
+
+# Main Interface
+st.markdown("*Search for detailed car information from Wikipedia*")
+
+# Pre-fill search box from other pages (if exists)
+default_car = st.session_state.get("selected_car_name", "")
+car_name = st.text_input("Enter Car Name", 
+                        value=default_car, 
+                        placeholder="e.g., Tata Nano, Toyota Camry, BMW X5, Maruti Swift")
+
+# Search options
+col1, col2 = st.columns([2, 1])
+with col1:
+    search_btn = st.button("🔎 Search Car Info", type="primary")
+with col2:
+    detailed_search = st.checkbox("Include similar models", value=True)
+
+# Handle Search
+if search_btn and car_name:
+    st.markdown("---")
+    st.subheader(f"🔍 Search Results for '{car_name}'")
+    
+    with st.spinner("🔍 Searching Wikipedia database..."):
+        # Try exact match first
+        car_data = fetch_single_car_info(car_name)
+        
+        if car_data:
+            # Display main result
+            display_car_info(car_data, car_name)
+            
+            # Show additional versions if detailed search is enabled
+            if detailed_search:
+                st.markdown("---")
+                st.subheader("🔍 Related Models & Versions")
+                
+                versions = fetch_versions(car_name)
+                additional_results = 0
+                
+                for version in versions:
+                    # Skip if it's the same as main result
+                    if version.lower() == car_data['title'].lower():
+                        continue
+                    
+                    version_data = fetch_single_car_info(version)
+                    if version_data and additional_results < 3:  # Limit to 3 additional results
+                        additional_results += 1
+                        
+                        with st.expander(f"📄 {version_data['title']}", expanded=False):
+                            # Compact display for additional results
+                            st.write(version_data['summary'][:500] + "..." if len(version_data['summary']) > 500 else version_data['summary'])
+                            
+                            if version_data['specifications']:
+                                st.markdown("**Key Specs:**")
+                                spec_items = list(version_data['specifications'].items())[:4]  # Show top 4 specs
+                                for key, value in spec_items:
+                                    st.write(f"• **{key}:** {value}")
+                            
+                            if version_data['image_url']:
+                                try:
+                                    st.image(version_data['image_url'], caption=version_data['title'], width=200)
+                                except:
+                                    pass
+                            
+                            if version_data['page_url']:
+                                st.markdown(f"[🔗 Read more]({version_data['page_url']})")
+                
+                if additional_results == 0:
+                    st.info("No additional related models found.")
+        
+        else:
+            # No exact match found, try broader search
+            st.warning(f"No exact match found for '{car_name}'. Searching for related results...")
+            
+            versions = fetch_versions(car_name)
+            results_found = 0
+            
+            if versions:
+                for version in versions:
+                    version_data = fetch_single_car_info(version)
+                    if version_data:
+                        results_found += 1
+                        
+                        with st.expander(f"📄 {version_data['title']}", expanded=results_found==1):
+                            display_success = display_car_info(version_data, version)
+                            
+                        if results_found >= 5:  # Limit results
+                            break
+            
+            if results_found == 0:
+                st.error("❌ No matching Wikipedia pages found.")
+                st.info("💡 **Search Tips:**")
+                st.write("• Try using the full car name (e.g., 'Toyota Camry' instead of 'Camry')")
+                st.write("• Include the model year (e.g., 'Honda Civic 2020')")
+                st.write("• Use alternative names or spellings")
+                st.write("• Search for the car manufacturer first")
+
+# Quick search suggestions
+if not car_name:
+    st.markdown("---")
+    st.markdown("### 💡 Popular Car Searches")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    suggestions = [
+        "Tata Nano", "Maruti Swift", "Hyundai Creta",
+        "Toyota Camry", "Honda Civic", "BMW X5",
+        "Tesla Model 3", "Ford Mustang", "Audi A4"
+    ]
+    
+    for i, suggestion in enumerate(suggestions):
+        with [col1, col2, col3][i % 3]:
+            if st.button(f"🔍 {suggestion}", key=f"suggest_{i}"):
+                st.session_state.selected_car_name = suggestion
+                st.rerun()
+
+
+# Footer
+st.markdown("---")
+st.markdown("*🔍 Enhanced Wikipedia search with detailed car specifications and images*")

src/Pages/2_Catogeries.py

@@ -0,0 +1,286 @@
+import streamlit as st
+import wikipedia
+import re
+from functools import lru_cache
+import time
+
+# Configure page
+st.set_page_config(
+    page_title="Car Categories Explorer", 
+    layout="centered",
+    page_icon="🚗"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        text-align: center;
+        color: #2E86AB;
+        margin-bottom: 2rem;
+    }
+    .car-card {
+        border: 1px solid #ddd;
+        border-radius: 10px;
+        padding: 1rem;
+        margin: 1rem 0;
+        background-color: #f9f9f9;
+    }
+    .error-message {
+        color: #d32f2f;
+        font-weight: bold;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+st.markdown('<h1 class="main-header">🚗 Car Categories Explorer</h1>', unsafe_allow_html=True)
+
+# --- Initialize session state ---
+if 'search_history' not in st.session_state:
+    st.session_state.search_history = []
+if 'favorites' not in st.session_state:
+    st.session_state.favorites = []
+
+# --- Sidebar Configuration ---
+st.sidebar.header("🚘 Car Categories")
+
+# Category selection with descriptions
+categories = {
+    "Vintage Cars": {
+        "description": "Classic automobiles from bygone eras",
+        "examples": ["Ford Model T", "Jaguar E-Type", "Rolls-Royce Silver Ghost", "Chevrolet Bel Air"]
+    },
+    "Trending Cars": {
+        "description": "Popular modern vehicles",
+        "examples": ["Tesla Model S", "Hyundai Exter", "Mahindra Thar", "Toyota Camry"]
+    },
+    "SUVs": {
+        "description": "Sport Utility Vehicles",
+        "examples": ["Tata Harrier", "Jeep Compass", "Hyundai Creta", "Ford EcoSport"]
+    },
+    "Electric Cars": {
+        "description": "Eco-friendly electric vehicles",
+        "examples": ["Tesla Model 3", "Nissan Leaf", "Tata Nexon EV", "BMW i3"]
+    }
+}
+
+category = st.sidebar.selectbox("Choose a Category", list(categories.keys()))
+
+# Display category info
+st.sidebar.markdown(f"**{categories[category]['description']}**")
+st.sidebar.markdown("#### 💡 Example Cars:")
+for example in categories[category]['examples']:
+    st.sidebar.markdown(f"- {example}")
+
+# Search history in sidebar
+if st.session_state.search_history:
+    st.sidebar.markdown("#### 🕐 Recent Searches:")
+    for item in st.session_state.search_history[-5:]:  # Show last 5 searches
+        if st.sidebar.button(f"🔍 {item}", key=f"history_{item}"):
+            st.session_state.current_search = item
+
+# --- Caching Functions ---
+@lru_cache(maxsize=100)
+def cached_wikipedia_search(query):
+    """Cache Wikipedia search results to avoid repeated API calls"""
+    try:
+        if len(query.strip()) < 3:
+            return []
+        return wikipedia.search(query, results=10)
+    except Exception as e:
+        st.error(f"Search error: {str(e)}")
+        return []
+
+@lru_cache(maxsize=50)
+def cached_wikipedia_page(car_name):
+    """Cache Wikipedia page content"""
+    try:
+        # Set language to English for better car results
+        wikipedia.set_lang("en")
+        page = wikipedia.page(car_name)
+        summary = wikipedia.summary(car_name, sentences=8)
+        
+        # Clean summary
+        clean_summary = re.sub(r'\[\d+\]', '', summary)
+        clean_summary = re.sub(r'\s+', ' ', clean_summary).strip()
+        
+        # Get first valid image
+        image_url = None
+        if page.images:
+            for img in page.images[:3]:  # Try first 3 images
+                if any(ext in img.lower() for ext in ['.jpg', '.jpeg', '.png', '.gif']):
+                    image_url = img
+                    break
+        
+        return clean_summary, image_url, page.url, page.title
+    except wikipedia.exceptions.DisambiguationError as e:
+        # Handle disambiguation by trying the first option
+        try:
+            return cached_wikipedia_page(e.options[0])
+        except:
+            return None, None, None, None
+    except wikipedia.exceptions.PageError:
+        return None, None, None, None
+    except Exception as e:
+        st.error(f"Error fetching page: {str(e)}")
+        return None, None, None, None
+
+def smart_search_cars(query, category):
+    """Enhanced search with category-specific terms"""
+    if not query.strip():
+        return []
+    
+    # Add category context to search
+    category_terms = {
+        "Vintage Cars": ["vintage", "classic", "antique"],
+        "Trending Cars": ["2023", "2024", "new", "latest"],
+        "SUVs": ["SUV", "crossover"],
+        "Electric Cars": ["electric", "EV", "hybrid"]
+    }
+    
+    # Try exact search first
+    results = cached_wikipedia_search(query)
+    
+    # If few results, try with category context
+    if len(results) < 3:
+        enhanced_query = f"{query} {category_terms.get(category, [''])[0]}"
+        enhanced_results = cached_wikipedia_search(enhanced_query)
+        results.extend([r for r in enhanced_results if r not in results])
+    
+    return results[:10]  # Limit to 10 results
+
+# --- Main Search Interface ---
+st.markdown(f"### 🔍 Search Cars in {category}")
+
+# Search input with debouncing
+search_container = st.container()
+with search_container:
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        query = st.text_input(
+            "Type a Car Name", 
+            placeholder="e.g., Tesla Model S, Ford Mustang",
+            key="search_input"
+        )
+    
+    with col2:
+        st.markdown("<br>", unsafe_allow_html=True)  # Add spacing
+        clear_btn = st.button("🗑️ Clear", help="Clear search")
+
+if clear_btn:
+    st.rerun()
+
+# Live suggestions with improved logic
+suggestions = []
+if query and len(query.strip()) >= 3:
+    with st.spinner("Searching..."):
+        suggestions = smart_search_cars(query, category)
+
+# Display suggestions
+if suggestions:
+    selected_car = st.selectbox("🔎 Select from suggestions:", [""] + suggestions)
+else:
+    selected_car = None
+
+# Search button
+submit_btn = st.button("🚘 Get Car Information", type="primary")
+
+# --- Display Results ---
+if submit_btn and selected_car:
+    # Add to search history
+    if selected_car not in st.session_state.search_history:
+        st.session_state.search_history.append(selected_car)
+    
+    st.markdown("---")
+    
+    # Progress bar for better UX
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    status_text.text("Fetching car information...")
+    progress_bar.progress(25)
+    
+    # Fetch car information
+    summary, image_url, page_url, page_title = cached_wikipedia_page(selected_car)
+    progress_bar.progress(75)
+    
+    if summary:
+        # Display main car info
+        st.markdown(f'<div class="car-card">', unsafe_allow_html=True)
+        
+        # Title with favorite button
+        col1, col2 = st.columns([4, 1])
+        with col1:
+            st.subheader(f"📄 {page_title or selected_car}")
+        with col2:
+            if st.button("⭐ Favorite", key=f"fav_{selected_car}"):
+                if selected_car not in st.session_state.favorites:
+                    st.session_state.favorites.append(selected_car)
+                    st.success("Added to favorites!")
+        
+        # Display image and summary
+        if image_url:
+            try:
+                st.image(image_url, caption=page_title or selected_car, use_column_width=True)
+            except:
+                st.info("📷 Image could not be loaded")
+        
+        st.write(summary)
+        
+        # Links and actions
+        col1, col2, col3 = st.columns(3)
+        with col1:
+            if page_url:
+                st.markdown(f"[🔗 Wikipedia Page]({page_url})")
+        with col2:
+            if st.button("🔄 Search Similar", key=f"similar_{selected_car}"):
+                # Extract brand name for similar search
+                brand = selected_car.split()[0]
+                similar_results = cached_wikipedia_search(f"{brand} cars")
+                if similar_results:
+                    st.info(f"Similar cars: {', '.join(similar_results[:3])}")
+        with col3:
+            if st.button("📤 Share", key=f"share_{selected_car}"):
+                st.code(f"Check out this car: {selected_car}\n{page_url}")
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        progress_bar.progress(100)
+        status_text.text("✅ Information loaded successfully!")
+        
+        # Clear progress indicators after 2 seconds
+        time.sleep(1)
+        progress_bar.empty()
+        status_text.empty()
+        
+    else:
+        progress_bar.progress(100)
+        status_text.empty()
+        progress_bar.empty()
+        
+        st.markdown('<div class="error-message">❌ No information found for this car.</div>', unsafe_allow_html=True)
+        st.info("💡 Try searching with a different spelling or check the suggestions above.")
+
+# --- Favorites Section ---
+if st.session_state.favorites:
+    st.markdown("---")
+    st.subheader("⭐ Your Favorite Cars")
+    
+    for i, fav in enumerate(st.session_state.favorites):
+        col1, col2 = st.columns([4, 1])
+        with col1:
+            st.write(f"🚗 {fav}")
+        with col2:
+            if st.button("🗑️", key=f"remove_{i}", help="Remove from favorites"):
+                st.session_state.favorites.remove(fav)
+                st.rerun()
+
+# --- Footer ---
+st.markdown("---")
+st.markdown("""
+<div style='text-align: center; color: #666;'>
+    <p>🚗 Car Categories Explorer | Powered by Wikipedia API</p>
+    <p><small>Data provided by Wikipedia. Images and content are subject to their respective licenses.</small></p>
+</div>
+""", unsafe_allow_html=True)

src/Pages/3_chatbot.py

@@ -0,0 +1,454 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+from sklearn.preprocessing import StandardScaler
+import wikipedia
+import re
+import json
+
+class CarRecommendationAI:
+    def __init__(self):
+        self.car_database = self.create_car_database()
+        self.vectorizer = TfidfVectorizer(stop_words='english', max_features=1000)
+        self.scaler = StandardScaler()
+        self.setup_recommendation_system()
+    
+    def create_car_database(self):
+        """Create a comprehensive car database with features"""
+        cars = [
+            {
+                'name': 'Toyota Camry',
+                'brand': 'Toyota',
+                'type': 'Sedan',
+                'fuel_type': 'Hybrid',
+                'price_range': 'Mid-range',
+                'size': 'Mid-size',
+                'mpg': 32,
+                'reliability_score': 9,
+                'safety_score': 8,
+                'features': 'fuel efficient reliable comfortable family sedan hybrid technology',
+                'year': 2024
+            },
+            {
+                'name': 'Honda Civic',
+                'brand': 'Honda',
+                'type': 'Sedan',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Budget',
+                'size': 'Compact',
+                'mpg': 31,
+                'reliability_score': 8,
+                'safety_score': 9,
+                'features': 'compact affordable reliable good gas mileage sporty',
+                'year': 2024
+            },
+            {
+                'name': 'BMW X5',
+                'brand': 'BMW',
+                'type': 'SUV',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Luxury',
+                'size': 'Large',
+                'mpg': 23,
+                'reliability_score': 7,
+                'safety_score': 9,
+                'features': 'luxury SUV powerful performance premium interior technology',
+                'year': 2024
+            },
+            {
+                'name': 'Tesla Model 3',
+                'brand': 'Tesla',
+                'type': 'Sedan',
+                'fuel_type': 'Electric',
+                'price_range': 'Premium',
+                'size': 'Mid-size',
+                'mpg': 120,  # MPGe for electric
+                'reliability_score': 7,
+                'safety_score': 10,
+                'features': 'electric autonomous driving technology innovative sustainable',
+                'year': 2024
+            },
+            {
+                'name': 'Ford F-150',
+                'brand': 'Ford',
+                'type': 'Truck',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Mid-range',
+                'size': 'Large',
+                'mpg': 20,
+                'reliability_score': 8,
+                'safety_score': 8,
+                'features': 'pickup truck powerful towing capacity work vehicle durable',
+                'year': 2024
+            },
+            {
+                'name': 'Porsche 911',
+                'brand': 'Porsche',
+                'type': 'Sports Car',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Luxury',
+                'size': 'Compact',
+                'mpg': 22,
+                'reliability_score': 8,
+                'safety_score': 7,
+                'features': 'sports car high performance luxury speed racing heritage',
+                'year': 2024
+            },
+            {
+                'name': 'Subaru Outback',
+                'brand': 'Subaru',
+                'type': 'SUV',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Mid-range',
+                'size': 'Mid-size',
+                'mpg': 26,
+                'reliability_score': 9,
+                'safety_score': 9,
+                'features': 'all wheel drive outdoor adventure reliable safe family',
+                'year': 2024
+            },
+            {
+                'name': 'Hyundai Elantra',
+                'brand': 'Hyundai',
+                'type': 'Sedan',
+                'fuel_type': 'Gasoline',
+                'price_range': 'Budget',
+                'size': 'Compact',
+                'mpg': 33,
+                'reliability_score': 8,
+                'safety_score': 8,
+                'features': 'affordable fuel efficient warranty reliable compact',
+                'year': 2024
+            }
+        ]
+        return pd.DataFrame(cars)
+    
+    def setup_recommendation_system(self):
+        """Setup the AI recommendation system"""
+        # Create feature matrix for text-based similarity
+        feature_matrix = self.vectorizer.fit_transform(self.car_database['features'])
+        self.feature_similarity = cosine_similarity(feature_matrix)
+        
+        # Create numerical feature matrix
+        numerical_features = self.car_database[['mpg', 'reliability_score', 'safety_score', 'year']].values
+        self.numerical_features_scaled = self.scaler.fit_transform(numerical_features)
+    
+    def get_user_preferences(self):
+        """Create UI for user preferences"""
+        st.subheader("🤖 AI Car Recommendation System")
+        st.write("Tell us your preferences and our AI will recommend the perfect car for you!")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            budget = st.selectbox(
+                "💰 Budget Range:",
+                ["Budget", "Mid-range", "Premium", "Luxury", "Any"]
+            )
+            
+            car_type = st.selectbox(
+                "🚗 Car Type:",
+                ["Sedan", "SUV", "Truck", "Sports Car", "Any"]
+            )
+            
+            fuel_preference = st.selectbox(
+                "⛽ Fuel Type:",
+                ["Gasoline", "Hybrid", "Electric", "Any"]
+            )
+        
+        with col2:
+            size_preference = st.selectbox(
+                "📏 Size Preference:",
+                ["Compact", "Mid-size", "Large", "Any"]
+            )
+            
+            priority = st.selectbox(
+                "🎯 What's Most Important:",
+                ["Fuel Efficiency", "Reliability", "Safety", "Performance", "Technology", "Balanced"]
+            )
+            
+            usage = st.selectbox(
+                "🛣️ Primary Usage:",
+                ["Daily Commuting", "Family Travel", "Work/Business", "Recreation", "Sports/Performance"]
+            )
+        
+        return {
+            'budget': budget,
+            'car_type': car_type,
+            'fuel_preference': fuel_preference,
+            'size_preference': size_preference,
+            'priority': priority,
+            'usage': usage
+        }
+    
+    def calculate_preference_score(self, car, preferences):
+        """Calculate how well a car matches user preferences"""
+        score = 0
+        max_score = 100
+        
+        # Budget matching (25 points)
+        if preferences['budget'] == 'Any' or car['price_range'] == preferences['budget']:
+            score += 25
+        elif (preferences['budget'] == 'Budget' and car['price_range'] == 'Mid-range') or \
+             (preferences['budget'] == 'Mid-range' and car['price_range'] in ['Budget', 'Premium']) or \
+             (preferences['budget'] == 'Premium' and car['price_range'] in ['Mid-range', 'Luxury']):
+            score += 15
+        
+        # Car type matching (20 points)
+        if preferences['car_type'] == 'Any' or car['type'] == preferences['car_type']:
+            score += 20
+        
+        # Fuel type matching (15 points)
+        if preferences['fuel_preference'] == 'Any' or car['fuel_type'] == preferences['fuel_preference']:
+            score += 15
+        
+        # Size matching (10 points)
+        if preferences['size_preference'] == 'Any' or car['size'] == preferences['size_preference']:
+            score += 10
+        
+        # Priority-based scoring (20 points)
+        priority_scores = {
+            'Fuel Efficiency': car['mpg'] / 50 * 20,  # Normalize MPG
+            'Reliability': car['reliability_score'] / 10 * 20,
+            'Safety': car['safety_score'] / 10 * 20,
+            'Performance': (10 - car['reliability_score']) / 10 * 20 if car['type'] == 'Sports Car' else 10,
+            'Technology': 20 if car['brand'] in ['Tesla', 'BMW'] else 10,
+            'Balanced': (car['reliability_score'] + car['safety_score']) / 20 * 20
+        }
+        score += priority_scores.get(preferences['priority'], 10)
+        
+        # Usage-based scoring (10 points)
+        usage_scores = {
+            'Daily Commuting': 10 if car['mpg'] > 25 else 5,
+            'Family Travel': 10 if car['type'] in ['SUV', 'Sedan'] and car['size'] in ['Mid-size', 'Large'] else 5,
+            'Work/Business': 10 if car['type'] in ['Truck', 'SUV'] else 5,
+            'Recreation': 10 if car['type'] in ['SUV', 'Truck'] else 5,
+            'Sports/Performance': 10 if car['type'] == 'Sports Car' else 5
+        }
+        score += usage_scores.get(preferences['usage'], 5)
+        
+        return min(score, max_score)
+    
+    def get_recommendations(self, preferences, num_recommendations=3):
+        """Get AI-powered car recommendations"""
+        scored_cars = []
+        
+        for idx, car in self.car_database.iterrows():
+            preference_score = self.calculate_preference_score(car, preferences)
+            
+            # Add some AI-based similarity scoring
+            similarity_bonus = np.mean(self.feature_similarity[idx]) * 10
+            
+            total_score = preference_score + similarity_bonus
+            
+            scored_cars.append({
+                'car': car,
+                'score': total_score,
+                'preference_match': preference_score,
+                'index': idx
+            })
+        
+        # Sort by total score
+        scored_cars.sort(key=lambda x: x['score'], reverse=True)
+        
+        return scored_cars[:num_recommendations]
+    
+    def get_wikipedia_info(self, car_name):
+        """Get Wikipedia information for a car"""
+        try:
+            # Search for the car on Wikipedia
+            search_results = wikipedia.search(car_name, results=3)
+            if search_results:
+                page = wikipedia.page(search_results[0])
+                summary = wikipedia.summary(car_name, sentences=3)
+                return {
+                    'summary': summary,
+                    'url': page.url,
+                    'title': page.title
+                }
+        except:
+            return {
+                'summary': f"Wikipedia information for {car_name} is not available at the moment.",
+                'url': "",
+                'title': car_name
+            }
+    
+    def explain_recommendation(self, car, preferences, score):
+        """Generate AI explanation for why this car was recommended"""
+        explanations = []
+        
+        if preferences['budget'] == 'Any' or car['price_range'] == preferences['budget']:
+            explanations.append(f"✅ Matches your {preferences['budget'].lower()} budget preference")
+        
+        if preferences['car_type'] == 'Any' or car['type'] == preferences['car_type']:
+            explanations.append(f"✅ Perfect {car['type'].lower()} match for your needs")
+        
+        if car['mpg'] > 30:
+            explanations.append("⛽ Excellent fuel efficiency")
+        
+        if car['reliability_score'] >= 8:
+            explanations.append("🔧 High reliability rating")
+        
+        if car['safety_score'] >= 8:
+            explanations.append("🛡️ Outstanding safety features")
+        
+        # Priority-based explanations
+        priority_explanations = {
+            'Fuel Efficiency': f"💡 Great choice for fuel efficiency with {car['mpg']} MPG",
+            'Reliability': f"💡 Highly reliable with {car['reliability_score']}/10 rating",
+            'Safety': f"💡 Excellent safety with {car['safety_score']}/10 rating",
+            'Performance': "💡 Built for performance and driving excitement",
+            'Technology': "💡 Features cutting-edge automotive technology"
+        }
+        
+        if preferences['priority'] in priority_explanations:
+            explanations.append(priority_explanations[preferences['priority']])
+        
+        return explanations
+
+def integrate_ai_recommendations():
+    """Main function to integrate AI recommendations into Streamlit app"""
+    
+    # Initialize the AI system
+    if 'ai_system' not in st.session_state:
+        st.session_state.ai_system = CarRecommendationAI()
+    
+    ai_system = st.session_state.ai_system
+    
+    # Create tabs for different functionalities
+    tab1,  tab3 = st.tabs(["🤖 AI Recommendations", "📊 Compare Cars"])
+    
+    with tab1:
+        st.title("🚗 AI-Powered Car Recommendations")
+        
+        # Get user preferences
+        preferences = ai_system.get_user_preferences()
+        
+        if st.button("🎯 Get My AI Recommendations", type="primary"):
+            with st.spinner("🤖 AI is analyzing your preferences..."):
+                recommendations = ai_system.get_recommendations(preferences)
+                
+                st.success("✨ Here are your personalized recommendations!")
+                
+                for i, rec in enumerate(recommendations, 1):
+                    car = rec['car']
+                    score = rec['preference_match']
+                    
+                    with st.expander(f"#{i} {car['name']} - Match Score: {score:.1f}%", expanded=i==1):
+                        col1, col2 = st.columns([2, 1])
+                        
+                        with col1:
+                            st.subheader(f"{car['brand']} {car['name']}")
+                            
+                            # Car details
+                            st.write(f"**Type:** {car['type']} | **Size:** {car['size']}")
+                            st.write(f"**Price Range:** {car['price_range']} | **Fuel:** {car['fuel_type']}")
+                            st.write(f"**MPG:** {car['mpg']} | **Year:** {car['year']}")
+                            
+                            # Ratings
+                            st.write("**Ratings:**")
+                            st.write(f"🔧 Reliability: {car['reliability_score']}/10")
+                            st.write(f"🛡️ Safety: {car['safety_score']}/10")
+                            
+                            # AI Explanation
+                            st.write("**🤖 Why we recommend this:**")
+                            explanations = ai_system.explain_recommendation(car, preferences, score)
+                            for explanation in explanations:
+                                st.write(f"• {explanation}")
+                        
+                        with col2:
+                            # Progress bars for ratings
+                            st.metric("Match Score", f"{score:.1f}%")
+                            st.progress(score/100)
+                            
+                            st.metric("Reliability", f"{car['reliability_score']}/10")
+                            st.progress(car['reliability_score']/10)
+                            
+                            st.metric("Safety", f"{car['safety_score']}/10")
+                            st.progress(car['safety_score']/10)
+                        
+                        # Wikipedia integration
+                        if st.button(f"📖 Learn more about {car['name']}", key=f"wiki_{i}"):
+                            with st.spinner("Fetching Wikipedia information..."):
+                                wiki_info = ai_system.get_wikipedia_info(car['name'])
+                                st.write("**Wikipedia Summary:**")
+                                st.write(wiki_info['summary'])
+                                if wiki_info['url']:
+                                    st.write(f"[Read more on Wikipedia]({wiki_info['url']})")
+    
+    # with tab2:
+    #     st.title("🔍 Enhanced Car Search")
+    #     search_term = st.text_input("Search for a specific car model:")
+        
+    #     if search_term:
+    #         # Filter cars based on search
+    #         filtered_cars = ai_system.car_database[
+    #             ai_system.car_database['name'].str.contains(search_term, case=False) |
+    #             ai_system.car_database['brand'].str.contains(search_term, case=False)
+    #         ]
+            
+    #         if not filtered_cars.empty:
+    #             for _, car in filtered_cars.iterrows():
+    #                 with st.expander(f"{car['name']}"):
+    #                     col1, col2 = st.columns(2)
+    #                     with col1:
+    #                         st.write(f"**Brand:** {car['brand']}")
+    #                         st.write(f"**Type:** {car['type']}")
+    #                         st.write(f"**Price Range:** {car['price_range']}")
+    #                     with col2:
+    #                         st.write(f"**MPG:** {car['mpg']}")
+    #                         st.write(f"**Reliability:** {car['reliability_score']}/10")
+    #                         st.write(f"**Safety:** {car['safety_score']}/10")
+                        
+    #                     if st.button(f"Get Wikipedia info for {car['name']}", key=f"search_wiki_{car['name']}"):
+    #                         wiki_info = ai_system.get_wikipedia_info(car['name'])
+    #                         st.write(wiki_info['summary'])
+    #                         if wiki_info['url']:
+    #                             st.write(f"[Read more]({wiki_info['url']})")
+    #         else:
+    #             st.warning("No cars found matching your search.")
+    
+    with tab3:
+        st.title("📊 Car Comparison Tool")
+        
+        car_names = ai_system.car_database['name'].tolist()
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            car1 = st.selectbox("Select first car:", car_names)
+        with col2:
+            car2 = st.selectbox("Select second car:", car_names, index=1)
+        
+        if st.button("Compare Cars"):
+            car1_data = ai_system.car_database[ai_system.car_database['name'] == car1].iloc[0]
+            car2_data = ai_system.car_database[ai_system.car_database['name'] == car2].iloc[0]
+            
+            comparison_df = pd.DataFrame({
+                car1: [car1_data['brand'], car1_data['type'], car1_data['price_range'], 
+                       car1_data['mpg'], car1_data['reliability_score'], car1_data['safety_score']],
+                car2: [car2_data['brand'], car2_data['type'], car2_data['price_range'], 
+                       car2_data['mpg'], car2_data['reliability_score'], car2_data['safety_score']]
+            }, index=['Brand', 'Type', 'Price Range', 'MPG', 'Reliability', 'Safety'])
+            
+            st.table(comparison_df)
+            
+            # AI-powered comparison insights
+            st.subheader("🤖 AI Comparison Insights")
+            
+            if car1_data['mpg'] > car2_data['mpg']:
+                st.write(f"✅ {car1} has better fuel efficiency ({car1_data['mpg']} vs {car2_data['mpg']} MPG)")
+            else:
+                st.write(f"✅ {car2} has better fuel efficiency ({car2_data['mpg']} vs {car1_data['mpg']} MPG)")
+            
+            if car1_data['reliability_score'] > car2_data['reliability_score']:
+                st.write(f"🔧 {car1} has higher reliability rating")
+            elif car2_data['reliability_score'] > car1_data['reliability_score']:
+                st.write(f"🔧 {car2} has higher reliability rating")
+            else:
+                st.write("🔧 Both cars have equal reliability ratings")
+
+# Usage example - Add this to your existing Streamlit app
+if __name__ == "__main__":
+    integrate_ai_recommendations()