fabricatio 0.2.8.dev3__tar.gz → 0.2.9.dev0__tar.gz

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.8.dev3
+Version: 0.2.9.dev0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/examples/make_diary/diary.py

@@ -4,7 +4,7 @@ import asyncio
 from datetime import datetime
 from typing import Optional, Set, Unpack
 
-from fabricatio import Action, Event, Role, Task, WorkFlow, fs_toolbox, logger
+from fabricatio import Action, Event, Role, Task, WorkFlow, logger, toolboxes
 from fabricatio.fs.readers import safe_json_read
 from fabricatio.models.tool import ToolBox
 from pydantic import Field
@@ -48,7 +48,7 @@ class WriteDiary(Action):
 class DumpText(Action):
     """Dump the text to a file."""
 
-    toolboxes: Set[ToolBox] = Field(default_factory=lambda: {fs_toolbox})
+    toolboxes: Set[ToolBox] = Field(default_factory=lambda: {toolboxes.fs_toolbox})
     output_key: str = "task_output"
 
     async def _execute(self, task_input: Task, dump_text: str, **_: Unpack) -> Optional[str]:

fabricatio-0.2.9.dev0/examples/rules/draft_ruleset.py

@@ -0,0 +1,50 @@
+"""Example of using the library."""
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.output import PersistentAll
+from fabricatio.actions.rules import DraftRuleSet
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
+
+if TYPE_CHECKING:
+    from fabricatio.models.extra.rule import RuleSet
+
+
+async def main() -> None:
+    """Main function."""
+    Role(
+        name="Undergraduate Researcher",
+        llm_temperature=1.15,
+        llm_model="openai/deepseek-v3-250324",
+        llm_rpm=1000,
+        llm_tpm=3000000,
+        llm_max_tokens=8190,
+        registry={
+            Event.quick_instantiate(ns := "article"): WorkFlow(
+                name="write ruleset",
+                description="Generate an outline for an article. dump the outline to the given path. in typst format.",
+                steps=(
+                    DraftRuleSet(
+                        ruleset_requirement="1.when try to use an article as reference cited in our article, you should obey the format like (author1, author2 et al., YYYY)\n"
+                        "2.we use typst to generate numeric citation. For example, for an article whose `bibtex_key` is `YanWindEnergy2018`, you can create a numeric citation by typing `#cite(<YanWindEnergy2018>)`(note that `bibtex_key` with `<` and `>` wrapped is needed), those notations could automatically be processed and output by compiler as a numeric citation like `[1]` in the upper right corner of text.\n"
+                        "3.in addition, since `#cite()` can ONLY cite ONE article at once, we need use multiple `#cite()` notations to cite multiple articles, for example, there are three articles whose `bibtex_key` are `YanWindEnergy2018`, `YanWindEnergy2019`, `YanWindEnergy2020, you can cite them three as numeric citation by typing `#cite(<YanWindEnergy2018>)#cite(<YanWindEnergy2019>)#cite(<YanWindEnergy2020>)` those notations could automatically be processed and output by compiler as a numeric citation like `[1,2,3]` in the upper right corner of text.\n"
+                        "4.to cover more references, we usually cite more than one articles that have similar opinions in a single sentence if possible.\n"
+                        "5.when using `#cite()` notation, you must be aware of the cite key should be wrapped by `<` and `>`, compiler wont let it pass compilation otherwise.",
+                        rule_count=5,
+                    ).to_task_output(),
+                    PersistentAll(persist_dir="persistent"),
+                ),
+            )
+        },
+    )
+
+    proposed_task: Task[RuleSet] = Task(name="write an ruleset")
+    ruleset = ok(await proposed_task.delegate(ns), "Failed to generate ruleset")
+    logger.success(f"The rule is: \n{ruleset.display()}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/examples/task_handle/handle_task.py

@@ -3,7 +3,7 @@
 import asyncio
 from typing import Any, Set, Unpack
 
-from fabricatio import Action, Event, PythonCapture, Role, Task, ToolBox, WorkFlow, fs_toolbox, logger
+from fabricatio import Action, Event, PythonCapture, Role, Task, ToolBox, WorkFlow, logger, toolboxes
 from pydantic import Field
 
 
@@ -23,7 +23,7 @@ class WriteCode(Action):
 class DumpText(Action):
     """Dump the text to a file."""
 
-    toolboxes: Set[ToolBox] = Field(default_factory=lambda: {fs_toolbox})
+    toolboxes: Set[ToolBox] = Field(default_factory=lambda: {toolboxes.fs_toolbox})
     output_key: str = "task_output"
 
     async def _execute(self, task_input: Task, dump_text: str, **_: Unpack) -> Any:

fabricatio-0.2.9.dev0/examples/write_article/.gitignore

@@ -0,0 +1,3 @@
+article_briefing.txt
+out.typ
+persistent

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/examples/write_article/write_article.py

@@ -23,11 +23,10 @@ async def main() -> None:
     Role(
         name="Undergraduate Researcher",
         description="Write an outline for an article in typst format.",
-        llm_top_p=0.8,
         llm_temperature=1.15,
         llm_model="openai/deepseek-v3-250324",
         llm_rpm=1000,
-        llm_tpm=1000000,
+        llm_tpm=3000000,
         llm_max_tokens=8190,
         registry={
             Event.quick_instantiate(ns := "article"): WorkFlow(
@@ -35,15 +34,15 @@ async def main() -> None:
                 description="Generate an outline for an article. dump the outline to the given path. in typst format.",
                 steps=(
                     GenerateArticleProposal(llm_temperature=1.18),
-                    GenerateInitialOutline(output_key="article_outline",llm_temperature=1.21, llm_top_p=0.5),
-                    FixIntrospectedErrors(output_key="article_outline"),
-                    FixIllegalReferences(output_key="article_outline"),
-                    TweakOutlineBackwardRef(output_key="article_outline"),
-                    TweakOutlineForwardRef(output_key="article_outline"),
-                    FixIllegalReferences(output_key="article_outline"),
-                    GenerateArticle(output_key="article", llm_temperature=1.2, llm_top_p=0.45),
+                    GenerateInitialOutline(output_key="article_outline",llm_temperature=1.21),
+                    FixIntrospectedErrors(output_key="article_outline",),
+                    FixIllegalReferences(output_key="article_outline",),
+                    TweakOutlineBackwardRef(output_key="article_outline",),
+                    TweakOutlineForwardRef(output_key="article_outline",),
+                    FixIllegalReferences(output_key="article_outline",),
+                    GenerateArticle(output_key="article", llm_temperature=1.2),
                     PersistentAll,
-                    TweakArticleRAG(output_key="to_dump", llm_temperature=1.2, llm_top_p=0.45),
+                    TweakArticleRAG(output_key="to_dump", llm_temperature=1.2),
                     DumpFinalizedOutput(output_key="task_output"),
                     PersistentAll,
                 ),
@@ -51,7 +50,7 @@ async def main() -> None:
                 article_briefing=Path("./article_briefing.txt").read_text(),
                 dump_path="out.typ",
                 persist_dir="persistent",
-                collection_name="article_essence"
+                collection_name="article_essence_0324"
             )
         },
     )

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/examples/write_outline/write_outline.py

@@ -2,7 +2,8 @@
 
 import asyncio
 
-from fabricatio import Event, Role, WriteOutlineWorkFlow, logger
+from fabricatio import Event, Role, logger
+from fabricatio.workflows.articles import WriteOutlineCorrectedWorkFlow
 
 
 async def main() -> None:
@@ -10,7 +11,7 @@ async def main() -> None:
     role = Role(
         name="Undergraduate Researcher",
         description="Write an outline for an article in typst format.",
-        registry={Event.quick_instantiate(ns := "article"): WriteOutlineWorkFlow},
+        registry={Event.quick_instantiate(ns := "article"): WriteOutlineCorrectedWorkFlow},
     )
 
     proposed_task = await role.propose_task(

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/examples/write_outline/write_outline_corrected.py

@@ -3,7 +3,7 @@
 import asyncio
 
 from fabricatio import Event, Role, WorkFlow, logger
-from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateOutline
+from fabricatio.actions.article import CorrectOutline, CorrectProposal, GenerateArticleProposal, GenerateInitialOutline
 from fabricatio.actions.output import DumpFinalizedOutput
 
 
@@ -25,7 +25,7 @@ async def main() -> None:
                         llm_model="deepseek/deepseek-reasoner",
                         llm_temperature=1.3,
                     ),
-                    GenerateOutline(llm_model="deepseek/deepseek-chat", llm_temperature=1.4, llm_top_p=0.5),
+                    GenerateInitialOutline(llm_model="deepseek/deepseek-chat", llm_temperature=1.4, llm_top_p=0.5),
                     CorrectOutline(output_key="to_dump", llm_temperature=1.4, llm_top_p=0.45),
                     DumpFinalizedOutput(output_key="task_output"),
                 ),

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.8-dev3"
+version = "0.2.9-dev0"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -57,7 +57,7 @@ build-backend = "maturin"
 
 [tool.maturin]
 python-source = "python"
-module-name = "fabricatio._rust"
+module-name = "fabricatio.rust"
 data = "extra"
 [dependency-groups]
 dev = [

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/python/fabricatio/__init__.py

@@ -1,10 +1,6 @@
 """Fabricatio is a Python library for building llm app using event-based agent structure."""
 
-from importlib.util import find_spec
-
-from fabricatio import actions, toolboxes, workflows
-from fabricatio._rust import BibManager
-from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio import actions, capabilities, toolboxes, workflows
 from fabricatio.core import env
 from fabricatio.journal import logger
 from fabricatio.models import extra
@@ -14,6 +10,8 @@ from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
 from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
+from fabricatio.rust import BibManager
+from fabricatio.rust_instances import TEMPLATE_MANAGER
 
 __all__ = [
     "TEMPLATE_MANAGER",
@@ -29,15 +27,10 @@ __all__ = [
     "ToolBox",
     "WorkFlow",
     "actions",
+    "capabilities",
     "env",
     "extra",
     "logger",
     "toolboxes",
     "workflows",
 ]
-
-
-if find_spec("pymilvus"):
-    from fabricatio.capabilities.rag import RAG
-
-    __all__ += ["RAG"]

fabricatio-0.2.9.dev0/python/fabricatio/actions/__init__.py

@@ -0,0 +1 @@
+"""A module containing some builtin actins."""

{fabricatio-0.2.8.dev3 → fabricatio-0.2.9.dev0}/python/fabricatio/actions/article.py

@@ -4,22 +4,26 @@ from asyncio import gather
 from pathlib import Path
 from typing import Any, Callable, List, Optional
 
-from fabricatio._rust import BibManager
-from fabricatio.capabilities.advanced_judge import AdvancedJudge
+from more_itertools import filter_map
+
+from fabricatio.capabilities.censor import Censor
+from fabricatio.capabilities.correct import Correct
+from fabricatio.capabilities.propose import Propose
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
-from fabricatio.models.extra.article_base import ArticleRefPatch
+from fabricatio.models.extra.article_base import ArticleRefSequencePatch
 from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article
 from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.article_proposal import ArticleProposal
+from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.task import Task
+from fabricatio.rust import BibManager
 from fabricatio.utils import ok
-from more_itertools import filter_map
 
 
-class ExtractArticleEssence(Action):
+class ExtractArticleEssence(Action, Propose):
     """Extract the essence of article(s) in text format from the paths specified in the task dependencies.
 
     Notes:
@@ -47,11 +51,11 @@ class ExtractArticleEssence(Action):
         out = []
 
         for ess in await self.propose(
-                ArticleEssence,
-                [
-                    f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it."
-                    for c in contents
-                ],
+            ArticleEssence,
+            [
+                f"{c}\n\n\nBased the provided academic article above, you need to extract the essence from it."
+                for c in contents
+            ],
         ):
             if ess is None:
                 logger.warning("Could not extract article essence")
@@ -91,7 +95,7 @@ class FixArticleEssence(Action):
         return out
 
 
-class GenerateArticleProposal(Action):
+class GenerateArticleProposal(Action, Propose):
     """Generate an outline for the article based on the extracted essence."""
 
     output_key: str = "article_proposal"
@@ -133,7 +137,7 @@ class GenerateArticleProposal(Action):
         return proposal
 
 
-class GenerateInitialOutline(Action):
+class GenerateInitialOutline(Action, Propose):
     """Generate the initial article outline based on the article proposal."""
 
     output_key: str = "initial_article_outline"
@@ -153,38 +157,29 @@ class GenerateInitialOutline(Action):
         ).update_ref(article_proposal)
 
 
-class FixIntrospectedErrors(Action):
+class FixIntrospectedErrors(Action, Censor):
     """Fix introspected errors in the article outline."""
 
     output_key: str = "introspected_errors_fixed_outline"
     """The key of the output data."""
 
+    ruleset: Optional[RuleSet] = None
+    """The ruleset to use to fix the introspected errors."""
+
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        introspect_manual = ok(
-            await self.draft_rating_manual(
-                topic=(
-                    intro_topic
-                    := "Fix the error in the article outline, make sure there is no more error in the article outline."
-                ),
-            ),
-            "Could not generate the rating manual.",
-        )
-
         while pack := article_outline.find_introspected():
             component, err = ok(pack)
             logger.warning(f"Found introspected error: {err}")
             corrected = ok(
-                await self.correct_obj(
+                await self.censor_obj(
                     component,
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
-                    topic=intro_topic,
-                    rating_manual=introspect_manual,
-                    supervisor_check=supervisor_check,
+                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Some Basic errors found from `{component.title}` that need to be fixed\n{err}",
                 ),
                 "Could not correct the component.",
             )
@@ -193,38 +188,29 @@ class FixIntrospectedErrors(Action):
         return article_outline
 
 
-class FixIllegalReferences(Action):
+class FixIllegalReferences(Action, Censor):
     """Fix illegal references in the article outline."""
 
     output_key: str = "illegal_references_fixed_outline"
     """The key of the output data."""
 
+    ruleset: Optional[RuleSet] = None
+    """Ruleset to use to fix the illegal references."""
+
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        ref_manual = ok(
-            await self.draft_rating_manual(
-                topic=(
-                    ref_topic
-                    := "Fix the internal referring error, make sure there is no more `ArticleRef` pointing to a non-existing article component."
-                ),
-            ),
-            "Could not generate the rating manual.",
-        )
-
         while pack := article_outline.find_illegal_ref(gather_identical=True):
             refs, err = ok(pack)
             logger.warning(f"Found illegal referring error: {err}")
             corrected_ref = ok(
-                await self.correct_obj(
+                await self.censor_obj(
                     refs[0],  # pyright: ignore [reportIndexIssue]
-                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
-                    topic=ref_topic,
-                    rating_manual=ref_manual,
-                    supervisor_check=supervisor_check,
+                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
+                    reference=f"# Original Article Outline\n{article_outline.display()}\n# Some Basic errors found that need to be fixed\n{err}",
                 )
             )
             for ref in refs:
@@ -233,43 +219,40 @@ class FixIllegalReferences(Action):
         return article_outline.update_ref(article_outline)
 
 
-class TweakOutlineForwardRef(Action, AdvancedJudge):
+class TweakOutlineForwardRef(Action, Censor):
     """Tweak the forward references in the article outline.
 
     Ensures that the conclusions of the current chapter effectively support the analysis of subsequent chapters.
     """
 
     output_key: str = "article_outline_fw_ref_checked"
+    ruleset: Optional[RuleSet] = None
+    """Ruleset to use to fix the illegal references."""
 
-    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+    async def _execute(
+        self, article_outline: ArticleOutline, ruleset: Optional[RuleSet] = None, **cxt
+    ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            supervisor_check,
-            topic="Ensure conclusions support the analysis of subsequent chapters, sections or subsections.",
+            ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
             field_name="support_to",
         )
 
-    async def _inner(
-        self, article_outline: ArticleOutline, supervisor_check: bool, topic: str, field_name: str
-    ) -> ArticleOutline:
-        tweak_support_to_manual = ok(
-            await self.draft_rating_manual(topic),
-            "Could not generate the rating manual.",
-        )
+    async def _inner(self, article_outline: ArticleOutline, ruleset: RuleSet, field_name: str) -> ArticleOutline:
         for a in article_outline.iter_dfs():
-            if await self.evidently_judge(
+            if judge := await self.evidently_judge(
                 f"{article_outline.as_prompt()}\n\n{a.display()}\n"
                 f"Does the `{a.__class__.__name__}`'s `{field_name}` field need to be extended or tweaked?"
             ):
-                patch = ArticleRefPatch.default()
+                patch = ArticleRefSequencePatch.default()
                 patch.tweaked = getattr(a, field_name)
 
-                await self.correct_obj_inplace(
+                await self.censor_obj_inplace(
                     patch,
-                    topic=topic,
-                    reference=f"{article_outline.as_prompt()}\nThe Article component whose `{field_name}` field needs to be extended or tweaked",
-                    rating_manual=tweak_support_to_manual,
-                    supervisor_check=supervisor_check,
+                    ruleset=ruleset,
+                    reference=f"{article_outline.as_prompt()}\n"
+                    f"The Article component titled `{a.title}` whose `{field_name}` field needs to be extended or tweaked.\n"
+                    f"# Judgement\n{judge.display()}",
                 )
         return article_outline
 
@@ -281,44 +264,41 @@ class TweakOutlineBackwardRef(TweakOutlineForwardRef):
     """
 
     output_key: str = "article_outline_bw_ref_checked"
+    ruleset: Optional[RuleSet] = None
 
-    async def _execute(self, article_outline: ArticleOutline, supervisor_check: bool = False, **cxt) -> ArticleOutline:
+    async def _execute(
+        self, article_outline: ArticleOutline, ruleset: Optional[RuleSet] = None, **cxt
+    ) -> ArticleOutline:
         return await self._inner(
             article_outline,
-            supervisor_check,
-            topic="Ensure the dependencies of the current chapter are neither abused nor missing.",
+            ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
             field_name="depend_on",
         )
 
 
-class GenerateArticle(Action):
+class GenerateArticle(Action, Censor):
     """Generate the article based on the outline."""
 
     output_key: str = "article"
     """The key of the output data."""
+    ruleset: Optional[RuleSet] = None
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        supervisor_check: bool = False,
+        ruleset: Optional[RuleSet] = None,
         **_,
     ) -> Optional[Article]:
         article: Article = Article.from_outline(ok(article_outline, "Article outline not specified.")).update_ref(
             article_outline
         )
 
-        write_para_manual = ok(
-            await self.draft_rating_manual(w_topic := "write the following paragraph in the subsection.")
-        )
-
         await gather(
             *[
-                self.correct_obj_inplace(
+                self.censor_obj_inplace(
                     subsec,
+                    ruleset=ok(ruleset or self.ruleset, "No ruleset provided"),
                     reference=f"# Original Article Outline\n{article_outline.display()}\n# Error Need to be fixed\n{err}",
-                    topic=w_topic,
-                    rating_manual=write_para_manual,
-                    supervisor_check=supervisor_check,
                 )
                 for _, __, subsec in article.iter_subsections()
                 if (err := subsec.introspect())
@@ -329,18 +309,16 @@ class GenerateArticle(Action):
         return article
 
 
-class CorrectProposal(Action):
+class CorrectProposal(Action, Censor):
     """Correct the proposal of the article."""
 
     output_key: str = "corrected_proposal"
 
     async def _execute(self, article_proposal: ArticleProposal, **_) -> Any:
-        return (await self.censor_obj(article_proposal, reference=article_proposal.referenced)).update_ref(
-            article_proposal
-        )
+        raise  NotImplementedError("Not implemented.")
 
 
-class CorrectOutline(Action):
+class CorrectOutline(Action, Correct):
     """Correct the outline of the article."""
 
     output_key: str = "corrected_outline"
@@ -351,12 +329,10 @@ class CorrectOutline(Action):
         article_outline: ArticleOutline,
         **_,
     ) -> ArticleOutline:
-        return (await self.censor_obj(article_outline, reference=article_outline.referenced.as_prompt())).update_ref(
-            article_outline
-        )
+        raise NotImplementedError("Not implemented.")
 
 
-class CorrectArticle(Action):
+class CorrectArticle(Action, Correct):
     """Correct the article based on the outline."""
 
     output_key: str = "corrected_article"
@@ -368,4 +344,4 @@ class CorrectArticle(Action):
         article_outline: ArticleOutline,
         **_,
     ) -> Article:
-        return await self.censor_obj(article, reference=article_outline.referenced.as_prompt())
+        raise NotImplementedError("Not implemented.")

fabricatio-0.2.9.dev0/python/fabricatio/actions/article_rag.py

@@ -0,0 +1,100 @@
+"""A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
+
+from asyncio import gather
+from typing import Optional
+
+from fabricatio.capabilities.censor import Censor
+from fabricatio.capabilities.rag import RAG
+from fabricatio.models.action import Action
+from fabricatio.models.extra.article_main import Article, ArticleParagraphSequencePatch, ArticleSubsection
+from fabricatio.models.extra.rule import RuleSet
+from fabricatio.utils import ok
+
+
+class TweakArticleRAG(Action, RAG, Censor):
+    """Write an article based on the provided outline.
+
+    This class inherits from `Action`, `RAG`, and `Censor` to provide capabilities for writing and refining articles
+    using Retrieval-Augmented Generation (RAG) techniques. It processes an article outline, enhances subsections by
+    searching for related references, and applies censoring rules to ensure compliance with the provided ruleset.
+
+    Attributes:
+        output_key (str): The key used to store the output of the action.
+        ruleset (Optional[RuleSet]): The ruleset to be used for censoring the article.
+    """
+
+    output_key: str = "rag_tweaked_article"
+    """The key used to store the output of the action."""
+
+    ruleset: Optional[RuleSet] = None
+    """The ruleset to be used for censoring the article."""
+
+    async def _execute(
+        self,
+        article: Article,
+        collection_name: str = "article_essence",
+        ruleset: Optional[RuleSet] = None,
+        parallel: bool = False,
+        **cxt,
+    ) -> Optional[Article]:
+        """Write an article based on the provided outline.
+
+        This method processes the article outline, either in parallel or sequentially, by enhancing each subsection
+        with relevant references and applying censoring rules.
+
+        Args:
+            article (Article): The article to be processed.
+            collection_name (str): The name of the collection to view for processing.
+            ruleset (Optional[RuleSet]): The ruleset to apply for censoring. If not provided, the class's ruleset is used.
+            parallel (bool): If True, process subsections in parallel. Otherwise, process them sequentially.
+            **cxt: Additional context parameters.
+
+        Returns:
+            Optional[Article]: The processed article with enhanced subsections and applied censoring rules.
+        """
+        self.view(collection_name)
+
+        if parallel:
+            await gather(
+                *[
+                    self._inner(article, subsec, ok(ruleset or self.ruleset, "No ruleset provided!"))
+                    for _, __, subsec in article.iter_subsections()
+                ],
+                return_exceptions=True,
+            )
+        else:
+            for _, __, subsec in article.iter_subsections():
+                await self._inner(article, subsec, ok(ruleset or self.ruleset, "No ruleset provided!"))
+        return article
+
+    async def _inner(self, article: Article, subsec: ArticleSubsection, ruleset: RuleSet) -> None:
+        """Enhance a subsection of the article with references and apply censoring rules.
+
+        This method refines the query for the subsection, retrieves related references, and applies censoring rules
+        to the subsection's paragraphs.
+
+        Args:
+            article (Article): The article containing the subsection.
+            subsec (ArticleSubsection): The subsection to be enhanced.
+            ruleset (RuleSet): The ruleset to apply for censoring.
+
+        Returns:
+            None
+        """
+        refind_q = ok(
+            await self.arefined_query(
+                f"{article.referenced.as_prompt()}\n"
+                f"# Subsection requiring reference enhancement\n"
+                f"{subsec.display()}\n"
+                f"# Requirement\n"
+                f"Search related articles in the base to find reference candidates, "
+                f"prioritizing both original article language and English usage",
+            )
+        )
+        patch = ArticleParagraphSequencePatch.default()
+        patch.tweaked = subsec.paragraphs
+        await self.censor_obj_inplace(
+            patch,
+            ruleset=ruleset,
+            reference=await self.aretrieve_compact(refind_q, final_limit=30),
+        )