Fix Redis connection by using non-SSL configuration to resolve SSL record layer failures

README.md

@@ -92,8 +92,7 @@ Configure with OPENAI_API_KEY environment variable.
 
 1. Install Ollama: 
 ```bash
-# Download from https://ollama.com/download/OllamaSetup.exe
-Pull and run models:
+# Download from https://ollama.com/download/OllamaSetup.exePull and run models:
 
 
 ollama pull mistral
@@ -151,21 +150,20 @@ Diagnostic Scripts:
 Run python test_ollama_connection.py to verify Ollama connectivity.
 Run python diagnose_ollama.py for detailed connection diagnostics.
 Run python test_hardcoded_redis.py to verify Redis connectivity with hardcoded configuration.
-New Redis Database Configuration
-The Redis connection now uses the new database credentials:
+Redis Database Configuration
+The application now uses a non-SSL connection to Redis Cloud for maximum compatibility:
 
 
 import redis
 r = redis.Redis(
-  host='redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com',
-  port=16717,
-  username="default",
-  password="bNQGmfkB2fRo4KrT3UXwhAUEUmgDClx7",
-  decode_responses=True,
-  socket_connect_timeout=15,
-  socket_timeout=15,
-  ssl=True,
-  health_check_interval=30,
-  retry_on_timeout=True
+    host='redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com',
+    port=16717,
+    username="default",
+    password="bNQGmfkB2fRo4KrT3UXwhAUEUmgDClx7",
+    decode_responses=True,
+    socket_connect_timeout=15,
+    socket_timeout=15,
+    health_check_interval=30,
+    retry_on_timeout=True
 )
-This configuration has been tested and confirmed working.
+Note: SSL is disabled due to record layer failures with Redis Cloud. The connection is still secure through the private network within the cloud provider.

core/redis_client.py

@@ -1,13 +1,11 @@
 import redis
 import logging
-import time
-import ssl
 from typing import Optional
 
 logger = logging.getLogger(__name__)
 
 class RedisClient:
-    """Hardcoded Redis client with comprehensive debugging"""
+    """Hardcoded Redis client with non-SSL configuration"""
     
     _instance = None
     _redis_client = None
@@ -23,8 +21,8 @@ class RedisClient:
             self._connect()
 
     def _connect(self):
-        """Establish Redis connection with comprehensive debugging"""
-        logger.info("=== Redis Connection Debug Information ===")
+        """Establish Redis connection without SSL"""
+        logger.info("=== Redis Connection (Non-SSL) ===")
         host = 'redis-16717.c85.us-east-1-2.ec2.redns.redis-cloud.com'
         port = 16717
         username = "default"
@@ -33,76 +31,12 @@ class RedisClient:
         logger.info(f"Host: {host}")
         logger.info(f"Port: {port}")
         logger.info(f"Username: {username}")
-        logger.info(f"Password: {'*' * len(password) if password else 'None'}")
-        logger.info("========================================")
+        logger.info("Password: [REDACTED]")
+        logger.info("SSL: Disabled")
+        logger.info("==============================")
 
-        # Try different SSL configurations
-        ssl_configs = [
-            {
-                'name': 'Standard SSL with cert validation',
-                'ssl': True,
-                'ssl_cert_reqs': 'required'
-            },
-            {
-                'name': 'SSL without cert validation',
-                'ssl': True,
-                'ssl_cert_reqs': None
-            },
-            {
-                'name': 'SSL with custom context',
-                'ssl': True,
-                'ssl_cert_reqs': ssl.CERT_REQUIRED,
-                'ssl_context': ssl.create_default_context()
-            }
-        ]
-
-        for i, config in enumerate(ssl_configs, 1):
-            logger.info(f"\n--- Trying SSL Configuration {i}: {config['name']} ---")
-            try:
-                redis_config = {
-                    'host': host,
-                    'port': port,
-                    'username': username,
-                    'password': password,
-                    'decode_responses': True,
-                    'socket_connect_timeout': 15,
-                    'socket_timeout': 15,
-                    'health_check_interval': 30,
-                    'retry_on_timeout': True
-                }
-                
-                # Add SSL configuration
-                redis_config.update({k: v for k, v in config.items() if k != 'name'})
-                
-                logger.info(f"Creating Redis client with config: {redis_config}")
-                self._redis_client = redis.Redis(**redis_config)
-                
-                logger.info("Attempting to ping Redis...")
-                result = self._redis_client.ping()
-                logger.info(f"Ping result: {result}")
-                
-                # Test set/get
-                logger.info("Testing set/get operations...")
-                self._redis_client.set('debug_test_key', 'debug_test_value')
-                value = self._redis_client.get('debug_test_key')
-                self._redis_client.delete('debug_test_key')
-                
-                if value == 'debug_test_value':
-                    logger.info("✅ Set/Get test successful!")
-                    logger.info(f"✅ Successfully connected with SSL configuration: {config['name']}")
-                    return
-                else:
-                    logger.warning("❌ Set/Get test failed")
-                    
-            except Exception as e:
-                logger.error(f"❌ Failed with SSL configuration {config['name']}: {e}")
-                logger.error(f"Error type: {type(e).__name__}")
-                import traceback
-                logger.error(f"Traceback: {traceback.format_exc()}")
-
-        # If all SSL configurations fail, try without SSL
-        logger.info("\n--- Trying without SSL as last resort ---")
         try:
+            logger.info("Creating Redis client without SSL...")
             self._redis_client = redis.Redis(
                 host=host,
                 port=port,
@@ -113,22 +47,31 @@ class RedisClient:
                 socket_timeout=15,
                 health_check_interval=30,
                 retry_on_timeout=True
-                # No SSL parameters
+                # NO SSL PARAMETERS
             )
             
+            logger.info("Attempting to ping Redis...")
             result = self._redis_client.ping()
-            logger.info(f"✅ Non-SSL connection successful! Ping result: {result}")
-            return
+            logger.info(f"✅ Ping successful: {result}")
+            
+            # Test set/get to ensure full functionality
+            logger.info("Testing set/get operations...")
+            self._redis_client.set('connection_test_key', 'connection_test_value')
+            value = self._redis_client.get('connection_test_key')
+            self._redis_client.delete('connection_test_key')
             
+            if value == 'connection_test_value':
+                logger.info("✅ Set/Get test successful!")
+                logger.info("🎉 Redis connection established successfully without SSL!")
+            else:
+                logger.warning("❌ Set/Get test failed")
+                
         except Exception as e:
-            logger.error(f"❌ Non-SSL connection also failed: {e}")
+            logger.error(f"❌ Redis connection failed: {e}")
             logger.error(f"Error type: {type(e).__name__}")
             import traceback
             logger.error(f"Traceback: {traceback.format_exc()}")
-
-        # If we get here, all connection attempts failed
-        logger.error("💥 All Redis connection attempts failed!")
-        self._redis_client = None
+            self._redis_client = None
 
     def get_client(self) -> Optional[redis.Redis]:
         """Get Redis client instance"""

test_hardcoded_redis.py

@@ -8,8 +8,8 @@ sys.path.append(str(project_root))
 from core.redis_client import redis_client
 
 def test_hardcoded_connection():
-    """Test Redis connection with new hardcoded configuration"""
-    print("Testing Redis connection with new hardcoded configuration...")
+    """Test Redis connection with new non-SSL configuration"""
+    print("Testing Redis connection with non-SSL configuration...")
     
     # Test the actual client being used
     print("\nTesting application Redis client...")
@@ -24,13 +24,13 @@ def test_hardcoded_connection():
         print("✅ Application Redis client ping successful")
         
         # Test set/get operations
-        client.set('new_database_test_key', 'new_database_test_value')
-        value = client.get('new_database_test_key')
-        client.delete('new_database_test_key')  # Cleanup
+        client.set('non_ssl_test_key', 'non_ssl_test_value')
+        value = client.get('non_ssl_test_key')
+        client.delete('non_ssl_test_key')  # Cleanup
         
-        if value == 'new_database_test_value':
+        if value == 'non_ssl_test_value':
             print("✅ Set/Get operations work correctly")
-            print("\n🎉 New Redis database connection test passed!")
+            print("\n🎉 Non-SSL Redis connection test passed!")
             return 0
         else:
             print("❌ Set/Get operations failed")