Upload 8 files

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY=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

README.md

@@ -1,20 +1,15 @@
 ---
-title: Culture Bot
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+title: CultureBot
+emoji: 🌍
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.32.0
+app_file: app.py
 pinned: false
-short_description: CultureBot is AI app that teaches world cultures and travels
 license: mit
 ---
 
-# Welcome to Streamlit!
+# CultureBot
 
-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).
+CultureBot is an AI-powered Streamlit app that helps users learn about world cultures by chatting with an assistant. Ask anything about traditions, festivals, or cultural facts!

ai_engine.py

@@ -0,0 +1,144 @@
+import openai
+import os
+import json
+import random
+from typing import Dict, List, Any
+from dotenv import load_dotenv
+from .content_db import CulturalDatabase
+
+# Load environment variables
+load_dotenv()
+
+class CultureAI:
+    def __init__(self):
+        # Initialize OpenAI client with the API key
+        openai.api_key = os.getenv("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")  # Use the environment variable for the API key
+        self.cultural_db = CulturalDatabase()
+        self.system_prompt = """
+        You are CultureBot, an expert AI assistant specializing in cultural knowledge from around the world. 
+        You provide accurate, respectful, and insightful information about:
+        - Cultural customs and traditions
+        - Social etiquette and norms
+        - Business practices across cultures
+        - Food customs and dining etiquette
+        - Religious and spiritual practices
+        - Language and communication styles
+        - Family structures and relationships
+        - Festivals and celebrations
+        
+        Guidelines:
+        1. Always be respectful and avoid stereotypes
+        2. Acknowledge cultural diversity within countries
+        3. Provide context and explain the reasoning behind customs
+        4. Mention when practices may vary by region or generation
+        5. Be educational and engaging
+        6. If unsure, acknowledge limitations and suggest further research
+        
+        Keep responses informative but conversational, and always maintain cultural sensitivity.
+        """
+    
+    async def generate_response(self, user_message: str) -> Dict[str, Any]:
+        """
+        Generate AI response using OpenAI with cultural context
+        """
+        try:
+            # Get relevant cultural facts from database
+            relevant_facts = self.cultural_db.search_facts(user_message)
+            
+            # Build context from relevant facts
+            context = ""
+            if relevant_facts:
+                context = "\n\nRelevant cultural information:\n"
+                for fact in relevant_facts[:3]:  # Limit to top 3 facts
+                    context += f"- {fact['country']}: {fact['fact']} (Category: {fact['category']})\n"
+            
+            # Create the full prompt
+            full_prompt = f"{self.system_prompt}\n\nUser  question: {user_message}{context}"
+            
+            # Call OpenAI API
+            response = openai.ChatCompletion.create(  # Corrected method call
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": self.system_prompt},
+                    {"role": "user", "content": f"{user_message}{context}"}
+                ],
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            ai_response = response.choices[0].message['content']  # Corrected access to response content
+            
+            # Determine category and confidence
+            category = self._determine_category(user_message)
+            confidence = self._calculate_confidence(user_message, relevant_facts)
+            sources = [fact['source'] for fact in relevant_facts if 'source' in fact]
+            
+            return {
+                "response": ai_response,
+                "confidence": confidence,
+                "sources": sources,
+                "category": category
+            }
+            
+        except Exception as e:
+            # Fallback to database-based response
+            return self._fallback_response(user_message)
+    
+    def _fallback_response(self, user_message: str) -> Dict[str, Any]:
+        """
+        Fallback response when OpenAI is unavailable
+        """
+        relevant_facts = self.cultural_db.search_facts(user_message)
+        
+        if relevant_facts:
+            fact = random.choice(relevant_facts)
+            response = f"Here's an interesting cultural insight about {fact['country']}: {fact['fact']}"
+        else:
+            response = "I'd be happy to help you learn about different cultures! Try asking about specific countries, customs, or cultural practices."
+        
+        return {
+            "response": response,
+            "confidence": 0.7,
+            "sources": ["Cultural Database"],
+            "category": "general"
+        }
+    
+    def _determine_category(self, message: str) -> str:
+        """
+        Determine the category of the user's question
+        """
+        message_lower = message.lower()
+        
+        categories = {
+            "greeting": ["greeting", "hello", "hi", "meet", "introduction"],
+            "business": ["business", "work", "office", "meeting", "professional"],
+            "food": ["food", "eat", "dining", "meal", "restaurant", "cuisine"],
+            "etiquette": ["etiquette", "manners", "polite", "rude", "behavior"],
+            "family": ["family", "parent", "child", "marriage", "wedding"],
+            "religion": ["religion", "religious", "spiritual", "worship", "prayer"],
+            "language": ["language", "speak", "communication", "translate"],
+            "festival": ["festival", "celebration", "holiday", "ceremony"]
+        }
+        
+        for category, keywords in categories.items():
+            if any(keyword in message_lower for keyword in keywords):
+                return category
+        
+        return "general"
+    
+    def _calculate_confidence(self, message: str, relevant_facts: List[Dict]) -> float:
+        """
+        Calculate confidence score based on available information
+        """
+        base_confidence = 0.8  # Base confidence for OpenAI responses
+        
+        # Adjust based on relevant facts
+        if relevant_facts:
+            base_confidence += min(len(relevant_facts) * 0.05, 0.15)
+        
+        # Adjust based on message specificity
+        if len(message.split()) > 5:
+            base_confidence += 0.05
+        
+        return min(base_confidence, 0.95)  # Corrected return statement
+

app.py

@@ -0,0 +1,392 @@
+import streamlit as st
+import requests
+import json
+from datetime import datetime
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+# Configuration
+BACKEND_URL = os.getenv("BACKEND_URL", "http://localhost:8000")
+
+# Page configuration
+st.set_page_config(
+    page_title="CultureBot - Your AI Cultural Guide",
+    page_icon="🌍",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for beautiful styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    
+    .sidebar-info {
+        background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        padding: 1.5rem;
+        border-radius: 10px;
+        color: white;
+        margin-bottom: 1rem;
+    }
+    
+    .chat-message {
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 0.5rem 0;
+    }
+    
+    .user-message {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        margin-left: 2rem;
+    }
+    
+    .bot-message {
+        background: #f8f9fa;
+        color:#333;
+        border-left: 4px solid #667eea;
+        margin-right: 2rem;
+    }
+    
+    .fact-card {
+        background: linear-gradient(135deg, #ffd3a5 0%, #fd6585 100%);
+        color:black;
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    
+    .metric-card {
+        background: white;
+        color:black;
+        padding: 1rem;
+        border-radius: 8px;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+        text-align: center;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Sidebar with app information
+with st.sidebar:
+    st.markdown("""
+    <div class="sidebar-info">
+        <h1 style="font-size: 2.5rem; font-weight: bold; margin-bottom: 1rem;">CultureBot</h1>
+        <div style="font-size: 0.9rem; opacity: 0.9;">
+            <p><strong>Team:</strong>  CultureCoders</p>
+            <p><strong>Version:</strong> 1.0</p>
+            <p><strong>Created:</strong> June 2025</p>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Navigation
+    st.markdown("### 🧭 Navigation")
+    page = st.selectbox(
+        "Choose a page:",
+        ["🏠 Home", "💬 Chat with CultureBot", "📚 Cultural Facts", "ℹ️ About"],
+        key="navigation"
+    )
+    
+    st.markdown("---")
+    
+    # Quick stats
+    st.markdown("### 📊 Quick Stats")
+    try:
+        response = requests.get(f"{BACKEND_URL}/health", timeout=5)
+        if response.status_code == 200:
+            st.success("🟢 Backend Online")
+        else:
+            st.error("🔴 Backend Offline")
+    except:
+        st.error("🔴 Backend Offline")
+    
+    # Random fact
+    st.markdown("### 🎲 Random Fact")
+    if st.button("Get Random Fact"):
+        try:
+            response = requests.get(f"{BACKEND_URL}/facts/random", timeout=10)
+            if response.status_code == 200:
+                fact = response.json()
+                st.markdown(f"""
+                <div class="fact-card">
+                    <h4>{fact['country']}</h4>
+                    <p>{fact['fact']}</p>
+                    <small>Category: {fact['category']}</small>
+                </div>
+                """, unsafe_allow_html=True)
+        except Exception as e:
+            st.error("Unable to fetch random fact")
+
+# Main content area
+if page == "🏠 Home":
+    # Home page
+    st.markdown("""
+    <div class="main-header">
+        <h1 style="font-size: 3rem; margin-bottom: 1rem;">Welcome to CultureBot</h1>
+        <p style="font-size: 1.2rem; opacity: 0.9;">Your AI-powered guide to understanding cultures, traditions, and social customs from around the world</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Feature cards
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("""
+        <div class="metric-card">
+            <h3>🌍 Global Insights</h3>
+            <p>Discover fascinating cultural facts and customs from countries across all continents.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("""
+        <div class="metric-card">
+            <h3>🤖 AI-Powered Chat</h3>
+            <p>Ask questions and get personalized responses about specific countries and cultural practices.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        st.markdown("""
+        <div class="metric-card">
+            <h3>📚 Learn & Explore</h3>
+            <p>Expand your cultural awareness and become a more informed global citizen.</p>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    st.markdown("---")
+    
+    # Getting started
+    st.markdown("## 🚀 Getting Started")
+    st.markdown("""
+    1. **Chat with CultureBot**: Ask questions about any culture or country
+    2. **Explore Facts**: Browse our curated collection of cultural insights
+    3. **Learn Continuously**: Discover new perspectives and traditions
+    """)
+    
+    if st.button("Start Chatting Now", type="primary"):
+        st.session_state.navigation = "💬 Chat with CultureBot"
+        st.rerun()
+
+elif page == "💬 Chat with CultureBot":
+    # Chat page
+    st.markdown("""
+    <div class="main-header">
+        <h1>Chat with CultureBot</h1>
+        <p>Ask me about any culture, country, or tradition!</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    
+    # Display chat messages
+    for message in st.session_state.messages:
+        if message["role"] == "user":
+            st.markdown(f"""
+            <div class="chat-message user-message">
+                <strong>You:</strong> {message["content"]}
+            </div>
+            """, unsafe_allow_html=True)
+        else:
+            st.markdown(f"""
+            <div class="chat-message bot-message">
+                <strong>CultureBot:</strong> {message["content"]}
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Chat input
+    user_input = st.chat_input("Ask about any culture or country...")
+    
+    if user_input:
+        # Add user message to chat history
+        st.session_state.messages.append({"role": "user", "content": user_input})
+        
+        # Get bot response
+        with st.spinner("CultureBot is thinking..."):
+            try:
+                response = requests.post(
+                    f"{BACKEND_URL}/chat",
+                    json={"message": user_input},
+                    timeout=30
+                )
+                
+                if response.status_code == 200:
+                    bot_response = response.json()
+                    st.session_state.messages.append({
+                        "role": "assistant", 
+                        "content": bot_response["response"]
+                    })
+                else:
+                    st.session_state.messages.append({
+                        "role": "assistant",
+                        "content": "I'm sorry, I'm having trouble connecting to my knowledge base right now. Please try again later."
+                    })
+            except Exception as e:
+                st.session_state.messages.append({
+                    "role": "assistant",
+                    "content": "I'm experiencing some technical difficulties. Please make sure the backend server is running and try again."
+                })
+        
+        st.rerun()
+    
+    # Suggested questions
+    st.markdown("### 💡 Try asking about:")
+    suggestions = [
+        "Tell me about Japanese business etiquette",
+        "What are some Indian greeting customs?",
+        "How do Germans view punctuality?",
+        "What should I know about dining in France?",
+        "Explain Chinese lucky numbers"
+    ]
+    
+    cols = st.columns(len(suggestions))
+    for i, suggestion in enumerate(suggestions):
+        with cols[i]:
+            if st.button(suggestion, key=f"suggestion_{i}"):
+                st.session_state.messages.append({"role": "user", "content": suggestion})
+                st.rerun()
+
+elif page == "📚 Cultural Facts":
+    # Cultural facts page
+    st.markdown("""
+    <div class="main-header">
+        <h1>Cultural Facts Explorer</h1>
+        <p>Browse our curated collection of cultural insights</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Filters
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        country_filter = st.selectbox(
+            "Filter by Country:",
+            ["All Countries", "Japan", "India", "Brazil", "Germany", "China", "France", "South Korea", "Mexico", "Egypt", "Russia", "Thailand", "Italy"]
+        )
+    
+    with col2:
+        category_filter = st.selectbox(
+            "Filter by Category:",
+            ["All Categories", "etiquette", "business", "greeting", "food", "language", "family", "beliefs", "general"]
+        )
+    
+    # Fetch and display facts
+    try:
+        if country_filter != "All Countries":
+            response = requests.get(f"{BACKEND_URL}/facts/country/{country_filter}", timeout=10)
+        elif category_filter != "All Categories":
+            response = requests.get(f"{BACKEND_URL}/facts/category/{category_filter}", timeout=10)
+        else:
+            # Get random facts for display
+            facts = []
+            for _ in range(10):
+                fact_response = requests.get(f"{BACKEND_URL}/facts/random", timeout=5)
+                if fact_response.status_code == 200:
+                    facts.append(fact_response.json())
+            
+            for fact in facts:
+                st.markdown(f"""
+                <div class="fact-card">
+                    <h3>{fact['country']}</h3>
+                    <p>{fact['fact']}</p>
+                    <div style="display: flex; justify-content: space-between; margin-top: 1rem;">
+                        <small><strong>Category:</strong> {fact['category']}</small>
+                        <small><strong>Source:</strong> {fact['source']}</small>
+                    </div>
+                </div>
+                """, unsafe_allow_html=True)
+        
+        if country_filter != "All Countries" or category_filter != "All Categories":
+            if response.status_code == 200:
+                facts = response.json()
+                if facts:
+                    for fact in facts:
+                        st.markdown(f"""
+                        <div class="fact-card">
+                            <h3>{fact['country']}</h3>
+                            <p>{fact['fact']}</p>
+                            <div style="display: flex; justify-content: space-between; margin-top: 1rem;">
+                                <small><strong>Category:</strong> {fact['category']}</small>
+                                <small><strong>Source:</strong> {fact['source']}</small>
+                            </div>
+                        </div>
+                        """, unsafe_allow_html=True)
+                else:
+                    st.info("No facts found for the selected filters.")
+            else:
+                st.error("Unable to fetch facts from the server.")
+    
+    except Exception as e:
+        st.error("Unable to connect to the backend server. Please make sure it's running.")
+
+else:  # About page
+    st.markdown("""
+    <div class="main-header">
+        <h1>About CultureBot</h1>
+        <p>Bridging cultures through AI-powered conversations</p>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    # Mission and features
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("""
+        ### 🎯 Our Mission
+        CultureBot was created to help people understand and appreciate the rich diversity of cultures around the world. 
+        In our increasingly connected world, cultural awareness is more important than ever.
+        
+        ### 🔧 Technology Stack
+        - **Frontend**: Streamlit (Python)
+        - **Backend**: FastAPI (Python)
+        - **AI Engine**: OpenAI GPT-3.5-turbo
+        - **Database**: In-memory cultural facts database
+        """)
+    
+    with col2:
+        st.markdown("""
+        ### ✨ Features
+        - **Global Coverage**: Cultural insights from countries across all continents
+        - **AI-Powered Chat**: Natural conversation interface powered by OpenAI
+        - **Curated Content**: Carefully researched and verified cultural facts
+        - **Smart Responses**: Context-aware answers tailored to your questions
+        - **Real-time Interaction**: Fast and responsive chat experience
+        """)
+    
+    st.markdown("---")
+    
+    # Technical details
+    st.markdown("### 🏗️ Architecture")
+    st.markdown("""
+    CultureBot follows a modern microservices architecture:
+    
+    1. **Streamlit Frontend**: Beautiful, interactive user interface
+    2. **FastAPI Backend**: High-performance API server
+    3. **OpenAI Integration**: Advanced natural language processing
+    4. **Cultural Database**: Curated collection of cultural facts and insights
+    """)
+    
+    # Contact and support
+    st.markdown("### 📞 Support")
+    st.markdown("""
+    For technical support or cultural content suggestions, please contact:
+    - **Team**: Cultural AI Labs
+    - **Version**: 2.1.0
+    - **Last Updated**: January 15, 2024
+    """)

content_db.py

@@ -0,0 +1,210 @@
+import json
+import random
+from typing import List, Dict, Any
+
+class CulturalDatabase:
+    def __init__(self):
+        self.cultural_facts = [
+            {
+                "country": "Japan",
+                "fact": "In Japan, it's considered rude to blow your nose in public. People excuse themselves to do it privately.",
+                "category": "etiquette",
+                "source": "Japanese Cultural Studies"
+            },
+            {
+                "country": "Japan",
+                "fact": "Japanese business cards (meishi) are exchanged with both hands and should be received with respect and careful examination.",
+                "category": "business",
+                "source": "Japanese Business Etiquette Guide"
+            },
+            {
+                "country": "India",
+                "fact": "India has 22 official languages and over 1,600 spoken languages, making it one of the most linguistically diverse countries.",
+                "category": "language",
+                "source": "Indian Linguistic Survey"
+            },
+            {
+                "country": "India",
+                "fact": "In Indian culture, touching someone's feet is a sign of respect, especially for elders and teachers.",
+                "category": "greeting",
+                "source": "Indian Cultural Traditions"
+            },
+            {
+                "country": "Brazil",
+                "fact": "Brazilians typically hug and kiss on the cheek when greeting, even in business settings.",
+                "category": "greeting",
+                "source": "Brazilian Social Customs"
+            },
+            {
+                "country": "Brazil",
+                "fact": "In Brazil, the 'OK' hand gesture is considered offensive, similar to giving someone the middle finger.",
+                "category": "etiquette",
+                "source": "Brazilian Cultural Guide"
+            },
+            {
+                "country": "Germany",
+                "fact": "Germans value punctuality so much that being late is considered very disrespectful, even by a few minutes.",
+                "category": "business",
+                "source": "German Business Culture"
+            },
+            {
+                "country": "Germany",
+                "fact": "In Germany, it's customary to maintain eye contact during toasts and say 'Prost' or 'Zum Wohl'.",
+                "category": "food",
+                "source": "German Dining Etiquette"
+            },
+            {
+                "country": "China",
+                "fact": "In Chinese culture, the number 8 is considered extremely lucky because it sounds like the word for 'prosperity'.",
+                "category": "beliefs",
+                "source": "Chinese Numerology Studies"
+            },
+            {
+                "country": "China",
+                "fact": "When receiving a business card in China, accept it with both hands and take a moment to read it carefully.",
+                "category": "business",
+                "source": "Chinese Business Etiquette"
+            },
+            {
+                "country": "France",
+                "fact": "French people typically don't eat meals while walking or standing - dining is seen as a social ritual to be savored.",
+                "category": "food",
+                "source": "French Culinary Culture"
+            },
+            {
+                "country": "France",
+                "fact": "In France, it's polite to greet shopkeepers with 'Bonjour' when entering and 'Au revoir' when leaving.",
+                "category": "etiquette",
+                "source": "French Social Customs"
+            },
+            {
+                "country": "South Korea",
+                "fact": "In Korea, you should use both hands when giving or receiving business cards as a sign of respect.",
+                "category": "business",
+                "source": "Korean Business Protocol"
+            },
+            {
+                "country": "South Korea",
+                "fact": "Korean age calculation includes the time spent in the womb, so Koreans are typically 1-2 years older in 'Korean age'.",
+                "category": "general",
+                "source": "Korean Cultural Practices"
+            },
+            {
+                "country": "Mexico",
+                "fact": "Mexican families often have multiple generations living together, and family loyalty is highly valued.",
+                "category": "family",
+                "source": "Mexican Family Structures"
+            },
+            {
+                "country": "Mexico",
+                "fact": "In Mexico, personal space is smaller than in many Western cultures, and people stand closer during conversations.",
+                "category": "etiquette",
+                "source": "Mexican Social Norms"
+            },
+            {
+                "country": "Egypt",
+                "fact": "In Egypt, showing the sole of your foot to someone is considered offensive, so keep feet flat on the ground when sitting.",
+                "category": "etiquette",
+                "source": "Egyptian Cultural Guidelines"
+            },
+            {
+                "country": "Egypt",
+                "fact": "Egyptian hospitality is legendary - guests are often offered tea or coffee multiple times as a sign of welcome.",
+                "category": "food",
+                "source": "Egyptian Hospitality Traditions"
+            },
+            {
+                "country": "Russia",
+                "fact": "Russians believe that smiling without reason is insincere, so don't be surprised by serious expressions in public.",
+                "category": "expression",
+                "source": "Russian Social Behavior"
+            },
+            {
+                "country": "Russia",
+                "fact": "In Russia, it's traditional to remove shoes when entering someone's home, and slippers are often provided for guests.",
+                "category": "etiquette",
+                "source": "Russian Home Customs"
+            },
+            {
+                "country": "Thailand",
+                "fact": "In Thailand, the head is considered sacred, so never touch someone's head, even children.",
+                "category": "etiquette",
+                "source": "Thai Cultural Sensitivities"
+            },
+            {
+                "country": "Thailand",
+                "fact": "Thai people use the 'wai' greeting - pressing palms together and bowing slightly - as a sign of respect.",
+                "category": "greeting",
+                "source": "Thai Greeting Customs"
+            },
+            {
+                "country": "Italy",
+                "fact": "In Italy, cappuccino is traditionally only drunk in the morning, never after meals.",
+                "category": "food",
+                "source": "Italian Coffee Culture"
+            },
+            {
+                "country": "Italy",
+                "fact": "Italians often speak with their hands, and gestures are an integral part of communication.",
+                "category": "language",
+                "source": "Italian Communication Styles"
+            }
+        ]
+    
+    def search_facts(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Search for relevant cultural facts based on query
+        """
+        query_lower = query.lower()
+        relevant_facts = []
+        
+        # Search by country
+        for fact in self.cultural_facts:
+            if fact['country'].lower() in query_lower:
+                relevant_facts.append(fact)
+        
+        # Search by category
+        if not relevant_facts:
+            for fact in self.cultural_facts:
+                if fact['category'].lower() in query_lower:
+                    relevant_facts.append(fact)
+        
+        # Search by keywords in fact content
+        if not relevant_facts:
+            keywords = query_lower.split()
+            for fact in self.cultural_facts:
+                fact_text = fact['fact'].lower()
+                if any(keyword in fact_text for keyword in keywords):
+                    relevant_facts.append(fact)
+        
+        return relevant_facts[:5]  # Return top 5 matches
+    
+    def get_random_fact(self) -> Dict[str, Any]:
+        """
+        Get a random cultural fact
+        """
+        return random.choice(self.cultural_facts)
+    
+    def get_facts_by_country(self, country: str) -> List[Dict[str, Any]]:
+        """
+        Get all facts for a specific country
+        """
+        return [fact for fact in self.cultural_facts if fact['country'].lower() == country.lower()]
+    
+    def get_facts_by_category(self, category: str) -> List[Dict[str, Any]]:
+        """
+        Get all facts for a specific category
+        """
+        return [fact for fact in self.cultural_facts if fact['category'].lower() == category.lower()]
+    
+    def get_all_countries(self) -> List[str]:
+        """
+        Get list of all countries in the database
+        """
+        return list(set(fact['country'] for fact in self.cultural_facts))
+    
+    def get_all_categories(self) -> List[str]:
+        """
+        Get list of all categories in the database
+        """
+        return list(set(fact['category'] for fact in self.cultural_facts))

main.py

@@ -0,0 +1,125 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import os
+from dotenv import load_dotenv
+from .ai_engine import CultureAI
+from .content_db import CulturalDatabase
+
+# Load environment variables
+load_dotenv()
+
+# Initialize FastAPI app
+app = FastAPI(
+    title="CultureBot API",
+    description="AI-powered cultural insights and information",
+    version="2.1.0"
+)
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize AI engine and database
+culture_ai = CultureAI()
+cultural_db = CulturalDatabase()
+
+# Define Pydantic models
+class ChatMessage(BaseModel):
+    message: str
+    user_id: Optional[str] = "anonymous"
+
+class ChatResponse(BaseModel):
+    response: str
+    confidence: float
+    sources: List[str]
+    category: Optional[str] = None
+
+class CulturalFact(BaseModel):
+    country: str
+    fact: str
+    category: str
+    source: str
+
+@app.get("/")
+async def root():
+    return {
+        "message": "Welcome to CultureBot API",
+        "version": "2.1.0",
+        "status": "active"
+    }
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_with_bot(message: ChatMessage):
+    """
+    Main chat endpoint for interacting with CultureBot
+    """
+    try:
+        # Get AI response
+        ai_response = await culture_ai.generate_response(message.message)
+        
+        # Get relevant cultural facts from database
+        relevant_facts = cultural_db.search_facts(message.message)
+        
+        return ChatResponse(
+            response=ai_response["response"],
+            confidence=ai_response["confidence"],
+            sources=ai_response["sources"],
+            category=ai_response.get("category")
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing request: {str(e)}")
+
+@app.get("/facts/random", response_model=CulturalFact)
+async def get_random_fact():
+    """
+    Get a random cultural fact
+    """
+    try:
+        fact = cultural_db.get_random_fact()
+        return CulturalFact(**fact)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching fact: {str(e)}")
+
+@app.get("/facts/country/{country}", response_model=List[CulturalFact])
+async def get_country_facts(country: str):
+    """
+    Get cultural facts for a specific country
+    """
+    try:
+        facts = cultural_db.get_facts_by_country(country)
+        return [CulturalFact(**fact) for fact in facts]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching country facts: {str(e)}")
+
+@app.get("/facts/category/{category}", response_model=List[CulturalFact])
+async def get_category_facts(category: str):
+    """
+    Get cultural facts for a specific category
+    """
+    try:
+        facts = cultural_db.get_facts_by_category(category)
+        return [CulturalFact(**fact) for fact in facts]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching category facts: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """
+    Health check endpoint
+    """
+    return {
+        "status": "healthy",
+        "ai_engine": "operational",
+        "database": "connected"
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)