Update app.py

app.py

@@ -941,8 +941,13 @@ class TinkerIQApp:
             return history, ""
 
     def handle_text_conversation(self, message: str) -> str:
-        """Handle text-only conversations"""
-        message_lower = message.lower()
+    """Handle text-only conversations using AI intelligence"""
+    try:
+        # Use AI to understand and respond to the message
+        return self._generate_ai_response(message)
+    except Exception as e:
+        print(f"Error in AI response generation: {e}")
+        return self._fallback_response(message)
         
         # Check for code generation requests
         if any(word in message_lower for word in ["code", "program", "sketch", "arduino", "esp32"]):
@@ -1097,6 +1102,247 @@ What would you like to work on today?
             print(error_msg)
             return error_msg
 
+        def _generate_ai_response(self, message: str) -> str:
+        """Generate intelligent responses using available AI providers"""
+        
+        # Get current context
+        context = self._build_conversation_context()
+        
+        # Create a comprehensive prompt for the AI
+        system_prompt = """You are TinkerIQ, an expert AI electronics assistant. You help with:
+
+- Circuit analysis and design
+- Component selection and recommendations
+- Code generation for Arduino, ESP32, Raspberry Pi
+- Bill of Materials (BOM) creation
+- Electronics troubleshooting
+- Project guidance and tutorials
+
+CURRENT CAPABILITIES:
+- Circuit Analysis: {circuit_available}
+- Code Generation: {code_available} 
+- BOM Management: {bom_available}
+- Component Search: {component_available}
+
+CONVERSATION CONTEXT:
+{context}
+
+Respond naturally and helpfully to electronics questions. If the user asks about:
+- Component recommendations: Provide specific products, pricing, suppliers
+- Board comparisons: Give detailed technical comparisons
+- Project help: Offer practical guidance and suggestions
+- Code examples: Provide actual code snippets when appropriate
+- Circuit analysis: Direct to upload feature if asking about specific circuit
+
+Be conversational, knowledgeable, and practical. Always aim to be maximally helpful.""".format(
+            circuit_available="Available" if self.vision_analysis else "Limited (upload images for basic parsing)",
+            code_available="Available" if self.code_generator else "Template-based",
+            bom_available="Available" if self.bom_writer else "Basic functionality",
+            component_available="Available" if self.component_search else "Limited",
+            context=context
+        )
+
+        user_prompt = f"User question: {message}"
+
+        # Try different AI providers in order of preference
+        ai_providers = [
+            ("openai", self._query_openai),
+            ("anthropic", self._query_anthropic),
+            ("sambanova", self._query_sambanova),
+            ("huggingface", self._query_huggingface)
+        ]
+
+        for provider_name, provider_func in ai_providers:
+            if self.ai_providers.get(provider_name):
+                try:
+                    response = provider_func(system_prompt, user_prompt)
+                    if response and len(response.strip()) > 20:  # Valid response
+                        return response
+                except Exception as e:
+                    print(f"AI provider {provider_name} failed: {e}")
+                    continue
+
+        # If all AI providers fail, use intelligent fallback
+        return self._intelligent_fallback(message)
+
+    def _build_conversation_context(self) -> str:
+        """Build context from current session state"""
+        context_parts = []
+        
+        if self.session_state.get("last_analysis"):
+            analysis = self.session_state["last_analysis"]
+            context_parts.append(f"Recent circuit analysis: {analysis.get('analysis', '')[:200]}...")
+        
+        if self.session_state.get("current_bom"):
+            bom = self.session_state["current_bom"]
+            context_parts.append(f"Current BOM: {bom.get('component_count', 0)} components, ${bom.get('total_cost', 0):.2f}")
+        
+        if self.session_state.get("last_code"):
+            code_info = self.session_state["last_code"]
+            context_parts.append(f"Recent code generation: {code_info.get('platform', 'unknown')} with features {code_info.get('features', [])}")
+
+        if not context_parts:
+            context_parts.append("No current project context - fresh conversation")
+        
+        return "\n".join(context_parts)
+
+    def _query_openai(self, system_prompt: str, user_prompt: str) -> str:
+        """Query OpenAI API"""
+        try:
+            import openai
+            
+            client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+            
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"OpenAI query failed: {e}")
+            return None
+
+    def _query_anthropic(self, system_prompt: str, user_prompt: str) -> str:
+        """Query Anthropic Claude API"""
+        try:
+            import anthropic
+            
+            client = anthropic.Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+            
+            response = client.messages.create(
+                model="claude-3-haiku-20240307",
+                max_tokens=500,
+                system=system_prompt,
+                messages=[{"role": "user", "content": user_prompt}]
+            )
+            
+            return response.content[0].text.strip()
+        except Exception as e:
+            print(f"Anthropic query failed: {e}")
+            return None
+
+    def _query_sambanova(self, system_prompt: str, user_prompt: str) -> str:
+        """Query SambaNova API"""
+        try:
+            import requests
+            
+            url = "https://api.sambanova.ai/v1/chat/completions"
+            headers = {
+                "Authorization": f"Bearer {os.getenv('SAMBANOVA_API_KEY')}",
+                "Content-Type": "application/json"
+            }
+            
+            data = {
+                "model": "Meta-Llama-3.1-8B-Instruct",
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                "max_tokens": 500,
+                "temperature": 0.7
+            }
+            
+            response = requests.post(url, headers=headers, json=data, timeout=30)
+            response.raise_for_status()
+            
+            result = response.json()
+            return result["choices"][0]["message"]["content"].strip()
+        except Exception as e:
+            print(f"SambaNova query failed: {e}")
+            return None
+
+    def _query_huggingface(self, system_prompt: str, user_prompt: str) -> str:
+        """Query Hugging Face API"""
+        try:
+            import requests
+            
+            # Use a good conversational model
+            api_url = "https://api-inference.huggingface.co/models/microsoft/DialoGPT-large"
+            headers = {"Authorization": f"Bearer {os.getenv('HUGGINGFACE_API_KEY')}"}
+            
+            # Combine prompts for HF format
+            full_prompt = f"{system_prompt}\n\nUser: {user_prompt}\nAssistant:"
+            
+            response = requests.post(
+                api_url,
+                headers=headers,
+                json={"inputs": full_prompt, "parameters": {"max_length": 500, "temperature": 0.7}},
+                timeout=30
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            if isinstance(result, list) and len(result) > 0:
+                generated_text = result[0].get("generated_text", "")
+                # Extract just the assistant's response
+                if "Assistant:" in generated_text:
+                    return generated_text.split("Assistant:")[-1].strip()
+            
+            return None
+        except Exception as e:
+            print(f"HuggingFace query failed: {e}")
+            return None
+
+    def _intelligent_fallback(self, message: str) -> str:
+        """Intelligent fallback when AI providers are unavailable"""
+        message_lower = message.lower()
+        
+        # Use simple keyword matching for basic responses
+        if any(word in message_lower for word in ["esp32", "arduino", "board"]) and any(word in message_lower for word in ["price", "cost", "under", "$"]):
+            return """🔧 **Board Recommendations:**
+
+For specific current pricing and availability, I'd recommend checking:
+- **Digi-Key** or **Mouser** for official boards with precise specs
+- **Amazon** for quick shipping of development boards  
+- **AliExpress** for budget-friendly options
+
+Popular options include ESP32 DevKit boards ($6-10) and Arduino Uno compatibles ($5-15).
+
+Would you like help with component search functionality, or do you have specific requirements for your project?"""
+
+        elif any(word in message_lower for word in ["help", "what can you do", "capabilities"]):
+            return f"""🤖 **TinkerIQ Capabilities:**
+
+**Available Now:**
+✅ Circuit component parsing and analysis
+✅ Code template generation (Arduino, ESP32, Raspberry Pi)  
+✅ Basic BOM management
+✅ Project guidance and recommendations
+
+**AI Features:** {sum(self.ai_providers.values())}/5 providers configured
+**Modules:** {sum([bool(self.component_search), bool(self.vision_analysis), bool(self.code_generator), bool(self.bom_writer)])}/4 available
+
+**How to get better responses:** Configure API keys for OpenAI, Anthropic, or SambaNova in your .env file for more intelligent conversations!
+
+What specific electronics topic can I help you with?"""
+
+        else:
+            return """🔧 **I'm here to help with electronics!**
+
+I can assist with component selection, board recommendations, circuit analysis, code generation, and project guidance.
+
+For the most intelligent responses, please configure AI provider API keys in your .env file.
+
+What specific electronics question do you have? I'll do my best to help with the information available."""
+
+    def _fallback_response(self, message: str) -> str:
+        """Simple fallback when everything else fails"""
+        return """I apologize, but I'm having trouble generating a response right now. 
+
+This might help:
+- Check your internet connection
+- Verify API keys are configured in .env file  
+- Try uploading a circuit image for analysis
+- Use the specific tabs for code generation or BOM management
+
+What specific electronics topic can I help you with using the available tools?"""        
+
 def build_interface(tinkeriq_app: TinkerIQApp):
     """Build the Gradio interface"""