memorisdk 2.1.1__tar.gz → 2.3.0__tar.gz

{memorisdk-2.1.1/memorisdk.egg-info → memorisdk-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorisdk
-Version: 2.1.1
+Version: 2.3.0
 Summary: The Open-Source Memory Layer for AI Agents & Multi-Agent Systems
 Author-email: GibsonAI Team <noc@gibsonai.com>
 License: Apache-2.0
@@ -482,6 +482,7 @@ Memori works seamlessly with popular AI frameworks:
 | [Agno](./examples/integrations/agno_example.py) | Memory-enhanced agent framework integration with persistent conversations | Simple chat agent with memory search |
 | [AWS Strands](./examples/integrations/aws_strands_example.py) | Professional development coach with Strands SDK and persistent memory | Career coaching agent with goal tracking |
 | [Azure AI Foundry](./examples/integrations/azure_ai_foundry_example.py) | Azure AI Foundry agents with persistent memory across conversations | Enterprise AI agents with Azure integration |
+| [AutoGen](./examples/integrations/autogen_example.py) |  Multi-agent group chat memory recording | Agent chats with memory integration |
 | [CamelAI](./examples/integrations/camelai_example.py) | Multi-agent communication framework with automatic memory recording and retrieval | Memory-enhanced chat agents with conversation continuity |
 | [CrewAI](./examples/integrations/crewai_example.py) | Multi-agent system with shared memory across agent interactions | Collaborative agents with memory |
 | [Digital Ocean AI](./examples/integrations/digital_ocean_example.py) | Memory-enhanced customer support using Digital Ocean's AI platform | Customer support assistant with conversation history |

{memorisdk-2.1.1 → memorisdk-2.3.0}/README.md

@@ -385,6 +385,7 @@ Memori works seamlessly with popular AI frameworks:
 | [Agno](./examples/integrations/agno_example.py) | Memory-enhanced agent framework integration with persistent conversations | Simple chat agent with memory search |
 | [AWS Strands](./examples/integrations/aws_strands_example.py) | Professional development coach with Strands SDK and persistent memory | Career coaching agent with goal tracking |
 | [Azure AI Foundry](./examples/integrations/azure_ai_foundry_example.py) | Azure AI Foundry agents with persistent memory across conversations | Enterprise AI agents with Azure integration |
+| [AutoGen](./examples/integrations/autogen_example.py) |  Multi-agent group chat memory recording | Agent chats with memory integration |
 | [CamelAI](./examples/integrations/camelai_example.py) | Multi-agent communication framework with automatic memory recording and retrieval | Memory-enhanced chat agents with conversation continuity |
 | [CrewAI](./examples/integrations/crewai_example.py) | Multi-agent system with shared memory across agent interactions | Collaborative agents with memory |
 | [Digital Ocean AI](./examples/integrations/digital_ocean_example.py) | Memory-enhanced customer support using Digital Ocean's AI platform | Customer support assistant with conversation history |

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/__init__.py

@@ -5,7 +5,7 @@ Professional-grade memory layer with comprehensive error handling, configuration
 management, and modular architecture for production AI systems.
 """
 
-__version__ = "2.1.1"
+__version__ = "2.3.0"
 __author__ = "Harshal More"
 __email__ = "harshalmore2468@gmail.com"
 

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/agents/conscious_agent.py

@@ -116,7 +116,7 @@ class ConsciouscAgent:
             return False
 
     async def initialize_existing_conscious_memories(
-        self, db_manager, namespace: str = "default"
+        self, db_manager, namespace: str = "default", limit: int = 10
     ) -> bool:
         """
         Initialize by copying ALL existing conscious-info memories to short-term memory
@@ -143,16 +143,17 @@ class ConsciouscAgent:
                 from sqlalchemy import text
 
                 with db_manager._get_connection() as connection:
-                    # Get ALL conscious-info labeled memories from long-term memory
+                    # Get top conscious-info labeled memories from long-term memory (limited for performance)
                     cursor = connection.execute(
                         text(
                             """SELECT memory_id, processed_data, summary, searchable_content,
                                   importance_score, created_at
                            FROM long_term_memory
                            WHERE namespace = :namespace AND classification = 'conscious-info'
-                           ORDER BY importance_score DESC, created_at DESC"""
+                           ORDER BY importance_score DESC, created_at DESC
+                           LIMIT :limit"""
                         ),
-                        {"namespace": namespace},
+                        {"namespace": namespace, "limit": limit},
                     )
                     existing_conscious_memories = cursor.fetchall()
 

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/agents/memory_agent.py

@@ -237,17 +237,19 @@ CONVERSATION CONTEXT:
                 )
 
             logger.debug(
-                f"Processed conversation {chat_id}: "
-                f"classification={processed_memory.classification}, "
-                f"importance={processed_memory.importance}, "
-                f"conscious_context={processed_memory.is_user_context}, "
-                f"promotion_eligible={processed_memory.promotion_eligible}"
+                f"[AGENT] Processed conversation {chat_id[:8]}... - "
+                f"classification: {processed_memory.classification.value} | "
+                f"importance: {processed_memory.importance.value} | "
+                f"conscious_context: {processed_memory.is_user_context} | "
+                f"promotion_eligible: {processed_memory.promotion_eligible}"
             )
 
             return processed_memory
 
         except Exception as e:
-            logger.error(f"Memory agent processing failed for {chat_id}: {e}")
+            logger.error(
+                f"[AGENT] Memory processing failed for {chat_id[:8]}... - {type(e).__name__}: {e}"
+            )
             return self._create_empty_long_term_memory(
                 chat_id, f"Processing failed: {str(e)}"
             )
@@ -307,7 +309,7 @@ CONVERSATION CONTEXT:
 
             if avg_similarity >= similarity_threshold:
                 logger.info(
-                    f"Duplicate detected: {avg_similarity:.2f} similarity with {existing.conversation_id}"
+                    f"[AGENT] Duplicate detected - {avg_similarity:.2f} similarity with {existing.conversation_id[:8]}..."
                 )
                 return existing.conversation_id
 

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/agents/retrieval_agent.py

@@ -218,15 +218,25 @@ Be strategic and comprehensive in your search planning."""
             all_results = []
             seen_memory_ids = set()
 
-            # For MongoDB and SQL, use the unified search_memories method as primary strategy
-            # This ensures we use the database's native search capabilities
-            logger.debug(f"Executing unified database search using {db_type} manager")
-            primary_results = db_manager.search_memories(
-                query=search_plan.query_text or query, namespace=namespace, limit=limit
-            )
-            logger.debug(
-                f"Primary database search returned {len(primary_results)} results"
-            )
+            # For MongoDB and SQL, use SearchService directly to avoid recursion
+            # This ensures we use the database's native search capabilities without triggering context injection
+            logger.debug(f"Executing direct SearchService search using {db_type}")
+            try:
+                from ..database.search_service import SearchService
+
+                with db_manager.SessionLocal() as session:
+                    search_service = SearchService(session, db_type)
+                    primary_results = search_service.search_memories(
+                        query=search_plan.query_text or query,
+                        namespace=namespace,
+                        limit=limit,
+                    )
+                logger.debug(
+                    f"Direct SearchService returned {len(primary_results)} results"
+                )
+            except Exception as e:
+                logger.error(f"SearchService direct access failed: {e}")
+                primary_results = []
 
             # Process primary results and add search metadata
             for result in primary_results:
@@ -383,9 +393,17 @@ Be strategic and comprehensive in your search planning."""
 
         search_terms = " ".join(keywords)
         try:
-            results = db_manager.search_memories(
-                query=search_terms, namespace=namespace, limit=limit
-            )
+            # Use SearchService directly to avoid recursion
+            from ..database.search_service import SearchService
+
+            db_type = self._detect_database_type(db_manager)
+
+            with db_manager.SessionLocal() as session:
+                search_service = SearchService(session, db_type)
+                results = search_service.search_memories(
+                    query=search_terms, namespace=namespace, limit=limit
+                )
+
             # Ensure results is a list of dictionaries
             if not isinstance(results, list):
                 logger.warning(f"Search returned non-list result: {type(results)}")
@@ -417,14 +435,24 @@ Be strategic and comprehensive in your search planning."""
         if not categories:
             return []
 
-        # This would need to be implemented in the database manager
-        # For now, get all memories and filter by category
+        # Use SearchService directly to avoid recursion
+        # Get all memories and filter by category
         logger.debug(
             f"Searching memories by categories: {categories} in namespace: {namespace}"
         )
-        all_results = db_manager.search_memories(
-            query="", namespace=namespace, limit=limit * 3
-        )
+        try:
+            from ..database.search_service import SearchService
+
+            db_type = self._detect_database_type(db_manager)
+
+            with db_manager.SessionLocal() as session:
+                search_service = SearchService(session, db_type)
+                all_results = search_service.search_memories(
+                    query="", namespace=namespace, limit=limit * 3
+                )
+        except Exception as e:
+            logger.error(f"Category search failed: {e}")
+            all_results = []
 
         logger.debug(
             f"Retrieved {len(all_results)} total results for category filtering"

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/core/conversation.py

@@ -207,7 +207,7 @@ class ConversationManager:
             elif mode == "auto":
                 # Auto mode: Search long-term memory database for relevant context
                 logger.debug(
-                    f"Auto-ingest: Processing user input for long-term memory search: '{user_input[:50]}...'"
+                    f"[CONTEXT] Auto-ingest processing - Query: '{user_input[:50]}...' | Session: {session_id[:8]}..."
                 )
                 context = (
                     memori_instance._get_auto_ingest_context(user_input)
@@ -217,11 +217,11 @@ class ConversationManager:
                 if context:
                     context_prompt = self._build_auto_context_prompt(context)
                     logger.debug(
-                        f"Auto-ingest: Successfully injected long-term memory context with {len(context)} items for session {session_id}"
+                        f"[CONTEXT] Long-term memory injected - {len(context)} items | Session: {session_id[:8]}..."
                     )
                 else:
                     logger.debug(
-                        f"Auto-ingest: No relevant memories found in long-term database for query '{user_input[:50]}...' in session {session_id}"
+                        f"[CONTEXT] No relevant memories found for '{user_input[:30]}...' | Session: {session_id[:8]}..."
                     )
 
             # Get conversation history
@@ -246,7 +246,7 @@ class ConversationManager:
                         system_content += f"{role_label}: {msg['content']}\n"
                     system_content += "--- End History ---\n"
                     logger.debug(
-                        f"Added {len(previous_messages)} history messages for session {session_id}"
+                        f"[CONTEXT] Added {len(previous_messages)} history messages | Session: {session_id[:8]}..."
                     )
 
             # Find existing system message or create new one
@@ -267,16 +267,17 @@ class ConversationManager:
                     0, {"role": "system", "content": system_content}
                 )
 
+            context_status = "yes" if context_prompt else "no"
+            history_status = "yes" if len(history_messages) > 1 else "no"
             logger.debug(
-                f"Enhanced messages for session {session_id}: context={'yes' if context_prompt else 'no'}, "
-                f"history={'yes' if len(history_messages) > 1 else 'no'}"
+                f"[CONTEXT] Enhanced messages for session {session_id[:8]}... - context: {context_status} | history: {history_status}"
             )
 
             return enhanced_messages
 
         except Exception as e:
             logger.error(
-                f"Failed to inject context with history for session {session_id}: {e}"
+                f"[CONTEXT] Failed to inject context for session {session_id[:8]}... - {type(e).__name__}: {e}"
             )
             return messages
 

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/core/memory.py

@@ -3,6 +3,7 @@ Main Memori class - Pydantic-based memory interface v1.0
 """
 
 import asyncio
+import threading
 import time
 import uuid
 from datetime import datetime
@@ -65,6 +66,7 @@ class Memori:
         schema_init: bool = True,  # Initialize database schema and create tables
         database_prefix: str | None = None,  # Database name prefix
         database_suffix: str | None = None,  # Database name suffix
+        conscious_memory_limit: int = 10,  # Limit for conscious memory processing
     ):
         """
         Initialize Memori memory system v1.0.
@@ -109,6 +111,14 @@ class Memori:
         self.schema_init = schema_init
         self.database_prefix = database_prefix
         self.database_suffix = database_suffix
+        # Validate conscious_memory_limit parameter
+        if not isinstance(conscious_memory_limit, int) or conscious_memory_limit < 1:
+            raise ValueError("conscious_memory_limit must be a positive integer")
+
+        self.conscious_memory_limit = conscious_memory_limit
+
+        # Thread safety for conscious memory initialization
+        self._conscious_init_lock = threading.RLock()
 
         # Configure provider based on explicit settings ONLY - no auto-detection
         if provider_config:
@@ -452,7 +462,7 @@ class Memori:
                 )
                 init_success = (
                     await self.conscious_agent.initialize_existing_conscious_memories(
-                        self.db_manager, self.namespace
+                        self.db_manager, self.namespace, self.conscious_memory_limit
                     )
                 )
                 if init_success:
@@ -478,52 +488,104 @@ class Memori:
 
     def _run_synchronous_conscious_initialization(self):
         """Run conscious agent initialization synchronously (when no event loop is available)"""
-        try:
-            if not self.conscious_agent:
-                return
+        with self._conscious_init_lock:
+            try:
+                if not self.conscious_agent:
+                    return
 
-            # If both auto_ingest and conscious_ingest are enabled,
-            # initialize by copying ALL existing conscious-info memories first
-            if self.auto_ingest and self.conscious_ingest:
-                logger.info(
-                    "Conscious-ingest: Both auto_ingest and conscious_ingest enabled - initializing existing conscious memories"
-                )
+                # Check if we've already initialized in this session to avoid repeated work
+                # Use namespace-specific key to prevent conflicts between instances
+                init_key = f"_conscious_initialized_{self.namespace or 'default'}"
+                if hasattr(self, init_key) and getattr(self, init_key):
+                    logger.debug(
+                        f"[CONSCIOUS] Already initialized for namespace '{self.namespace or 'default'}', skipping"
+                    )
+                    return
 
-                # Run synchronous initialization of existing memories
-                self._initialize_existing_conscious_memories_sync()
+                # If both auto_ingest and conscious_ingest are enabled,
+                # initialize by copying the most important existing conscious-info memories first
+                if self.auto_ingest and self.conscious_ingest:
+                    logger.info(
+                        "[CONSCIOUS] Both auto_ingest and conscious_ingest enabled - initializing existing conscious memories"
+                    )
 
-            logger.debug(
-                "Conscious-ingest: Synchronous conscious context extraction completed"
-            )
+                    # Run optimized synchronous initialization of existing memories
+                    import time
 
-        except Exception as e:
-            logger.error(f"Synchronous conscious agent initialization failed: {e}")
+                    start_time = time.time()
+
+                    initialized = self._initialize_existing_conscious_memories_sync()
+
+                    elapsed = time.time() - start_time
+                    if initialized:
+                        logger.debug(
+                            f"[CONSCIOUS] Initialization completed in {elapsed:.2f}s"
+                        )
+                    else:
+                        logger.debug(
+                            f"[CONSCIOUS] Initialization skipped (no work needed) in {elapsed:.2f}s"
+                        )
+
+                # Mark as initialized to avoid repeated work for this specific namespace
+                init_key = f"_conscious_initialized_{self.namespace or 'default'}"
+                setattr(self, init_key, True)
+
+                logger.debug(
+                    "[CONSCIOUS] Synchronous conscious context extraction completed"
+                )
+
+            except Exception as e:
+                logger.error(f"Synchronous conscious agent initialization failed: {e}")
 
     def _initialize_existing_conscious_memories_sync(self):
-        """Synchronously initialize existing conscious-info memories"""
+        """Synchronously initialize existing conscious-info memories with optimization"""
         try:
             from sqlalchemy import text
 
             with self.db_manager._get_connection() as connection:
-                # Get ALL conscious-info labeled memories from long-term memory
+                # First, check if we already have conscious memories in short-term storage
+                existing_short_term = connection.execute(
+                    text(
+                        """SELECT COUNT(*) FROM short_term_memory
+                           WHERE namespace = :namespace
+                           AND (category_primary = 'conscious_context' OR memory_id LIKE 'conscious_%')"""
+                    ),
+                    {"namespace": self.namespace or "default"},
+                ).scalar()
+
+                if existing_short_term > 0:
+                    logger.debug(
+                        f"[CONSCIOUS] {existing_short_term} conscious memories already in short-term storage, skipping initialization"
+                    )
+                    return False
+
+                # Get only the most important conscious-info memories (limit to 10 for performance)
                 cursor = connection.execute(
                     text(
                         """SELECT memory_id, processed_data, summary, searchable_content,
                               importance_score, created_at
                        FROM long_term_memory
                        WHERE namespace = :namespace AND classification = 'conscious-info'
-                       ORDER BY importance_score DESC, created_at DESC"""
+                       ORDER BY importance_score DESC, created_at DESC
+                       LIMIT :limit"""
                     ),
-                    {"namespace": self.namespace or "default"},
+                    {
+                        "namespace": self.namespace or "default",
+                        "limit": self.conscious_memory_limit,
+                    },
                 )
                 existing_conscious_memories = cursor.fetchall()
 
             if not existing_conscious_memories:
                 logger.debug(
-                    "Conscious-ingest: No existing conscious-info memories found for initialization"
+                    "[CONSCIOUS] No conscious-info memories found for initialization"
                 )
                 return False
 
+            # Batch process memories for efficiency
+            logger.debug(
+                f"[CONSCIOUS] Processing {len(existing_conscious_memories)} conscious memories..."
+            )
             copied_count = 0
             for memory_row in existing_conscious_memories:
                 success = self._copy_memory_to_short_term_sync(memory_row)
@@ -532,12 +594,12 @@ class Memori:
 
             if copied_count > 0:
                 logger.info(
-                    f"Conscious-ingest: Initialized {copied_count} existing conscious-info memories to short-term memory"
+                    f"[CONSCIOUS] Initialized {copied_count} conscious memories to short-term storage"
                 )
                 return True
             else:
                 logger.debug(
-                    "Conscious-ingest: No new conscious memories to initialize (all were duplicates)"
+                    "[CONSCIOUS] No new conscious memories to initialize (all were duplicates)"
                 )
                 return False
 
@@ -564,26 +626,25 @@ class Memori:
             from sqlalchemy import text
 
             with self.db_manager._get_connection() as connection:
-                # Check if similar content already exists in short-term memory
+                # Database-agnostic duplicate check with safer pattern matching
                 existing_check = connection.execute(
                     text(
                         """SELECT COUNT(*) FROM short_term_memory
                            WHERE namespace = :namespace
-                           AND category_primary = 'conscious_context'
-                           AND (searchable_content = :searchable_content
-                                OR summary = :summary)"""
+                           AND (memory_id = :exact_id
+                               OR memory_id LIKE :conscious_pattern)"""
                     ),
                     {
                         "namespace": self.namespace or "default",
-                        "searchable_content": searchable_content,
-                        "summary": summary,
+                        "exact_id": memory_id,
+                        "conscious_pattern": f"conscious_{memory_id}_%",
                     },
                 )
 
                 existing_count = existing_check.scalar()
                 if existing_count > 0:
                     logger.debug(
-                        f"Conscious-ingest: Skipping duplicate memory {memory_id} - similar content already exists in short-term memory"
+                        f"[CONSCIOUS] Skipping duplicate memory {memory_id[:8]}... - already exists in short-term memory"
                     )
                     return False
 
@@ -1892,7 +1953,7 @@ class Memori:
 
         # Debug logging for conversation recording
         logger.info(
-            f"Recording conversation - Input: '{user_input[:100]}...' Model: {model}"
+            f"[MEMORY] Recording conversation - Input: '{user_input[:60]}...' | Model: {model} | Session: {self.session_id[:8]}..."
         )
 
         # Parse response
@@ -1915,29 +1976,31 @@ class Memori:
                 namespace=self.namespace,
                 metadata=metadata or {},
             )
-            logger.debug(
-                f"Successfully stored chat history for conversation: {chat_id}"
-            )
+            logger.debug(f"[MEMORY] Chat history stored - ID: {chat_id[:8]}...")
 
             # Always process into long-term memory when memory agent is available
             if self.memory_agent:
                 self._schedule_memory_processing(
                     chat_id, user_input, response_text, response_model
                 )
-                logger.debug(f"Scheduled memory processing for conversation: {chat_id}")
+                logger.debug(f"[MEMORY] Processing scheduled - ID: {chat_id[:8]}...")
             else:
                 logger.warning(
-                    f"Memory agent not available, skipping memory processing for: {chat_id}"
+                    f"[MEMORY] Agent unavailable, skipping processing - ID: {chat_id[:8]}..."
                 )
 
-            logger.info(f"Recorded conversation successfully: {chat_id}")
+            logger.info(
+                f"[MEMORY] Conversation recorded successfully - ID: {chat_id[:8]}..."
+            )
             return chat_id
 
         except Exception as e:
-            logger.error(f"Failed to record conversation {chat_id}: {e}")
+            logger.error(
+                f"[MEMORY] Failed to record conversation {chat_id[:8]}... - {type(e).__name__}: {e}"
+            )
             import traceback
 
-            logger.error(f"Recording error details: {traceback.format_exc()}")
+            logger.debug(f"[MEMORY] Recording error details: {traceback.format_exc()}")
             raise
 
     def _schedule_memory_processing(

{memorisdk-2.1.1 → memorisdk-2.3.0}/memori/database/auto_creator.py

@@ -28,6 +28,21 @@ class DatabaseAutoCreator:
         self.schema_init = schema_init
         self.utils = DatabaseConnectionUtils()
 
+    def _is_gibsonai_temp_connection(self, components: dict[str, str] | None) -> bool:
+        """Detect GibsonAI temporary database credentials to avoid noisy warnings."""
+        if not components:
+            return False
+
+        host = (components.get("host") or "").lower()
+        if "gibsonai.com" not in host:
+            return False
+
+        user = components.get("user") or components.get("username") or ""
+        database = components.get("database") or ""
+
+        # GibsonAI temporary credentials follow predictable us_/db_ prefixes
+        return user.startswith("us_") or database.startswith("db_")
+
     def ensure_database_exists(self, connection_string: str) -> str:
         """
         Ensure target database exists, creating it if necessary.
@@ -45,6 +60,7 @@ class DatabaseAutoCreator:
             logger.debug("Auto-creation disabled, using original connection string")
             return connection_string
 
+        components = None
         try:
             # Parse connection string
             components = self.utils.parse_connection_string(connection_string)
@@ -56,6 +72,13 @@ class DatabaseAutoCreator:
                 )
                 return connection_string
 
+            # Skip noisy warnings for managed GibsonAI temporary databases
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_SETUP] GibsonAI managed database detected - skipping auto-creation checks"
+                )
+                return connection_string
+
             # Validate database name
             if not self.utils.validate_database_name(components["database"]):
                 raise ValueError(f"Invalid database name: {components['database']}")
@@ -70,10 +93,39 @@ class DatabaseAutoCreator:
             logger.info(f"Successfully created database '{components['database']}'")
             return connection_string
 
+        except PermissionError as e:
+            if components and self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_SETUP] GibsonAI managed database does not allow auto-creation (permission denied)"
+                )
+                return connection_string
+
+            logger.error(f"[DB_SETUP] Permission denied - {e}")
+            if components:
+                logger.warning(
+                    f"[DB_SETUP] Database '{components['database']}' may need manual creation with proper permissions"
+                )
+            else:
+                logger.warning(
+                    "[DB_SETUP] Database may need manual creation with proper permissions"
+                )
+            return connection_string
+        except RuntimeError as e:
+            logger.error(f"[DB_SETUP] Database creation error - {e}")
+            logger.info(
+                "[DB_SETUP] Proceeding with original connection string, database may need manual setup"
+            )
+            return connection_string
         except Exception as e:
-            logger.error(f"Database auto-creation failed: {e}")
-            # Don't raise exception - let the original connection attempt proceed
-            # This allows graceful degradation if user has manual setup
+            logger.error(
+                f"[DB_SETUP] Unexpected database auto-creation failure - {type(e).__name__}: {e}"
+            )
+            if components:
+                logger.debug(
+                    f"[DB_SETUP] Connection string: {components['engine']}://{components['host']}:{components['port']}/{components['database']}"
+                )
+            else:
+                logger.debug(f"[DB_SETUP] Connection string: {connection_string}")
             return connection_string
 
     def _database_exists(self, components: dict[str, str]) -> bool:
@@ -90,7 +142,12 @@ class DatabaseAutoCreator:
                 return False
 
         except Exception as e:
-            logger.error(f"Failed to check database existence: {e}")
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    "[DB_CONNECTION] Skipping GibsonAI database existence check due to restricted permissions"
+                )
+            else:
+                logger.error(f"Failed to check database existence: {e}")
             return False
 
     def _postgresql_database_exists(self, components: dict[str, str]) -> bool:
@@ -176,7 +233,17 @@ class DatabaseAutoCreator:
                 logger.error(error_msg)
             return False
         except Exception as e:
-            logger.error(f"MySQL database existence check failed: {e}")
+            if self._is_gibsonai_temp_connection(components):
+                logger.debug(
+                    f"[DB_CONNECTION] GibsonAI existence check bypassed for '{components['database']}' ({e})"
+                )
+            else:
+                logger.error(
+                    f"[DB_CONNECTION] MySQL database existence check failed for '{components['database']}': {e}"
+                )
+                logger.debug(
+                    f"[DB_CONNECTION] Connection details - host: {components.get('host')}, port: {components.get('port')}, user: {components.get('user') or components.get('username')}"
+                )
             return False
 
     def _create_database(self, components: dict[str, str]) -> None: