Update app.py

app.py

@@ -15,16 +15,14 @@ nltk.download('stopwords', quiet=True)
 nltk.download('punkt', quiet=True)
 print("NLTK data downloaded.")
 
-# Reliable model names and descriptions
+# Reliable model names and descriptions - replaced KeyBERT with working alternatives
 KEYWORD_MODELS = {
     'yake_yake': 'YAKE - Yet Another Keyword Extractor (statistical)',
-    'keybert_all-MiniLM-L6-v2': 'KeyBERT MiniLM - Lightweight BERT-based extraction',
-    'rake_nltk': 'RAKE-NLTK - Rapid Automatic Keyword Extraction'
+    'tfidf_cosine': 'TF-IDF with Cosine Similarity - Document similarity approach',
+    'rake_nltk': 'RAKE-NLTK - Rapid Automatic Keyword Extraction',
+    'textrank': 'TextRank - Graph-based ranking algorithm'
 }
 
-# Reduced model list for better compatibility
-# Removed models that might be too large for Spaces
-
 # Color palette for keywords based on scores
 SCORE_COLORS = {
     'high': '#00B894',      # Green - High relevance
@@ -41,7 +39,6 @@ KEYWORD_COLORS = [
 
 class KeywordExtractionManager:
     def __init__(self):
-        self.keybert_models = {}
         self.rake_extractor = None
         self.models_initialized = False
         self.initialize_models()
@@ -57,21 +54,6 @@ class KeywordExtractionManager:
         except ImportError as e:
             print(f"✗ YAKE not available: {e}")
             
-        # Test KeyBERT
-        try:
-            from keybert import KeyBERT
-            from sentence_transformers import SentenceTransformer
-            print("✓ KeyBERT library available")
-            
-            # Try to load a small model
-            try:
-                test_model = SentenceTransformer('all-MiniLM-L6-v2')
-                print("✓ Sentence transformers working")
-            except Exception as e:
-                print(f"✗ Sentence transformer model failed: {e}")
-        except ImportError as e:
-            print(f"✗ KeyBERT not available: {e}")
-            
         # Test RAKE
         try:
             from rake_nltk import Rake
@@ -79,36 +61,22 @@ class KeywordExtractionManager:
         except ImportError as e:
             print(f"✗ RAKE-NLTK not available: {e}")
             
+        # Test sklearn for TF-IDF
+        try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            print("✓ Scikit-learn available for TF-IDF")
+        except ImportError as e:
+            print(f"✗ Scikit-learn not available: {e}")
+            
+        # Test networkx for TextRank
+        try:
+            import networkx
+            print("✓ NetworkX available for TextRank")
+        except ImportError as e:
+            print(f"✗ NetworkX not available: {e}")
+            
         self.models_initialized = True
         
-    def load_keybert_model(self, model_name):
-        """Load KeyBERT model with better error handling"""
-        if model_name not in self.keybert_models:
-            try:
-                from keybert import KeyBERT
-                from sentence_transformers import SentenceTransformer
-                
-                # Extract the actual model name from the identifier
-                actual_model = model_name.replace('keybert_', '')
-                
-                print(f"Loading KeyBERT with {actual_model}...")
-                
-                # Try to load the sentence transformer first
-                try:
-                    sentence_model = SentenceTransformer(actual_model)
-                    self.keybert_models[model_name] = KeyBERT(model=sentence_model)
-                    print(f"✓ KeyBERT model {actual_model} loaded successfully")
-                except Exception as e:
-                    print(f"Failed to load sentence transformer {actual_model}: {e}")
-                    # Try with just the model name
-                    self.keybert_models[model_name] = KeyBERT(model=actual_model)
-                    
-            except Exception as e:
-                print(f"Error loading KeyBERT model {model_name}: {str(e)}")
-                print(f"Full error: {type(e).__name__}: {str(e)}")
-                return None
-        return self.keybert_models.get(model_name)
-        
     def load_rake_extractor(self):
         """Load RAKE extractor with better error handling"""
         if self.rake_extractor is None:
@@ -135,10 +103,12 @@ class KeywordExtractionManager:
             # Handle different model types
             if model_name.startswith('yake_'):
                 return self.extract_yake_keywords(text, num_keywords, ngram_range, progress)
-            elif model_name.startswith('keybert_'):
-                return self.extract_keybert_keywords(text, model_name, num_keywords, ngram_range, progress)
+            elif model_name.startswith('tfidf_'):
+                return self.extract_tfidf_cosine_keywords(text, num_keywords, ngram_range, progress)
             elif model_name.startswith('rake_'):
                 return self.extract_rake_keywords(text, num_keywords, progress)
+            elif model_name.startswith('textrank'):
+                return self.extract_textrank_keywords(text, num_keywords, ngram_range, progress)
             else:
                 raise ValueError(f"Unknown model: {model_name}")
                 
@@ -186,54 +156,200 @@ class KeywordExtractionManager:
             print(f"YAKE extraction failed: {type(e).__name__}: {str(e)}")
             return self.fallback_keyword_extraction(text, num_keywords)
     
-    def extract_keybert_keywords(self, text, model_name, num_keywords, ngram_range, progress):
-        """Extract keywords using KeyBERT"""
+    def extract_tfidf_cosine_keywords(self, text, num_keywords, ngram_range, progress):
+        """Extract keywords using TF-IDF with cosine similarity"""
         try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            from sklearn.metrics.pairwise import cosine_similarity
+            import numpy as np
+            
             if progress:
-                progress(0.4, desc="Loading KeyBERT model...")
+                progress(0.5, desc="Processing with TF-IDF...")
+            
+            # Create TF-IDF vectorizer
+            vectorizer = TfidfVectorizer(
+                ngram_range=ngram_range,
+                stop_words='english',
+                max_features=5000,
+                min_df=1,
+                max_df=0.95
+            )
+            
+            # Extract candidate keywords/phrases
+            words = re.findall(r'\b[a-z]+\b', text.lower())
+            candidates = []
+            
+            # Generate n-grams
+            for n in range(ngram_range[0], ngram_range[1] + 1):
+                for i in range(len(words) - n + 1):
+                    candidate = ' '.join(words[i:i+n])
+                    if len(candidate) > 2 and candidate not in candidates:
+                        candidates.append(candidate)
             
-            kw_model = self.load_keybert_model(model_name)
-            if kw_model is None:
-                print(f"KeyBERT model {model_name} could not be loaded")
+            if not candidates:
                 return self.fallback_keyword_extraction(text, num_keywords)
             
+            # Limit candidates to prevent memory issues
+            candidates = candidates[:300]
+            
             if progress:
-                progress(0.6, desc="Processing with KeyBERT...")
+                progress(0.7, desc="Computing similarities...")
             
-            # Extract keywords with error handling
             try:
-                keywords = kw_model.extract_keywords(
-                    text, 
-                    keyphrase_ngram_range=ngram_range,
-                    stop_words='english',
-                    top_n=num_keywords
-                )
+                # Create document embedding
+                doc_embedding = vectorizer.fit_transform([text])
+                
+                # Create embeddings for candidates
+                candidate_embeddings = vectorizer.transform(candidates)
+                
+                # Calculate similarities
+                similarities = cosine_similarity(doc_embedding, candidate_embeddings)[0]
+                
+                # Get top keywords
+                top_indices = similarities.argsort()[-num_keywords:][::-1]
+                
+                results = []
+                for idx in top_indices:
+                    if similarities[idx] > 0:
+                        results.append({
+                            'keyword': candidates[idx],
+                            'score': float(similarities[idx]),
+                            'model': 'TF-IDF-Cosine'
+                        })
+                
+                if progress:
+                    progress(0.8, desc="Formatting results...")
+                
+                print(f"TF-IDF extracted {len(results)} keywords")
+                return results
+                
             except Exception as e:
-                print(f"KeyBERT extraction error: {e}")
-                # Try without stop words
-                keywords = kw_model.extract_keywords(
-                    text, 
-                    keyphrase_ngram_range=ngram_range,
-                    top_n=num_keywords
-                )
+                print(f"TF-IDF approach failed: {e}")
+                # Fall back to simple TF-IDF
+                return self.simple_tfidf_extraction(text, num_keywords, ngram_range)
+                
+        except ImportError:
+            print("scikit-learn not available for TF-IDF")
+            return self.fallback_keyword_extraction(text, num_keywords)
+        except Exception as e:
+            print(f"TF-IDF extraction failed: {e}")
+            return self.fallback_keyword_extraction(text, num_keywords)
+    
+    def extract_textrank_keywords(self, text, num_keywords, ngram_range, progress):
+        """Extract keywords using TextRank algorithm"""
+        try:
+            import numpy as np
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            from sklearn.metrics.pairwise import cosine_similarity
+            import networkx as nx
+            
+            if progress:
+                progress(0.5, desc="Processing with TextRank...")
+            
+            # Split text into sentences
+            sentences = re.split(r'[.!?]+', text)
+            sentences = [s.strip() for s in sentences if s.strip()]
+            
+            if len(sentences) < 2:
+                # If text is too short, use simple extraction
+                return self.simple_tfidf_extraction(text, num_keywords, ngram_range)
+            
+            # Create TF-IDF matrix
+            vectorizer = TfidfVectorizer(
+                ngram_range=(1, 1),  # Use unigrams for sentence similarity
+                stop_words='english'
+            )
+            
+            tfidf_matrix = vectorizer.fit_transform(sentences)
+            
+            # Calculate similarity matrix
+            similarity_matrix = cosine_similarity(tfidf_matrix)
             
             if progress:
-                progress(0.8, desc="Formatting results...")
+                progress(0.6, desc="Building graph...")
+            
+            # Build graph
+            nx_graph = nx.from_numpy_array(similarity_matrix)
+            
+            # Calculate PageRank scores
+            scores = nx.pagerank(nx_graph)
+            
+            # Extract keywords from top-ranked sentences
+            top_sentence_indices = sorted(scores.keys(), key=lambda x: scores[x], reverse=True)[:3]
+            
+            # Extract keywords from top sentences
+            keyword_vectorizer = TfidfVectorizer(
+                ngram_range=ngram_range,
+                stop_words='english',
+                max_features=num_keywords * 2
+            )
+            
+            top_sentences = [sentences[i] for i in top_sentence_indices]
+            top_text = ' '.join(top_sentences)
+            
+            if progress:
+                progress(0.7, desc="Extracting keywords...")
+            
+            tfidf_matrix = keyword_vectorizer.fit_transform([top_text])
+            feature_names = keyword_vectorizer.get_feature_names_out()
+            tfidf_scores = tfidf_matrix.toarray()[0]
+            
+            # Get top keywords
+            top_indices = tfidf_scores.argsort()[-num_keywords:][::-1]
             
-            # Format results
             results = []
-            for keyword, score in keywords:
-                results.append({
-                    'keyword': keyword,
-                    'score': score,
-                    'model': f"KeyBERT-{model_name.replace('keybert_', '')}"
-                })
-                
-            print(f"KeyBERT extracted {len(results)} keywords")
+            for idx in top_indices:
+                if tfidf_scores[idx] > 0:
+                    results.append({
+                        'keyword': feature_names[idx],
+                        'score': float(tfidf_scores[idx]),
+                        'model': 'TextRank'
+                    })
+            
+            print(f"TextRank extracted {len(results)} keywords")
             return results
             
+        except ImportError as e:
+            print(f"Required library not available for TextRank: {e}")
+            return self.fallback_keyword_extraction(text, num_keywords)
         except Exception as e:
-            print(f"KeyBERT extraction failed: {type(e).__name__}: {str(e)}")
+            print(f"TextRank extraction failed: {e}")
+            return self.fallback_keyword_extraction(text, num_keywords)
+    
+    def simple_tfidf_extraction(self, text, num_keywords, ngram_range):
+        """Simple TF-IDF extraction without cosine similarity"""
+        try:
+            from sklearn.feature_extraction.text import TfidfVectorizer
+            
+            vectorizer = TfidfVectorizer(
+                ngram_range=ngram_range,
+                stop_words='english',
+                max_features=num_keywords * 2
+            )
+            
+            # Fit and transform
+            tfidf_matrix = vectorizer.fit_transform([text])
+            
+            # Get feature names and scores
+            feature_names = vectorizer.get_feature_names_out()
+            scores = tfidf_matrix.toarray()[0]
+            
+            # Get top keywords
+            top_indices = scores.argsort()[-num_keywords:][::-1]
+            
+            results = []
+            for idx in top_indices:
+                if scores[idx] > 0:
+                    results.append({
+                        'keyword': feature_names[idx],
+                        'score': float(scores[idx]),
+                        'model': 'TF-IDF-Simple'
+                    })
+            
+            return results
+            
+        except Exception as e:
+            print(f"Simple TF-IDF failed: {e}")
             return self.fallback_keyword_extraction(text, num_keywords)
     
     def extract_rake_keywords(self, text, num_keywords, progress):
@@ -324,6 +440,19 @@ def get_score_color(score, max_score):
     else:
         return SCORE_COLORS['low']
 
+def get_relevance_level(score, max_score):
+    """Get relevance level name based on score"""
+    if max_score == 0:
+        return 'medium'
+    
+    relative_score = score / max_score
+    if relative_score >= 0.7:
+        return 'high'
+    elif relative_score >= 0.4:
+        return 'medium'
+    else:
+        return 'low'
+
 def create_highlighted_html(text, keywords):
     """Create HTML with highlighted keywords in the text"""
     if not keywords:
@@ -341,12 +470,13 @@ def create_highlighted_html(text, keywords):
         keyword = kw_data['keyword']
         score = kw_data['score']
         color = get_score_color(score, max_score)
+        relevance = get_relevance_level(score, max_score)
         
         # Create regex pattern for whole word matching (case-insensitive)
         pattern = r'\b' + re.escape(keyword) + r'\b'
         
         # Replace with highlighted version
-        replacement = f'<span style="background-color: {color}; padding: 2px 4px; ' \
+        replacement = f'<span class="keyword-{relevance}" style="background-color: {color}; padding: 2px 4px; ' \
                      f'border-radius: 3px; margin: 0 1px; ' \
                      f'border: 1px solid {color}; color: white; font-weight: bold;" ' \
                      f'title="Score: {score:.3f}">{keyword}</span>'
@@ -356,12 +486,12 @@ def create_highlighted_html(text, keywords):
     return f"""
     <div style='padding: 15px; border: 2px solid #ddd; border-radius: 8px; background-color: #fafafa; margin: 10px 0;'>
         <h4 style='margin: 0 0 15px 0; color: #333;'>📝 Text with Highlighted Keywords</h4>
-        <div style='line-height: 1.8; font-size: 16px; background-color: white; padding: 15px; border-radius: 5px;'>{highlighted_text}</div>
+        <div id="highlighted-text" style='line-height: 1.8; font-size: 16px; background-color: white; padding: 15px; border-radius: 5px;'>{highlighted_text}</div>
     </div>
     """
 
 def create_keyword_table_html(keywords):
-    """Create HTML table for keywords"""
+    """Create HTML table for keywords with filtering capability"""
     if not keywords:
         return "<p style='text-align: center; padding: 20px;'>No keywords found.</p>"
     
@@ -372,7 +502,7 @@ def create_keyword_table_html(keywords):
     table_html = """
     <div style='max-height: 600px; overflow-y: auto; border: 2px solid #ddd; border-radius: 8px; padding: 20px; background-color: #fafafa;'>
         <h3 style="margin: 0 0 20px 0;">🎯 Extracted Keywords</h3>
-        <table style="width: 100%; border-collapse: collapse; border: 1px solid #ddd; background-color: white;">
+        <table id="keywords-table" style="width: 100%; border-collapse: collapse; border: 1px solid #ddd; background-color: white;">
             <thead>
                 <tr style="background-color: #4ECDC4; color: white;">
                     <th style="padding: 12px; text-align: left; border: 1px solid #ddd;">Rank</th>
@@ -388,6 +518,7 @@ def create_keyword_table_html(keywords):
     for i, kw_data in enumerate(sorted_keywords):
         score = kw_data['score']
         color = get_score_color(score, max_score)
+        relevance = get_relevance_level(score, max_score)
         
         # Create relevance bar
         bar_width = int((score / max_score) * 100) if max_score > 0 else 0
@@ -398,7 +529,7 @@ def create_keyword_table_html(keywords):
         """
         
         table_html += f"""
-            <tr style="background-color: #fff;">
+            <tr class="keyword-row relevance-{relevance}" style="background-color: #fff;">
                 <td style="padding: 10px; border: 1px solid #ddd; text-align: center; font-weight: bold;">#{i+1}</td>
                 <td style="padding: 10px; border: 1px solid #ddd; font-weight: bold;">{kw_data['keyword']}</td>
                 <td style="padding: 10px; border: 1px solid #ddd;">
@@ -422,22 +553,87 @@ def create_keyword_table_html(keywords):
     return table_html
 
 def create_legend_html():
-    """Create a legend showing score colors"""
+    """Create an interactive legend showing score colors"""
     html = """
     <div style='margin: 15px 0; padding: 15px; background-color: #f8f9fa; border-radius: 8px;'>
-        <h4 style='margin: 0 0 15px 0;'>🎨 Relevance Score Legend</h4>
+        <h4 style='margin: 0 0 15px 0;'>🎨 Relevance Score Legend (Click to Filter)</h4>
         <div style='display: flex; flex-wrap: wrap; gap: 15px;'>
-            <span style='background-color: #00B894; padding: 4px 12px; border-radius: 15px; color: white; font-weight: bold;'>
+            <button onclick="filterByRelevance('all')" 
+                    style='background-color: #6c757d; padding: 8px 16px; border-radius: 15px; 
+                           color: white; font-weight: bold; border: none; cursor: pointer;
+                           transition: all 0.3s ease;'>
+                Show All
+            </button>
+            <button onclick="filterByRelevance('high')" 
+                    style='background-color: #00B894; padding: 8px 16px; border-radius: 15px; 
+                           color: white; font-weight: bold; border: none; cursor: pointer;
+                           transition: all 0.3s ease;'>
                 High Relevance (70%+)
-            </span>
-            <span style='background-color: #F9CA24; padding: 4px 12px; border-radius: 15px; color: white; font-weight: bold;'>
+            </button>
+            <button onclick="filterByRelevance('medium')" 
+                    style='background-color: #F9CA24; padding: 8px 16px; border-radius: 15px; 
+                           color: white; font-weight: bold; border: none; cursor: pointer;
+                           transition: all 0.3s ease;'>
                 Medium Relevance (40-70%)
-            </span>
-            <span style='background-color: #FF6B6B; padding: 4px 12px; border-radius: 15px; color: white; font-weight: bold;'>
+            </button>
+            <button onclick="filterByRelevance('low')" 
+                    style='background-color: #FF6B6B; padding: 8px 16px; border-radius: 15px; 
+                           color: white; font-weight: bold; border: none; cursor: pointer;
+                           transition: all 0.3s ease;'>
                 Low Relevance (<40%)
-            </span>
+            </button>
         </div>
     </div>
+    
+    <script>
+    function filterByRelevance(level) {
+        const table = document.getElementById('keywords-table');
+        const rows = table.getElementsByClassName('keyword-row');
+        const textContainer = document.getElementById('highlighted-text');
+        const keywords = textContainer.getElementsByTagName('span');
+        
+        // Filter table rows
+        for (let row of rows) {
+            if (level === 'all') {
+                row.style.display = '';
+            } else {
+                if (row.classList.contains('relevance-' + level)) {
+                    row.style.display = '';
+                } else {
+                    row.style.display = 'none';
+                }
+            }
+        }
+        
+        // Highlight keywords in text
+        for (let keyword of keywords) {
+            if (level === 'all') {
+                keyword.style.opacity = '1';
+                keyword.style.filter = 'none';
+            } else {
+                if (keyword.classList.contains('keyword-' + level)) {
+                    keyword.style.opacity = '1';
+                    keyword.style.filter = 'none';
+                } else {
+                    keyword.style.opacity = '0.3';
+                    keyword.style.filter = 'grayscale(100%)';
+                }
+            }
+        }
+        
+        // Update button styles
+        const buttons = document.querySelectorAll('button');
+        buttons.forEach(button => {
+            if (button.onclick && button.onclick.toString().includes(level)) {
+                button.style.transform = 'scale(1.1)';
+                button.style.boxShadow = '0 4px 8px rgba(0,0,0,0.2)';
+            } else {
+                button.style.transform = 'scale(1)';
+                button.style.boxShadow = 'none';
+            }
+        });
+    }
+    </script>
     """
     return html
 
@@ -476,7 +672,7 @@ def process_text(text, selected_model, num_keywords, ngram_min, ngram_max, progr
     
     # Create summary
     avg_score = sum(k['score'] for k in keywords) / len(keywords)
-    model_display = selected_model.replace('yake_', '').replace('keybert_', 'KeyBERT-').replace('rake_', 'RAKE-').title()
+    model_display = selected_model.replace('yake_', '').replace('tfidf_', 'TF-IDF ').replace('rake_', 'RAKE-').replace('textrank', 'TextRank').title()
     summary = f"""
     ## 📊 Analysis Summary
     - **Keywords extracted:** {len(keywords)}
@@ -495,13 +691,14 @@ def create_interface():
         gr.Markdown("""
         # Keyword Extraction Explorer Tool
         
-        Extract the most important keywords and phrases from your text using various algorithms! This tool uses modern keyword extraction methods including YAKE, KeyBERT, and RAKE for comprehensive analysis.
+        Extract the most important keywords and phrases from your text using various algorithms! This tool uses modern keyword extraction methods including YAKE, TF-IDF, RAKE, and TextRank for comprehensive analysis.
           
         ### How to use:
         1. **📝 Enter your text** in the text area below
         2. **🎯 Select a model** from the dropdown for keyword extraction
         3. **⚙️ Adjust parameters** (number of keywords, n-gram range)
         4. **🔍 Click "Extract Keywords"** to see results with organized output
+        5. **🎨 Click on the legend buttons** to filter keywords by relevance level
         """)
         
         # Add tip box
@@ -573,13 +770,17 @@ def create_interface():
                         <dd style="display: inline; margin-left: 5px;">Statistical approach requiring no training - works well on short texts and multilingual content</dd>
                     </div>
                     <div style="margin-bottom: 8px;">
-                        <dt style="font-weight: bold; display: inline; color: #795548;">KeyBERT MiniLM:</dt>
-                        <dd style="display: inline; margin-left: 5px;">Lightweight BERT model - faster processing with good results</dd>
+                        <dt style="font-weight: bold; display: inline; color: #795548;">TF-IDF with Cosine Similarity:</dt>
+                        <dd style="display: inline; margin-left: 5px;">Document similarity approach - extracts keywords most similar to the overall document</dd>
                     </div>
                     <div style="margin-bottom: 8px;">
                         <dt style="font-weight: bold; display: inline; color: #FF5722;">RAKE-NLTK:</dt>
                         <dd style="display: inline; margin-left: 5px;">Classic keyword extraction algorithm - fast and reliable for phrase extraction</dd>
                     </div>
+                    <div style="margin-bottom: 8px;">
+                        <dt style="font-weight: bold; display: inline; color: #607D8B;">TextRank:</dt>
+                        <dd style="display: inline; margin-left: 5px;">Graph-based ranking algorithm inspired by PageRank - good for extracting key concepts</dd>
+                    </div>
                 </dl>
             </div>
         </details>
@@ -624,7 +825,7 @@ def create_interface():
                 ],
                 [
                     "In Jane Austen's 'Pride and Prejudice', Elizabeth Bennet first meets Mr. Darcy at the Meryton assembly. The novel, published in 1813, explores themes of marriage and social class in Regency England. Austen wrote to her sister Cassandra about the manuscript while staying at Chawton Cottage.",
-                    "keybert_all-MiniLM-L6-v2",
+                    "tfidf_cosine",
                     10,
                     1,
                     3
@@ -658,9 +859,9 @@ def create_interface():
                         Yet Another Keyword Extractor ↗
                     </a>
                 </li>
-                <li><strong>KeyBERT:</strong> 
-                    <a href="https://github.com/MaartenGr/KeyBERT" target="_blank" style="color: #1976d2;">
-                        Minimal keyword extraction with BERT ↗
+                <li><strong>TF-IDF:</strong> 
+                    <a href="https://scikit-learn.org/stable/modules/feature_extraction.html#tfidf-term-weighting" target="_blank" style="color: #1976d2;">
+                        Term Frequency-Inverse Document Frequency ↗
                     </a>
                 </li>
                 <li><strong>RAKE-NLTK:</strong> 
@@ -668,9 +869,9 @@ def create_interface():
                         Rapid Automatic Keyword Extraction with NLTK ↗
                     </a>
                 </li>
-                <li><strong>Sentence Transformers:</strong> 
-                    <a href="https://www.sbert.net/" target="_blank" style="color: #1976d2;">
-                        BERT-based models for semantic similarity ↗
+                <li><strong>TextRank:</strong> 
+                    <a href="https://web.eecs.umich.edu/~mihalcea/papers/mihalcea.emnlp04.pdf" target="_blank" style="color: #1976d2;">
+                        TextRank: Bringing Order into Text ↗
                     </a>
                 </li>
             </ul>