feat: add Groq API integration

- Added groq_api.py to handle Groq API interactions
- Updated __init__.py to include GroqAPI in exports
- Added GroqAPI initialization in ChatInterface
- Updated _handle_chat to use Groq API as fallback
- Improved error handling and logging

api/__init__.py

@@ -2,5 +2,6 @@
 
 from .openai_compatible import OpenAICompatibleAPI
 from .venture_api import VentureAPI
+from .groq_api import GroqAPI
 
-__all__ = ['OpenAICompatibleAPI', 'VentureAPI']
+__all__ = ['OpenAICompatibleAPI', 'VentureAPI', 'GroqAPI']

api/groq_api.py

@@ -0,0 +1,70 @@
+"""
+Groq API Integration
+------------------
+Handles interactions with the Groq API for language model inference.
+"""
+
+import os
+import logging
+from typing import Dict, Any, Optional
+import requests
+
+logger = logging.getLogger(__name__)
+
+class GroqAPI:
+    """Handles interactions with the Groq API."""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """Initialize the Groq API client."""
+        self.api_key = api_key or os.getenv('GROQ_API_KEY')
+        self.base_url = "https://api.groq.com/v1"
+        self.default_model = "mixtral-8x7b-32768"
+        
+    async def predict(self, prompt: str, model: Optional[str] = None) -> Dict[str, Any]:
+        """Make a prediction using the Groq API."""
+        try:
+            if not self.api_key:
+                return {
+                    "success": False,
+                    "error": "GROQ_API_KEY not set in environment variables",
+                    "answer": "Error: GROQ_API_KEY not configured"
+                }
+            
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": model or self.default_model,
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.7,
+                "max_tokens": 1000
+            }
+            
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=data
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                return {
+                    "success": True,
+                    "answer": result["choices"][0]["message"]["content"]
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"API Error: {response.status_code}",
+                    "answer": f"Error: {response.text}"
+                }
+                
+        except Exception as e:
+            logger.error(f"Error calling Groq API: {str(e)}")
+            return {
+                "success": False,
+                "error": str(e),
+                "answer": f"Error: {str(e)}"
+            }

app.py

@@ -34,6 +34,7 @@ from reasoning import (
 )
 from api.openai_compatible import OpenAICompatibleAPI
 from api.venture_api import VentureAPI
+from api.groq_api import GroqAPI
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -99,6 +100,7 @@ class ChatInterface:
         self.orchestrator = AgentOrchestrator(config)
         self.team_manager = TeamManager(self.orchestrator)
         self.reasoning_engine = UnifiedReasoningEngine()
+        self.groq_api = GroqAPI()
         
         # Set up the agentic system
         self.agentic_system = AgenticSystem(config)
@@ -412,22 +414,40 @@ class ChatInterface:
     async def _handle_chat(self, message: str) -> str:
         """Handle general chat interactions with error recovery."""
         try:
-            # Use reasoning engine for response generation
-            result = await self.reasoning_engine.reason(
-                query=message,
-                context={
-                    "chat_history": self.chat_history,
-                    "active_objectives": self.active_objectives
-                }
-            )
-            
-            # Handle UnifiedResult object
-            if isinstance(result, UnifiedResult):
-                return result.response if hasattr(result, 'response') else str(result)
-            elif isinstance(result, dict):
-                return result.get('response', str(result))
-            else:
-                return str(result)
+            # First try using the reasoning engine
+            try:
+                result = await self.reasoning_engine.reason(
+                    query=message,
+                    context={
+                        "chat_history": self.chat_history,
+                        "active_objectives": self.active_objectives,
+                        "groq_api": self.groq_api
+                    }
+                )
+                
+                # Handle UnifiedResult object
+                if isinstance(result, UnifiedResult):
+                    if not result.success:
+                        # If reasoning engine fails, fallback to Groq API
+                        groq_result = await self.groq_api.predict(message)
+                        if groq_result["success"]:
+                            return groq_result["answer"]
+                        else:
+                            return "I encountered an error. Please try rephrasing your question."
+                    return result.answer if hasattr(result, 'answer') else str(result)
+                elif isinstance(result, dict):
+                    return result.get('response', str(result))
+                else:
+                    return str(result)
+                
+            except Exception as reasoning_error:
+                logger.error(f"Reasoning engine error: {str(reasoning_error)}")
+                # Fallback to Groq API
+                groq_result = await self.groq_api.predict(message)
+                if groq_result["success"]:
+                    return groq_result["answer"]
+                else:
+                    raise Exception(f"Both reasoning engine and Groq API failed: {groq_result.get('error')}")
             
         except Exception as e:
             logger.error(f"Error in chat response: {str(e)}")