Upload 2 files

api/routers/processor_llm_base.py

@@ -0,0 +1,133 @@
+"""
+Processor Base com integração LLM REAL
+Substitui processamento MOCK por chamadas ao Groq
+"""
+from typing import Dict, Any, Optional, List
+from datetime import datetime
+import logging
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorLLMBase(ABC):
+    """
+    Processor base que integra com LLM real (Groq).
+
+    Substitui hardcoded por prompts e chamadas reais.
+    """
+
+    def __init__(
+        self,
+        specialist_id: int,
+        specialist_name: str,
+        llm_client=None
+    ):
+        """
+        Args:
+            specialist_id: ID do especialista (1-9)
+            specialist_name: Nome descritivo
+            llm_client: Cliente LLM configurado (GroqClient)
+        """
+        self.specialist_id = specialist_id
+        self.specialist_name = specialist_name
+        self.llm_client = llm_client
+        self.execution_time = 0
+        self.confidence_score = 0
+        self.errors = []
+        self.warnings = []
+
+        if not llm_client:
+            self.add_warning("LLM client não configurado - usando fallback mock")
+
+    @abstractmethod
+    def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Processa acórdão usando LLM real."""
+        pass
+
+    @abstractmethod
+    def get_prompt(self, acordao_data: Dict[str, Any]) -> str:
+        """Retorna prompt para o LLM."""
+        pass
+
+    @abstractmethod
+    def validate(self, result: Dict[str, Any]) -> bool:
+        """Valida resultado."""
+        pass
+
+    def call_llm(
+        self,
+        prompt: str,
+        max_tokens: int = 2048,
+        temperature: float = 0.3
+    ) -> str:
+        """
+        Faz chamada ao LLM real.
+
+        Args:
+            prompt: Prompt a enviar
+            max_tokens: Máximo de tokens
+            temperature: Temperatura (0-1)
+
+        Returns:
+            Resposta do LLM
+        """
+        if not self.llm_client:
+            self.add_error("LLM client não disponível")
+            return ""
+
+        try:
+            start_time = datetime.now()
+
+            logger.info(
+                f"[{self.specialist_name}] Chamando LLM... "
+                f"(max_tokens={max_tokens}, temp={temperature})"
+            )
+
+            # Chamada real ao LLM
+            response = self.llm_client.generate(
+                prompt=prompt,
+                max_tokens=max_tokens,
+                temperature=temperature
+            )
+
+            elapsed = (datetime.now() - start_time).total_seconds()
+            self.execution_time += elapsed
+
+            logger.info(
+                f"[{self.specialist_name}] LLM respondeu em {elapsed:.2f}s "
+                f"({len(response)} chars)"
+            )
+
+            return response
+
+        except Exception as e:
+            self.add_error(f"Erro ao chamar LLM: {e}")
+            logger.error(f"[{self.specialist_name}] Erro LLM: {e}", exc_info=True)
+            return ""
+
+    def add_error(self, error_msg: str):
+        """Adiciona erro."""
+        self.errors.append(error_msg)
+
+    def add_warning(self, warning_msg: str):
+        """Adiciona aviso."""
+        self.warnings.append(warning_msg)
+
+    def set_confidence(self, score: int):
+        """Define score de confiança (0-100)."""
+        if 0 <= score <= 100:
+            self.confidence_score = score
+
+    def postprocess(self, result: Dict[str, Any]) -> Dict[str, Any]:
+        """Pós-processa resultado."""
+        return {
+            "specialist_id": self.specialist_id,
+            "specialist_name": self.specialist_name,
+            "result": result,
+            "execution_time": self.execution_time,
+            "confidence_score": self.confidence_score,
+            "errors": self.errors,
+            "warnings": self.warnings,
+            "timestamp": datetime.now().isoformat()
+        }

api/routers/processor_metadados_llm.py

@@ -0,0 +1,88 @@
+"""
+Especialista 1: Metadados com LLM REAL
+"""
+from typing import Dict, Any
+import json
+import logging
+import re
+from api.processors.processor_llm_base import ProcessorLLMBase
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessorMetadadosLLM(ProcessorLLMBase):
+    """Extração de metadados via LLM."""
+
+    def __init__(self, llm_client=None):
+        super().__init__(
+            specialist_id=1,
+            specialist_name="Metadados (LLM)",
+            llm_client=llm_client
+        )
+
+    def process(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Extrai metadados usando LLM."""
+        try:
+            prompt = self.get_prompt(acordao_data)
+            llm_response = self.call_llm(prompt, max_tokens=1024, temperature=0.2)
+
+            if not llm_response:
+                return self._fallback_mock(acordao_data)
+
+            metadados = self._parse_llm_response(llm_response)
+
+            if self.validate(metadados):
+                self.set_confidence(90)
+                return metadados
+            else:
+                return self._fallback_mock(acordao_data)
+
+        except Exception as e:
+            self.add_error(f"Erro: {e}")
+            return self._fallback_mock(acordao_data)
+
+    def get_prompt(self, acordao_data: Dict[str, Any]) -> str:
+        """Gera prompt."""
+        ementa = acordao_data.get("ementa", "")[:1000]
+        integra = acordao_data.get("integra", "")[:2000]
+
+        return f"""Extraia metadados deste acórdão. Retorne JSON válido:
+
+EMENTA: {ementa}
+ÍNTEGRA (trecho): {integra}
+
+JSON esperado:
+{{
+  "tribunal": "TJPR",
+  "relator": "Nome do Relator",
+  "ramo_especializado": "Direito do Consumidor"
+}}
+
+JSON:"""
+
+    def validate(self, result: Dict[str, Any]) -> bool:
+        """Valida."""
+        return "relator" in result and len(result.get("relator", "")) > 3
+
+    def _parse_llm_response(self, response: str) -> Dict[str, Any]:
+        """Parse resposta LLM."""
+        try:
+            # Tentar parsear como JSON direto
+            return json.loads(response)
+        except:
+            # Extrair JSON do texto
+            match = re.search(r'\{[^{}]+\}', response)
+            if match:
+                try:
+                    return json.loads(match.group())
+                except:
+                    pass
+            return {}
+
+    def _fallback_mock(self, acordao_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Fallback."""
+        return {
+            "tribunal": "TJPR",
+            "relator": "RELATOR NÃO IDENTIFICADO",
+            "ramo_especializado": "DIREITO CÍVEL"
+        }