add ai improvement

app/models/content.py

@@ -36,6 +36,7 @@ class UploadedContent(Base):
     title = Column(Text, nullable=False)
     content_url = Column(Text)  # URL or file path
     description = Column(Text)  # Brief summary
+    ai_summary = Column(Text)   # AI-generated teacher-friendly summary
     
     # Source tracking
     source_type = Column(Text, default="internal")  # internal, external

app/routes/help.py

@@ -80,7 +80,11 @@ def create_help_request(
                 status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
                 detail="Speech recognition not available"
             )
-        query_text, detected_language = SpeechService.transcribe_audio(request.audio_base64)
+        language_hint = current_teacher.language_preference
+        query_text, detected_language = SpeechService.transcribe_audio(
+            request.audio_base64, 
+            language_hint=language_hint
+        )
     
     if not query_text:
         raise HTTPException(
@@ -90,11 +94,9 @@ def create_help_request(
     
     # CRITICAL: Resolve to concept_id
     # This is the core of the multilingual search system
-    concept_id, language, normalized_text = ConceptResolver.resolve_concept(db, query_text)
-    
-    # Use detected language from speech if available
-    if detected_language:
-        language = detected_language
+    concept_id, language, normalized_text = ConceptResolver.resolve_concept(
+        db, query_text, speech_language=detected_language
+    )
     
     # Store help request for analytics
     help_request = HelpRequest(

app/routes/suggestions.py

@@ -29,6 +29,7 @@ router = APIRouter(prefix="/suggestions", tags=["Suggestions"])
 def get_suggestions(
     concept_id: str = Query(..., description="The resolved concept ID"),
     language: Optional[str] = Query(None, description="Language override"),
+    problem_description: Optional[str] = Query(None, description="Detailed problem context from teacher"),
     limit: int = Query(10, ge=1, le=50),
     db: Session = Depends(get_db),
     current_teacher: Teacher = Depends(get_current_teacher)
@@ -65,7 +66,8 @@ def get_suggestions(
         db,
         concept_id,
         target_lang,
-        limit
+        limit,
+        problem_description
     )
     
     # Build response
@@ -88,8 +90,8 @@ def get_suggestions(
                 source_type=content.source_type,
                 is_verified=content.is_verified,
                 created_at=content.created_at,
-                feedback_score=item["feedback_score"],
-                uploader_name=item["uploader_name"]
+                uploader_name=item["uploader_name"],
+                ai_summary=content.ai_summary
             ))
             source = item["source"]
     else:
@@ -115,8 +117,8 @@ def get_suggestions(
                 source_type=content.source_type,
                 is_verified=content.is_verified,
                 created_at=content.created_at,
-                feedback_score=0,
-                uploader_name="Google Search"
+                uploader_name="Google Search",
+                ai_summary=content.ai_summary
             ))
     
     # Add warning message for unverified content

app/schemas/content.py

@@ -35,6 +35,7 @@ class ContentResponse(BaseModel):
     # Computed fields for display
     feedback_score: Optional[float] = None
     uploader_name: Optional[str] = None
+    ai_summary: Optional[str] = None
     likes_count: int = 0
     views_count: int = 0
     user_liked: bool = False

app/services/concept_resolver.py

@@ -165,13 +165,14 @@ class ConceptResolver:
         return text
     
     @staticmethod
-    def resolve_concept(db: Session, text: str) -> Tuple[Optional[str], str, str]:
+    def resolve_concept(db: Session, text: str, speech_language: Optional[str] = None) -> Tuple[Optional[str], str, str]:
         """
         Main resolution function.
         
         Args:
             db: Database session
             text: User input in any language
+            speech_language: Optional language detected by speech engine
             
         Returns:
             Tuple of (concept_id, detected_language, normalized_text)
@@ -179,6 +180,14 @@ class ConceptResolver:
         """
         # Step 1: Detect language
         language = ConceptResolver.detect_language(text)
+        
+        # If script detection says "en" but speech engine detected "kn" or "hi",
+        # it's likely transliterated text (Hinglish/Kanglish).
+        # In this case, trust the speech engine.
+        if language == "en" and speech_language in ["kn", "hi"]:
+            language = speech_language
+            print(f"[ConceptResolver] Overriding script language 'en' with speech language '{language}' (Transliteration detected)")
+            
         print(f"[ConceptResolver] Input: '{text}' | Language: {language}")
         
         # Step 2: Normalize text

app/services/content_service.py

@@ -15,6 +15,7 @@ import uuid
 
 from app.models.content import UploadedContent, ContentFeedback, ContentInteraction
 from app.models.teacher import Teacher
+from app.models.concept import Concept
 from app.services.gemini_service import GeminiService
 
 
@@ -30,7 +31,8 @@ class ContentService:
         db: Session,
         concept_id: str,
         teacher_language: str = "en",
-        limit: int = 10
+        limit: int = 10,
+        problem_description: Optional[str] = None
     ) -> Tuple[List[UploadedContent], str]:
         """
         Get content suggestions for a concept.
@@ -114,7 +116,11 @@ class ContentService:
         
         # Step 4: Use Google Web Search via Gemini to find external content
         print(f"[ContentService] No content found for '{concept_id}', trying Google Web Search...")
-        search_results = GeminiService.google_web_search(concept_id.replace("_", " "), num_results=5)
+        search_results = GeminiService.google_web_search(
+            concept_id.replace("_", " "), 
+            num_results=5,
+            problem_description=problem_description
+        )
         
         if search_results:
             # Create/Get content entries from search results
@@ -130,6 +136,17 @@ class ContentService:
                 ).first()
                 
                 if existing_content:
+                    # If we have a specific problem description, re-generate summary even for existing content
+                    # to ensure it's tailored to the current session.
+                    if problem_description:
+                        # Re-generate summary dynamically (won't persist to DB unless explicit save)
+                        # This gives a "session-aware" summary
+                        existing_content.ai_summary = GeminiService.generate_summary(
+                            title=existing_content.title,
+                            snippet=existing_content.description,
+                            topic=concept_id.replace("_", " ").title(),
+                            problem_description=problem_description
+                        )
                     web_content.append(existing_content)
                     continue
 
@@ -140,14 +157,30 @@ class ContentService:
                 elif url.endswith(".pdf"):
                     content_type = "document"
                 
+                # Get concept details for subject and grade
+                concept = db.query(Concept).filter(Concept.concept_id == concept_id).first()
+                subject = concept.subject if concept else "General"
+                grade = concept.grade if concept else "All"
+
+                # Generate AI summary for better teacher experience
+                ai_summary = GeminiService.generate_summary(
+                    title=result.get("title", "External Resource"),
+                    snippet=result.get("snippet", ""),
+                    topic=concept_id.replace("_", " ").title(),
+                    problem_description=problem_description
+                )
+
                 # Persist new content (without specific uploader)
                 new_content = UploadedContent(
                     id=uuid.uuid4(), # Explicitly setting UUID or letting DB handle it
                     title=result.get("title", "External Resource"),
                     description=result.get("snippet", "Found via Google Search"),
+                    ai_summary=ai_summary,
                     content_type=content_type,
                     content_url=url,
                     concept_id=concept_id,
+                    subject=subject,
+                    grade=grade,
                     language="en", # Default to English for external content
                     source_type="external",
                     is_verified=False,
@@ -174,14 +207,15 @@ class ContentService:
         db: Session,
         concept_id: str,
         teacher_language: str = "en",
-        limit: int = 10
+        limit: int = 10,
+        problem_description: Optional[str] = None
     ) -> List[dict]:
         """
         Get content with computed feedback scores.
         Returns dictionaries with content and score.
         """
         content_list, source = ContentService.get_suggestions(
-            db, concept_id, teacher_language, limit
+            db, concept_id, teacher_language, limit, problem_description
         )
         
         # For Google Search results, return directly without DB queries

app/services/gemini_service.py

@@ -96,7 +96,7 @@ class GeminiService:
             raise e
 
     @staticmethod
-    def google_web_search(query: str, num_results: int = 5) -> List[dict]:
+    def google_web_search(query: str, num_results: int = 5, problem_description: str = None) -> List[dict]:
         """
         Use Google Search via Gemini API to find educational content.
         
@@ -107,10 +107,14 @@ class GeminiService:
             return []
         
         try:
+            search_query = f"educational resources about {query}"
+            if problem_description:
+                search_query += f" specifically help for: {problem_description}"
+                
             # Use google_search tool with Gemini
             data = {
                 "contents": [{
-                    "parts": [{"text": f"Find {num_results} educational resources (videos, articles, websites) about: {query}. For each result, provide the title, URL, and a brief description. Focus on educational content suitable for teachers and students."}]
+                    "parts": [{"text": f"Find {num_results} {search_query}. For each result, provide the title, URL, and a brief description. Focus on educational content suitable for teachers and students."}]
                 }],
                 "tools": [{
                     "google_search": {}
@@ -396,3 +400,48 @@ Rules:
                 "search_keywords": [query],
                 "error": str(e)
             }
+
+    @staticmethod
+    def generate_summary(
+        title: str,
+        snippet: str,
+        topic: str = None,
+        problem_description: str = None
+    ) -> str:
+        """
+        Generate a teacher-friendly summary for a suggested resource.
+        
+        Args:
+            title: Title of the resource
+            snippet: Search snippet or context
+            topic: The concept/topic name
+            problem_description: Specific problem context provided by teacher
+            
+        Returns:
+            A concise, high-quality summary
+        """
+        if not GeminiService.is_available():
+            return snippet or "No summary available."
+            
+        try:
+            prompt = f"""You are an expert educational consultant helping teachers in India.
+Write a concise, teacher-friendly summary (2-3 sentences) explaining how an educational resource directly solves a teacher's specific classroom problem.
+
+Resource Title: {title}
+Resource Context: {snippet}
+{f'Core Topic: {topic}' if topic else ''}
+{f"Teacher's Specific Problem: {problem_description}" if problem_description else ""}
+
+Rules:
+1. FOCUS: If a specific problem is provided, the summary MUST explain how this resource solves THAT specific problem. 
+2. AVOID: Do not waste words describing the platform (e.g., "Khan Academy offers videos"). Instead, say "This resource helps you explain [Topic] using [Method] to address [Problem]".
+3. DEPTH: Mention specific features or content (from the snippet) that are relevant to the problem.
+4. TONE: Professional, practical, and highly encouraging.
+5. CONCISENESS: Under 60 words. No intro/outro.
+
+Summary:"""
+            
+            return GeminiService._call_gemini(prompt).strip()
+        except Exception as e:
+            print(f"[GeminiService] Summary generation failed: {e}")
+            return snippet or "No summary available."

app/services/speech_service.py

@@ -50,12 +50,13 @@ class SpeechService:
     """
     
     @staticmethod
-    def transcribe_audio(audio_base64: str) -> Tuple[str, str]:
+    def transcribe_audio(audio_base64: str, language_hint: str = None) -> Tuple[str, str]:
         """
         Transcribe base64-encoded audio to text.
         
         Args:
             audio_base64: Base64 encoded audio data
+            language_hint: Optional language code hint (en, kn, hi)
             
         Returns:
             Tuple of (transcribed_text, detected_language)
@@ -76,10 +77,18 @@ class SpeechService:
         try:
             model = get_whisper_model()
             
-            # Transcribe with language detection
+            # Map our hint to Whisper language codes
+            whisper_lang = None
+            if language_hint == "kn":
+                whisper_lang = "kn"
+            elif language_hint == "hi":
+                whisper_lang = "hi"
+            
+            # Transcribe with language detection/hint
             result = model.transcribe(
                 tmp_path,
                 task="transcribe",
+                language=whisper_lang
             )
             
             text = result["text"].strip()