Update model_classes.py

model_classes.py

@@ -21,10 +21,11 @@ from langchain.schema import Document
 from scipy.sparse import csr_matrix, vstack
 from sklearn.preprocessing import normalize
 from langchain.schema import Document
-from collections import defaultdict
 from sklearn.metrics.pairwise import cosine_similarity
 import concurrent.futures
 import heapq
+from scipy.sparse import csr_matrix, vstack
+from sklearn.preprocessing import normalize
 
 class IntelligentIntentRecognizer:
     def __init__(self, vectorstore):
@@ -283,18 +284,6 @@ class DynamicConceptAnalyzer:
         
         return min(confidence, 1.0)
 
-from scipy.sparse import csr_matrix, vstack
-from sklearn.preprocessing import normalize
-import numpy as np
-import networkx as nx
-from datetime import datetime
-from typing import Dict, List, Optional, Any, Tuple
-from langchain.schema import Document
-from collections import defaultdict
-from sklearn.metrics.pairwise import cosine_similarity
-import concurrent.futures
-import heapq
-
 class EnhancedHybridSearcher:
     """Optimierte Hybrid-Suche für RAG Chatbots mit integrierten Suchstrategien"""
     
@@ -337,17 +326,13 @@ class EnhancedHybridSearcher:
 
     # 1. Hauptsuchfunktion
     def hybrid_search(self, query: str, context: Optional[Dict[str, Any]] = None, 
-                     k: int = 5) -> List[Dict[str, Any]]:
-        """Hauptsuchfunktion, die alle Suchmethoden kombiniert"""
+                 k: int = 5) -> List[Dict[str, Any]]:
         try:
             # Cache-Check
             cache_key = f"{query}_{str(context)}"
             if cache_key in self.result_cache:
                 return self.result_cache[cache_key]
-
-            # Start Performance-Tracking
-            start_time = datetime.now()
-
+    
             # 1. Parallele Suche
             search_results = self._parallel_search(query, k*2)
             
@@ -362,23 +347,15 @@ class EnhancedHybridSearcher:
                 weights
             )
             
-            # 4. Kontext-Reranking
-            if context and context.get('active_themes'):
-                combined_results = self._context_reranking(
-                    combined_results,
-                    context,
-                    query
-                )
-            
-            # 5. Qualitätsverbesserung
-            final_results = self._enhance_results(combined_results[:k], query)
+            # Schneide auf k Ergebnisse
+            final_results = combined_results[:k]
             
             # Update Cache und Metriken
             self._update_cache(cache_key, final_results)
-            self._update_performance_metrics(query, final_results, start_time)
+            self._update_performance_metrics(query, final_results, datetime.now())
             
             return final_results
-            
+                
         except Exception as e:
             print(f"Fehler in hybrid_search: {str(e)}")
             return []
@@ -456,14 +433,13 @@ class EnhancedHybridSearcher:
     def _semantic_search(self, query: str, k: int) -> List[Dict[str, Any]]:
         """Führt semantische Suche durch"""
         try:
-            results = self.vectorstore.similarity_search_with_score(query, k=k)
+            results = self.vectorstore.similarity_search_with_relevance_scores(query, k=k)  # Geänderte Methode
             return [
                 {
                     'content': doc.page_content,
                     'score': float(score),
                     'type': 'semantic',
-                    'metadata': doc.metadata if hasattr(doc, 'metadata') else {},
-                    'quality_metrics': self._calculate_quality_metrics(doc.page_content)
+                    'metadata': doc.metadata if hasattr(doc, 'metadata') else {}
                 }
                 for doc, score in results
             ]
@@ -702,10 +678,9 @@ class EnhancedHybridSearcher:
             return self.search_weights
 
     def _combine_all_results(self, search_results: Dict[str, List[Dict]],
-                           query: str,
-                           context: Optional[Dict],
-                           weights: Dict[str, float]) -> List[Dict[str, Any]]:
-        """Kombiniert alle Suchergebnisse mit adaptiver Gewichtung"""
+                       query: str,
+                       context: Optional[Dict],
+                       weights: Dict[str, float]) -> List[Dict[str, Any]]:
         try:
             combined_scores = defaultdict(lambda: {
                 'score': 0.0,
@@ -714,47 +689,30 @@ class EnhancedHybridSearcher:
                 'quality_metrics': {}
             })
             
-            # Kombiniere alle Ergebnisse
+            # Kombiniere nur vorhandene Ergebnisse
             for search_type, results in search_results.items():
-                for result in results:
-                    key = result['content']
-                    entry = combined_scores[key]
-                    
-                    # Gewichteter Score
-                    entry['score'] += result['score'] * weights[search_type]
-                    entry['sources'].append(search_type)
-                    
-                    # Sammle Metadaten
-                    entry['metadata'].update(result.get('metadata', {}))
-                    if 'quality_metrics' in result:
-                        entry['quality_metrics'].update(result['quality_metrics'])
-            
-            # Berechne finale Scores
-            for content, entry in combined_scores.items():
-                # Diversity Bonus
-                entry['score'] *= (1 + 0.1 * len(entry['sources']))
-                
-                # Qualitätsbonus
-                if entry['quality_metrics']:
-                    avg_quality = np.mean(list(entry['quality_metrics'].values()))
-                    entry['score'] *= (1 + 0.2 * avg_quality)
+                if search_type in weights:  # Nur wenn Gewicht existiert
+                    for result in results:
+                        key = result['content']
+                        entry = combined_scores[key]
+                        entry['score'] += result['score'] * weights[search_type]
+                        entry['sources'].append(search_type)
+                        entry['metadata'].update(result.get('metadata', {}))
             
-            # Erstelle sortierte Liste
             return sorted([
                 {
                     'content': content,
                     'score': data['score'],
                     'sources': data['sources'],
-                    'metadata': data['metadata'],
-                    'quality_metrics': data['quality_metrics']
+                    'metadata': data['metadata']
                 }
                 for content, data in combined_scores.items()
             ], key=lambda x: x['score'], reverse=True)
-            
+                
         except Exception as e:
             print(f"Fehler beim Kombinieren der Ergebnisse: {str(e)}")
             return []
-
+        
     def _add_graph_edges(self, graph: nx.DiGraph, documents: List[Document]):
         """Fügt Kanten zwischen ähnlichen Dokumenten hinzu"""
         try: