Merge branch 'main' of https://huggingface.co/spaces/NLP-Debater-Project/FastAPI-Backend-Models

config.py

@@ -42,6 +42,9 @@ GROQ_TTS_FORMAT = "wav"
 # **Chat Model**
 GROQ_CHAT_MODEL = "llama3-70b-8192"
 
+# **Topic Extraction Model**
+GROQ_TOPIC_MODEL = "llama-3.3-70b-versatile"  # Latest production model, fallback: "llama3-70b-8192"
+
 # ============ SUPABASE ============
 SUPABASE_URL = os.getenv("SUPABASE_URL", "")
 SUPABASE_KEY = os.getenv("SUPABASE_KEY", "")
@@ -87,6 +90,7 @@ logger.info(f"  HF Label Model  : {HUGGINGFACE_LABEL_MODEL_ID}")
 logger.info(f"  GROQ STT Model  : {GROQ_STT_MODEL}")
 logger.info(f"  GROQ TTS Model  : {GROQ_TTS_MODEL}")
 logger.info(f"  GROQ Chat Model : {GROQ_CHAT_MODEL}")
+logger.info(f"  GROQ Topic Model: {GROQ_TOPIC_MODEL}")
 logger.info(f"  Google API Key  : {'✓ Configured' if GOOGLE_API_KEY else '✗ Not configured'}")
 logger.info(f"  Supabase URL    : {'✓ Configured' if SUPABASE_URL else '✗ Not configured'}")
 logger.info("="*60)

main.py

@@ -55,10 +55,12 @@ def cleanup_on_exit():
 stance_model_manager = None
 kpa_model_manager = None
 generate_model_manager = None
+topic_similarity_service = None
 try:
     from services.stance_model_manager import stance_model_manager
     from services.label_model_manager import kpa_model_manager 
     from services.generate_model_manager import generate_model_manager 
+    from services.topic_similarity_service import topic_similarity_service
     logger.info("✓ Gestionnaires de modèles importés")
 except ImportError as e:
     logger.warning(f"⚠ Impossible d'importer les gestionnaires de modèles: {e}")
@@ -103,6 +105,18 @@ async def lifespan(app: FastAPI):
         logger.error(f"✗ Failed to load Generation model: {str(e)}")
         logger.error("⚠️  Generation endpoints will not work!")
     
+    # Initialize Topic Extraction service (uses Groq LLM)
+    if topic_similarity_service and GROQ_API_KEY:
+        try:
+            logger.info("Initializing Topic Extraction service (Groq LLM)...")
+            topic_similarity_service.initialize()
+            logger.info("✓ Topic Extraction service initialized")
+        except Exception as e:
+            logger.error(f"✗ Failed to initialize Topic Extraction service: {str(e)}")
+            logger.error("⚠️  Topic extraction endpoints will not work!")
+    elif not GROQ_API_KEY:
+        logger.warning("⚠ GROQ_API_KEY not configured. Topic extraction service will not be available.")
+    
     logger.info("✓ API startup complete")
     logger.info("https://nlp-debater-project-fastapi-backend-models.hf.space/docs")
     
@@ -149,7 +163,11 @@ async def lifespan(app: FastAPI):
     logger.info(f"  STT Model: {GROQ_STT_MODEL}")
     logger.info(f"  TTS Model: {GROQ_TTS_MODEL}")
     logger.info(f"  Chat Model: {GROQ_CHAT_MODEL}")
+    logger.info(f"  Topic Extraction: {'Initialized' if (topic_similarity_service and topic_similarity_service.initialized) else 'Not initialized'}")
+    logger.info(f"  Voice Chat: {'Available' if GROQ_API_KEY else 'Disabled (no GROQ_API_KEY)'}")
     logger.info(f"  MCP: {'Activé' if MCP_ENABLED else 'Désactivé'}")
+    if MCP_ENABLED:
+        logger.info(f"    - Tools: detect_stance, match_keypoint_argument, transcribe_audio, generate_speech, generate_argument, extract_topic, voice_chat, health_check")
     logger.info("="*60)
     
     yield
@@ -262,12 +280,21 @@ async def health():
             "stt": GROQ_STT_MODEL if GROQ_API_KEY else "disabled",
             "tts": GROQ_TTS_MODEL if GROQ_API_KEY else "disabled",
             "chat": GROQ_CHAT_MODEL if GROQ_API_KEY else "disabled",
+            "topic_extraction": "initialized" if (topic_similarity_service and hasattr(topic_similarity_service, 'initialized') and topic_similarity_service.initialized) else "not initialized",
+            "voice_chat": "available" if GROQ_API_KEY else "disabled",
             "stance_model": "loaded" if (stance_model_manager and hasattr(stance_model_manager, 'model_loaded') and stance_model_manager.model_loaded) else "not loaded",
             "kpa_model": "loaded" if (kpa_model_manager and hasattr(kpa_model_manager, 'model_loaded') and kpa_model_manager.model_loaded) else "not loaded",
+            "generate_model": "loaded" if (generate_model_manager and hasattr(generate_model_manager, 'model_loaded') and generate_model_manager.model_loaded) else "not loaded",
             "mcp": "enabled" if MCP_ENABLED else "disabled"
         },
         "endpoints": {
-            "mcp": "/api/v1/mcp" if MCP_ENABLED else "disabled"
+            "mcp": "/api/v1/mcp" if MCP_ENABLED else "disabled",
+            "topic_extraction": "/api/v1/topic/extract",
+            "voice_chat": "/voice-chat/voice or /voice-chat/text",
+            "mcp_tools": {
+                "extract_topic": "/api/v1/mcp/tools/extract-topic",
+                "voice_chat": "/api/v1/mcp/tools/voice-chat"
+            } if MCP_ENABLED else "disabled"
         }
     }
     return health_status
@@ -285,13 +312,22 @@ async def not_found_handler(request, exc):
         "GET /health": "Health check",
         "POST /api/v1/stt/": "Speech to text",
         "POST /api/v1/tts/": "Text to speech",
-        "POST /voice-chat/voice": "Voice chat"
+        "POST /voice-chat/voice": "Voice chat (audio input)",
+        "POST /voice-chat/text": "Voice chat (text input)",
+        "POST /api/v1/topic/extract": "Extract topic from text"
     }
     if MCP_ENABLED:
         endpoints.update({
             "GET /api/v1/mcp/health": "Health check MCP",
             "GET /api/v1/mcp/tools": "Liste outils MCP",
-            "POST /api/v1/mcp/tools/call": "Appel d'outil MCP"
+            "POST /api/v1/mcp/tools/call": "Appel d'outil MCP",
+            "POST /api/v1/mcp/tools/extract-topic": "Extract topic (MCP tool)",
+            "POST /api/v1/mcp/tools/voice-chat": "Voice chat (MCP tool)",
+            "POST /api/v1/mcp/tools/detect-stance": "Detect stance (MCP tool)",
+            "POST /api/v1/mcp/tools/match-keypoint": "Match keypoint (MCP tool)",
+            "POST /api/v1/mcp/tools/transcribe-audio": "Transcribe audio (MCP tool)",
+            "POST /api/v1/mcp/tools/generate-speech": "Generate speech (MCP tool)",
+            "POST /api/v1/mcp/tools/generate-argument": "Generate argument (MCP tool)"
         })
     return {
         "error": "Not Found",

models/mcp_models.py

@@ -15,7 +15,7 @@ class ToolCallRequest(BaseModel):
         }
     )
     
-    tool_name: str = Field(..., description="Name of the MCP tool to call (e.g., 'detect_stance', 'match_keypoint_argument', 'transcribe_audio', 'generate_speech', 'generate_argument')")
+    tool_name: str = Field(..., description="Name of the MCP tool to call (e.g., 'detect_stance', 'match_keypoint_argument', 'transcribe_audio', 'generate_speech', 'generate_argument', 'extract_topic', 'voice_chat')")
     arguments: Dict[str, Any] = Field(default_factory=dict, description="Arguments for the tool (varies by tool)")
 
 class ToolCallResponse(BaseModel):
@@ -105,6 +105,40 @@ class GenerateSpeechResponse(BaseModel):
     
     audio_path: str = Field(..., description="Path to generated audio file")
 
+class ExtractTopicResponse(BaseModel):
+    """Response model for topic extraction"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "text": "Governments should subsidize electric cars to encourage adoption.",
+                "topic": "government subsidies for electric vehicle adoption",
+                "timestamp": "2024-01-01T12:00:00"
+            }
+        }
+    )
+    
+    text: str = Field(..., description="The input text")
+    topic: str = Field(..., description="The extracted topic")
+    timestamp: Optional[str] = Field(None, description="Timestamp of extraction")
+
+class VoiceChatResponse(BaseModel):
+    """Response model for voice chat"""
+    model_config = ConfigDict(
+        json_schema_extra={
+            "example": {
+                "user_input": "What is climate change?",
+                "conversation_id": "uuid-here",
+                "response": "Climate change refers to long-term changes in global temperatures and weather patterns.",
+                "timestamp": "2024-01-01T12:00:00"
+            }
+        }
+    )
+    
+    user_input: str = Field(..., description="The user's input text")
+    conversation_id: Optional[str] = Field(None, description="The conversation ID")
+    response: str = Field(..., description="The chatbot's response")
+    timestamp: Optional[str] = Field(None, description="Timestamp of response")
+
 class ResourceInfo(BaseModel):
     """Information about an MCP resource"""
     uri: str

requirements.txt

@@ -16,6 +16,10 @@ langchain-core>=0.1.0
 langchain-groq>=0.1.0
 langsmith>=0.1.0
 
+# Fix urllib3 compatibility issues
+urllib3>=1.26.0,<3.0.0
+requests-toolbelt>=1.0.0
+
 # Audio processing (optionnel si vous avez besoin de traitement local)
 soundfile>=0.12.1
 

routes/mcp_routes.py

@@ -14,6 +14,8 @@ from services.mcp_service import mcp_server
 from services.stance_model_manager import stance_model_manager
 from services.label_model_manager import kpa_model_manager
 from services.generate_model_manager import generate_model_manager
+from services.topic_service import topic_service
+from services.chat_service import generate_chat_response
 from models.mcp_models import (
     ToolListResponse, 
     ToolInfo, 
@@ -22,7 +24,9 @@ from models.mcp_models import (
     DetectStanceResponse,
     MatchKeypointResponse,
     TranscribeAudioResponse,
-    GenerateSpeechResponse
+    GenerateSpeechResponse,
+    ExtractTopicResponse,
+    VoiceChatResponse
 )
 from models.generate import GenerateRequest, GenerateResponse
 from datetime import datetime
@@ -75,6 +79,30 @@ class GenerateSpeechRequest(BaseModel):
             }
         }
 
+class ExtractTopicRequest(BaseModel):
+    """Request pour extraire un topic d'un texte"""
+    text: str = Field(..., min_length=5, max_length=5000, description="Le texte/argument à partir duquel extraire le topic")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "text": "Governments should subsidize electric cars to encourage adoption."
+            }
+        }
+
+class VoiceChatRequest(BaseModel):
+    """Request pour générer une réponse de chatbot vocal"""
+    user_input: str = Field(..., description="L'entrée utilisateur (en anglais)")
+    conversation_id: Optional[str] = Field(None, description="ID de conversation pour maintenir le contexte")
+    
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "user_input": "What is climate change?",
+                "conversation_id": "optional-conversation-id"
+            }
+        }
+
 
 
 # ===== Routes MCP =====
@@ -90,6 +118,8 @@ async def mcp_health():
             "transcribe_audio",
             "generate_speech",
             "generate_argument",
+            "extract_topic",
+            "voice_chat",
             "health_check"
         ]
         return {
@@ -167,6 +197,29 @@ async def list_mcp_tools():
                     "required": ["topic", "position"]
                 }
             ),
+            ToolInfo(
+                name="extract_topic",
+                description="Extrait un topic à partir d'un texte/argument donné",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "text": {"type": "string", "description": "Le texte/argument à partir duquel extraire le topic"}
+                    },
+                    "required": ["text"]
+                }
+            ),
+            ToolInfo(
+                name="voice_chat",
+                description="Génère une réponse de chatbot vocal en anglais",
+                input_schema={
+                    "type": "object",
+                    "properties": {
+                        "user_input": {"type": "string", "description": "L'entrée utilisateur (en anglais)"},
+                        "conversation_id": {"type": "string", "description": "ID de conversation pour maintenir le contexte (optionnel)"}
+                    },
+                    "required": ["user_input"]
+                }
+            ),
             ToolInfo(
                 name="health_check",
                 description="Health check pour le serveur MCP",
@@ -244,6 +297,27 @@ async def call_mcp_tool(request: ToolCallRequest):
       }
     }
     ```
+    
+    6. **extract_topic** - Extraire un topic d'un texte:
+    ```json
+    {
+      "tool_name": "extract_topic",
+      "arguments": {
+        "text": "Governments should subsidize electric cars to encourage adoption."
+      }
+    }
+    ```
+    
+    7. **voice_chat** - Générer une réponse de chatbot vocal:
+    ```json
+    {
+      "tool_name": "voice_chat",
+      "arguments": {
+        "user_input": "What is climate change?",
+        "conversation_id": "optional-conversation-id"
+      }
+    }
+    ```
     """
     try:
         result = await mcp_server.call_tool(request.tool_name, request.arguments)
@@ -510,6 +584,62 @@ async def mcp_generate_argument(request: GenerateRequest):
         logger.error(f"Error in generate_argument: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=f"Error executing tool generate_argument: {e}")
 
+@router.post("/tools/extract-topic", response_model=ExtractTopicResponse, summary="Extraire un topic d'un texte")
+async def mcp_extract_topic(request: ExtractTopicRequest):
+    """Extrait un topic à partir d'un texte/argument donné"""
+    try:
+        # Vérifier que le service est initialisé
+        if not topic_service.initialized:
+            topic_service.initialize()
+        
+        # Appeler directement le service (plus fiable que via MCP)
+        topic_text = topic_service.extract_topic(request.text)
+        
+        # Construire la réponse structurée
+        response = ExtractTopicResponse(
+            text=request.text,
+            topic=topic_text,
+            timestamp=datetime.now().isoformat()
+        )
+        
+        logger.info(f"Topic extracted from text '{request.text[:50]}...': {topic_text[:50]}...")
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error in extract_topic: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error in extract_topic: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error executing tool extract_topic: {e}")
+
+@router.post("/tools/voice-chat", response_model=VoiceChatResponse, summary="Générer une réponse de chatbot vocal")
+async def mcp_voice_chat(request: VoiceChatRequest):
+    """Génère une réponse de chatbot vocal en anglais"""
+    try:
+        # Appeler directement le service (plus fiable que via MCP)
+        response_text = generate_chat_response(
+            user_input=request.user_input,
+            conversation_id=request.conversation_id
+        )
+        
+        # Construire la réponse structurée
+        response = VoiceChatResponse(
+            user_input=request.user_input,
+            conversation_id=request.conversation_id,
+            response=response_text,
+            timestamp=datetime.now().isoformat()
+        )
+        
+        logger.info(f"Voice chat response generated for input '{request.user_input[:50]}...': {response_text[:50]}...")
+        return response
+        
+    except ValueError as e:
+        logger.error(f"Validation error in voice_chat: {str(e)}")
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error in voice_chat: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Error executing tool voice_chat: {e}")
+
 @router.get("/tools/health-check", summary="Health check MCP (outil)")
 async def mcp_tool_health_check() -> Dict[str, Any]:
     """Health check via l'outil MCP"""

services/mcp_service.py

@@ -1,7 +1,7 @@
 """Service pour initialiser le serveur MCP avec FastMCP"""
 
 from mcp.server.fastmcp import FastMCP
-from typing import Dict, Any
+from typing import Dict, Any, Optional
 import logging
 
 from fastapi import FastAPI
@@ -11,6 +11,8 @@ from services.label_model_manager import kpa_model_manager
 from services.stt_service import speech_to_text
 from services.tts_service import text_to_speech
 from services.generate_model_manager import generate_model_manager
+from services.topic_service import topic_service
+from services.chat_service import generate_chat_response
 
 logger = logging.getLogger(__name__)
 
@@ -62,6 +64,30 @@ def generate_argument(topic: str, position: str) -> Dict[str, Any]:
         "argument": argument
     }
 
+@mcp_server.tool()
+def extract_topic(text: str) -> Dict[str, Any]:
+    """Extract a topic from the given text/argument"""
+    if not topic_service.initialized:
+        topic_service.initialize()
+    topic = topic_service.extract_topic(text)
+    return {
+        "text": text,
+        "topic": topic
+    }
+
+@mcp_server.tool()
+def voice_chat(user_input: str, conversation_id: Optional[str] = None) -> Dict[str, Any]:
+    """Generate a chatbot response for voice chat (English only)"""
+    response_text = generate_chat_response(
+        user_input=user_input,
+        conversation_id=conversation_id
+    )
+    return {
+        "user_input": user_input,
+        "conversation_id": conversation_id,
+        "response": response_text
+    }
+
 @mcp_server.resource("debate://prompt")
 def get_debate_prompt() -> str:
     return "Tu es un expert en débat. Génère 3 arguments PRO pour le topic donné. Sois concis et persuasif."
@@ -78,6 +104,8 @@ def health_check() -> Dict[str, Any]:
             "transcribe_audio",
             "generate_speech",
             "generate_argument",
+            "extract_topic",
+            "voice_chat",
             "health_check"
         ]
     except Exception:

topic_similarity_google_example.py

@@ -1,182 +0,0 @@
-from datetime import datetime
-import os
-import json
-import hashlib
-from pathlib import Path
-from dotenv import load_dotenv
-from google import genai
-from google.genai import types
-import numpy as np
-from sklearn.metrics.pairwise import cosine_similarity
-
-# Load environment variables from .env file
-load_dotenv()
-GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-if not GOOGLE_API_KEY:
-    raise ValueError("GOOGLE_API_KEY is not set in environment variables.")
-
-# Get the path to topics.json relative to this file
-TOPICS_FILE = Path(__file__).parent.parent / "data" / "topics.json"
-# Cache file for topic embeddings
-EMBEDDINGS_CACHE_FILE = Path(__file__).parent.parent / "data" / "topic_embeddings_cache.json"
-
-# Create a Google Generative AI client with the API key
-client = genai.Client(api_key=GOOGLE_API_KEY)
-
-
-def load_topics():
-    """Load topics from topics.json file."""
-    with open(TOPICS_FILE, 'r', encoding='utf-8') as f:
-        data = json.load(f)
-    return data.get("topics", [])
-
-
-def get_topics_hash(topics):
-    """Generate a hash of the topics list to verify cache validity."""
-    topics_str = json.dumps(topics, sort_keys=True)
-    return hashlib.md5(topics_str.encode('utf-8')).hexdigest()
-
-
-def load_cached_embeddings():
-    """Load cached topic embeddings if they exist and are valid."""
-    if not EMBEDDINGS_CACHE_FILE.exists():
-        return None
-    
-    try:
-        with open(EMBEDDINGS_CACHE_FILE, 'r', encoding='utf-8') as f:
-            cache_data = json.load(f)
-        
-        # Verify cache is valid by checking topics hash
-        current_topics = load_topics()
-        current_hash = get_topics_hash(current_topics)
-        
-        if cache_data.get("topics_hash") == current_hash:
-            # Convert list embeddings back to numpy arrays
-            embeddings = [np.array(emb) for emb in cache_data.get("embeddings", [])]
-            return embeddings
-        else:
-            # Topics have changed, cache is invalid
-            return None
-    except (json.JSONDecodeError, KeyError, ValueError) as e:
-        # Cache file is corrupted or invalid format
-        print(f"Warning: Could not load cached embeddings: {e}")
-        return None
-
-
-def save_cached_embeddings(embeddings, topics):
-    """Save topic embeddings to cache file."""
-    topics_hash = get_topics_hash(topics)
-    
-    # Convert numpy arrays to lists for JSON serialization
-    embeddings_list = [emb.tolist() for emb in embeddings]
-    
-    cache_data = {
-        "topics_hash": topics_hash,
-        "embeddings": embeddings_list,
-        "model": "models/text-embedding-004",
-        "cached_at": datetime.now().isoformat()
-    }
-    
-    try:
-        with open(EMBEDDINGS_CACHE_FILE, 'w', encoding='utf-8') as f:
-            json.dump(cache_data, f, indent=2)
-        print(f"Cached {len(embeddings)} topic embeddings to {EMBEDDINGS_CACHE_FILE}")
-    except Exception as e:
-        print(f"Warning: Could not save cached embeddings: {e}")
-
-
-def get_topic_embeddings():
-    """
-    Get topic embeddings, loading from cache if available, otherwise generating and caching them.
-    
-    Returns:
-        numpy.ndarray: Array of topic embeddings
-    """
-    topics = load_topics()
-    
-    # Try to load from cache first
-    cached_embeddings = load_cached_embeddings()
-    if cached_embeddings is not None:
-        print(f"Loaded {len(cached_embeddings)} topic embeddings from cache")
-        return np.array(cached_embeddings)
-    
-    # Cache miss or invalid - generate embeddings
-    print(f"Generating embeddings for {len(topics)} topics (this may take a moment)...")
-    embedding_response = client.models.embed_content(
-        model="models/text-embedding-004",
-        contents=topics,
-        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")
-    )
-    
-    if not hasattr(embedding_response, "embeddings") or embedding_response.embeddings is None:
-        raise RuntimeError("Embedding API did not return embeddings.")
-    
-    embeddings = [np.array(e.values) for e in embedding_response.embeddings]
-    
-    # Save to cache for future use
-    save_cached_embeddings(embeddings, topics)
-    
-    return np.array(embeddings)
-
-
-def find_most_similar_topic(input_text: str):
-    """
-    Compare a single input text to all topics and return the highest cosine similarity.
-    Uses cached topic embeddings to avoid re-embedding topics on every call.
-    
-    Args:
-        input_text: The text to compare against topics
-        
-    Returns:
-        dict: Contains 'topic', 'similarity', and 'index' of the most similar topic
-    """
-    # Load topics from JSON file
-    topics = load_topics()
-    
-    if not topics:
-        raise ValueError("No topics found in topics.json")
-    
-    # Get topic embeddings (from cache or generate)
-    topic_embeddings = get_topic_embeddings()
-    
-    # Only embed the input text (much faster!)
-    embedding_response = client.models.embed_content(
-        model="models/text-embedding-004",
-        contents=[input_text],
-        config=types.EmbedContentConfig(task_type="SEMANTIC_SIMILARITY")
-    )
-    
-    if not hasattr(embedding_response, "embeddings") or embedding_response.embeddings is None:
-        raise RuntimeError("Embedding API did not return embeddings.")
-    
-    # Extract input embedding
-    input_embedding = np.array(embedding_response.embeddings[0].values).reshape(1, -1)
-    
-    # Calculate cosine similarity between input and each topic
-    similarities = cosine_similarity(input_embedding, topic_embeddings)[0]
-    
-    # Find the highest similarity
-    max_index = np.argmax(similarities)
-    max_similarity = similarities[max_index]
-    most_similar_topic = topics[max_index]
-    
-    return {
-        "topic": most_similar_topic,
-        "similarity": float(max_similarity),
-        "index": int(max_index)
-    }
-
-
-if __name__ == "__main__":
-    # Example usage
-    #start time
-    start_time = datetime.now()
-    test_text = "we should abandon the use of school uniform since one should be allowed to express their individuality by the clothes they were."
-    result = find_most_similar_topic(test_text)
-    print(f"Input text: '{test_text}'")
-    print(f"Most similar topic: '{result['topic']}'")
-    print(f"Cosine similarity: {result['similarity']:.4f}%")
-    #end time
-    end_time = datetime.now()
-    #in seconds
-    print(f"Time taken: {(end_time - start_time).total_seconds()} seconds")

topic_similarity_langchain_example.py

@@ -1,54 +0,0 @@
-import json
-import os
-from datetime import datetime
-from dotenv import load_dotenv
-load_dotenv()
-
-from langchain_community.vectorstores import FAISS
-from langchain_core.example_selectors import (
-    SemanticSimilarityExampleSelector,
-)
-from langchain_google_genai import GoogleGenerativeAIEmbeddings
-
-# Load topics from data file
-with open(
-    file="data/topics.json",
-    encoding="utf-8"
-) as f:
-    data = json.load(f)
-
-# Make sure each example is a dict with "topic" key (wrap as dict if plain string)
-def format_examples(examples):
-    formatted = []
-    for ex in examples:
-        if isinstance(ex, str):
-            formatted.append({"topic": ex})
-        elif isinstance(ex, dict) and "topic" in ex:
-            formatted.append({"topic": ex["topic"]})
-        else:
-            formatted.append({"topic": str(ex)})
-    return formatted
-
-# topics.json should have a top-level "topics" key
-examples = data.get("topics", [])
-formatted_examples = format_examples(examples)
-
-start_time = datetime.now()
-example_selector = SemanticSimilarityExampleSelector.from_examples(
-    examples=formatted_examples,
-    embeddings=GoogleGenerativeAIEmbeddings(
-        model="models/text-embedding-004",
-        api_key=os.getenv("GOOGLE_API_KEY")
-    ),
-    vectorstore_cls=FAISS,
-    k=1,
-    input_keys=["topic"],
-)
-
-# Example call to selector (for demonstration; remove in production)
-result = example_selector.select_examples(
-    {"topic": "people who are terminally ill and suffering greatly should have the right to end their own life if they so desire."}
-)
-print(result)
-end_time = datetime.now()
-print(f"Time taken: {(end_time - start_time).total_seconds()} seconds")