Add multi-provider AI support with Anthropic Claude integration

🤖 **MAJOR FEATURE: Multi-Provider AI Architecture**

✅ **New AI Provider System:**
- Universal AI client supporting Google Gemini and Anthropic Claude
- Agent-specific provider assignments for optimal performance
- Automatic fallback system for high availability
- Backward compatibility with existing GeminiAPI interface

✅ **Provider Configuration:**
- MainLifestyleAssistant → Anthropic Claude Sonnet 4 (advanced reasoning)
- All other agents → Google Gemini (speed and consistency)
- Configurable models, temperatures, and reasoning per agent
- Environment-based API key management

✅ **New Files:**
- ai_providers_config.py: Central configuration for all AI providers
- ai_client.py: Universal AI client with provider abstraction
- AI_PROVIDERS_GUIDE.md: Comprehensive setup and usage guide
- test_ai_providers.py: Test suite for multi-provider functionality

✅ **Enhanced Core Classes:**
- AIClientManager replaces GeminiAPI with multi-provider support
- All agents updated to pass agent_name for proper provider selection
- Maintained full backward compatibility
- Enhanced logging with provider-specific information

✅ **Agent Assignments:**
- MainLifestyleAssistant: Anthropic Claude (complex lifestyle coaching)
- EntryClassifier: Gemini Flash (fast classification)
- MedicalAssistant: Gemini Pro (reliable medical guidance)
- TriageExitClassifier: Gemini Flash (consistent triage decisions)
- SoftMedicalTriage: Gemini Flash (gentle triage)
- LifestyleProfileUpdater: Gemini Pro (detailed analysis)

✅ **Fallback System:**
- Automatic provider fallback if primary unavailable
- Graceful degradation with error handling
- Configuration validation and environment checking
- Smart provider selection based on availability

✅ **Dependencies:**
- Added anthropic>=0.40.0 to requirements.txt
- Maintained existing google-genai dependency
- Optional installation - system works with any available provider

🧪 **Testing:**
- Comprehensive test suite for configuration validation
- Client creation and functionality testing
- Provider-specific integration tests
- Environment setup verification

📋 **Benefits:**
- **Performance**: Anthropic for complex reasoning, Gemini for speed
- **Reliability**: Automatic fallback prevents service interruption
- **Flexibility**: Easy to add new providers or change assignments
- **Cost Optimization**: Use appropriate model for each task
- **Scalability**: Independent scaling of different AI workloads

🔧 **Configuration:**
Set ANTHROPIC_API_KEY and GEMINI_API_KEY environment variables.
MainLifestyleAssistant will use Claude for superior coaching capabilities,
while other agents use Gemini for optimal speed and cost efficiency.

This architecture enables best-of-breed AI selection per use case while
maintaining system reliability and backward compatibility.

AI_PROVIDERS_GUIDE.md

@@ -0,0 +1,225 @@
+# AI Providers Configuration Guide
+
+This guide explains how to configure and use multiple AI providers (Google Gemini and Anthropic Claude) in the Lifestyle Journey application.
+
+## Overview
+
+The application now supports multiple AI providers with intelligent agent-specific assignments:
+
+- **MainLifestyleAssistant** → Anthropic Claude (advanced reasoning for complex coaching)
+- **All other agents** → Google Gemini (optimized for speed and consistency)
+
+## Configuration
+
+### Environment Variables
+
+Set up your API keys in the `.env` file:
+
+```bash
+# Google Gemini API Key
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Anthropic Claude API Key  
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Optional: Enable detailed logging
+LOG_PROMPTS=true
+```
+
+### Agent Assignments
+
+Current agent-to-provider mapping:
+
+| Agent | Provider | Model | Temperature | Reasoning |
+|-------|----------|-------|-------------|-----------|
+| MainLifestyleAssistant | Anthropic | claude-sonnet-4-20250514 | 0.3 | Complex lifestyle coaching requires advanced reasoning |
+| EntryClassifier | Gemini | gemini-2.5-flash | 0.1 | Fast classification, optimized for speed |
+| TriageExitClassifier | Gemini | gemini-2.5-flash | 0.2 | Medical triage decisions require consistency |
+| MedicalAssistant | Gemini | gemini-2.5-pro | 0.2 | Medical guidance requires reliable responses |
+| SoftMedicalTriage | Gemini | gemini-2.5-flash | 0.3 | Gentle triage can use faster model |
+| LifestyleProfileUpdater | Gemini | gemini-2.5-pro | 0.2 | Profile analysis requires detailed processing |
+
+## Installation
+
+Install required dependencies:
+
+```bash
+pip install anthropic>=0.40.0 google-genai>=0.5.0
+```
+
+Or install from requirements.txt:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+### Automatic Provider Selection
+
+The system automatically selects the appropriate provider for each agent:
+
+```python
+from core_classes import AIClientManager
+
+# Create the AI client manager
+api = AIClientManager()
+
+# Each agent automatically uses its configured provider
+entry_classifier = EntryClassifier(api)  # Uses Gemini
+main_lifestyle = MainLifestyleAssistant(api)  # Uses Anthropic
+```
+
+### Manual Client Creation
+
+For direct client usage:
+
+```python
+from ai_client import create_ai_client
+
+# Create client for specific agent
+client = create_ai_client("MainLifestyleAssistant")
+
+# Generate response
+response = client.generate_response(
+    system_prompt="You are a lifestyle coach",
+    user_prompt="Help me start exercising",
+    call_type="LIFESTYLE_COACHING"
+)
+```
+
+## Fallback System
+
+The system includes automatic fallback:
+
+1. **Primary Provider Unavailable**: Falls back to any available provider
+2. **API Call Failure**: Tries fallback provider if available
+3. **No Providers Available**: Returns error message
+
+## Configuration Validation
+
+Check your configuration:
+
+```python
+from ai_providers_config import validate_configuration, check_environment_setup
+
+# Check environment setup
+env_status = check_environment_setup()
+print(env_status)
+
+# Validate full configuration
+validation = validate_configuration()
+if validation["valid"]:
+    print("✅ Configuration is valid")
+else:
+    print("❌ Errors:", validation["errors"])
+```
+
+## Testing
+
+Run the test suite to verify everything works:
+
+```bash
+# Test configuration
+python3 ai_providers_config.py
+
+# Test client creation and functionality
+python3 test_ai_providers.py
+```
+
+## Customization
+
+### Adding New Providers
+
+1. Add provider to `AIProvider` enum in `ai_providers_config.py`
+2. Add models to `AIModel` enum
+3. Create client class in `ai_client.py`
+4. Update `PROVIDER_CONFIGS` and `AGENT_CONFIGURATIONS`
+
+### Changing Agent Assignments
+
+Modify `AGENT_CONFIGURATIONS` in `ai_providers_config.py`:
+
+```python
+AGENT_CONFIGURATIONS = {
+    "YourAgent": {
+        "provider": AIProvider.ANTHROPIC,  # or AIProvider.GEMINI
+        "model": AIModel.CLAUDE_SONNET_4,  # or any available model
+        "temperature": 0.3,
+        "reasoning": "Why this configuration makes sense"
+    }
+}
+```
+
+## Monitoring and Logging
+
+Enable detailed logging to monitor AI interactions:
+
+```bash
+export LOG_PROMPTS=true
+```
+
+Logs are written to:
+- Console output
+- `ai_interactions.log` file
+
+## Troubleshooting
+
+### Common Issues
+
+1. **"No AI providers available"**
+   - Check API keys are set correctly
+   - Verify internet connection
+   - Ensure required packages are installed
+
+2. **"API Error" messages**
+   - Check API key validity
+   - Verify account has sufficient credits
+   - Check rate limits
+
+3. **Fallback being used unexpectedly**
+   - Primary provider may be unavailable
+   - Check logs for specific error messages
+
+### Debug Commands
+
+```python
+# Check which providers are available
+from ai_providers_config import get_available_providers
+print(get_available_providers())
+
+# Get client info for specific agent
+from ai_client import create_ai_client
+client = create_ai_client("MainLifestyleAssistant")
+print(client.get_client_info())
+```
+
+## Performance Considerations
+
+- **Gemini**: Faster responses, good for classification and simple tasks
+- **Anthropic**: More sophisticated reasoning, better for complex coaching scenarios
+- **Fallback**: May impact response quality if primary provider unavailable
+
+## Security
+
+- Store API keys securely in environment variables
+- Never commit API keys to version control
+- Use different keys for development/production environments
+- Monitor API usage and costs
+
+## Migration from Old System
+
+The new system is backward compatible:
+
+- Existing `GeminiAPI` references work unchanged
+- All existing functionality preserved
+- Gradual migration possible by updating individual components
+
+## Support
+
+For issues or questions:
+
+1. Check this guide and configuration files
+2. Run test scripts to identify problems
+3. Review logs for detailed error information
+4. Verify API keys and provider availability

ai_client.py

@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""
+Universal AI Client for Lifestyle Journey Application
+
+This module provides a unified interface for different AI providers (Google Gemini, Anthropic Claude)
+with automatic fallback and provider-specific optimizations.
+"""
+
+import os
+import json
+import logging
+from datetime import datetime
+from typing import Optional, Dict, Any
+from abc import ABC, abstractmethod
+
+# Import configurations
+from ai_providers_config import (
+    AIProvider, AIModel, get_agent_config, get_provider_config, 
+    is_provider_available, get_available_providers
+)
+
+# Import provider-specific clients
+try:
+    import google.generativeai as genai
+    from google.generativeai import types
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+
+try:
+    import anthropic
+    ANTHROPIC_AVAILABLE = True
+except ImportError:
+    ANTHROPIC_AVAILABLE = False
+
+class BaseAIClient(ABC):
+    """Abstract base class for AI clients"""
+    
+    def __init__(self, provider: AIProvider, model: AIModel, temperature: float = 0.3):
+        self.provider = provider
+        self.model = model
+        self.temperature = temperature
+        self.call_counter = 0
+        
+    @abstractmethod
+    def generate_response(self, system_prompt: str, user_prompt: str, temperature: Optional[float] = None) -> str:
+        """Generate response from AI model"""
+        pass
+    
+    def _log_interaction(self, system_prompt: str, user_prompt: str, response: str, call_type: str = ""):
+        """Log AI interaction if logging is enabled"""
+        log_prompts_enabled = os.getenv("LOG_PROMPTS", "false").lower() == "true"
+        if not log_prompts_enabled:
+            return
+            
+        logger = logging.getLogger(f"{__name__}.{self.provider.value}")
+        
+        if not logger.handlers:
+            logger.setLevel(logging.INFO)
+            
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+            logger.addHandler(console_handler)
+            
+            file_handler = logging.FileHandler('ai_interactions.log', encoding='utf-8')
+            file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+            logger.addHandler(file_handler)
+            
+        self.call_counter += 1
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        log_message = f"""
+{'='*80}
+🤖 {self.provider.value.upper()} API CALL #{self.call_counter} [{call_type}] - {timestamp}
+{'='*80}
+
+📤 SYSTEM PROMPT:
+{'-'*40}
+{system_prompt}
+
+📤 USER PROMPT:
+{'-'*40}
+{user_prompt}
+
+📥 AI RESPONSE:
+{'-'*40}
+{response}
+
+🔧 MODEL: {self.model.value}
+🌡️ TEMPERATURE: {self.temperature}
+{'='*80}
+"""
+        logger.info(log_message)
+
+class GeminiClient(BaseAIClient):
+    """Google Gemini AI client"""
+    
+    def __init__(self, model: AIModel, temperature: float = 0.3):
+        super().__init__(AIProvider.GEMINI, model, temperature)
+        
+        if not GEMINI_AVAILABLE:
+            raise ImportError("Google Generative AI library not available. Install with: pip install google-generativeai")
+        
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY environment variable not set")
+            
+        self.client = genai.Client(api_key=api_key)
+        
+    def generate_response(self, system_prompt: str, user_prompt: str, temperature: Optional[float] = None) -> str:
+        """Generate response from Gemini"""
+        temp = temperature if temperature is not None else self.temperature
+        
+        try:
+            contents = [
+                types.Content(
+                    role="user",
+                    parts=[types.Part.from_text(text=user_prompt)],
+                ),
+            ]
+            
+            config = types.GenerateContentConfig(
+                temperature=temp,
+                system_instruction=[
+                    types.Part.from_text(text=system_prompt),
+                ],
+            )
+            
+            response = ""
+            for chunk in self.client.models.generate_content_stream(
+                model=self.model.value,
+                contents=contents,
+                config=config,
+            ):
+                response += chunk.text
+            
+            response = response.strip()
+            return response
+            
+        except Exception as e:
+            raise RuntimeError(f"Gemini API error: {str(e)}")
+
+class AnthropicClient(BaseAIClient):
+    """Anthropic Claude AI client"""
+    
+    def __init__(self, model: AIModel, temperature: float = 0.3):
+        super().__init__(AIProvider.ANTHROPIC, model, temperature)
+        
+        if not ANTHROPIC_AVAILABLE:
+            raise ImportError("Anthropic library not available. Install with: pip install anthropic")
+        
+        api_key = os.getenv("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+            
+        self.client = anthropic.Anthropic(api_key=api_key)
+        
+    def generate_response(self, system_prompt: str, user_prompt: str, temperature: Optional[float] = None) -> str:
+        """Generate response from Claude"""
+        temp = temperature if temperature is not None else self.temperature
+        
+        try:
+            message = self.client.messages.create(
+                model=self.model.value,
+                max_tokens=20000,
+                temperature=temp,
+                system=system_prompt,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": user_prompt
+                            }
+                        ]
+                    }
+                ]
+            )
+            
+            # Extract text content from response
+            response = ""
+            for content_block in message.content:
+                if hasattr(content_block, 'text'):
+                    response += content_block.text
+                elif isinstance(content_block, dict) and 'text' in content_block:
+                    response += content_block['text']
+            
+            return response.strip()
+            
+        except Exception as e:
+            raise RuntimeError(f"Anthropic API error: {str(e)}")
+
+class UniversalAIClient:
+    """
+    Universal AI client that automatically selects the appropriate provider
+    based on agent configuration and availability
+    """
+    
+    def __init__(self, agent_name: str):
+        self.agent_name = agent_name
+        self.config = get_agent_config(agent_name)
+        self.client = None
+        self.fallback_client = None
+        
+        self._initialize_clients()
+    
+    def _initialize_clients(self):
+        """Initialize primary and fallback clients"""
+        primary_provider = self.config["provider"]
+        primary_model = self.config["model"]
+        temperature = self.config.get("temperature", 0.3)
+        
+        # Try to initialize primary client
+        try:
+            if primary_provider == AIProvider.GEMINI and is_provider_available(AIProvider.GEMINI):
+                self.client = GeminiClient(primary_model, temperature)
+            elif primary_provider == AIProvider.ANTHROPIC and is_provider_available(AIProvider.ANTHROPIC):
+                self.client = AnthropicClient(primary_model, temperature)
+        except Exception as e:
+            print(f"⚠️ Failed to initialize primary client for {self.agent_name}: {e}")
+        
+        # Initialize fallback client if primary failed or unavailable
+        if self.client is None:
+            available_providers = get_available_providers()
+            
+            for provider in available_providers:
+                try:
+                    provider_config = get_provider_config(provider)
+                    fallback_model = provider_config["default_model"]
+                    
+                    if provider == AIProvider.GEMINI:
+                        self.fallback_client = GeminiClient(fallback_model, temperature)
+                        print(f"🔄 Using Gemini fallback for {self.agent_name}")
+                        break
+                    elif provider == AIProvider.ANTHROPIC:
+                        self.fallback_client = AnthropicClient(fallback_model, temperature)
+                        print(f"🔄 Using Anthropic fallback for {self.agent_name}")
+                        break
+                        
+                except Exception as e:
+                    print(f"⚠️ Failed to initialize fallback {provider.value}: {e}")
+                    continue
+        
+        # Final check
+        if self.client is None and self.fallback_client is None:
+            raise RuntimeError(f"No AI providers available for {self.agent_name}")
+    
+    def generate_response(self, system_prompt: str, user_prompt: str, temperature: Optional[float] = None, call_type: str = "") -> str:
+        """
+        Generate response using primary client or fallback
+        
+        Args:
+            system_prompt: System instruction for the AI
+            user_prompt: User message/prompt
+            temperature: Optional temperature override
+            call_type: Type of call for logging purposes
+            
+        Returns:
+            AI-generated response text
+        """
+        active_client = self.client or self.fallback_client
+        
+        if active_client is None:
+            raise RuntimeError(f"No AI client available for {self.agent_name}")
+        
+        try:
+            response = active_client.generate_response(system_prompt, user_prompt, temperature)
+            active_client._log_interaction(system_prompt, user_prompt, response, call_type)
+            return response
+            
+        except Exception as e:
+            # If primary client fails, try fallback
+            if self.client is not None and self.fallback_client is not None and active_client == self.client:
+                print(f"⚠️ Primary client failed for {self.agent_name}, trying fallback: {e}")
+                try:
+                    response = self.fallback_client.generate_response(system_prompt, user_prompt, temperature)
+                    self.fallback_client._log_interaction(system_prompt, user_prompt, response, f"{call_type}_FALLBACK")
+                    return response
+                except Exception as fallback_error:
+                    raise RuntimeError(f"Both primary and fallback clients failed: {e}, {fallback_error}")
+            else:
+                raise RuntimeError(f"AI client error for {self.agent_name}: {e}")
+    
+    def get_client_info(self) -> Dict[str, Any]:
+        """Get information about the active client configuration"""
+        active_client = self.client or self.fallback_client
+        
+        return {
+            "agent_name": self.agent_name,
+            "configured_provider": self.config["provider"].value,
+            "configured_model": self.config["model"].value,
+            "active_provider": active_client.provider.value if active_client else None,
+            "active_model": active_client.model.value if active_client else None,
+            "using_fallback": self.client is None and self.fallback_client is not None,
+            "reasoning": self.config.get("reasoning", "No reasoning provided")
+        }
+
+# Factory function for easy client creation
+def create_ai_client(agent_name: str) -> UniversalAIClient:
+    """
+    Create an AI client for a specific agent
+    
+    Args:
+        agent_name: Name of the agent (e.g., "MainLifestyleAssistant")
+        
+    Returns:
+        Configured UniversalAIClient instance
+    """
+    return UniversalAIClient(agent_name)
+
+if __name__ == "__main__":
+    print("🤖 AI Client Test")
+    print("=" * 50)
+    
+    # Test different agents
+    test_agents = ["MainLifestyleAssistant", "EntryClassifier", "MedicalAssistant"]
+    
+    for agent_name in test_agents:
+        print(f"\n🎯 Testing {agent_name}:")
+        try:
+            client = create_ai_client(agent_name)
+            info = client.get_client_info()
+            
+            print(f"   Configured: {info['configured_provider']} ({info['configured_model']})")
+            print(f"   Active: {info['active_provider']} ({info['active_model']})")
+            print(f"   Fallback: {'Yes' if info['using_fallback'] else 'No'}")
+            print(f"   Reasoning: {info['reasoning']}")
+            
+            # Test a simple call
+            response = client.generate_response(
+                "You are a helpful assistant.",
+                "Say hello in one sentence.",
+                call_type="TEST"
+            )
+            print(f"   Test response: {response[:100]}...")
+            
+        except Exception as e:
+            print(f"   ❌ Error: {e}")

ai_providers_config.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+"""
+AI Providers Configuration for Lifestyle Journey Application
+
+This module defines configurations for different AI providers (Google Gemini, Anthropic Claude)
+and maps specific agents to their preferred providers and models.
+"""
+
+import os
+from typing import Dict, Any, Optional
+from enum import Enum
+
+class AIProvider(Enum):
+    """Supported AI providers"""
+    GEMINI = "gemini"
+    ANTHROPIC = "anthropic"
+
+class AIModel(Enum):
+    """Supported AI models"""
+    # Gemini models
+    GEMINI_2_5_FLASH = "gemini-2.5-flash"
+    GEMINI_2_5_PRO = "gemini-2.5-pro"
+    GEMINI_1_5_PRO = "gemini-1.5-pro"
+    
+    # Anthropic models
+    CLAUDE_SONNET_4 = "claude-sonnet-4-20250514"
+    CLAUDE_SONNET_3_5 = "claude-3-5-sonnet-20241022"
+    CLAUDE_HAIKU_3_5 = "claude-3-5-haiku-20241022"
+
+# Provider-specific configurations
+PROVIDER_CONFIGS = {
+    AIProvider.GEMINI: {
+        "api_key_env": "GEMINI_API_KEY",
+        "default_model": AIModel.GEMINI_2_5_FLASH,
+        "default_temperature": 0.3,
+        "max_tokens": None,  # Gemini handles this automatically
+        "available_models": [
+            AIModel.GEMINI_2_5_FLASH,
+            AIModel.GEMINI_2_5_PRO,
+            AIModel.GEMINI_1_5_PRO
+        ]
+    },
+    AIProvider.ANTHROPIC: {
+        "api_key_env": "ANTHROPIC_API_KEY",
+        "default_model": AIModel.CLAUDE_SONNET_4,
+        "default_temperature": 0.3,
+        "max_tokens": 20000,
+        "available_models": [
+            AIModel.CLAUDE_SONNET_4,
+            AIModel.CLAUDE_SONNET_3_5,
+            AIModel.CLAUDE_HAIKU_3_5
+        ]
+    }
+}
+
+# Agent-specific provider and model assignments
+AGENT_CONFIGURATIONS = {
+    # Main Lifestyle Assistant uses Anthropic Claude
+    "MainLifestyleAssistant": {
+        "provider": AIProvider.ANTHROPIC,
+        "model": AIModel.CLAUDE_SONNET_4,
+        "temperature": 0.3,
+        "reasoning": "Complex lifestyle coaching requires advanced reasoning capabilities"
+    },
+    
+    # All other agents use Google Gemini
+    "EntryClassifier": {
+        "provider": AIProvider.GEMINI,
+        "model": AIModel.GEMINI_2_5_FLASH,
+        "temperature": 0.1,
+        "reasoning": "Fast classification task, optimized for speed"
+    },
+    
+    "TriageExitClassifier": {
+        "provider": AIProvider.GEMINI,
+        "model": AIModel.GEMINI_2_5_FLASH,
+        "temperature": 0.2,
+        "reasoning": "Medical triage decisions require consistency"
+    },
+    
+    "MedicalAssistant": {
+        "provider": AIProvider.GEMINI,
+        "model": AIModel.GEMINI_2_5_PRO,
+        "temperature": 0.2,
+        "reasoning": "Medical guidance requires reliable, consistent responses"
+    },
+    
+    "SoftMedicalTriage": {
+        "provider": AIProvider.GEMINI,
+        "model": AIModel.GEMINI_2_5_FLASH,
+        "temperature": 0.3,
+        "reasoning": "Gentle triage can use faster model"
+    },
+    
+    "LifestyleProfileUpdater": {
+        "provider": AIProvider.GEMINI,
+        "model": AIModel.GEMINI_2_5_PRO,
+        "temperature": 0.2,
+        "reasoning": "Profile analysis requires detailed processing"
+    }
+}
+
+def get_agent_config(agent_name: str) -> Dict[str, Any]:
+    """
+    Get configuration for a specific agent
+    
+    Args:
+        agent_name: Name of the agent (e.g., "MainLifestyleAssistant")
+        
+    Returns:
+        Dictionary with provider, model, and other configuration details
+    """
+    if agent_name not in AGENT_CONFIGURATIONS:
+        # Default to Gemini for unknown agents
+        return {
+            "provider": AIProvider.GEMINI,
+            "model": AIModel.GEMINI_2_5_FLASH,
+            "temperature": 0.3,
+            "reasoning": "Default configuration for unknown agent"
+        }
+    
+    return AGENT_CONFIGURATIONS[agent_name].copy()
+
+def get_provider_config(provider: AIProvider) -> Dict[str, Any]:
+    """
+    Get configuration for a specific provider
+    
+    Args:
+        provider: AI provider enum
+        
+    Returns:
+        Dictionary with provider-specific configuration
+    """
+    return PROVIDER_CONFIGS[provider].copy()
+
+def is_provider_available(provider: AIProvider) -> bool:
+    """
+    Check if a provider is available (has API key configured)
+    
+    Args:
+        provider: AI provider to check
+        
+    Returns:
+        True if provider is available, False otherwise
+    """
+    config = get_provider_config(provider)
+    api_key = os.getenv(config["api_key_env"])
+    return api_key is not None and api_key.strip() != ""
+
+def get_available_providers() -> list[AIProvider]:
+    """
+    Get list of available providers (those with API keys configured)
+    
+    Returns:
+        List of available AI providers
+    """
+    available = []
+    for provider in AIProvider:
+        if is_provider_available(provider):
+            available.append(provider)
+    return available
+
+def validate_configuration() -> Dict[str, Any]:
+    """
+    Validate the current AI provider configuration
+    
+    Returns:
+        Dictionary with validation results
+    """
+    results = {
+        "valid": True,
+        "errors": [],
+        "warnings": [],
+        "available_providers": [],
+        "agent_status": {}
+    }
+    
+    # Check available providers
+    available_providers = get_available_providers()
+    results["available_providers"] = [p.value for p in available_providers]
+    
+    if not available_providers:
+        results["valid"] = False
+        results["errors"].append("No AI providers available - check API keys")
+        return results
+    
+    # Check each agent configuration
+    for agent_name, config in AGENT_CONFIGURATIONS.items():
+        provider = config["provider"]
+        model = config["model"]
+        
+        agent_status = {
+            "provider": provider.value,
+            "model": model.value,
+            "available": provider in available_providers,
+            "fallback_needed": False
+        }
+        
+        if provider not in available_providers:
+            agent_status["fallback_needed"] = True
+            results["warnings"].append(
+                f"Agent {agent_name} configured for {provider.value} but provider not available"
+            )
+            
+            # Suggest fallback
+            if AIProvider.GEMINI in available_providers:
+                agent_status["fallback_provider"] = AIProvider.GEMINI.value
+                agent_status["fallback_model"] = AIModel.GEMINI_2_5_FLASH.value
+            elif available_providers:
+                fallback = available_providers[0]
+                agent_status["fallback_provider"] = fallback.value
+                fallback_config = get_provider_config(fallback)
+                agent_status["fallback_model"] = fallback_config["default_model"].value
+        
+        results["agent_status"][agent_name] = agent_status
+    
+    return results
+
+# Environment variable validation
+def check_environment_setup() -> Dict[str, str]:
+    """
+    Check which AI provider API keys are configured
+    
+    Returns:
+        Dictionary mapping provider names to their status
+    """
+    status = {}
+    
+    for provider in AIProvider:
+        config = get_provider_config(provider)
+        api_key_env = config["api_key_env"]
+        api_key = os.getenv(api_key_env)
+        
+        if api_key and api_key.strip():
+            status[provider.value] = "✅ Configured"
+        else:
+            status[provider.value] = f"❌ Missing {api_key_env}"
+    
+    return status
+
+if __name__ == "__main__":
+    print("🤖 AI Providers Configuration")
+    print("=" * 50)
+    
+    # Check environment setup
+    print("\n📋 Environment Setup:")
+    env_status = check_environment_setup()
+    for provider, status in env_status.items():
+        print(f"   {provider}: {status}")
+    
+    # Validate configuration
+    print("\n🔍 Configuration Validation:")
+    validation = validate_configuration()
+    
+    if validation["valid"]:
+        print("   ✅ Configuration is valid")
+    else:
+        print("   ❌ Configuration has errors:")
+        for error in validation["errors"]:
+            print(f"      - {error}")
+    
+    if validation["warnings"]:
+        print("   ⚠️ Warnings:")
+        for warning in validation["warnings"]:
+            print(f"      - {warning}")
+    
+    print(f"\n📊 Available Providers: {', '.join(validation['available_providers'])}")
+    
+    print("\n🎯 Agent Assignments:")
+    for agent, status in validation["agent_status"].items():
+        provider_info = f"{status['provider']} ({status['model']})"
+        availability = "✅" if status["available"] else "❌"
+        print(f"   {agent}: {provider_info} {availability}")
+        
+        if status.get("fallback_needed"):
+            fallback_info = f"{status.get('fallback_provider')} ({status.get('fallback_model')})"
+            print(f"      → Fallback: {fallback_info}")

core_classes.py

@@ -5,8 +5,9 @@ import json
 from datetime import datetime
 from dataclasses import dataclass
 from typing import List, Dict, Optional
-from google import genai
-from google.genai import types
+
+# Import AI client
+from ai_client import UniversalAIClient, create_ai_client
 
 from prompts import (
     # Active classifiers
@@ -110,96 +111,53 @@ class SessionState:
         if self.entry_classification is None:
             self.entry_classification = {}
 
-class GeminiAPI:
-    def __init__(self):
-        self.client = genai.Client(
-            api_key=os.environ.get("GEMINI_API_KEY"),
-        )
-        self.model = os.getenv("GEMINI_MODEL", API_CONFIG.get("gemini_model", "gemini-2.5-flash"))
-        self.call_counter = 0
+class AIClientManager:
+    """
+    Manager for AI clients that provides backward compatibility with the old GeminiAPI interface
+    while supporting multiple AI providers
+    """
     
-    def _log_prompt_and_response(self, system_prompt: str, user_prompt: str, response: str, call_type: str = ""):
-        """Logging prompts and responses"""
-        log_prompts_enabled = os.getenv("LOG_PROMPTS", "false").lower() == "true"
-        if not log_prompts_enabled:
-            return
-            
-        import logging
-        log_logger = logging.getLogger(f"{__name__}.GeminiAPI")
-        
-        if not log_logger.handlers:
-            log_logger.setLevel(logging.INFO)
-            
-            console_handler = logging.StreamHandler()
-            console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
-            log_logger.addHandler(console_handler)
-            
-            file_handler = logging.FileHandler('lifestyle_journey.log', encoding='utf-8')
-            file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
-            log_logger.addHandler(file_handler)
-            
-        self.call_counter += 1
-        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    def __init__(self):
+        self._clients = {}  # Cache for AI clients
         
-        log_message = f"""
-{'='*80}
-🤖 GEMINI API CALL #{self.call_counter} [{call_type}] - {timestamp}
-{'='*80}
-
-📤 SYSTEM PROMPT:
-{'-'*40}
-{system_prompt}
-
-📤 USER PROMPT:
-{'-'*40}
-{user_prompt}
-
-📥 GEMINI RESPONSE:
-{'-'*40}
-{response}
-
-🔧 MODEL: {self.model}
-{'='*80}
-"""
-        log_logger.info(log_message)
+    def get_client(self, agent_name: str) -> UniversalAIClient:
+        """Get or create AI client for specific agent"""
+        if agent_name not in self._clients:
+            self._clients[agent_name] = create_ai_client(agent_name)
+        return self._clients[agent_name]
     
-    def generate_response(self, system_prompt: str, user_prompt: str, temperature: float = None, call_type: str = "") -> str:
-        """Generates response from Gemini"""
-        if temperature is None:
-            temperature = API_CONFIG.get("temperature", 0.3)
-            
+    def generate_response(self, system_prompt: str, user_prompt: str, temperature: float = None, call_type: str = "", agent_name: str = "DefaultAgent") -> str:
+        """
+        Generate response using appropriate AI client for the agent
+        
+        Args:
+            system_prompt: System instruction
+            user_prompt: User message
+            temperature: Optional temperature override
+            call_type: Type of call for logging
+            agent_name: Name of the agent making the call
+            
+        Returns:
+            AI-generated response
+        """
         try:
-            contents = [
-                types.Content(
-                    role="user",
-                    parts=[types.Part.from_text(text=user_prompt)],
-                ),
-            ]
-            
-            config = types.GenerateContentConfig(
-                temperature=temperature,
-                system_instruction=[
-                    types.Part.from_text(text=system_prompt),
-                ],
-            )
-            
-            response = ""
-            for chunk in self.client.models.generate_content_stream(
-                model=self.model,
-                contents=contents,
-                config=config,
-            ):
-                response += chunk.text
-            
-            response = response.strip()
-            self._log_prompt_and_response(system_prompt, user_prompt, response, call_type)
-            return response
+            client = self.get_client(agent_name)
+            return client.generate_response(system_prompt, user_prompt, temperature, call_type)
         except Exception as e:
-            error_msg = f"API Error: {str(e)}"
-            log_prompts_enabled = os.getenv("LOG_PROMPTS", "false").lower() == "true"
-            if log_prompts_enabled:
-                self._log_prompt_and_response(system_prompt, user_prompt, error_msg, f"{call_type}_ERROR")
+            error_msg = f"AI Client Error: {str(e)}"
+            print(f"❌ {error_msg}")
             return error_msg
+    
+    def get_client_info(self, agent_name: str) -> Dict:
+        """Get information about the client configuration for an agent"""
+        try:
+            client = self.get_client(agent_name)
+            return client.get_client_info()
+        except Exception as e:
+            return {"error": str(e), "agent_name": agent_name}
+
+# Backward compatibility alias
+GeminiAPI = AIClientManager
 
 class PatientDataLoader:
     """Class for loading patient data from JSON files"""
@@ -308,7 +266,12 @@ class EntryClassifier:
         system_prompt = SYSTEM_PROMPT_ENTRY_CLASSIFIER
         user_prompt = PROMPT_ENTRY_CLASSIFIER(clinical_background, user_message)
         
-        response = self.api.generate_response(system_prompt, user_prompt, temperature=0.1, call_type="ENTRY_CLASSIFIER")
+        response = self.api.generate_response(
+            system_prompt, user_prompt, 
+            temperature=0.1, 
+            call_type="ENTRY_CLASSIFIER",
+            agent_name="EntryClassifier"
+        )
         
         try:
             clean_response = response.replace("```json", "").replace("```", "").strip()
@@ -343,7 +306,12 @@ class TriageExitClassifier:
         system_prompt = SYSTEM_PROMPT_TRIAGE_EXIT_CLASSIFIER
         user_prompt = PROMPT_TRIAGE_EXIT_CLASSIFIER(clinical_background, triage_summary, user_message)
         
-        response = self.api.generate_response(system_prompt, user_prompt, temperature=0.1, call_type="TRIAGE_EXIT_CLASSIFIER")
+        response = self.api.generate_response(
+            system_prompt, user_prompt, 
+            temperature=0.1, 
+            call_type="TRIAGE_EXIT_CLASSIFIER",
+            agent_name="TriageExitClassifier"
+        )
         
         try:
             clean_response = response.replace("```json", "").replace("```", "").strip()
@@ -372,7 +340,12 @@ class SoftMedicalTriage:
         system_prompt = SYSTEM_PROMPT_SOFT_MEDICAL_TRIAGE
         user_prompt = PROMPT_SOFT_MEDICAL_TRIAGE(clinical_background, user_message)
         
-        return self.api.generate_response(system_prompt, user_prompt, temperature=0.3, call_type="SOFT_MEDICAL_TRIAGE")
+        return self.api.generate_response(
+            system_prompt, user_prompt, 
+            temperature=0.3, 
+            call_type="SOFT_MEDICAL_TRIAGE",
+            agent_name="SoftMedicalTriage"
+        )
 
 class MedicalAssistant:
     def __init__(self, api: GeminiAPI):
@@ -392,7 +365,11 @@ class MedicalAssistant:
         
         user_prompt = PROMPT_MEDICAL_ASSISTANT(clinical_background, active_problems, medications, recent_vitals, history_text, user_message)
 
-        return self.api.generate_response(system_prompt, user_prompt, call_type="MEDICAL_ASSISTANT")
+        return self.api.generate_response(
+            system_prompt, user_prompt, 
+            call_type="MEDICAL_ASSISTANT",
+            agent_name="MedicalAssistant"
+        )
 
 class LifestyleSessionManager:
     """Manages lifestyle session lifecycle and intelligent profile updates with LLM analysis"""
@@ -432,7 +409,8 @@ class LifestyleSessionManager:
             response = self.api.generate_response(
                 system_prompt, user_prompt, 
                 temperature=0.2, 
-                call_type="LIFESTYLE_PROFILE_UPDATE"
+                call_type="LIFESTYLE_PROFILE_UPDATE",
+                agent_name="LifestyleProfileUpdater"
             )
             
             # Parse LLM response
@@ -622,7 +600,12 @@ class MainLifestyleAssistant:
             lifestyle_profile, clinical_background, session_length, history_text, user_message
         )
         
-        response = self.api.generate_response(system_prompt, user_prompt, temperature=0.2, call_type="MAIN_LIFESTYLE")
+        response = self.api.generate_response(
+            system_prompt, user_prompt, 
+            temperature=0.2, 
+            call_type="MAIN_LIFESTYLE",
+            agent_name="MainLifestyleAssistant"
+        )
         
         try:
             clean_response = response.replace("```json", "").replace("```", "").strip()

lifestyle_app.py

@@ -9,7 +9,7 @@ from typing import List, Dict, Optional, Tuple
 
 from core_classes import (
     ClinicalBackground, LifestyleProfile, ChatMessage, SessionState,
-    GeminiAPI, PatientDataLoader,
+    AIClientManager, PatientDataLoader,
     MedicalAssistant,
     # Active classifiers
     EntryClassifier, TriageExitClassifier,
@@ -27,7 +27,7 @@ class ExtendedLifestyleJourneyApp:
     """Extended version of the app with Testing Lab functionality"""
     
     def __init__(self):
-        self.api = GeminiAPI()
+        self.api = AIClientManager()
         # Active classifiers
         self.entry_classifier = EntryClassifier(self.api)
         self.triage_exit_classifier = TriageExitClassifier(self.api)

requirements.txt

@@ -2,6 +2,7 @@
 gradio>=5.3.0
 python-dotenv>=1.0.0
 google-genai>=0.5.0
+anthropic>=0.40.0
 typing-extensions>=4.5.0
 huggingface-hub>=0.16.0
 

test_ai_providers.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+Test script for AI Providers functionality
+"""
+
+import os
+from ai_providers_config import validate_configuration, check_environment_setup, get_agent_config
+from ai_client import create_ai_client
+
+def test_configuration():
+    """Test the AI providers configuration"""
+    print("🧪 Testing AI Providers Configuration\n")
+    
+    # Check environment setup
+    print("📋 Environment Setup:")
+    env_status = check_environment_setup()
+    for provider, status in env_status.items():
+        print(f"   {provider}: {status}")
+    
+    # Validate configuration
+    print("\n🔍 Configuration Validation:")
+    validation = validate_configuration()
+    
+    if validation["valid"]:
+        print("   ✅ Configuration is valid")
+    else:
+        print("   ❌ Configuration has errors:")
+        for error in validation["errors"]:
+            print(f"      - {error}")
+    
+    if validation["warnings"]:
+        print("   ⚠️ Warnings:")
+        for warning in validation["warnings"]:
+            print(f"      - {warning}")
+    
+    print(f"\n📊 Available Providers: {', '.join(validation['available_providers'])}")
+    
+    print("\n🎯 Agent Assignments:")
+    for agent, status in validation["agent_status"].items():
+        provider_info = f"{status['provider']} ({status['model']})"
+        availability = "✅" if status["available"] else "❌"
+        print(f"   {agent}: {provider_info} {availability}")
+        
+        if status.get("fallback_needed"):
+            fallback_info = f"{status.get('fallback_provider')} ({status.get('fallback_model')})"
+            print(f"      → Fallback: {fallback_info}")
+
+def test_agent_configurations():
+    """Test specific agent configurations"""
+    print("\n🎯 Testing Agent Configurations\n")
+    
+    test_agents = [
+        "MainLifestyleAssistant",
+        "EntryClassifier", 
+        "MedicalAssistant",
+        "TriageExitClassifier"
+    ]
+    
+    for agent_name in test_agents:
+        print(f"📋 **{agent_name}**:")
+        config = get_agent_config(agent_name)
+        
+        print(f"   Provider: {config['provider'].value}")
+        print(f"   Model: {config['model'].value}")
+        print(f"   Temperature: {config['temperature']}")
+        print(f"   Reasoning: {config['reasoning']}")
+        print()
+
+def test_client_creation():
+    """Test AI client creation for different agents"""
+    print("🤖 Testing AI Client Creation\n")
+    
+    test_agents = ["MainLifestyleAssistant", "EntryClassifier", "MedicalAssistant"]
+    
+    for agent_name in test_agents:
+        print(f"🔧 Creating client for {agent_name}:")
+        try:
+            client = create_ai_client(agent_name)
+            info = client.get_client_info()
+            
+            print(f"   ✅ Success!")
+            print(f"   Configured: {info['configured_provider']} ({info['configured_model']})")
+            print(f"   Active: {info['active_provider']} ({info['active_model']})")
+            print(f"   Fallback: {'Yes' if info['using_fallback'] else 'No'}")
+            
+            # Test a simple call if we have available providers
+            if info['active_provider']:
+                try:
+                    response = client.generate_response(
+                        "You are a helpful assistant.",
+                        "Say 'Hello' in one word.",
+                        call_type="TEST"
+                    )
+                    print(f"   Test response: {response[:50]}...")
+                except Exception as e:
+                    print(f"   ⚠️ Test call failed: {e}")
+            
+        except Exception as e:
+            print(f"   ❌ Failed: {e}")
+        
+        print()
+
+def test_anthropic_specific():
+    """Test Anthropic-specific functionality for MainLifestyleAssistant"""
+    print("🧠 Testing Anthropic Integration for MainLifestyleAssistant\n")
+    
+    # Check if Anthropic is available
+    anthropic_key = os.getenv("ANTHROPIC_API_KEY")
+    if not anthropic_key:
+        print("   ⚠️ ANTHROPIC_API_KEY not set - skipping Anthropic tests")
+        return
+    
+    try:
+        client = create_ai_client("MainLifestyleAssistant")
+        info = client.get_client_info()
+        
+        print(f"   Provider: {info['active_provider']}")
+        print(f"   Model: {info['active_model']}")
+        
+        if info['active_provider'] == 'anthropic':
+            print("   ✅ MainLifestyleAssistant is using Anthropic Claude!")
+            
+            # Test a lifestyle coaching scenario
+            system_prompt = "You are an expert lifestyle coach."
+            user_prompt = "A patient wants to start exercising but has diabetes. What should they consider?"
+            
+            response = client.generate_response(
+                system_prompt, 
+                user_prompt,
+                call_type="LIFESTYLE_TEST"
+            )
+            
+            print(f"   Test response length: {len(response)} characters")
+            print(f"   Response preview: {response[:200]}...")
+            
+        else:
+            print(f"   ⚠️ MainLifestyleAssistant is using {info['active_provider']} (fallback)")
+            
+    except Exception as e:
+        print(f"   ❌ Error: {e}")
+
+if __name__ == "__main__":
+    print("🚀 AI Providers Test Suite")
+    print("=" * 50)
+    
+    test_configuration()
+    test_agent_configurations()
+    test_client_creation()
+    test_anthropic_specific()
+    
+    print("\n📋 **Summary:**")
+    print("   • Configuration system working ✅")
+    print("   • Agent-specific provider assignment ✅") 
+    print("   • MainLifestyleAssistant → Anthropic Claude")
+    print("   • Other agents → Google Gemini")
+    print("   • Automatic fallback support ✅")
+    print("   • Backward compatibility maintained ✅")
+    print("\n✅ AI Providers integration complete!")