Upload groq_client.py

llm/clients/groq_client.py

@@ -1,15 +1,11 @@
-"""Cliente para Groq API."""
+"""Cliente Groq usando HTTP requests diretos (curl-style)."""
 
 import os
-import asyncio
-from typing import Optional, AsyncGenerator
-from dataclasses import dataclass
+import json
 import logging
-
-try:
-    from groq import Groq, AsyncGroq
-except ImportError:
-    raise ImportError("Instale groq: pip install groq")
+from typing import Optional, Dict, List
+from dataclasses import dataclass
+import requests
 
 logger = logging.getLogger(__name__)
 
@@ -20,109 +16,249 @@ class GroqResponse:
     content: str
     tokens_input: int
     tokens_output: int
+    total_tokens: int
     finish_reason: str
+    model: str
 
 
 class GroqClient:
-    """Cliente para Groq."""
-    
+    """Cliente Groq usando requests HTTP diretos (curl-style)."""
+
     def __init__(self, api_key: Optional[str] = None):
         """
-        Inicializa cliente Groq.
-        
+        Inicializa cliente Groq com requests.
+
         Args:
             api_key: API key (se None, usa GROQ_API_KEY)
         """
         self.api_key = api_key or os.getenv('GROQ_API_KEY')
         if not self.api_key:
             raise ValueError("GROQ_API_KEY não configurada")
-        
-        self.client = Groq(api_key=self.api_key)
-        self.async_client = AsyncGroq(api_key=self.api_key)
-        logger.info("GroqClient inicializado")
-    
-    async def generate(self,
-                      prompt: str,
-                      model: str = "openai/gpt-oss-120b",
-                      temperature: float = 0.7,
-                      max_tokens: Optional[int] = None,
-                      top_p: float = 0.9) -> GroqResponse:
+
+        self.base_url = "https://api.groq.com/openai/v1/chat/completions"
+        self.default_timeout = int(os.getenv('GROQ_TIMEOUT', '120'))
+        logger.info("GroqClient inicializado (HTTP requests)")
+
+    def generate(self,
+                 prompt: str,
+                 system_prompt: Optional[str] = None,
+                 model: str = "llama-3.3-70b-versatile",
+                 temperature: float = 0.7,
+                 max_tokens: Optional[int] = None,
+                 response_format: Optional[Dict] = None,
+                 timeout: Optional[int] = None) -> GroqResponse:
         """
-        Gera resposta usando Groq.
-        
+        Gera resposta usando Groq via HTTP requests (curl-style).
+
         Args:
-            prompt: Prompt para gerar
+            prompt: Prompt do usuário
+            system_prompt: Prompt do sistema (com schema JSON)
             model: Modelo a usar
-            temperature: Criatividade
-            max_tokens: Tokens máximos
-            top_p: Top-p sampling
-        
+            temperature: Temperatura (0-2)
+            max_tokens: Máximo de tokens na resposta
+            response_format: Formato da resposta (ex: {"type": "json_object"})
+            timeout: Timeout da requisição
+
         Returns:
-            GroqResponse
+            GroqResponse com content, tokens e metadados
         """
+        # Monta headers
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        # Monta messages
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        # Monta payload
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+
+        # Adiciona response_format se fornecido
+        if response_format:
+            payload["response_format"] = response_format
+
+        # Timeout
+        request_timeout = timeout or self.default_timeout
+
         try:
-            response = await self.async_client.chat.completions.create(
-                model=model,
-                messages=[{"role": "user", "content": prompt}],
-                temperature=temperature,
-                max_tokens=max_tokens,
-                top_p=top_p,
-                stream=False,
+            # Requisição HTTP POST (curl-style)
+            logger.debug(f"Enviando request para Groq: model={model}, temp={temperature}")
+
+            response = requests.post(
+                self.base_url,
+                headers=headers,
+                json=payload,
+                timeout=request_timeout
             )
-            
+
+            # Verifica erros HTTP
+            response.raise_for_status()
+
+            # Parse response JSON
+            data = response.json()
+
+            # Extrai dados
+            content = data['choices'][0]['message']['content']
+            finish_reason = data['choices'][0]['finish_reason']
+
+            usage = data.get('usage', {})
+            tokens_input = usage.get('prompt_tokens', 0)
+            tokens_output = usage.get('completion_tokens', 0)
+            total_tokens = usage.get('total_tokens', tokens_input + tokens_output)
+
+            logger.info(f"✅ Groq response: {total_tokens} tokens, finish={finish_reason}")
+
             return GroqResponse(
-                content=response.choices[0].message.content,
-                tokens_input=response.usage.prompt_tokens,
-                tokens_output=response.usage.completion_tokens,
-                finish_reason=response.choices[0].finish_reason,
+                content=content,
+                tokens_input=tokens_input,
+                tokens_output=tokens_output,
+                total_tokens=total_tokens,
+                finish_reason=finish_reason,
+                model=model
             )
-        
+
+        except requests.exceptions.HTTPError as e:
+            status_code = e.response.status_code if e.response else 0
+            error_body = e.response.text if e.response else str(e)
+            logger.error(f"❌ Groq HTTP Error {status_code}: {error_body}")
+            raise
+
+        except requests.exceptions.Timeout:
+            logger.error(f"❌ Groq timeout após {request_timeout}s")
+            raise
+
         except Exception as e:
-            logger.error(f"Erro ao gerar com Groq: {e}")
+            logger.error(f"❌ Groq erro inesperado: {e}")
             raise
-    
-    async def generate_stream(self,
-                             prompt: str,
-                             model: str = "mixtral-8x7b-32768",
-                             temperature: float = 0.7,
-                             max_tokens: Optional[int] = None,
-                             top_p: float = 0.9) -> AsyncGenerator[str, None]:
+
+    def generate_with_retry(self,
+                           prompt: str,
+                           system_prompt: Optional[str] = None,
+                           max_retries: int = 3,
+                           **kwargs) -> GroqResponse:
         """
-        Gera resposta em streaming usando Groq.
-        
+        Gera com retry automático para erros 429/503.
+
         Args:
-            prompt: Prompt para gerar
-            model: Modelo a usar
-            temperature: Criatividade
-            max_tokens: Tokens máximos
-            top_p: Top-p sampling
-        
-        Yields:
-            Chunks de texto
+            prompt: Prompt do usuário
+            system_prompt: System prompt
+            max_retries: Número máximo de tentativas
+            **kwargs: Argumentos adicionais para generate()
+
+        Returns:
+            GroqResponse
         """
+        import time
+        import random
+
+        for tentativa in range(1, max_retries + 1):
+            try:
+                return self.generate(prompt, system_prompt, **kwargs)
+
+            except requests.exceptions.HTTPError as e:
+                status_code = e.response.status_code if e.response else 0
+
+                # Rate limit ou service unavailable
+                if status_code in [429, 503] and tentativa < max_retries:
+                    delay = (2 ** tentativa) + random.uniform(0, 2)
+                    logger.warning(f"🔄 Groq {status_code} - retry {tentativa}/{max_retries} em {delay:.1f}s")
+                    time.sleep(delay)
+                    continue
+
+                # Outros erros HTTP - propaga
+                raise
+
+            except Exception as e:
+                # Erros não-HTTP - propaga imediatamente
+                raise
+
+        raise RuntimeError(f"Falha após {max_retries} tentativas")
+
+
+# ============================================================================
+# ASYNC VERSION (Opcional - mantém compatibilidade)
+# ============================================================================
+
+class AsyncGroqClient:
+    """Cliente Groq assíncrono usando aiohttp."""
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv('GROQ_API_KEY')
+        if not self.api_key:
+            raise ValueError("GROQ_API_KEY não configurada")
+
+        self.base_url = "https://api.groq.com/openai/v1/chat/completions"
+        self.default_timeout = int(os.getenv('GROQ_TIMEOUT', '120'))
+        logger.info("AsyncGroqClient inicializado")
+
+    async def generate(self,
+                      prompt: str,
+                      system_prompt: Optional[str] = None,
+                      model: str = "llama-3.3-70b-versatile",
+                      temperature: float = 0.7,
+                      max_tokens: Optional[int] = None,
+                      response_format: Optional[Dict] = None) -> GroqResponse:
+        """Versão assíncrona do generate."""
         try:
-            stream = await self.async_client.chat.completions.create(
-                model=model,
-                messages=[{"role": "user", "content": prompt}],
-                temperature=temperature,
-                max_tokens=max_tokens,
-                top_p=top_p,
-                stream=True,
-            )
-            
-            async for chunk in stream:
-                if chunk.choices[0].delta.content:
-                    yield chunk.choices[0].delta.content
-        
-        except Exception as e:
-            logger.error(f"Erro ao gerar stream com Groq: {e}")
-            raise
-    
-    def list_models(self) -> list:
-        """Lista modelos disponíveis."""
-        try:
-            models = self.client.models.list()
-            return [m.id for m in models.data]
-        except Exception as e:
-            logger.error(f"Erro ao listar modelos: {e}")
-            raise
+            import aiohttp
+        except ImportError:
+            raise ImportError("aiohttp não instalado: pip install aiohttp")
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        messages = []
+        if system_prompt:
+            messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": prompt})
+
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+        }
+
+        if max_tokens:
+            payload["max_tokens"] = max_tokens
+        if response_format:
+            payload["response_format"] = response_format
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                self.base_url,
+                headers=headers,
+                json=payload,
+                timeout=aiohttp.ClientTimeout(total=self.default_timeout)
+            ) as response:
+                response.raise_for_status()
+                data = await response.json()
+
+                content = data['choices'][0]['message']['content']
+                finish_reason = data['choices'][0]['finish_reason']
+
+                usage = data.get('usage', {})
+                tokens_input = usage.get('prompt_tokens', 0)
+                tokens_output = usage.get('completion_tokens', 0)
+                total_tokens = usage.get('total_tokens', tokens_input + tokens_output)
+
+                return GroqResponse(
+                    content=content,
+                    tokens_input=tokens_input,
+                    tokens_output=tokens_output,
+                    total_tokens=total_tokens,
+                    finish_reason=finish_reason,
+                    model=model
+                )