Update app.py

app.py

@@ -8,8 +8,9 @@ import numpy as np
 import hashlib
 from collections import defaultdict
 import math
+import random
 
-class VectorizedGeopoliticalAI:
+class ConversationalGeopoliticalAI:
     def __init__(self):
         # Spazi vettoriali multidimensionali per analisi geopolitica
         self.vector_dimensions = 512
@@ -37,11 +38,27 @@ class VectorizedGeopoliticalAI:
             "un_news": "https://news.un.org/en/rss/rss.xml"
         }
         
+        # Context memory per conversazioni
+        self.conversation_context = {
+            "recent_topics": [],
+            "mentioned_entities": set(),
+            "analysis_history": [],
+            "user_interests": set()
+        }
+        
+        # Personalità conversazionale
+        self.personality_traits = {
+            "analytical": 0.8,
+            "authoritative": 0.7,
+            "accessible": 0.9,
+            "empathetic": 0.6,
+            "forward_thinking": 0.8
+        }
+        
         self.initialize_embeddings()
         
     def initialize_semantic_space(self):
         """Inizializza spazio semantico multidimensionale"""
-        # Crea base ortonormale per lo spazio semantico geopolitico
         semantic_basis = {}
         
         # Dimensioni fondamentali della geopolitica
@@ -53,7 +70,6 @@ class VectorizedGeopoliticalAI:
         
         for i, concept in enumerate(fundamental_concepts):
             vector = np.zeros(self.vector_dimensions)
-            # Distribuzione gaussiana per embedding iniziale
             vector[:len(fundamental_concepts)] = np.random.normal(0, 0.1, len(fundamental_concepts))
             vector[i] = 1.0  # Componente principale
             semantic_basis[concept] = vector / np.linalg.norm(vector)
@@ -63,7 +79,6 @@ class VectorizedGeopoliticalAI:
     def initialize_embeddings(self):
         """Inizializza embeddings per entità geopolitiche"""
         
-        # Entità geopolitiche con caratteristiche vettoriali
         entities = {
             'USA': {'power': 0.95, 'economy': 0.92, 'military': 0.98, 'influence': 0.90},
             'China': {'power': 0.88, 'economy': 0.89, 'military': 0.85, 'influence': 0.82},
@@ -79,24 +94,66 @@ class VectorizedGeopoliticalAI:
         }
         
         for entity, characteristics in entities.items():
-            # Crea vettore multidimensionale per l'entità
             vector = np.zeros(self.vector_dimensions)
             
-            # Mappa caratteristiche su dimensioni vettoriali
             for i, (char, value) in enumerate(characteristics.items()):
                 if char in self.semantic_space:
                     vector += value * self.semantic_space[char]
             
-            # Aggiungi rumore gaussiano per robustezza
             vector += np.random.normal(0, 0.05, self.vector_dimensions)
-            
-            # Normalizza
             self.entity_embeddings[entity] = vector / (np.linalg.norm(vector) + 1e-8)
     
+    def fetch_real_time_data(self):
+        """Recupera dati real-time per alimentare le conversazioni"""
+        news_data = []
+        
+        try:
+            # Reuters RSS
+            response = requests.get(self.data_sources["reuters_rss"], timeout=10)
+            if response.status_code == 200:
+                root = ET.fromstring(response.content)
+                for item in root.findall(".//item")[:10]:
+                    title = item.find("title")
+                    description = item.find("description")
+                    pub_date = item.find("pubDate")
+                    
+                    if title is not None:
+                        news_data.append({
+                            "source": "Reuters",
+                            "title": title.text,
+                            "description": description.text if description is not None else "",
+                            "date": pub_date.text if pub_date is not None else "",
+                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
+                        })
+        except:
+            pass
+            
+        try:
+            # BBC RSS
+            response = requests.get(self.data_sources["bbc_rss"], timeout=10)
+            if response.status_code == 200:
+                root = ET.fromstring(response.content)
+                for item in root.findall(".//item")[:10]:
+                    title = item.find("title")
+                    description = item.find("description")
+                    pub_date = item.find("pubDate")
+                    
+                    if title is not None:
+                        news_data.append({
+                            "source": "BBC",
+                            "title": title.text,
+                            "description": description.text if description is not None else "",
+                            "date": pub_date.text if pub_date is not None else "",
+                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
+                        })
+        except:
+            pass
+        
+        return news_data[:15]  # Top 15 notizie più recenti
+    
     def text_to_vector(self, text):
         """Converte testo in rappresentazione vettoriale robusta"""
         if not text or not text.strip():
-            # Vettore casuale per input vuoti
             return np.random.normal(0, 0.1, self.vector_dimensions)
         
         words = re.findall(r'\b\w+\b', text.lower())
@@ -137,7 +194,7 @@ class VectorizedGeopoliticalAI:
             'power': 'power', 'influence': 'influence', 'control': 'power',
             'domination': 'power', 'hegemony': 'power', 'superpower': 'power',
             
-            # Paesi specifici (mapping diretto)
+            # Paesi specifici
             'ukraine': 'conflict', 'russia': 'power', 'china': 'power',
             'usa': 'power', 'america': 'power', 'taiwan': 'conflict',
             'iran': 'conflict', 'israel': 'conflict', 'gaza': 'conflict'
@@ -146,7 +203,6 @@ class VectorizedGeopoliticalAI:
         matched_words = 0
         semantic_weights = defaultdict(float)
         
-        # Prima passata: mapping diretto
         for word in words:
             if word in semantic_mapping:
                 concept = semantic_mapping[word]
@@ -157,7 +213,6 @@ class VectorizedGeopoliticalAI:
                 semantic_weights[word] += 1.0
                 matched_words += 1
         
-        # Seconda passata: pattern parziali
         if matched_words == 0:
             for word in words:
                 for pattern, concept in semantic_mapping.items():
@@ -166,24 +221,19 @@ class VectorizedGeopoliticalAI:
                             semantic_weights[concept] += 0.5
                             matched_words += 0.5
         
-        # Costruzione vettore con pesi
         for concept, weight in semantic_weights.items():
             if concept in self.semantic_space:
                 composite_vector += weight * self.semantic_space[concept]
         
-        # Aggiungi componente casuale se nessun match
         if matched_words == 0:
-            # Crea vettore basato su hash del testo per consistenza
             text_hash = int(hashlib.md5(text.encode()).hexdigest(), 16)
             np.random.seed(text_hash % 2**31)
             composite_vector = np.random.normal(0, 0.3, self.vector_dimensions)
             matched_words = 1
         
-        # Normalizzazione adattiva
         if matched_words > 0:
             composite_vector *= math.log(matched_words + 1) / (matched_words + 0.1)
         
-        # Assicura che il vettore non sia zero
         norm = np.linalg.norm(composite_vector)
         if norm < 1e-6:
             composite_vector = np.random.normal(0, 0.1, self.vector_dimensions)
@@ -191,537 +241,642 @@ class VectorizedGeopoliticalAI:
             
         return composite_vector / norm
     
-    def compute_entity_relations(self, entities):
-        """Calcola relazioni tra entità nello spazio vettoriale con valori realistici"""
-        relations = {}
-        
-        for i, entity1 in enumerate(entities):
-            if entity1 not in self.entity_embeddings:
-                continue
-                
-            for j, entity2 in enumerate(entities[i+1:], i+1):
-                if entity2 not in self.entity_embeddings:
-                    continue
-                
-                vec1 = self.entity_embeddings[entity1]
-                vec2 = self.entity_embeddings[entity2]
-                
-                # Similarità coseno con correzione numerica
-                dot_product = np.dot(vec1, vec2)
-                norm_product = np.linalg.norm(vec1) * np.linalg.norm(vec2)
-                cosine_sim = dot_product / (norm_product + 1e-8)
-                
-                # Distanza euclidea normalizzata
-                euclidean_dist = np.linalg.norm(vec1 - vec2) / math.sqrt(self.vector_dimensions)
-                
-                # Proiezioni su sottospazi semantici
-                alliance_vec = self.semantic_space['alliance']
-                conflict_vec = self.semantic_space['conflict']
-                
-                # Proiezione alliance: (v1 + v2) · alliance_basis
-                alliance_sum = (vec1 + vec2) / 2
-                alliance_projection = np.dot(alliance_sum, alliance_vec)
-                
-                # Proiezione conflict: |v1 - v2| · conflict_basis  
-                conflict_diff = vec1 - vec2
-                conflict_projection = abs(np.dot(conflict_diff, conflict_vec))
-                
-                # Power differential basato su norma dei vettori
-                power_diff = np.linalg.norm(vec1) - np.linalg.norm(vec2)
-                
-                # Relazioni storiche note (override per realismo)
-                historical_adjustments = {
-                    ('Russia', 'Ukraine'): {'conflict_boost': 0.7, 'alliance_penalty': -0.8},
-                    ('USA', 'Russia'): {'conflict_boost': 0.4, 'alliance_penalty': -0.6},
-                    ('USA', 'China'): {'conflict_boost': 0.3, 'alliance_penalty': -0.5},
-                    ('Israel', 'Iran'): {'conflict_boost': 0.8, 'alliance_penalty': -0.9},
-                    ('China', 'Taiwan'): {'conflict_boost': 0.9, 'alliance_penalty': -0.9},
-                    ('NATO', 'Russia'): {'conflict_boost': 0.6, 'alliance_penalty': -0.7}
-                }
-                
-                # Applica aggiustamenti storici
-                key = (entity1, entity2)
-                reverse_key = (entity2, entity1)
-                
-                if key in historical_adjustments:
-                    adj = historical_adjustments[key]
-                    conflict_projection += adj['conflict_boost']
-                    alliance_projection += adj['alliance_penalty']
-                elif reverse_key in historical_adjustments:
-                    adj = historical_adjustments[reverse_key]
-                    conflict_projection += adj['conflict_boost'] 
-                    alliance_projection += adj['alliance_penalty']
-                
-                # Clamp valori in range realistico
-                alliance_projection = max(-1.0, min(1.0, alliance_projection))
-                conflict_projection = max(0.0, min(1.0, conflict_projection))
-                
-                relations[(entity1, entity2)] = {
-                    'similarity': cosine_sim,
-                    'distance': euclidean_dist,
-                    'alliance_potential': alliance_projection,
-                    'conflict_potential': conflict_projection,
-                    'power_differential': power_diff
-                }
-        
-        return relations
-    
-    def apply_transformation_matrices(self, input_vector, context_type):
-        """Applica matrici di trasformazione per analisi contestuale"""
-        if context_type not in self.transformation_matrices:
-            return input_vector
-        
-        transformation_matrix = self.transformation_matrices[context_type]
-        transformed_vector = np.dot(transformation_matrix, input_vector)
-        
-        # Applicazione funzione di attivazione (tanh per mantenere bounded)
-        activated_vector = np.tanh(transformed_vector)
-        
-        return activated_vector
-    
-    def vector_space_analysis(self, query_vector, entities, real_time_data):
-        """Analisi nello spazio vettoriale multidimensionale"""
-        analysis = {}
-        
-        # 1. Analisi di proiezione su sottospazi semantici
-        semantic_projections = {}
-        for concept, basis_vector in self.semantic_space.items():
-            projection = np.dot(query_vector, basis_vector)
-            semantic_projections[concept] = projection
-        
-        # 2. Calcolo delle distanze nel manifold geopolitico
-        entity_distances = {}
-        for entity in entities:
-            if entity in self.entity_embeddings:
-                distance = np.linalg.norm(query_vector - self.entity_embeddings[entity])
-                entity_distances[entity] = distance
-        
-        # 3. Analisi delle trasformazioni contestuali
-        contextual_transforms = {}
-        for context in self.transformation_matrices.keys():
-            transformed = self.apply_transformation_matrices(query_vector, context)
-            # Calcola l'entropia della trasformazione
-            entropy = -np.sum(transformed * np.log(np.abs(transformed) + 1e-8))
-            contextual_transforms[context] = {
-                'vector': transformed,
-                'entropy': entropy,
-                'norm': np.linalg.norm(transformed)
-            }
+    def detect_question_type(self, query):
+        """Rileva il tipo di domanda per personalizzare la risposta"""
+        query_lower = query.lower()
+        
+        question_types = {
+            'what_happening': ['what', 'happening', 'current', 'now', 'latest', 'today'],
+            'why_analysis': ['why', 'because', 'reason', 'cause', 'explain'],
+            'how_process': ['how', 'process', 'method', 'way', 'steps'],
+            'when_timeline': ['when', 'timeline', 'time', 'date', 'schedule'],
+            'who_actors': ['who', 'actors', 'players', 'countries', 'leaders'],
+            'where_location': ['where', 'location', 'place', 'region', 'area'],
+            'prediction': ['will', 'future', 'predict', 'forecast', 'expect'],
+            'comparison': ['vs', 'versus', 'compare', 'difference', 'between'],
+            'opinion': ['think', 'believe', 'opinion', 'view', 'perspective'],
+            'impact': ['impact', 'effect', 'consequence', 'result', 'outcome']
+        }
         
-        analysis['semantic_projections'] = semantic_projections
-        analysis['entity_distances'] = entity_distances
-        analysis['contextual_transforms'] = contextual_transforms
+        detected_types = []
+        for qtype, keywords in question_types.items():
+            if any(keyword in query_lower for keyword in keywords):
+                detected_types.append(qtype)
         
-        return analysis
+        return detected_types if detected_types else ['general']
     
-    def fetch_real_time_data(self):
-        """Recupera dati real-time per alimentare i vettori"""
-        news_data = []
-        
-        try:
-            # Reuters RSS
-            response = requests.get(self.data_sources["reuters_rss"], timeout=10)
-            if response.status_code == 200:
-                root = ET.fromstring(response.content)
-                for item in root.findall(".//item")[:8]:
-                    title = item.find("title")
-                    description = item.find("description")
-                    
-                    if title is not None:
-                        news_data.append({
-                            "source": "Reuters",
-                            "title": title.text,
-                            "description": description.text if description is not None else "",
-                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
-                        })
-        except:
-            pass
-            
-        try:
-            # BBC RSS
-            response = requests.get(self.data_sources["bbc_rss"], timeout=10)
-            if response.status_code == 200:
-                root = ET.fromstring(response.content)
-                for item in root.findall(".//item")[:8]:
-                    title = item.find("title")
-                    description = item.find("description")
-                    
-                    if title is not None:
-                        news_data.append({
-                            "source": "BBC",
-                            "title": title.text,
-                            "description": description.text if description is not None else "",
-                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
-                        })
-        except:
-            pass
-        
-        return news_data
-    
-    def extract_entities_advanced(self, text_data):
-        """Estrazione avanzata di entità con confidence scores"""
+    def extract_entities_conversational(self, text):
+        """Estrae entità con contesto conversazionale"""
         entities = []
-        entity_vectors = {}
+        entity_confidence = {}
         
-        # Pattern più sofisticati per entità geopolitiche
         entity_patterns = {
-            'USA|United States|America|Washington': 'USA',
-            'China|Chinese|Beijing|PRC': 'China',
-            'Russia|Russian|Moscow|Kremlin': 'Russia',
-            'Ukraine|Ukrainian|Kyiv|Kiev': 'Ukraine',
-            'Iran|Iranian|Tehran': 'Iran',
-            'Israel|Israeli|Jerusalem': 'Israel',
-            'Taiwan|Taipei': 'Taiwan',
-            'North Korea|DPRK|Pyongyang': 'North Korea',
-            'NATO|North Atlantic': 'NATO',
-            'European Union|EU': 'EU',
-            'Germany|German|Berlin': 'Germany'
+            'USA|United States|America|Washington|Biden': 'USA',
+            'China|Chinese|Beijing|PRC|Xi Jinping': 'China',
+            'Russia|Russian|Moscow|Kremlin|Putin': 'Russia',
+            'Ukraine|Ukrainian|Kyiv|Kiev|Zelensky': 'Ukraine',
+            'Iran|Iranian|Tehran|Ayatollah': 'Iran',
+            'Israel|Israeli|Jerusalem|Netanyahu': 'Israel',
+            'Taiwan|Taipei|Taiwanese': 'Taiwan',
+            'North Korea|DPRK|Pyongyang|Kim Jong': 'North Korea',
+            'NATO|North Atlantic|Alliance': 'NATO',
+            'European Union|EU|Brussels': 'EU',
+            'Germany|German|Berlin|Scholz': 'Germany',
+            'France|French|Paris|Macron': 'France',
+            'UK|Britain|British|London': 'UK',
+            'Japan|Japanese|Tokyo': 'Japan',
+            'India|Indian|Delhi|Modi': 'India',
+            'Turkey|Turkish|Ankara|Erdogan': 'Turkey',
+            'Saudi Arabia|Saudi|Riyadh': 'Saudi Arabia'
         }
         
-        combined_text = ""
-        if isinstance(text_data, list):
-            for item in text_data:
-                if isinstance(item, dict):
-                    combined_text += f" {item.get('title', '')} {item.get('description', '')}"
-                else:
-                    combined_text += f" {str(item)}"
-        else:
-            combined_text = str(text_data)
-        
-        # Estrai entità con confidence
         for pattern, entity in entity_patterns.items():
-            matches = re.findall(pattern, combined_text, re.IGNORECASE)
+            matches = re.findall(pattern, text, re.IGNORECASE)
             if matches:
-                confidence = len(matches) / len(combined_text.split()) * 100
-                entities.append({
-                    'name': entity,
-                    'confidence': min(confidence, 1.0),
-                    'mentions': len(matches)
-                })
+                confidence = min(len(matches) * 0.3, 1.0)
+                entities.append(entity)
+                entity_confidence[entity] = confidence
                 
-                if entity in self.entity_embeddings:
-                    entity_vectors[entity] = self.entity_embeddings[entity]
+                # Aggiungi al context
+                self.conversation_context["mentioned_entities"].add(entity)
         
-        return entities, entity_vectors
+        return entities, entity_confidence
     
-    def generate_mathematical_analysis(self, query, real_time_data):
-        """Genera analisi matematica avanzata dai vettori"""
+    def generate_conversational_response(self, query, real_time_data):
+        """Genera risposta conversazionale naturale"""
         
         try:
-            # 1. Converte query in vettore multidimensionale
-            query_vector = self.text_to_vector(query)
+            # 1. Analizza il tipo di domanda
+            question_types = self.detect_question_type(query)
             
-            # 2. Estrai entità e loro vettori
-            entities, entity_vectors = self.extract_entities_advanced([{"title": query}] + real_time_data)
-            entity_names = [e['name'] for e in entities]
+            # 2. Estrai entità dalla domanda
+            entities, entity_confidence = self.extract_entities_conversational(query)
             
-            # 3. Calcola relazioni nello spazio vettoriale
-            relations = self.compute_entity_relations(entity_names)
+            # 3. Trova notizie correlate
+            correlated_news = self.find_correlated_news(query, real_time_data)
             
-            # 4. Analisi vettoriale completa
-            vector_analysis = self.vector_space_analysis(query_vector, entity_names, real_time_data)
+            # 4. Analisi vettoriale per insights
+            query_vector = self.text_to_vector(query)
+            vector_insights = self.get_vector_insights(query_vector, entities)
             
-            # 5. Genera report matematico
-            report = self.generate_vector_report(query, query_vector, entities, relations, vector_analysis, real_time_data)
+            # 5. Genera risposta basata sul tipo di domanda
+            response = self.craft_natural_response(
+                query, question_types, entities, correlated_news, vector_insights, real_time_data
+            )
+            
+            # 6. Aggiorna context conversazionale
+            self.update_conversation_context(query, entities, question_types)
             
-            return report
+            return response
             
         except Exception as e:
-            return f"❌ Errore nell'analisi vettoriale: {str(e)}"
+            return f"Mi dispiace, ho riscontrato un problema nell'analisi: {str(e)}. Puoi riprovare con una formulazione diversa?"
+    
+    def find_correlated_news(self, query, news_data):
+        """Trova notizie correlate alla domanda"""
+        if not news_data:
+            return []
+        
+        query_vector = self.text_to_vector(query)
+        correlations = []
+        
+        for news in news_data:
+            if 'vector' in news:
+                correlation = np.dot(query_vector, news['vector'])
+                correlations.append((news, correlation))
+        
+        # Ordina per correlazione e prendi le top 3
+        correlations.sort(key=lambda x: abs(x[1]), reverse=True)
+        return [news for news, corr in correlations[:3] if abs(corr) > 0.1]
+    
+    def get_vector_insights(self, query_vector, entities):
+        """Ottiene insights dall'analisi vettoriale"""
+        insights = {}
+        
+        # Proiezioni semantiche
+        semantic_projections = {}
+        for concept, basis_vector in self.semantic_space.items():
+            projection = np.dot(query_vector, basis_vector)
+            if abs(projection) > 0.1:
+                semantic_projections[concept] = projection
+        
+        # Top 3 concetti più rilevanti
+        top_concepts = sorted(semantic_projections.items(), key=lambda x: abs(x[1]), reverse=True)[:3]
+        
+        insights['dominant_themes'] = top_concepts
+        insights['complexity'] = np.count_nonzero(np.abs(query_vector) > 0.1)
+        insights['intensity'] = np.linalg.norm(query_vector)
+        
+        return insights
+    
+    def craft_natural_response(self, query, question_types, entities, correlated_news, vector_insights, all_news):
+        """Crea risposta naturale e conversazionale"""
+        
+        response_parts = []
+        
+        # Saluto contestuale
+        greetings = [
+            "Basandomi sui dati più recenti che sto monitorando,",
+            "Dalla mia analisi real-time della situazione globale,",
+            "Guardando quello che sta succedendo in questo momento,",
+            "Considerando gli sviluppi delle ultime ore,"
+        ]
+        
+        response_parts.append(random.choice(greetings))
+        response_parts.append("")
+        
+        # Risposta specifica per tipo di domanda
+        if 'what_happening' in question_types:
+            response_parts.extend(self.answer_what_happening(entities, correlated_news, all_news))
+        elif 'why_analysis' in question_types:
+            response_parts.extend(self.answer_why_analysis(entities, vector_insights, correlated_news))
+        elif 'prediction' in question_types:
+            response_parts.extend(self.answer_prediction(entities, vector_insights, correlated_news))
+        elif 'comparison' in question_types:
+            response_parts.extend(self.answer_comparison(entities, vector_insights))
+        elif 'impact' in question_types:
+            response_parts.extend(self.answer_impact_analysis(entities, correlated_news, vector_insights))
+        else:
+            response_parts.extend(self.answer_general(query, entities, correlated_news, vector_insights))
+        
+        # Aggiungi contesto real-time se rilevante
+        if correlated_news:
+            response_parts.append("")
+            response_parts.append("**📡 Sviluppi Real-Time Correlati:**")
+            for i, news in enumerate(correlated_news[:2], 1):
+                response_parts.append(f"{i}. **[{news['source']}]** {news['title']}")
+        
+        # Insights matematici se rilevanti
+        if vector_insights['dominant_themes']:
+            response_parts.append("")
+            response_parts.append("**🔍 La mia analisi vettoriale indica:**")
+            for concept, strength in vector_insights['dominant_themes']:
+                direction = "forte focus su" if strength > 0 else "tensione relativa a"
+                response_parts.append(f"• {direction} **{concept}** (intensità: {abs(strength):.2f})")
+        
+        # Chiusura conversazionale
+        closings = [
+            "Vuoi che approfondisca qualche aspetto specifico?",
+            "C'è altro che ti interessa sapere su questa situazione?",
+            "Posso analizzare ulteriori dettagli se hai domande specifiche.",
+            "Dimmi se vuoi che esplori altri angoli di questa vicenda."
+        ]
+        
+        response_parts.append("")
+        response_parts.append(random.choice(closings))
+        
+        return "\n".join(response_parts)
     
-    def generate_vector_report(self, query, query_vector, entities, relations, vector_analysis, real_time_data):
-        """Genera report basato su analisi vettoriale matematica"""
-        
-        report_parts = []
-        
-        # Header matematico
-        report_parts.append("🧮 VECTORIZED GEOPOLITICAL ANALYSIS")
-        report_parts.append("═" * 60)
-        report_parts.append(f"📐 Vector Space: R^{self.vector_dimensions} | Semantic Manifold Analysis")
-        report_parts.append(f"🕐 Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
-        report_parts.append("")
-        
-        # Query Vector Analysis
-        query_norm = np.linalg.norm(query_vector)
-        query_entropy = -np.sum(query_vector * np.log(np.abs(query_vector) + 1e-8))
-        report_parts.append(f"🎯 QUERY VECTORIZATION:")
-        report_parts.append(f"  ∥q∥₂ = {query_norm:.4f} | H(q) = {query_entropy:.4f}")
-        report_parts.append(f"  Dimensional complexity: {np.count_nonzero(np.abs(query_vector) > 0.1)}/{self.vector_dimensions}")
-        report_parts.append("")
-        
-        # Semantic Projections
-        top_projections = sorted(vector_analysis['semantic_projections'].items(), 
-                                key=lambda x: abs(x[1]), reverse=True)[:6]
-        
-        report_parts.append("📊 SEMANTIC SPACE PROJECTIONS:")
-        for concept, projection in top_projections:
-            intensity = "█" * int(abs(projection) * 20 + 1)
-            sign = "+" if projection > 0 else "-"
-            report_parts.append(f"  {concept:.<15} {sign}{abs(projection):.3f} {intensity}")
-        report_parts.append("")
-        
-        # Entity Analysis with Confidence
+    def answer_what_happening(self, entities, correlated_news, all_news):
+        """Risponde a domande su cosa sta succedendo"""
+        response = []
+        
         if entities:
-            report_parts.append("🎭 ENTITY DETECTION (CONFIDENCE-WEIGHTED):")
-            sorted_entities = sorted(entities, key=lambda x: x['confidence'], reverse=True)
-            for entity in sorted_entities[:8]:
-                confidence_bar = "▓" * int(entity['confidence'] * 20)
-                report_parts.append(f"  {entity['name']:.<12} π={entity['confidence']:.3f} n={entity['mentions']} {confidence_bar}")
-        report_parts.append("")
-        
-        # Vector Relations Analysis
-        if relations:
-            report_parts.append("🔗 INTER-ENTITY VECTOR RELATIONS:")
-            sorted_relations = sorted(relations.items(), key=lambda x: x[1]['similarity'], reverse=True)
-            for (e1, e2), rel_data in sorted_relations[:5]:
-                sim = rel_data['similarity']
-                conflict_pot = rel_data['conflict_potential']
-                alliance_pot = rel_data['alliance_potential']
-                
-                # Classificazione relazione basata su metriche vettoriali
-                if alliance_pot > 0.3 and sim > 0.5:
-                    relation_type = "🤝 ALLIANCE"
-                elif conflict_pot > 0.4 and sim < 0.2:
-                    relation_type = "⚔️ ADVERSARIAL"
-                elif abs(rel_data['power_differential']) > 0.3:
-                    relation_type = "⚖️ ASYMMETRIC"
-                else:
-                    relation_type = "🔄 NEUTRAL"
-                
-                report_parts.append(f"  {e1} ↔ {e2}")
-                report_parts.append(f"    {relation_type} | cos(θ)={sim:.3f} | ∆P={rel_data['power_differential']:.3f}")
-        report_parts.append("")
-        
-        # Contextual Transformations
-        report_parts.append("🔄 CONTEXTUAL MANIFOLD TRANSFORMATIONS:")
-        for context, transform_data in vector_analysis['contextual_transforms'].items():
-            entropy = transform_data['entropy']
-            norm = transform_data['norm']
+            entity_str = ", ".join(entities[:3])
+            response.append(f"**La situazione attuale con {entity_str}:**")
+        else:
+            response.append("**Ecco cosa sta succedendo nel panorama geopolitico globale:**")
+        
+        if correlated_news:
+            response.append("")
+            for i, news in enumerate(correlated_news, 1):
+                response.append(f"{i}. {news['title']}")
+                if news.get('description'):
+                    response.append(f"   _{news['description'][:100]}..._")
+        else:
+            # Usa notizie generali
+            response.append("")
+            response.append("Gli ultimi sviluppi includono:")
+            for i, news in enumerate(all_news[:3], 1):
+                response.append(f"{i}. {news['title']}")
+        
+        return response
+    
+    def answer_why_analysis(self, entities, vector_insights, correlated_news):
+        """Risponde a domande sul perché"""
+        response = []
+        
+        response.append("**Analizzando le cause profonde:**")
+        response.append("")
+        
+        # Usa insights vettoriali per spiegare le cause
+        if vector_insights['dominant_themes']:
+            dominant_theme = vector_insights['dominant_themes'][0]
+            concept, strength = dominant_theme
             
-            # Calcola divergenza dal vettore originale
-            divergence = np.linalg.norm(query_vector - transform_data['vector'])
+            explanations = {
+                'conflict': "Le tensioni derivano da interessi strategici conflittuali e dispute territoriali irrisolte.",
+                'power': "È principalmente una questione di equilibri di potere e sfere d'influenza in trasformazione.",
+                'economy': "Le dinamiche economiche e l'accesso alle risorse stanno guidando questi sviluppi.",
+                'military': "Considerazioni di sicurezza e deterrenza militare sono i fattori chiave.",
+                'diplomacy': "Si tratta di manovre diplomatiche e negoziazioni complesse tra multiple parti.",
+                'alliance': "Le alleanze e i partenariati strategici stanno ridefinendo gli equilibri regionali."
+            }
             
-            report_parts.append(f"  {context.replace('_', ' ').title()}:")
-            report_parts.append(f"    H(T(q)) = {entropy:.3f} | ∥T(q)∥ = {norm:.3f} | D_KL = {divergence:.3f}")
-        report_parts.append("")
-        
-        # Real-Time Vector Correlation
-        if real_time_data:
-            report_parts.append("📡 REAL-TIME VECTOR CORRELATION:")
-            correlations = []
+            if concept in explanations:
+                response.append(explanations[concept])
+            else:
+                response.append(f"I fattori dominanti sono legati a {concept}, che sta influenzando significativamente la situazione.")
+        
+        # Aggiungi contesto dalle notizie
+        if correlated_news:
+            response.append("")
+            response.append("**Le evidenze recenti mostrano:**")
+            for news in correlated_news[:2]:
+                response.append(f"• {news['title']}")
+        
+        return response
+    
+    def answer_prediction(self, entities, vector_insights, correlated_news):
+        """Risponde a domande predittive"""
+        response = []
+        
+        response.append("**Basandomi sui pattern attuali, le proiezioni indicano:**")
+        response.append("")
+        
+        # Usa intensità vettoriale per calibrare le previsioni
+        intensity = vector_insights.get('intensity', 0.5)
+        
+        if intensity > 0.8:
+            response.append("🔴 **Alta probabilità di escalation** - I segnali indicano un sistema in rapida evoluzione")
+        elif intensity > 0.5:
+            response.append("🟡 **Evoluzione graduale** - La situazione sta progredendo ma con controlli in atto")
+        else:
+            response.append("🟢 **Stabilità relativa** - Gli indicatori suggeriscono equilibrio controllato")
+        
+        # Scenari specifici basati su entità
+        if entities:
+            if 'Russia' in entities and 'Ukraine' in entities:
+                response.append("")
+                response.append("**Scenari probabili per Russia-Ucraina:**")
+                response.append("• Continuazione del conflitto con intensità variabile")
+                response.append("• Possibili negoziati parziali su corridoi umanitari")
+                response.append("• Crescente coinvolgimento diplomatico internazionale")
             
-            for news in real_time_data[:5]:
-                if 'vector' in news:
-                    correlation = np.dot(query_vector, news['vector'])
-                    correlations.append((news['title'][:50] + "...", correlation))
+            elif 'China' in entities and 'Taiwan' in entities:
+                response.append("")
+                response.append("**Scenari Taiwan-Cina:**")
+                response.append("• Mantenimento status quo teso con provocazioni limitate")
+                response.append("• Rafforzamento deterrenza USA-alleati nella regione")
+                response.append("• Escalation diplomatica prima di quella militare")
+        
+        return response
+    
+    def answer_comparison(self, entities, vector_insights):
+        """Risponde a domande comparative"""
+        response = []
+        
+        if len(entities) >= 2:
+            entity1, entity2 = entities[0], entities[1]
+            response.append(f"**Confrontando {entity1} vs {entity2}:**")
+            response.append("")
             
-            sorted_correlations = sorted(correlations, key=lambda x: abs(x[1]), reverse=True)
-            for title, corr in sorted_correlations[:3]:
-                corr_intensity = "●" * int(abs(corr) * 15 + 1)
-                report_parts.append(f"  ρ={corr:.3f} {corr_intensity}")
-                report_parts.append(f"    {title}")
-        report_parts.append("")
-        
-        # Mathematical Predictions
-        report_parts.append("🔮 MATHEMATICAL TRAJECTORY ANALYSIS:")
-        
-        # Calcola gradiente nel semantic space
-        gradient_vector = np.zeros(self.vector_dimensions)
-        for concept, projection in vector_analysis['semantic_projections'].items():
-            if abs(projection) > 0.2:  # Soglia significatività
-                gradient_vector += projection * self.semantic_space[concept]
-        
-        gradient_norm = np.linalg.norm(gradient_vector)
-        
-        if gradient_norm > 0.5:
-            report_parts.append("  📈 HIGH-GRADIENT TRAJECTORY: Sistema in evoluzione rapida")
-            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Instabilità prevista")
-        elif gradient_norm > 0.2:
-            report_parts.append("  📊 MODERATE-GRADIENT: Evoluzione controllata")
-            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Stabilità relativa")
+            # Usa embeddings per confronti
+            if entity1 in self.entity_embeddings and entity2 in self.entity_embeddings:
+                vec1 = self.entity_embeddings[entity1]
+                vec2 = self.entity_embeddings[entity2]
+                
+                similarity = np.dot(vec1, vec2)
+                
+                if similarity > 0.7:
+                    response.append("🤝 **Profili simili** - Entrambi condividono caratteristiche strategiche comparabili")
+                elif similarity > 0.3:
+                    response.append("⚖️ **Differenze moderate** - Approcci diversi ma alcuni interessi comuni")
+                else:
+                    response.append("🔄 **Profili contrastanti** - Strategie e priorità significativamente diverse")
         else:
-            report_parts.append("  📉 LOW-GRADIENT: Sistema in equilibrio")
-            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Convergenza locale")
-        
-        # Risk Assessment basato su metriche vettoriali
-        risk_metrics = self.calculate_vector_risk_metrics(vector_analysis, relations)
-        report_parts.append("")
-        report_parts.append("⚠️ VECTOR-BASED RISK ASSESSMENT:")
-        report_parts.append(f"  Risk Magnitude: ∥R∥ = {risk_metrics['magnitude']:.3f}")
-        report_parts.append(f"  Entropy Level: H(R) = {risk_metrics['entropy']:.3f}")
-        report_parts.append(f"  Stability Index: σ = {risk_metrics['stability']:.3f}")
-        
-        # Footer metodologico
-        report_parts.append("")
-        report_parts.append("📚 MATHEMATICAL FRAMEWORK:")
-        report_parts.append("  • High-dimensional semantic embedding (512D)")
-        report_parts.append("  • Manifold learning on geopolitical concepts")
-        report_parts.append("  • Real-time vector correlation analysis")
-        report_parts.append("  • Multi-contextual transformation matrices")
-        report_parts.append("  • Information-theoretic risk quantification")
-        
-        report_parts.append(f"")
-        report_parts.append(f"🔄 Next vector update: {(datetime.now() + timedelta(minutes=30)).strftime('%H:%M UTC')}")
-        
-        return "\n".join(report_parts)
+            response.append("**Per un confronto accurato, specifica gli attori che vuoi comparare.**")
+        
+        return response
     
-    def calculate_vector_risk_metrics(self, vector_analysis, relations):
-        """Calcola metriche di rischio basate su analisi vettoriale con valori realistici"""
-        
-        # Risk magnitude basato su proiezioni semantiche con pesi
-        conflict_indicators = {
-            'conflict': 3.0,    # Peso alto per conflitto diretto
-            'military': 2.5,    # Peso medio-alto per aspetti militari
-            'power': 1.5        # Peso medio per dinamiche di potere
-        }
+    def answer_impact_analysis(self, entities, correlated_news, vector_insights):
+        """Risponde a domande sull'impatto"""
+        response = []
+        
+        response.append("**Analisi degli impatti:**")
+        response.append("")
+        
+        # Categorizza gli impatti basandosi sui temi dominanti
+        if vector_insights['dominant_themes']:
+            for concept, strength in vector_insights['dominant_themes'][:2]:
+                if concept == 'economy':
+                    response.append("💰 **Impatti Economici:**")
+                    response.append("• Volatilità dei mercati finanziari globali")
+                    response.append("• Riconfigurazione delle catene di approvvigionamento")
+                    response.append("• Pressioni inflazionistiche su energia e commodities")
+                elif concept == 'military':
+                    response.append("⚔️ **Impatti sulla Sicurezza:**")
+                    response.append("• Riallineamento delle alleanze militari")
+                    response.append("• Incremento delle spese per la difesa")
+                    response.append("• Rafforzamento dei sistemi di deterrenza")
+                elif concept == 'diplomacy':
+                    response.append("🌐 **Impatti Diplomatici:**")
+                    response.append("• Nuove dinamiche nelle organizzazioni internazionali")
+                    response.append("• Ridefinizione delle partnership strategiche")
+                    response.append("• Cambiamenti negli equilibri regionali")
+        
+        return response
+    
+    def answer_general(self, query, entities, correlated_news, vector_insights):
+        """Risposta generale per domande non categorizzate"""
+        response = []
         
-        risk_magnitude = 0.0
-        for indicator, weight in conflict_indicators.items():
-            projection = abs(vector_analysis['semantic_projections'].get(indicator, 0))
-            risk_magnitude += projection * weight
+        if entities:
+            response.append(f"**Riguardo a {', '.join(entities[:3])}:**")
+        else:
+            response.append("**Sulla situazione che mi hai chiesto:**")
         
-        # Normalizza tra 0 e 1
-        risk_magnitude = min(risk_magnitude / 5.0, 1.0)
+        response.append("")
         
-        # Aggiungi boost se ci sono conflitti noti nelle relazioni
-        if relations:
-            max_conflict_potential = max(
-                (rel.get('conflict_potential', 0) for rel in relations.values()), 
-                default=0
-            )
-            risk_magnitude = max(risk_magnitude, max_conflict_potential * 0.7)
-        
-        # Entropy del sistema basata su trasformazioni contestuali
-        entropies = []
-        for context_name, transform in vector_analysis['contextual_transforms'].items():
-            # Calcola entropy dalla distribuzione del vettore trasformato
-            vector = transform['vector']
-            # Soft-max per creare distribuzione di probabilità
-            exp_vector = np.exp(vector - np.max(vector))
-            prob_dist = exp_vector / np.sum(exp_vector)
-            entropy = -np.sum(prob_dist * np.log(prob_dist + 1e-8))
-            entropies.append(entropy)
-        
-        # Entropy media normalizzata
-        system_entropy = np.mean(entropies) / math.log(self.vector_dimensions) if entropies else 0.3
-        
-        # Stability index basato su varianza delle relazioni + fattori aggiuntivi
-        stability_factors = []
-        
-        if relations:
-            # Varianza delle similarità
-            similarities = [rel['similarity'] for rel in relations.values()]
-            if similarities:
-                similarity_variance = np.var(similarities)
-                stability_factors.append(1.0 - similarity_variance)
-            
-            # Asimmetria di potere
-            power_diffs = [abs(rel['power_differential']) for rel in relations.values()]
-            if power_diffs:
-                power_asymmetry = np.mean(power_diffs)
-                stability_factors.append(1.0 - min(power_asymmetry, 1.0))
-        
-        # Stability semantica basata su coherenza delle proiezioni
-        semantic_projections = list(vector_analysis['semantic_projections'].values())
-        if semantic_projections:
-            semantic_coherence = 1.0 - (np.var(semantic_projections) / (np.mean(np.abs(semantic_projections)) + 1e-8))
-            stability_factors.append(max(0.0, min(1.0, semantic_coherence)))
-        
-        # Stability index finale
-        if stability_factors:
-            stability = np.mean(stability_factors)
+        # Fornisci contesto generale
+        complexity = vector_insights.get('complexity', 0)
+        if complexity > 10:
+            response.append("Si tratta di una situazione **molto complessa** con multiple dimensioni interconnesse.")
+        elif complexity > 5:
+            response.append("La situazione presenta **diversi livelli di complessità** che richiedono analisi attenta.")
         else:
-            stability = 0.5  # Default per situazioni neutre
-        
-        # Aggiustamenti basati su context
-        # Se ci sono molte trasformazioni attive, riduce stabilità
-        active_transforms = sum(1 for t in vector_analysis['contextual_transforms'].values() 
-                              if t['norm'] > 0.1)
-        if active_transforms > 3:
-            stability *= 0.85
-        
-        return {
-            'magnitude': max(0.0, min(1.0, risk_magnitude)),
-            'entropy': max(0.0, min(1.0, system_entropy)), 
-            'stability': max(0.0, min(1.0, stability))
-        }
+            response.append("È una questione **relativamente diretta** ma con implicazioni significative.")
+        
+        # Usa notizie per contesto
+        if correlated_news:
+            response.append("")
+            response.append("**Dalle ultime notizie emerge che:**")
+            for news in correlated_news[:2]:
+                response.append(f"• {news['title']}")
+        
+        return response
+    
+    def update_conversation_context(self, query, entities, question_types):
+        """Aggiorna il context della conversazione"""
+        # Aggiungi topic recenti
+        if len(self.conversation_context["recent_topics"]) > 10:
+            self.conversation_context["recent_topics"].pop(0)
+        
+        self.conversation_context["recent_topics"].append({
+            "query": query[:100],
+            "entities": entities,
+            "types": question_types,
+            "timestamp": datetime.now()
+        })
+        
+        # Aggiungi entità menzionate
+        for entity in entities:
+            self.conversation_context["mentioned_entities"].add(entity)
+        
+        # Inferisci interessi utente
+        for qtype in question_types:
+            self.conversation_context["user_interests"].add(qtype)
 
-# Inizializza il sistema AI vettoriale
-ai_system = VectorizedGeopoliticalAI()
+# Inizializza il sistema AI conversazionale
+conversational_ai = ConversationalGeopoliticalAI()
 
-def analyze_vectorized(user_query):
-    """Funzione principale con analisi vettoriale matematica"""
-    if not user_query.strip():
-        return "❌ Inserisci una query per l'analisi vettoriale geopolitica."
+def chat_with_ai(user_message, history):
+    """Funzione principale per chat conversazionale"""
+    if not user_message.strip():
+        return "Ciao! Sono il tuo analista geopolitico AI. Puoi chiedermi qualsiasi cosa sulla situazione mondiale, dalle ultime notizie alle analisi predittive. Cosa ti interessa sapere?"
     
-    # Recupera dati real-time e processa
-    real_time_data = ai_system.fetch_real_time_data()
-    
-    # Analisi matematica completa
-    return ai_system.generate_mathematical_analysis(user_query, real_time_data)
+    try:
+        # Recupera dati real-time
+        real_time_data = conversational_ai.fetch_real_time_data()
+        
+        # Genera risposta conversazionale
+        response = conversational_ai.generate_conversational_response(user_message, real_time_data)
+        
+        return response
+        
+    except Exception as e:
+        error_responses = [
+            f"Mi scuso, ho avuto un problema tecnico nell'analizzare la tua richiesta. Potresti riformularla?",
+            f"Sto riscontrando alcune difficoltà nel recuperare i dati più aggiornati. Riprova tra un momento.",
+            f"C'è stato un intoppo nella mia analisi. Puoi provare a fare la domanda in modo diverso?"
+        ]
+        return random.choice(error_responses)
 
-# Esempi con focus su complessità matematica
-examples = [
-    "Analizza la dinamica vettoriale del conflitto Russia-Ucraina",
-    "Proiezione multidimensionale delle tensioni USA-Cina", 
-    "Manifold geopolitico della crisi energetica europea",
-    "Trasformazioni contestuali delle alleanze NATO",
-    "Correlazioni vettoriali nell'instabilità mediorientale",
-    "Analisi del gradiente nelle relazioni Indo-Pacifiche"
+def get_current_global_situation():
+    """Fornisce un briefing automatico della situazione globale"""
+    try:
+        news_data = conversational_ai.fetch_real_time_data()
+        
+        briefing_parts = []
+        briefing_parts.append("🌍 **BRIEFING GEOPOLITICO GLOBALE**")
+        briefing_parts.append(f"*Aggiornamento: {datetime.now().strftime('%d/%m/%Y - %H:%M UTC')}*")
+        briefing_parts.append("")
+        
+        if news_data:
+            # Categorizza le notizie
+            categories = {
+                'conflict': [],
+                'diplomacy': [],
+                'economy': [],
+                'general': []
+            }
+            
+            for news in news_data[:10]:
+                title_lower = news['title'].lower()
+                if any(word in title_lower for word in ['war', 'conflict', 'attack', 'military']):
+                    categories['conflict'].append(news)
+                elif any(word in title_lower for word in ['summit', 'meeting', 'treaty', 'agreement']):
+                    categories['diplomacy'].append(news)
+                elif any(word in title_lower for word in ['economic', 'trade', 'market', 'sanctions']):
+                    categories['economy'].append(news)
+                else:
+                    categories['general'].append(news)
+            
+            # Presenta per categoria
+            if categories['conflict']:
+                briefing_parts.append("⚔️ **TENSIONI E CONFLITTI:**")
+                for news in categories['conflict'][:3]:
+                    briefing_parts.append(f"• **[{news['source']}]** {news['title']}")
+                briefing_parts.append("")
+            
+            if categories['diplomacy']:
+                briefing_parts.append("🤝 **SVILUPPI DIPLOMATICI:**")
+                for news in categories['diplomacy'][:3]:
+                    briefing_parts.append(f"• **[{news['source']}]** {news['title']}")
+                briefing_parts.append("")
+            
+            if categories['economy']:
+                briefing_parts.append("💰 **QUESTIONI ECONOMICHE:**")
+                for news in categories['economy'][:3]:
+                    briefing_parts.append(f"• **[{news['source']}]** {news['title']}")
+                briefing_parts.append("")
+            
+            if categories['general']:
+                briefing_parts.append("📰 **ALTRI SVILUPPI:**")
+                for news in categories['general'][:2]:
+                    briefing_parts.append(f"• **[{news['source']}]** {news['title']}")
+        
+        briefing_parts.append("")
+        briefing_parts.append("*Puoi chiedermi di approfondire qualsiasi argomento o fare domande specifiche!*")
+        
+        return "\n".join(briefing_parts)
+        
+    except Exception as e:
+        return "Al momento non riesco a recuperare il briefing globale. Puoi comunque farmi domande specifiche!"
+
+# Esempi conversazionali
+conversation_examples = [
+    ["Cosa sta succedendo in Ucraina?", ""],
+    ["Perché Cina e USA sono in tensione?", ""],
+    ["Quale sarà il futuro della NATO?", ""],
+    ["Come influisce la crisi energetica sull'Europa?", ""],
+    ["Cosa pensi delle prossime elezioni americane?", ""],
+    ["Spiegami la situazione in Medio Oriente", ""],
+    ["Quali sono i rischi per Taiwan?", ""],
+    ["Come cambierà l'ordine mondiale?", ""]
 ]
 
-# Interface con focus matematico
-demo = gr.Interface(
-    fn=analyze_vectorized,
-    inputs=[
-        gr.Textbox(
-            label="Geopolitical Vector Query", 
-            placeholder="Es: Analizza lo spazio vettoriale delle tensioni Taiwan-Cina nel manifold indo-pacifico...",
-            lines=3
-        )
-    ],
-    outputs=[
-        gr.Textbox(
-            label="Mathematical Geopolitical Analysis",
-            lines=35,
-            max_lines=45
-        )
-    ],
-    title="🧮 Vectorized Geopolitical Intelligence AI",
-    description="""
-    **🚀 Analisi Geopolitica tramite Spazi Vettoriali Multidimensionali**
-    
-    🔬 **Framework Matematico:**
-    • 📐 **Embedding Semantico**: 512-dimensional vector space
-    • 🌐 **Manifold Learning**: Proiezioni su sottospazi geopolitici
-    • 🔄 **Matrici di Trasformazione**: Analisi contestuali multiple
-    • 📊 **Correlazione Vettoriale**: Input real-time transformati
-    • ⚡ **Information Theory**: Risk assessment entropico
-    
-    💡 **Advanced Capabilities:**
-    • Conversione linguaggio naturale → vettori multidimensionali
-    • Relazioni inter-entità calcolate in spazio astratto
-    • Gradient analysis per previsioni di traiettoria
-    • Metriche quantitative per assessment geopolitico
-    
-    🎯 **Output**: Analisi matematica rigorosa invece di template generici
-    """,
-    examples=examples,
-    theme=gr.themes.Monochrome(),
+# Interfaccia Chat conversazionale
+with gr.Blocks(
+    theme=gr.themes.Soft(),
     css="""
     .gradio-container {
-        max-width: 1100px;
+        max-width: 900px;
         margin: auto;
-        font-family: 'Courier New', monospace;
     }
-    .description {
+    .chat-container {
+        height: 600px;
+    }
+    .header {
         background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         color: white;
-        padding: 25px;
-        border-radius: 15px;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+        text-align: center;
     }
     """
-)
+) as demo:
+    
+    # Header
+    with gr.Row():
+        gr.HTML("""
+        <div class="header">
+            <h1>🌍 Conversational Geopolitical AI</h1>
+            <p><b>AI Geopolitica Conversazionale con Dati Real-Time</b></p>
+            <p>Chiedimi qualsiasi cosa sulla situazione mondiale - dalle ultime notizie alle analisi predittive!</p>
+        </div>
+        """)
+    
+    # Chat interface principale
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(
+                label="💬 Chat con il tuo Analista Geopolitico AI",
+                height=500,
+                show_label=True,
+                container=True,
+                bubble_full_width=False
+            )
+            
+            msg = gr.Textbox(
+                label="Il tuo messaggio",
+                placeholder="Es: Cosa sta succedendo tra Russia e Ucraina? Quali sono le prospettive per Taiwan?",
+                lines=2,
+                max_lines=4
+            )
+            
+            with gr.Row():
+                send_btn = gr.Button("Invia 💬", variant="primary", scale=2)
+                clear_btn = gr.Button("Nuova Chat 🔄", variant="secondary", scale=1)
+    
+    # Sidebar con funzionalità extra
+    with gr.Column(scale=1):
+        gr.HTML("<h3>🚀 Funzionalità</h3>")
+        
+        briefing_btn = gr.Button("📡 Briefing Globale", variant="secondary", size="sm")
+        
+        gr.HTML("<h4>💡 Esempi di domande:</h4>")
+        gr.HTML("""
+        <ul style="font-size: 12px;">
+            <li>Cosa sta succedendo in [paese]?</li>
+            <li>Perché [paese A] e [paese B] sono in conflitto?</li>
+            <li>Quale sarà il futuro di [situazione]?</li>
+            <li>Come influisce [evento] su [regione]?</li>
+            <li>Spiegami la crisi di [argomento]</li>
+            <li>Quali sono i rischi per [paese]?</li>
+        </ul>
+        """)
+        
+        gr.HTML("<h4>🔍 Capacità AI:</h4>")
+        gr.HTML("""
+        <ul style="font-size: 12px;">
+            <li>📡 Dati real-time da fonti globali</li>
+            <li>🧮 Analisi vettoriale matematica</li>
+            <li>🎯 Risposte contestualizzate</li>
+            <li>🔮 Proiezioni e scenari futuri</li>
+            <li>💬 Conversazione naturale</li>
+        </ul>
+        """)
+    
+    # Funzioni di interazione
+    def respond(message, history):
+        if not message.strip():
+            return history, ""
+        
+        # Ottieni risposta dall'AI
+        bot_response = chat_with_ai(message, history)
+        
+        # Aggiungi alla history
+        history.append([message, bot_response])
+        return history, ""
+    
+    def show_briefing(history):
+        briefing = get_current_global_situation()
+        history.append(["🤖 Briefing Automatico", briefing])
+        return history
+    
+    def clear_chat():
+        # Reset conversation context
+        conversational_ai.conversation_context = {
+            "recent_topics": [],
+            "mentioned_entities": set(),
+            "analysis_history": [],
+            "user_interests": set()
+        }
+        return [], ""
+    
+    # Event handlers
+    send_btn.click(
+        respond,
+        inputs=[msg, chatbot],
+        outputs=[chatbot, msg]
+    )
+    
+    msg.submit(
+        respond,
+        inputs=[msg, chatbot],
+        outputs=[chatbot, msg]
+    )
+    
+    clear_btn.click(
+        clear_chat,
+        outputs=[chatbot, msg]
+    )
+    
+    briefing_btn.click(
+        show_briefing,
+        inputs=[chatbot],
+        outputs=[chatbot]
+    )
+    
+    # Esempi cliccabili
+    gr.Examples(
+        examples=[ex[0] for ex in conversation_examples],
+        inputs=msg,
+        label="🎯 Esempi di Conversazione"
+    )
+    
+    # Footer informativo
+    gr.HTML("""
+    <div style="text-align: center; margin-top: 20px; padding: 15px; background-color: #f0f0f0; border-radius: 8px;">
+        <p><b>🌍 Powered by Real-Time Geopolitical Intelligence</b></p>
+        <p style="font-size: 12px;">
+            Fonti: Reuters, BBC World, UN News • Analisi: Vector AI + Mathematical Modeling<br>
+            Aggiornamento dati: ogni 30 minuti • Conversazione: Natural Language Processing
+        </p>
+    </div>
+    """)
 
 if __name__ == "__main__":
     demo.launch()