[refactor]: migrate classification logic with simplification

Author: smokeyScraper

backend/app/agents/classification_router.py

@@ -0,0 +1,59 @@
+import logging
+from typing import Dict, Any
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.messages import HumanMessage
+from app.core.config import settings
+from .prompt import DEVREL_TRIAGE_PROMPT
+
+logger = logging.getLogger(__name__)
+
+class ClassificationRouter:
+    """Simple DevRel triage - determines if message needs DevRel assistance"""
+
+    def __init__(self, llm_client=None):
+        self.llm = llm_client or ChatGoogleGenerativeAI(
+            model=settings.classification_agent_model,
+            temperature=0.1,
+            google_api_key=settings.gemini_api_key
+        )
+
+    async def should_process_message(self, message: str, context: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Simple triage: Does this message need DevRel assistance?"""
+        try:
+            triage_prompt = DEVREL_TRIAGE_PROMPT.format(
+                message=message,
+                context=context or 'No additional context'
+            )
+
+            response = await self.llm.ainvoke([HumanMessage(content=triage_prompt)])
+
+            response_text = response.content.strip()
+            if '{' in response_text:
+                json_start = response_text.find('{')
+                json_end = response_text.rfind('}') + 1
+                json_str = response_text[json_start:json_end]
+
+                import json
+                result = json.loads(json_str)
+
+                return {
+                    "needs_devrel": result.get("needs_devrel", True),
+                    "priority": result.get("priority", "medium"),
+                    "reasoning": result.get("reasoning", "LLM classification"),
+                    "original_message": message
+                }
+
+            return self._fallback_triage(message)
+
+        except Exception as e:
+            logger.error(f"Triage error: {str(e)}")
+            return self._fallback_triage(message)
+
+    def _fallback_triage(self, message: str) -> Dict[str, Any]:
+        """Fallback: assume it needs DevRel help"""
+        return {
+            "needs_devrel": True,
+            "priority": "medium",
+            "reasoning": "Fallback - assuming DevRel assistance needed",
+            "original_message": message
+        }

backend/app/classification/__init__.py

@@ -0,0 +1,26 @@
+DEVREL_TRIAGE_PROMPT = """Analyze this message to determine if it needs DevRel assistance.
+
+Message: {message}
+
+Context: {context}
+
+DevRel handles:
+- Technical questions about projects/APIs
+- Developer onboarding and support
+- Bug reports and feature requests  
+- Community discussions about development
+- Documentation requests
+- General developer experience questions
+
+Respond ONLY with JSON:
+{{
+    "needs_devrel": true/false,
+    "priority": "high|medium|low",
+    "reasoning": "brief explanation"
+}}
+
+Examples:
+- "How do I contribute?" → {{"needs_devrel": true, "priority": "high", "reasoning": "Onboarding question"}}
+- "What's for lunch?" → {{"needs_devrel": false, "priority": "low", "reasoning": "Not development related"}}
+- "API is throwing errors" → {{"needs_devrel": true, "priority": "high", "reasoning": "Technical support needed"}}
+"""

backend/app/classification/classification_router.py

@@ -3,7 +3,7 @@
 import logging
 from typing import Dict, Any, Optional
 from app.core.orchestration.queue_manager import AsyncQueueManager, QueuePriority
-from app.agents.classification_router import ClassificationRouter
+from app.classification.classification_router import ClassificationRouter
 
 logger = logging.getLogger(__name__)
 
@@ -51,8 +51,7 @@ async def on_message(self, message):
             return
 
         try:
-            # Classify message locally first
-            classification = await self.classifier.classify_message(
+            triage_result = await self.classifier.should_process_message(
                 message.content,
                 {
                     "channel_id": str(message.channel.id),
@@ -61,16 +60,15 @@ async def on_message(self, message):
                 }
             )
 
-            logger.info(f"Message classified as: {classification}")
+            logger.info(f"Message triage result: {triage_result}")
 
-            # Only process if DevRel intervention is needed
-            if classification.get("needs_devrel", False):
-                await self._handle_devrel_message(message, classification)
+            if triage_result.get("needs_devrel", False):
+                await self._handle_devrel_message(message, triage_result)
 
         except Exception as e:
             logger.error(f"Error processing message: {str(e)}")
 
-    async def _handle_devrel_message(self, message, classification: Dict[str, Any]):
+    async def _handle_devrel_message(self, message, triage_result: Dict[str, Any]):
         """Handle messages that need DevRel intervention"""
         try:
             user_id = str(message.author.id)
@@ -87,7 +85,7 @@ async def _handle_devrel_message(self, message, classification: Dict[str, Any]):
                 "thread_id": thread_id,
                 "memory_thread_id": user_id,
                 "content": message.content,
-                "classification": classification,
+                "triage": triage_result,
                 "platform": "discord",
                 "timestamp": message.created_at.isoformat(),
                 "author": {
@@ -96,13 +94,13 @@ async def _handle_devrel_message(self, message, classification: Dict[str, Any]):
                 }
             }
 
-            # Determine priority based on classification
+            # Determine priority based on triage
             priority_map = {
                 "high": QueuePriority.HIGH,
                 "medium": QueuePriority.MEDIUM,
                 "low": QueuePriority.LOW
             }
-            priority = priority_map.get(classification.get("priority"), QueuePriority.MEDIUM)
+            priority = priority_map.get(triage_result.get("priority"), QueuePriority.MEDIUM)
 
             # Enqueue for agent processing
             await self.queue_manager.enqueue(agent_message, priority)