fabricatio 0.2.6.dev6__tar.gz → 0.2.6.dev8__tar.gz

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.6.dev6
+Version: 0.2.6.dev8
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

fabricatio-0.2.6.dev8/examples/extract_and_inject/.gitignore

@@ -0,0 +1,2 @@
+bpdf_out
+output*

fabricatio-0.2.6.dev8/examples/extract_and_inject/extract_and_inject.py

@@ -0,0 +1,59 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+from pathlib import Path
+from typing import List, Optional
+
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article import ExtractArticleEssence
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.fs.curd import dump_text, gather_files
+from fabricatio.models.extra import ArticleEssence
+
+
+class SaveToFS(Action):
+    """Save to file system."""
+
+    async def _execute(self, to_inject: List[Optional[ArticleEssence]], output_dir: Path, **_) -> None:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        empty_count = 0
+        for i, e in enumerate(to_inject):
+            if e is None:
+                empty_count += 1
+                logger.error(f"Invalid essence at index {i}")
+                continue
+            dump_text(output_dir / f"{i}.json", e.display())
+        logger.info(f"Passed {empty_count} empty essence ")
+
+
+async def main() -> None:
+    """Main function."""
+    role = Role(
+        name="Researcher",
+        description="Extract article essence",
+        llm_model="openai/deepseek-r1-distill-llama-70b",
+        llm_rpm=50,
+        llm_tpm=100000,
+        registry={
+            Event.quick_instantiate("article"): WorkFlow(
+                name="extract",
+                steps=(ExtractArticleEssence(output_key="to_inject"), SaveToFS, InjectToDB(output_key="task_output")),
+                extra_init_context={"collection_name": "article_essence", "output_dir": Path("output")},
+            )
+        },
+    )
+
+    task: Task[str] = await role.propose_task(
+        "Extract the essence of the article from the files in './bpdf_out'",
+    )
+
+    col_name = await task.override_dependencies(gather_files("bpdf_out", "md")).delegate("article")
+
+    if col_name is None:
+        logger.error("No essence found")
+        return
+    logger.success(f"Injected to collection: {col_name}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.6-dev6"
+version = "0.2.6-dev8"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/python/fabricatio/actions/rag.py

@@ -3,6 +3,7 @@
 from typing import List, Optional
 
 from fabricatio.capabilities.rag import RAG
+from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.generic import PrepareVectorization
 
@@ -13,13 +14,13 @@ class InjectToDB(Action, RAG):
     output_key: str = "collection_name"
 
     async def _execute[T: PrepareVectorization](
-        self, to_inject: T | List[T], collection_name: Optional[str] = "my_collection", **_
+        self, to_inject: Optional[T] | List[Optional[T]], collection_name: Optional[str] = "my_collection", **_
     ) -> Optional[str]:
         if not isinstance(to_inject, list):
             to_inject = [to_inject]
-
+        logger.info(f"Injecting {len(to_inject)} items into the collection '{collection_name}'")
         await self.view(collection_name, create=True).consume_string(
-            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject],
+            [t.prepare_vectorization(self.embedding_max_sequence_length) for t in to_inject if isinstance(t,PrepareVectorization)],
         )
 
         return collection_name

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/python/fabricatio/capabilities/rag.py

@@ -15,7 +15,7 @@ from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import (
     ChooseKwargs,
-    CollectionSimpleConfigKwargs,
+    CollectionConfigKwargs,
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
@@ -63,10 +63,18 @@ class RAG(EmbeddingUsage):
             uri=milvus_uri or ok(self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
             token=milvus_token
             or (token.get_secret_value() if (token := (self.milvus_token or configs.rag.milvus_token)) else ""),
-            timeout=milvus_timeout or self.milvus_timeout,
+            timeout=milvus_timeout or self.milvus_timeout or configs.rag.milvus_timeout,
         )
         return self
 
+    def check_client(self, init: bool = True) -> Self:
+        """Check if the client is initialized, and if not, initialize it."""
+        if self._client is None and init:
+            return self.init_client()
+        if self._client is None and not init:
+            raise RuntimeError("Client is not initialized. Have you called `self.init_client()`?")
+        return self
+
     @overload
     async def pack(
         self, input_text: List[str], subject: Optional[str] = None, **kwargs: Unpack[EmbeddingKwargs]
@@ -102,17 +110,24 @@ class RAG(EmbeddingUsage):
         ]
 
     def view(
-        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionSimpleConfigKwargs]
+        self, collection_name: Optional[str], create: bool = False, **kwargs: Unpack[CollectionConfigKwargs]
     ) -> Self:
         """View the specified collection.
 
         Args:
             collection_name (str): The name of the collection.
             create (bool): Whether to create the collection if it does not exist.
-            **kwargs (Unpack[CollectionSimpleConfigKwargs]): Additional keyword arguments for collection configuration.
+            **kwargs (Unpack[CollectionConfigKwargs]): Additional keyword arguments for collection configuration.
         """
-        if create and collection_name and self.client.has_collection(collection_name):
-            kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
+        if create and collection_name and not self.check_client().client.has_collection(collection_name):
+            kwargs["dimension"] = ok(
+                kwargs.get("dimension")
+                or self.milvus_dimensions
+                or configs.rag.milvus_dimensions
+                or self.embedding_dimensions
+                or configs.embedding.dimensions,
+                "`dimension` is not set at any level.",
+            )
             self.client.create_collection(collection_name, auto_id=True, **kwargs)
             logger.info(f"Creating collection {collection_name}")
 
@@ -158,7 +173,7 @@ class RAG(EmbeddingUsage):
         else:
             raise TypeError(f"Expected MilvusData or list of MilvusData, got {type(data)}")
         c_name = collection_name or self.safe_target_collection
-        self.client.insert(c_name, prepared_data)
+        self.check_client().client.insert(c_name, prepared_data)
 
         if flush:
             logger.debug(f"Flushing collection {c_name}")
@@ -219,7 +234,7 @@ class RAG(EmbeddingUsage):
             List[Dict[str, Any]] | List[Any]: The retrieved data.
         """
         # Step 1: Search for vectors
-        search_results = self.client.search(
+        search_results = self.check_client().client.search(
             collection_name or self.safe_target_collection,
             vecs,
             search_params={"radius": similarity_threshold},

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/python/fabricatio/config.py

@@ -277,7 +277,7 @@ class RagConfig(BaseModel):
 
     milvus_uri: Optional[HttpUrl] = Field(default=HttpUrl("http://localhost:19530"))
     """The URI of the Milvus server."""
-    milvus_timeout: Optional[PositiveFloat] = Field(default=None)
+    milvus_timeout: Optional[PositiveFloat] = Field(default=30.0)
     """The timeout of the Milvus server."""
     milvus_token: Optional[SecretStr] = Field(default=None)
     """The token of the Milvus server."""
@@ -303,11 +303,13 @@ class RoutingConfig(BaseModel):
 
     model_config = ConfigDict(use_attribute_docstrings=True)
 
-    allowed_fails: Optional[int] = 1
+    max_parallel_requests: Optional[int] = 60
+    """The maximum number of parallel requests. None means not checked."""
+    allowed_fails: Optional[int] = 3
     """The number of allowed fails before the routing is considered failed."""
     retry_after: int = 15
     """The time in seconds to wait before retrying the routing after a fail."""
-    cooldown_time: Optional[int] = 120
+    cooldown_time: Optional[int] = 30
     """The time in seconds to wait before retrying the routing after a cooldown."""
 
 

{fabricatio-0.2.6.dev6 → fabricatio-0.2.6.dev8}/python/fabricatio/models/action.py

@@ -216,3 +216,15 @@ class WorkFlow(WithBriefing, ToolBoxUsage):
         """
         self.provide_tools_to(self._instances)
         return self
+
+    def update_init_context(self, **kwargs) -> Self:
+        """Update the initial context with additional key-value pairs.
+
+        Args:
+            **kwargs: Key-value pairs to add to the initial context.
+
+        Returns:
+            Self: The workflow instance for method chaining.
+        """
+        self.extra_init_context.update(kwargs)
+        return self