crewplus 0.2.58__py3-none-any.whl → 0.2.60__py3-none-any.whl

crewplus/services/init_services.py

@@ -1,6 +1,7 @@
-import os
 import logging
+import os
 from typing import Optional
+
 from .model_load_balancer import ModelLoadBalancer
 
 model_balancer = None
@@ -26,9 +27,13 @@ def init_load_balancer(
     global model_balancer
     if model_balancer is None:
         # Use parameter if provided, otherwise check env var, then default
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        base_package_dir = os.path.dirname(os.path.dirname(current_dir))
+        default_config_path = os.path.join(base_package_dir, "_config", "models_config.json")
+
         final_config_path = config_path or os.getenv(
-            "MODEL_CONFIG_PATH", 
-            "config/models_config.json"
+            "MODEL_CONFIG_PATH",
+            default_config_path
         )
         try:
             # 1. Create a local instance first.

crewplus/vectorstores/milvus/vdb_service.py

@@ -234,7 +234,7 @@ class VDBService(object):
             return AsyncMilvusClient(**client_args)
         except Exception as e:
             self.logger.error(f"Failed to initialize AsyncMilvusClient, trying again. Error: {e}")
-            # Second attempt after failure
+            time.sleep(1) # sync sleep is fine, we are in a thread
             try:
                 return AsyncMilvusClient(**client_args)
             except Exception as e_retry:
@@ -254,18 +254,14 @@ class VDBService(object):
 
         return self._client
 
-    def get_async_vector_client(self) -> AsyncMilvusClient:
+    async def aget_async_vector_client(self) -> AsyncMilvusClient:
         """
-        Returns the active AsyncMilvusClient instance, initializing it if necessary.
+        Asynchronously returns the active AsyncMilvusClient instance, initializing it if necessary.
 
         Returns:
             AsyncMilvusClient: The initialized async client for interacting with the vector database.
         """
-        if self._async_client is None:
-            self.logger.debug("Initializing asynchronous AsyncMilvusClient...")
-            self._async_client = self._initialize_async_milvus_client(self._provider)
-        
-        return self._async_client
+        return await self._get_or_create_async_client()
 
     def get_vector_field(self, collection_name: str) -> str:
         """
@@ -374,7 +370,7 @@ class VDBService(object):
         Asynchronously checks if a collection exists and creates it if it doesn't.
         """
         try:
-            client = self.get_async_vector_client()
+            client = await self.aget_async_vector_client()
             if check_existence and not await client.has_collection(collection_name):
                 self.logger.info(f"Collection '{collection_name}' does not exist. Creating it.")
                 
@@ -512,6 +508,35 @@ class VDBService(object):
 
         return vdb
 
+    async def _get_or_create_async_client(self) -> AsyncMilvusClient:
+        """
+        Lazily initializes and returns the AsyncMilvusClient.
+        This runs the blocking constructor in a separate thread, but also creates
+        a temporary event loop inside that thread to satisfy the client's
+        initialization requirements.
+        """
+        if self._async_client is None:
+            self.logger.info("Lazily initializing AsyncMilvusClient...")
+            
+            def _create_with_loop():
+                # This function runs in a separate thread via asyncio.to_thread
+                try:
+                    # Check if an event loop exists in this new thread
+                    asyncio.get_running_loop()
+                except RuntimeError:  # 'RuntimeError: There is no current event loop...'
+                    # If not, create and set a new one
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+
+                # Now, with an event loop present in this thread, initialize the client.
+                # This is still a blocking call, but it's contained in the thread.
+                provider = self.settings.get("vector_store", {}).get("provider")
+                return self._initialize_async_milvus_client(provider)
+
+            self._async_client = await asyncio.to_thread(_create_with_loop)
+            
+        return self._async_client
+
     async def aget_vector_store(self, collection_name: str, embeddings: Embeddings = None, metric_type: str = "IP") -> Milvus:
         """
         Asynchronously gets a vector store instance, creating it if it doesn't exist.
@@ -539,12 +564,12 @@ class VDBService(object):
         if embeddings is None:
             embeddings = self.get_embeddings()
 
-        await self._aensure_collection_exists(collection_name, embeddings, check_existence=check_existence)
+        # await self._aensure_collection_exists(collection_name, embeddings, check_existence=check_existence)
 
         try:
-            self.logger.debug(f"Testing embedding function for collection '{collection_name}'...")
+            self.logger.info(f"Testing embedding function for collection '{collection_name}'...")
             await embeddings.aembed_query("validation_test_string")
-            self.logger.debug("Embedding function is valid.")
+            self.logger.info("Embedding function is valid.")
         except Exception as e:
             self.logger.error(
                 f"The provided embedding function is invalid and failed with error: {e}. "
@@ -558,24 +583,67 @@ class VDBService(object):
             "params": {}
         }
         
+        # Create a dedicated connection_args for the async path with the correct alias
+        async_conn_args = self.connection_args.copy()
+        async_conn_args['alias'] = self.async_alias
+        
         # For async operations, we MUST instantiate the Milvus object using the SYNCHRONOUS alias
-        # because its __init__ method is synchronous.
-        vdb = self._create_milvus_instance_with_retry(
+        # because its __init__ method is synchronous. This is now done in a separate thread.
+        vdb = await self._acreate_milvus_instance_with_retry(
             collection_name=collection_name,
             embeddings=embeddings,
             index_params=index_params,
-            connection_args=self.connection_args  # This uses the sync_alias by default
+            connection_args=async_conn_args  # Pass the async-specific connection args
         )
 
         # After successful synchronous initialization, we hot-swap the alias on the
         # ASYNCHRONOUS client to ensure future async operations use the correct connection.
-        self.logger.debug(f"Swapping to async alias for instance of collection {collection_name}")
+        self.logger.info(f"Swapping to async alias for instance of collection {collection_name}")
+        await self._get_or_create_async_client()
         vdb.aclient._using = self.async_alias
 
         self._async_instances[collection_name] = vdb
 
         return vdb
 
+    async def _acreate_milvus_instance_with_retry(self, collection_name: str, embeddings: Embeddings, index_params: dict, connection_args: Optional[dict] = None) -> Milvus:
+        """
+        Asynchronously creates a Milvus instance with a retry mechanism, running the synchronous
+        constructor in a separate thread to avoid blocking the event loop.
+        """
+        retries = 2
+        conn_args = connection_args if connection_args is not None else self.connection_args
+        
+        def _create_instance():
+            # This synchronous function will be run in a thread
+            return Milvus(
+                embedding_function=embeddings,
+                collection_name=collection_name,
+                connection_args=conn_args,
+                index_params=index_params
+            )
+
+        self.logger.info(f"Creating Milvus instance for collection '{collection_name}' in a separate thread...")
+        self.logger.info(f"Connection args: {conn_args}")
+
+        for attempt in range(retries + 1):
+            try:
+                # Run the blocking constructor in a separate thread
+                vdb = await asyncio.to_thread(_create_instance)
+                
+                self.logger.info(f"Successfully connected to Milvus for collection '{collection_name}' on attempt {attempt + 1}.")
+                return vdb  # Return on success
+            except Exception as e:
+                self.logger.warning(
+                    f"Attempt {attempt + 1}/{retries + 1} to connect to Milvus for collection '{collection_name}' failed: {e}"
+                )
+                if attempt < retries:
+                    self.logger.info("Retrying in 3 seconds...")
+                    await asyncio.sleep(3) # Use async sleep
+                else:
+                    self.logger.error(f"Failed to connect to Milvus for collection '{collection_name}' after {retries + 1} attempts.")
+                    raise RuntimeError(f"Could not connect to Milvus after {retries + 1} attempts.") from e
+
     def _create_milvus_instance_with_retry(self, collection_name: str, embeddings: Embeddings, index_params: dict, connection_args: Optional[dict] = None) -> Milvus:
         """
         Creates a Milvus instance with a retry mechanism for connection failures.
@@ -651,7 +719,7 @@ class VDBService(object):
         self.logger.info(f"Attempting to drop collection asynchronously: {collection_name}")
 
         try:
-            client = self.get_async_vector_client()
+            client = await self.aget_async_vector_client()
             await client.drop_collection(collection_name=collection_name)
             self.logger.info(f"Successfully dropped collection asynchronously: {collection_name}")
         except Exception as e:
@@ -690,7 +758,7 @@ class VDBService(object):
         self.logger.info(f"Delete data by filter asynchronously:{filter}")
 
         try:
-            client=self.get_async_vector_client()
+            client= await self.aget_async_vector_client()
             if collection_name is None or client is None or filter is None:
                 return RuntimeError(f"collection_name must be not null or check out your client to link milvus")
             await client.delete(collection_name=collection_name, filter=filter)

{crewplus-0.2.58.dist-info → crewplus-0.2.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: crewplus
-Version: 0.2.58
+Version: 0.2.60
 Summary: Base services for CrewPlus AI applications
 Author-Email: Tim Liu <tim@opsmateai.com>
 License: MIT
@@ -15,7 +15,6 @@ Requires-Dist: google-genai>=1.21.1
 Requires-Dist: langchain-milvus<0.3.0,>=0.2.1
 Requires-Dist: langfuse<4.0.0,>=3.1.3
 Requires-Dist: langchain-mcp-adapters>=0.1.4
-Requires-Dist: protobuf<6.0,>=5.27
 Description-Content-Type: text/markdown
 
 # CrewPlus

{crewplus-0.2.58.dist-info → crewplus-0.2.60.dist-info}/RECORD

@@ -1,14 +1,14 @@
-crewplus-0.2.58.dist-info/METADATA,sha256=bcVORIdlBj4keo_14dBUc9N6UDu9ch2p8JmBXSvFqIk,5459
-crewplus-0.2.58.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-crewplus-0.2.58.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
-crewplus-0.2.58.dist-info/licenses/LICENSE,sha256=2_NHSHRTKB_cTcT_GXgcenOCtIZku8j343mOgAguTfc,1087
+crewplus-0.2.60.dist-info/METADATA,sha256=PBmO4kKCatXJ6RnPqFdLqyHtncR3HfDzCgnyly9kcsc,5424
+crewplus-0.2.60.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+crewplus-0.2.60.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+crewplus-0.2.60.dist-info/licenses/LICENSE,sha256=2_NHSHRTKB_cTcT_GXgcenOCtIZku8j343mOgAguTfc,1087
 crewplus/__init__.py,sha256=m46HkZL1Y4toD619NL47Sn2Qe084WFFSFD7e6VoYKZc,284
 crewplus/callbacks/__init__.py,sha256=YG7ieeb91qEjp1zF0-inEN7mjZ7yT_D2yzdWFT8Z1Ws,63
 crewplus/callbacks/async_langfuse_handler.py,sha256=A4uFeLpvOUdc58M7sZoE65_C1V98u0QCvx5jUquM0pM,7006
 crewplus/services/__init__.py,sha256=V1CG8b2NOmRzNgQH7BPl4KVxWSYJH5vfEsW1wVErKNE,375
 crewplus/services/azure_chat_model.py,sha256=iWzJ2GQFSNmwJx-2O5_xKPSB6VVc-7T6bcfFI8_WezA,5521
 crewplus/services/gemini_chat_model.py,sha256=DYqz01H2TIHiCDQesSozVfOsMigno6QGwOtIweg7UHk,40103
-crewplus/services/init_services.py,sha256=7oZ1GmesK32EDB_DYnTzW17MEpXjXK41_U_1pmqu_m4,2183
+crewplus/services/init_services.py,sha256=tc1ti8Yufo2ixlJpwg8uH0KmoyQ4EqxCOe4uTEWnlRM,2413
 crewplus/services/model_load_balancer.py,sha256=Q9Gx3GrbKworU-Ytxeqp0ggHSgZ1Q6brtTk-nCl4sak,12095
 crewplus/services/tracing_manager.py,sha256=0KR-F0BKYEMdADANWofFZH9D9jcWDHzDICUE7nDhzJc,6579
 crewplus/utils/__init__.py,sha256=2Gk1n5srFJQnFfBuYTxktdtKOVZyNrFcNaZKhXk35Pw,142
@@ -17,9 +17,9 @@ crewplus/utils/schema_document_updater.py,sha256=frvffxn2vbi71fHFPoGb9hq7gH2azmm
 crewplus/vectorstores/milvus/__init__.py,sha256=OeYv2rdyG7tcREIjBJPyt2TbE54NvyeRoWMe7LwopRE,245
 crewplus/vectorstores/milvus/milvus_schema_manager.py,sha256=-QRav-hzu-XWeJ_yKUMolal_EyMUspSg-nvh5sqlrlQ,11442
 crewplus/vectorstores/milvus/schema_milvus.py,sha256=wwNpfqsKS0xeozZES40IvB0iNwUtpCall_7Hkg0dL1g,27223
-crewplus/vectorstores/milvus/vdb_service.py,sha256=sVDThSfsSq_aISJToU4yWY0nRfm9cOyIpIj_0YeJCXg,35111
+crewplus/vectorstores/milvus/vdb_service.py,sha256=qlmFWO_ZRXIeCGZGSEAlS2ciHhTPTH1Dg2ovovA1ZEY,38792
 docs/GeminiChatModel.md,sha256=zZYyl6RmjZTUsKxxMiC9O4yV70MC4TD-IGUmWhIDBKA,8677
 docs/ModelLoadBalancer.md,sha256=aGHES1dcXPz4c7Y8kB5-vsCNJjriH2SWmjBkSGoYKiI,4398
 docs/VDBService.md,sha256=Dw286Rrf_fsi13jyD3Bo4Sy7nZ_G7tYm7d8MZ2j9hxk,9375
 docs/index.md,sha256=3tlc15uR8lzFNM5WjdoZLw0Y9o1P1gwgbEnOdIBspqc,1643
-crewplus-0.2.58.dist-info/RECORD,,
+crewplus-0.2.60.dist-info/RECORD,,