memorisdk 2.1.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

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.0"
+__version__ = "2.1.1"
 __author__ = "Harshal More"
 __email__ = "harshalmore2468@gmail.com"
 

memori/database/connectors/mongodb_connector.py

@@ -24,9 +24,9 @@ try:
     from pymongo.errors import ConnectionFailure, OperationFailure  # noqa: F401
 
     PYMONGO_AVAILABLE = True
-    MongoClient = _MongoClient
-    Collection = _Collection
-    Database = _Database
+    MongoClient = _MongoClient  # type: ignore
+    Collection = _Collection  # type: ignore
+    Database = _Database  # type: ignore
 except ImportError:
     PYMONGO_AVAILABLE = False
     MongoClient = None  # type: ignore
@@ -72,21 +72,86 @@ class MongoDBConnector(BaseDatabaseConnector):
     def _parse_connection_string(self):
         """Parse MongoDB connection string to extract components"""
         try:
-            parsed = urlparse(self.connection_string)
-            self.host = parsed.hostname or "localhost"
-            self.port = parsed.port or 27017
-            self.database_name = parsed.path.lstrip("/") or "memori"
-            self.username = parsed.username
-            self.password = parsed.password
-
-            # Extract query parameters
-            self.options = {}
-            if parsed.query:
-                params = parsed.query.split("&")
-                for param in params:
-                    if "=" in param:
-                        key, value = param.split("=", 1)
-                        self.options[key] = value
+            # Handle MongoDB connection strings properly (including replica sets)
+            if self.connection_string.startswith(
+                "mongodb://"
+            ) or self.connection_string.startswith("mongodb+srv://"):
+                # For MongoDB URIs, extract database name and basic info for logging
+                # but let pymongo handle the full parsing
+                if "?" in self.connection_string:
+                    uri_part, query_part = self.connection_string.split("?", 1)
+                else:
+                    uri_part, query_part = self.connection_string, ""
+
+                # Extract database name from path
+                if "/" in uri_part:
+                    path_part = uri_part.split("/")[-1]
+                    self.database_name = path_part if path_part else "memori"
+                else:
+                    self.database_name = "memori"
+
+                # Extract host info for logging
+                is_srv_uri = self.connection_string.startswith("mongodb+srv://")
+
+                if is_srv_uri:
+                    # For SRV URIs, extract the service hostname
+                    if "@" in uri_part:
+                        srv_host = uri_part.split("@")[1].split("/")[0].split("?")[0]
+                    else:
+                        srv_host = (
+                            uri_part.replace("mongodb+srv://", "")
+                            .split("/")[0]
+                            .split("?")[0]
+                        )
+                    self.host = srv_host
+                    self.port = (
+                        27017  # SRV uses default port, actual ports resolved via DNS
+                    )
+                else:
+                    # Regular mongodb:// URI parsing
+                    if "@" in uri_part:
+                        host_part = uri_part.split("@")[1]
+                    else:
+                        host_part = uri_part.replace("mongodb://", "")
+
+                    # Get first host for logging purposes
+                    if "," in host_part:
+                        first_host = host_part.split(",")[0].split("/")[0]
+                    else:
+                        first_host = host_part.split("/")[0]
+
+                    if ":" in first_host:
+                        self.host, port_str = first_host.split(":", 1)
+                        try:
+                            self.port = int(port_str)
+                        except ValueError:
+                            self.port = 27017
+                    else:
+                        self.host = first_host
+                        self.port = 27017
+
+                # Extract auth info
+                parsed = urlparse(self.connection_string)
+                self.username = parsed.username
+                self.password = parsed.password
+
+                # Extract query parameters
+                self.options = {}
+                if query_part:
+                    params = query_part.split("&")
+                    for param in params:
+                        if "=" in param:
+                            key, value = param.split("=", 1)
+                            self.options[key] = value
+            else:
+                # Fall back to urlparse for simple connection strings
+                parsed = urlparse(self.connection_string)
+                self.host = parsed.hostname or "localhost"
+                self.port = parsed.port or 27017
+                self.database_name = parsed.path.lstrip("/") or "memori"
+                self.username = parsed.username
+                self.password = parsed.password
+                self.options = {}
 
         except Exception as e:
             logger.warning(f"Failed to parse MongoDB connection string: {e}")
@@ -99,7 +164,7 @@ class MongoDBConnector(BaseDatabaseConnector):
             self.options = {}
 
     def get_connection(self) -> MongoClient:
-        """Get MongoDB client connection"""
+        """Get MongoDB client connection with support for mongodb+srv DNS seedlist"""
         if self.client is None:
             try:
                 # Create MongoDB client with appropriate options
@@ -111,14 +176,76 @@ class MongoDBConnector(BaseDatabaseConnector):
                     "retryWrites": True,  # Enable retryable writes
                 }
 
-                # Add any additional options from connection string
+                # Special handling for mongodb+srv URIs
+                is_srv_uri = self.connection_string.startswith("mongodb+srv://")
+
+                if is_srv_uri:
+                    # For mongodb+srv URIs, TLS is automatically enabled
+                    # Don't set directConnection for SRV URIs as they use DNS seedlist discovery
+                    logger.info(
+                        "Using MongoDB Atlas DNS seedlist discovery (mongodb+srv)"
+                    )
+
+                    # Add modern SRV-specific options for 2025
+                    srv_options = {
+                        "srvMaxHosts": 0,  # No limit on SRV hosts (default)
+                        "srvServiceName": "mongodb",  # Default service name
+                    }
+                    client_options.update(srv_options)
+                else:
+                    # For standard mongodb:// URIs
+                    # Handle replica sets vs single hosts
+                    if "replicaSet" in self.options:
+                        logger.info("Using MongoDB replica set connection")
+                    elif "," in self.connection_string:
+                        logger.info("Using MongoDB multiple host connection")
+                    else:
+                        logger.info("Using MongoDB single host connection")
+
+                # Add any additional options from connection string (these override defaults)
                 client_options.update(self.options)
 
+                # Never set directConnection for SRV URIs or replica sets
+                if is_srv_uri or "replicaSet" in self.options:
+                    client_options.pop("directConnection", None)
+
+                logger.debug(f"MongoDB connection options: {client_options}")
                 self.client = MongoClient(self.connection_string, **client_options)
 
-                # Test connection
+                # Test connection with more detailed logging
                 self.client.admin.command("ping")
-                logger.info(f"Connected to MongoDB at {self.host}:{self.port}")
+
+                # Get server info for better logging
+                try:
+                    server_info = self.client.server_info()
+                    version = server_info.get("version", "unknown")
+                    logger.info(
+                        f"Connected to MongoDB {version} at {self.host}:{self.port}"
+                    )
+
+                    if is_srv_uri:
+                        # Log DNS-resolved hosts for SRV connections
+                        topology = self.client.topology_description
+                        hosts = []
+                        for server in topology.server_descriptions():
+                            if hasattr(server, "address") and server.address:
+                                if (
+                                    isinstance(server.address, tuple)
+                                    and len(server.address) >= 2
+                                ):
+                                    hosts.append(
+                                        f"{server.address[0]}:{server.address[1]}"
+                                    )
+                                else:
+                                    hosts.append(str(server.address))
+
+                        if hosts:
+                            logger.info(f"DNS resolved hosts: {', '.join(hosts)}")
+                        else:
+                            logger.info("DNS seedlist discovery completed successfully")
+                except Exception as e:
+                    logger.warning(f"Could not get server info: {e}")
+                    logger.info(f"Connected to MongoDB at {self.host}:{self.port}")
 
             except Exception as e:
                 raise DatabaseError(f"Failed to connect to MongoDB: {e}")

memori/database/mongodb_manager.py

@@ -31,9 +31,9 @@ try:
     )
 
     PYMONGO_AVAILABLE = True
-    MongoClient = _MongoClient
-    Collection = _Collection
-    Database = _Database
+    MongoClient = _MongoClient  # type: ignore
+    Collection = _Collection  # type: ignore
+    Database = _Database  # type: ignore
 except ImportError:
     PYMONGO_AVAILABLE = False
     MongoClient = None  # type: ignore
@@ -92,20 +92,27 @@ class MongoDBDatabaseManager:
             # Handle both mongodb:// and mongodb+srv:// schemes
             parsed = urlparse(self.database_connect)
 
-            # Extract host - ensure it's a proper hostname/IP
+            # Extract host - handle SRV URIs differently
             hostname = parsed.hostname
-            if hostname and hostname != "localhost":
-                # Check if it's a valid hostname/IP, if not fall back to localhost
-                import socket
+            is_srv_uri = self.database_connect.startswith("mongodb+srv://")
 
-                try:
-                    socket.gethostbyname(hostname)
+            if hostname and hostname != "localhost":
+                if is_srv_uri:
+                    # For SRV URIs, don't try to resolve hostname directly
+                    # PyMongo will handle SRV resolution internally
                     self.host = hostname
-                except socket.gaierror:
-                    logger.warning(
-                        f"Cannot resolve hostname '{hostname}', falling back to localhost"
-                    )
-                    self.host = "localhost"
+                else:
+                    # For regular mongodb:// URIs, check hostname resolution
+                    import socket
+
+                    try:
+                        socket.gethostbyname(hostname)
+                        self.host = hostname
+                    except socket.gaierror:
+                        logger.warning(
+                            f"Cannot resolve hostname '{hostname}', falling back to localhost"
+                        )
+                        self.host = "localhost"
             else:
                 self.host = hostname or "localhost"
 
@@ -138,7 +145,7 @@ class MongoDBDatabaseManager:
             self.options = {}
 
     def _get_client(self) -> MongoClient:
-        """Get MongoDB client connection with caching and fallbacks"""
+        """Get MongoDB client connection with support for mongodb+srv DNS seedlist"""
         if self.client is None:
             try:
                 # Create MongoDB client with appropriate options
@@ -148,33 +155,108 @@ class MongoDBDatabaseManager:
                     "socketTimeoutMS": 10000,  # 10 second socket timeout
                     "maxPoolSize": 50,  # Connection pool size
                     "retryWrites": True,  # Enable retryable writes
-                    "directConnection": True,  # Direct connection to avoid replica set issues
                 }
 
-                # Add any additional options from connection string
-                client_options.update(self.options)
+                # Check if this is a mongodb+srv URI for DNS seedlist discovery
+                is_srv_uri = self.database_connect.startswith("mongodb+srv://")
 
-                # Try original connection string first
-                try:
+                if is_srv_uri:
+                    logger.info(
+                        "Using MongoDB Atlas DNS seedlist discovery (mongodb+srv)"
+                    )
+
+                    # Add modern SRV-specific options for 2025
+                    srv_options = {
+                        "srvMaxHosts": 0,  # No limit on SRV hosts (default)
+                        "srvServiceName": "mongodb",  # Default service name
+                    }
+                    client_options.update(srv_options)
+
+                    # For SRV URIs, don't use fallback - they handle discovery automatically
+                    # Add any additional options from connection string (these override defaults)
+                    client_options.update(self.options)
+
+                    # Never set directConnection for SRV URIs
+                    client_options.pop("directConnection", None)
+
+                    logger.debug(f"MongoDB+SRV connection options: {client_options}")
                     self.client = MongoClient(self.database_connect, **client_options)
+
                     # Test connection
                     self.client.admin.command("ping")
-                    logger.info("Connected to MongoDB using original connection string")
-                except Exception as original_error:
-                    logger.warning(f"Original connection failed: {original_error}")
 
-                    # Try fallback with explicit host:port
-                    fallback_uri = (
-                        f"mongodb://{self.host}:{self.port}/{self.database_name}"
-                    )
-                    logger.info(f"Trying fallback connection: {fallback_uri}")
+                    # Get server info and DNS-resolved hosts for better logging
+                    try:
+                        server_info = self.client.server_info()
+                        version = server_info.get("version", "unknown")
+                        logger.info(f"Connected to MongoDB Atlas {version}")
+
+                        # Log DNS-resolved hosts for SRV connections
+                        try:
+                            topology = self.client.topology_description
+                            hosts = []
+                            for server in topology.server_descriptions():
+                                try:
+                                    if hasattr(server, "address") and server.address:
+                                        if (
+                                            isinstance(server.address, tuple)
+                                            and len(server.address) >= 2
+                                        ):
+                                            hosts.append(
+                                                f"{server.address[0]}:{server.address[1]}"
+                                            )
+                                        else:
+                                            hosts.append(str(server.address))
+                                except AttributeError:
+                                    # Some server descriptions might not have address attribute
+                                    continue
+
+                            if hosts:
+                                logger.info(
+                                    f"DNS resolved MongoDB Atlas hosts: {', '.join(hosts)}"
+                                )
+                            else:
+                                logger.info(
+                                    "MongoDB Atlas DNS seedlist discovery completed successfully"
+                                )
+                        except Exception as e:
+                            logger.debug(
+                                f"Could not get Atlas server topology info: {e}"
+                            )
+                    except Exception as e:
+                        logger.warning(f"Could not get Atlas server info: {e}")
+                        logger.info("Connected to MongoDB Atlas successfully")
 
-                    self.client = MongoClient(fallback_uri, **client_options)
-                    # Test connection
-                    self.client.admin.command("ping")
-                    logger.info(
-                        f"Connected to MongoDB at {self.host}:{self.port}/{self.database_name}"
-                    )
+                else:
+                    # Legacy mongodb:// URI handling with fallbacks
+                    # Add any additional options from connection string
+                    client_options.update(self.options)
+
+                    # Try original connection string first
+                    try:
+                        self.client = MongoClient(
+                            self.database_connect, **client_options
+                        )
+                        # Test connection
+                        self.client.admin.command("ping")
+                        logger.info(
+                            "Connected to MongoDB using original connection string"
+                        )
+                    except Exception as original_error:
+                        logger.warning(f"Original connection failed: {original_error}")
+
+                        # Try fallback with explicit host:port (only for non-SRV URIs)
+                        fallback_uri = (
+                            f"mongodb://{self.host}:{self.port}/{self.database_name}"
+                        )
+                        logger.info(f"Trying fallback connection: {fallback_uri}")
+
+                        self.client = MongoClient(fallback_uri, **client_options)
+                        # Test connection
+                        self.client.admin.command("ping")
+                        logger.info(
+                            f"Connected to MongoDB at {self.host}:{self.port}/{self.database_name}"
+                        )
 
             except Exception as e:
                 error_msg = f"Failed to connect to MongoDB: {e}"

{memorisdk-2.1.0.dist-info → memorisdk-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorisdk
-Version: 2.1.0
+Version: 2.1.1
 Summary: The Open-Source Memory Layer for AI Agents & Multi-Agent Systems
 Author-email: GibsonAI Team <noc@gibsonai.com>
 License: Apache-2.0
@@ -53,11 +53,11 @@ Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgres"
 Provides-Extra: mysql
 Requires-Dist: PyMySQL>=1.0.0; extra == "mysql"
 Provides-Extra: mongodb
-Requires-Dist: pymongo>=4.0.0; extra == "mongodb"
+Requires-Dist: pymongo[srv]>=4.0.0; extra == "mongodb"
 Provides-Extra: databases
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "databases"
 Requires-Dist: PyMySQL>=1.0.0; extra == "databases"
-Requires-Dist: pymongo>=4.0.0; extra == "databases"
+Requires-Dist: pymongo[srv]>=4.0.0; extra == "databases"
 Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.3.0; extra == "anthropic"
 Provides-Extra: litellm
@@ -87,6 +87,7 @@ Requires-Dist: mkdocs-minify-plugin>=0.7.0; extra == "all"
 Requires-Dist: mkdocs-redirects>=1.2.0; extra == "all"
 Requires-Dist: psycopg2-binary>=2.9.0; extra == "all"
 Requires-Dist: PyMySQL>=1.0.0; extra == "all"
+Requires-Dist: pymongo[srv]>=4.0.0; extra == "all"
 Requires-Dist: litellm>=1.0.0; extra == "all"
 Requires-Dist: anthropic>=0.3.0; extra == "all"
 Requires-Dist: streamlit>=1.28.0; extra == "all"

{memorisdk-2.1.0.dist-info → memorisdk-2.1.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-memori/__init__.py,sha256=cwAJcWkWX1bbulI3oQK512OSd7mv_0wEAhzwE3OWUYo,3670
+memori/__init__.py,sha256=u5Y2fGofYR3hZwRLN0lwu24iVztgmDLk0JGZfwhSjW8,3670
 memori/agents/__init__.py,sha256=9M3IG5R10FfVgT8tUzBZ2pZ0SypSpYkFfhtyvMyeTpE,261
 memori/agents/conscious_agent.py,sha256=x3MFps2BSIt9CubjwFUZ_2g4EXESO66aT2lyHx_LiDQ,22225
 memori/agents/memory_agent.py,sha256=khCbbBaMfHm7uYxZvIw4JO4kXzM848R_Cual0uSVZ2A,23957
@@ -16,7 +16,7 @@ memori/database/__init__.py,sha256=yungdfis0lyDE2eZFs86miYCAMG4klhS-TLhKq-1K3w,4
 memori/database/auto_creator.py,sha256=oMUKuJlLqwG4OxbhkMMjq0e5DDan3KcvAfEM2a56jOQ,12662
 memori/database/connection_utils.py,sha256=QQ50IQlrNUd0CWiFQeH76yIi1evbgMv8dDV29QkSAsc,6796
 memori/database/models.py,sha256=jPsD_ALGHMgv6_nxgizSQ2BTbNTupCMPOuS5EBaUiFU,14826
-memori/database/mongodb_manager.py,sha256=9i65D5mX2v0nM-3mR6-YxouybvHtnnLMB5i58uPBs7Y,55049
+memori/database/mongodb_manager.py,sha256=aB4vEnL2Jrb0ny4wbhsQGouTwkKfcVGNwsc-D8k7WYA,59270
 memori/database/query_translator.py,sha256=ruwzfIVxhcO5ouNamRVlxIUMkesU7xE8N5LzgaPW9Qc,6988
 memori/database/search_service.py,sha256=QH0CQaDONR3aSd7Su2C6Ysz4pikbYk3NDFRkP4EcFws,26856
 memori/database/sqlalchemy_manager.py,sha256=qSVSUp76CFiAy7CUvwdq3xGeXPGimhZxac0OtnV6XKQ,34926
@@ -27,7 +27,7 @@ memori/database/adapters/postgresql_adapter.py,sha256=QQEQtWVozlLDa4Cz2yWk1xC1Of
 memori/database/adapters/sqlite_adapter.py,sha256=Mu6Vjy2dCirAZcO591omLZXnbO0zMkD-WO23KGfV4Ck,9142
 memori/database/connectors/__init__.py,sha256=vQvrAVrN93Sd-kRpFllKLsFJPOCu35E1NHyCLIfG6cw,519
 memori/database/connectors/base_connector.py,sha256=y-XZVGWf01VmxVpvh9EiG73io6zmVLXXWfhgYlT1U7k,9603
-memori/database/connectors/mongodb_connector.py,sha256=_bYXgPzmP8Bq-WcqCfPOSnGKya0150ywXbAeNeWyNPs,21416
+memori/database/connectors/mongodb_connector.py,sha256=hRWPD2JvV3CxsYe7E63FHIKUVenCe7uGbalqd5eaFcI,27646
 memori/database/connectors/mysql_connector.py,sha256=RviFF2GRjug90NA60PcvLZ5aJSjAvXkGa42uXSjIIx0,13319
 memori/database/connectors/postgres_connector.py,sha256=AvLZ6XwWPYhIPrT2zlH1bfB5heEPibisO86r68R3FMg,16635
 memori/database/connectors/sqlite_connector.py,sha256=7UUFA-6U-N2K8JXxSzF7j2nKYwDV1awWNAJTzMiWH7A,11680
@@ -64,8 +64,8 @@ memori/utils/security_audit.py,sha256=SZyqdHyIUzrrnMxO__dAcnB-3x0vSuHW7eW0apOGT2
 memori/utils/security_integration.py,sha256=xiyYQ1sEo0yk_0NhWeXzzjTJ60pNbI0SEyAz766iilA,13050
 memori/utils/transaction_manager.py,sha256=kyxI_gRJUY8b1lq0ZUDN65rNmUC5qIGOyL8obFIysBQ,18735
 memori/utils/validators.py,sha256=u5emqDrSkN9JlJxdo5yxcCqs510UDOiLf16F6p-Oyps,11267
-memorisdk-2.1.0.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
-memorisdk-2.1.0.dist-info/METADATA,sha256=nMjmuDVkehI1B5nxNiwaONaP5y0_zuQD89BAwwZo85Q,19846
-memorisdk-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-memorisdk-2.1.0.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
-memorisdk-2.1.0.dist-info/RECORD,,
+memorisdk-2.1.1.dist-info/licenses/LICENSE,sha256=gyrDaYsSODngoYE1l68l_UfjppS-oYDrf1MvY1JGhgE,10430
+memorisdk-2.1.1.dist-info/METADATA,sha256=6KWbuv3JjXWmNrCjwqZ-MisJQVK5CqgS9H-0W-AyY0c,19907
+memorisdk-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+memorisdk-2.1.1.dist-info/top_level.txt,sha256=Nm3ad0isbJYBzTEce-O_gmkAEiTbAbyilgAhRt8IoGA,7
+memorisdk-2.1.1.dist-info/RECORD,,