fabricatio 0.2.11.dev2__tar.gz → 0.2.12.dev1__tar.gz

{fabricatio-0.2.11.dev2 → fabricatio-0.2.12.dev1}/.gitignore

@@ -166,3 +166,5 @@ cython_debug/
 extra/scripts/*
 output/
 .vscode/
+templates/customed
+*.typ

{fabricatio-0.2.11.dev2 → fabricatio-0.2.12.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.11.dev2
+Version: 0.2.12.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -20,18 +20,20 @@ Requires-Dist: pydantic-settings>=2.7.1
 Requires-Dist: pymitter>=1.0.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: ujson>=5.10.0
-Requires-Dist: fabricatio[calc,ftd,plot,qa,rag] ; extra == 'full'
+Requires-Dist: fabricatio[calc,ftd,plot,qa,rag,cli] ; extra == 'full'
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
 Requires-Dist: matplotlib>=3.10.1 ; extra == 'plot'
 Requires-Dist: questionary>=2.1.0 ; extra == 'qa'
 Requires-Dist: magika>=0.6.1 ; extra == 'ftd'
+Requires-Dist: typer-slim[standard]>=0.15.2 ; extra == 'cli'
 Provides-Extra: full
 Provides-Extra: rag
 Provides-Extra: calc
 Provides-Extra: plot
 Provides-Extra: qa
 Provides-Extra: ftd
+Provides-Extra: cli
 License-File: LICENSE
 Summary: A LLM multi-agent framework.
 Keywords: ai,agents,multi-agent,llm,pyo3

fabricatio-0.2.12.dev1/examples/write_article/.gitignore

@@ -0,0 +1,4 @@
+article_briefing.txt
+article_outline_raw.txt
+out.typ
+persistent*

fabricatio-0.2.12.dev1/examples/write_article/write_article.py

@@ -0,0 +1,196 @@
+"""Example of using the library."""
+
+import asyncio
+from pathlib import Path
+
+import typer
+from fabricatio import Event, Role, WorkFlow, logger
+from fabricatio.actions.article import ExtractOutlineFromRaw, GenerateArticleProposal, GenerateInitialOutline
+from fabricatio.actions.article_rag import ArticleConsultRAG, WriteArticleContentRAG
+from fabricatio.actions.output import DumpFinalizedOutput, PersistentAll
+from fabricatio.models.extra.article_outline import ArticleOutline
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
+from typer import Typer
+
+# from pydantic import HttpUrl
+
+Role(
+    name="Undergraduate Researcher",
+    description="Write an outline for an article in typst format.",
+    llm_model="openai/qwen-plus",
+    llm_temperature=0.35,
+    # llm_api_endpoint=HttpUrl("https://dashscope.aliyuncs.com/compatible-mode/v1"),
+    llm_top_p=0.95,
+    llm_max_tokens=8191,
+    llm_stream=True,
+    llm_rpm=600,
+    llm_tpm=1000000,
+    llm_timeout=600,
+    registry={
+        Event.quick_instantiate(ns := "article"): WorkFlow(
+            name="Generate Article",
+            description="Generate an article. dump the outline to the given path. in typst format.",
+            steps=(
+                GenerateArticleProposal,
+                GenerateInitialOutline(output_key="article_outline"),
+                PersistentAll,
+                (
+                    a := WriteArticleContentRAG(
+                        output_key="to_dump",
+                        ref_limit=18,
+                        threshold=0.58,
+                        result_per_query=2,
+                        llm_model="openai/qwq-plus",
+                        extractor_model="openai/qwen-max",
+                        query_model="openai/qwen-turbo",
+                    )
+                ),
+                DumpFinalizedOutput(output_key="task_output"),
+                PersistentAll,
+            ),
+        ),
+        Event.quick_instantiate(ns2 := "complete"): WorkFlow(
+            name="Generate Article",
+            description="Generate an article with given raw article outline. dump the outline to the given path. in typst format.",
+            steps=(
+                ExtractOutlineFromRaw(output_key="article_outline"),
+                PersistentAll,
+                a,
+                DumpFinalizedOutput(output_key="task_output"),
+                PersistentAll,
+            ),
+        ),
+        Event.quick_instantiate(ns3 := "finish"): WorkFlow(
+            name="Finish Article",
+            description="Finish an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(
+                a,
+                DumpFinalizedOutput(output_key="task_output"),
+                PersistentAll,
+            ),
+        ),
+        Event.quick_instantiate(ns4 := "consult"): WorkFlow(
+            name="Consult Article",
+            description="Consult an article with given article outline. dump the outline to the given path. in typst format.",
+            steps=(ArticleConsultRAG().to_task_output(),),
+        ),
+    },
+)
+
+
+app = Typer()
+
+
+@app.command()
+def consult(
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+) -> None:
+    """Consult an article based on a given article outline."""
+    _ = asyncio.run(
+        Task(name="Answer Question")
+        .update_init_context(
+            collection_name=collection_name,
+        )
+        .delegate(ns4)
+    )
+
+    logger.info("Finished")
+
+
+@app.command()
+def finish(
+    article_outline_path: Path = typer.Argument(  # noqa: B008
+        help="Path to the article outline raw file."
+    ),
+    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    persist_dir: Path = typer.Option(  # noqa: B008
+        Path("persistent"), "-p", "--persist-dir", help="Directory to persist the output."
+    ),
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+    supervisor: bool = typer.Option(False, "-s", "--supervisor", help="Whether to use the supervisor mode."),
+) -> None:
+    """Finish an article based on a given article outline."""
+    path = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_outline=ArticleOutline.from_persistent(article_outline_path),
+                dump_path=dump_path,
+                persist_dir=persist_dir,
+                collection_name=collection_name,
+                supervisor=supervisor,
+            )
+            .delegate(ns3)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{path}")
+
+
+@app.command()
+def completion(
+    article_outline_raw_path: Path = typer.Option(  # noqa: B008
+        Path("article_outline_raw.txt"), "-a", "--article-outline-raw", help="Path to the article outline raw file."
+    ),
+    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    persist_dir: Path = typer.Option(  # noqa: B008
+        Path("persistent"), "-p", "--persist-dir", help="Directory to persist the output."
+    ),
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+    supervisor: bool = typer.Option(False, "-s", "--supervisor", help="Whether to use the supervisor mode."),
+) -> None:
+    """Write an article based on a raw article outline."""
+    path = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_outline_raw_path=article_outline_raw_path,
+                dump_path=dump_path,
+                persist_dir=persist_dir,
+                collection_name=collection_name,
+                supervisor=supervisor,
+            )
+            .delegate(ns2)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{path}")
+
+
+@app.command()
+def write(
+    article_briefing: Path = typer.Option(  # noqa: B008
+        Path("article_briefing.txt"), "-a", "--article-briefing", help="Path to the article briefing file."
+    ),
+    dump_path: Path = typer.Option(Path("out.typ"), "-d", "--dump-path", help="Path to dump the final output."),  # noqa: B008
+    persist_dir: Path = typer.Option(  # noqa: B008
+        Path("persistent"), "-p", "--persist-dir", help="Directory to persist the output."
+    ),
+    collection_name: str = typer.Option("article_chunks", "-c", "--collection-name", help="Name of the collection."),
+    supervisor: bool = typer.Option(False, "-s", "--supervisor", help="Whether to use the supervisor mode."),
+) -> None:
+    """Write an article based on a briefing.
+
+    This function generates an article outline and content based on the provided briefing.
+    The outline and content are then dumped to the specified path and persisted in the given directory.
+    """
+    path = ok(
+        asyncio.run(
+            Task(name="write an article")
+            .update_init_context(
+                article_briefing=article_briefing.read_text(),
+                dump_path=dump_path,
+                persist_dir=persist_dir,
+                collection_name=collection_name,
+                supervisor=supervisor,
+            )
+            .delegate(ns)
+        ),
+        "Failed to generate an article ",
+    )
+    logger.success(f"The outline is saved in:\n{path}")
+
+
+if __name__ == "__main__":
+    app()

{fabricatio-0.2.11.dev2 → fabricatio-0.2.12.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.11-dev2"
+version = "0.2.12-dev1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -74,7 +74,7 @@ dev = [
 
 [project.optional-dependencies]
 full = [
-    "fabricatio[calc,ftd,plot,qa,rag]",
+    "fabricatio[calc,ftd,plot,qa,rag,cli]",
 ]
 rag = [
     "pymilvus>=2.5.4",
@@ -92,6 +92,9 @@ qa = [
 ftd = [
     "magika>=0.6.1",
 ]
+cli = [
+    "typer-slim[standard]>=0.15.2",
+]
 
 [tool.ruff]
 include = ["pyproject.toml", "python/fabricatio/*.py", "python/fabricatio/*.pyi", "examples/*.py"]
@@ -134,7 +137,8 @@ ignore = [
     "PYI063",
     "PYI021",
     "ASYNC109",
-    "RUF001"
+    "RUF001",
+    "PYI019"
 ]
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{fabricatio-0.2.11.dev2 → fabricatio-0.2.12.dev1}/python/fabricatio/actions/article.py

@@ -149,10 +149,10 @@ class GenerateInitialOutline(Action, Extract):
     async def _execute(
         self,
         article_proposal: ArticleProposal,
+        supervisor: Optional[bool] = None,
         **_,
     ) -> Optional[ArticleOutline]:
-        raw_outline = await self.aask(
-            f"{(article_proposal.as_prompt())}\n"
+        req = (
             f"Design each chapter of a proper and academic and ready for release manner.\n"
             f"You Must make sure every chapter have sections, and every section have subsections.\n"
             f"Make the chapter and sections and subsections bing divided into a specific enough article component.\n"
@@ -160,14 +160,16 @@ class GenerateInitialOutline(Action, Extract):
             f"Note that you SHALL use `{article_proposal.language}` as written language",
         )
 
-        if self.supervisor:
+        raw_outline = await self.aask(f"{(article_proposal.as_prompt())}\n{req}")
+
+        if supervisor or (supervisor is None and self.supervisor):
             from questionary import confirm, text
 
             r_print(raw_outline)
             while not await confirm("Accept this version and continue?", default=True).ask_async():
                 imp = await text("Enter the improvement:").ask_async()
                 raw_outline = await self.aask(
-                    f"{article_proposal.as_prompt()}\n{wrapp_in_block(raw_outline, 'Previous ArticleOutline')}\n{imp}"
+                    f"{article_proposal.as_prompt()}\n{wrapp_in_block(raw_outline, 'Previous ArticleOutline')}\n{req}\n{wrapp_in_block(imp, title='Improvement')}"
                 )
                 r_print(raw_outline)
 
@@ -177,6 +179,20 @@ class GenerateInitialOutline(Action, Extract):
         ).update_ref(article_proposal)
 
 
+class ExtractOutlineFromRaw(Action, Extract):
+    """Extract the outline from the raw outline."""
+
+    output_key: str = "article_outline_from_raw"
+
+    async def _execute(self, article_outline_raw_path: str | Path, **cxt) -> ArticleOutline:
+        logger.info(f"Extracting outline from raw: {Path(article_outline_raw_path).as_posix()}")
+
+        return ok(
+            await self.extract(ArticleOutline, safe_text_read(article_outline_raw_path)),
+            "Could not extract the outline from raw.",
+        )
+
+
 class FixIntrospectedErrors(Action, Censor):
     """Fix introspected errors in the article outline."""
 

{fabricatio-0.2.11.dev2 → fabricatio-0.2.12.dev1}/python/fabricatio/actions/article_rag.py

@@ -4,6 +4,8 @@ from asyncio import gather
 from pathlib import Path
 from typing import List, Optional
 
+from pydantic import PositiveInt
+
 from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.extract import Extract
@@ -18,13 +20,35 @@ from fabricatio.models.extra.article_outline import ArticleOutline
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ask_retain, ok
 
+TYPST_CITE_USAGE = (
+    "citation number is REQUIRED to cite any reference!,for example in Auther Pattern: 'Doe et al.[[1]], Jack et al.[[2]]' or in Sentence Suffix Sattern: 'Global requirement is incresing[[1]].'\n"
+    "Everything is build upon the typst language, which is similar to latex, \n"
+    "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
+    "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
+    "Those reference mark shall not be omitted during the extraction\n"
+    "It's recommended to cite multiple references that supports your conclusion at a time.\n"
+    "Wrapp inline expression using $ $,like '$>5m$' '$89%$' , and wrapp block equation using $$ $$. if you are using '$' as the money unit, you should add a '\\' before it to avoid being interpreted as a inline equation. For example 'The pants worths 5\\$.'\n"
+    "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>` like `<energy-release-rate-equation>`.Note that the label string should be a summarizing title for the equation being labeled.\n"
+    "you can refer to that label by using the syntax with prefix of `@eqt:`, which indicate that this notation is citing a label from the equations. For example ' @eqt:energy-release-rate-equation ' DO remember that the notation shall have both suffixed and prefixed space char which enable the compiler to distinguish the notation from the plaintext."
+    "Below is a usage example:\n"
+    "```typst\n"
+    "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
+    "$$\n"
+    "E = m c^2\n"
+    "$$  <mass-energy-equation>\n\n\n"
+    "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
+    "```"
+)
+
 
 class WriteArticleContentRAG(Action, RAG, Extract):
     """Write an article based on the provided outline."""
 
+    search_increment_multiplier: float = 1.6
+    """The increment multiplier of the search increment."""
     ref_limit: int = 35
     """The limit of references to be retrieved"""
-    threshold: float = 0.55
+    threshold: float = 0.62
     """The threshold of relevance"""
     extractor_model: str
     """The model to use for extracting the content from the retrieved references."""
@@ -32,43 +56,24 @@ class WriteArticleContentRAG(Action, RAG, Extract):
     """The model to use for querying the database"""
     supervisor: bool = False
     """Whether to use supervisor mode"""
-    req: str = (
-        "citation number is REQUIRED to cite any reference!\n"
-        "Everything is build upon the typst language, which is similar to latex, \n"
-        "Legal citing syntax examples(seperated by |): [[1]]|[[1,2]]|[[1-3]]|[[12,13-15]]|[[1-3,5-7]]\n"
-        "Illegal citing syntax examples(seperated by |): [[1],[2],[3]]|[[1],[1-2]]\n"
-        "Those reference mark shall not be omitted during the extraction\n"
-        "It's recommended to cite multiple references that supports your conclusion at a time.\n"
-        "Wrapp inline expression using $ $, and wrapp block equation using $$ $$."
-        "In addition to that, you can add a label outside the block equation which can be used as a cross reference identifier, the label is a string wrapped in `<` and `>`,"
-        "you can refer to that label by using the syntax with prefix of `@eqt:`"
-        "Below is a usage example:\n"
-        "```typst\n"
-        "See @eqt:mass-energy-equation , it's the foundation of physics.\n"
-        "$$\n"
-        "E = m c^2"
-        "$$\n"
-        "<mass-energy-equation>\n\n"
-        "In @eqt:mass-energy-equation , $m$ stands for mass, $c$ stands for speed of light, and $E$ stands for energy. \n"
-        "```"
-    )
+    result_per_query: PositiveInt = 4
+    """The number of results to be returned per query."""
+    req: str = TYPST_CITE_USAGE
+    """The req of the write article content."""
 
     async def _execute(
         self,
         article_outline: ArticleOutline,
-        writing_ruleset: RuleSet,
-        collection_name: str = "article_chunks",
+        collection_name: Optional[str] = None,
+        supervisor: Optional[bool] = None,
         **cxt,
     ) -> Article:
         article = Article.from_outline(article_outline).update_ref(article_outline)
+        self.target_collection = collection_name or self.safe_target_collection
+        if supervisor or (supervisor is None and self.supervisor):
+            for chap, sec, subsec in article.iter_subsections():
+                await self._supervisor_inner(article, article_outline, chap, sec, subsec)
 
-        if self.supervisor:
-            await gather(
-                *[
-                    self._supervisor_inner(article, article_outline, chap, sec, subsec)
-                    for chap, sec, subsec in article.iter_subsections()
-                ]
-            )
         else:
             await gather(
                 *[
@@ -92,21 +97,29 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         from questionary import confirm, text
         from rich import print as r_print
 
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-
-        cm = CitationManager(article_chunks=await ask_retain([r.chunk for r in ret], ret)).set_cite_number_all()
+        cm = CitationManager()
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
         r_print(raw)
+
         while not await confirm("Accept this version and continue?").ask_async():
-            if await confirm("Search for more refs?").ask_async():
-                new_refs = await self.search_database(article, article_outline, chap, sec, subsec)
-                cm.add_chunks(await ask_retain([r.chunk for r in new_refs], new_refs))
+            if inst := await text("Search for more refs for additional spec.").ask_async():
+                await self.search_database(
+                    article,
+                    article_outline,
+                    chap,
+                    sec,
+                    subsec,
+                    cm,
+                    supervisor=True,
+                    extra_instruction=inst,
+                )
 
-            instruction = await text("Enter the instructions to improve").ask_async()
-            raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
-            if await confirm("Edit it?").ask_async():
-                raw = await text("Edit", default=raw).ask_async() or raw
+            if instruction := await text("Enter the instructions to improve").ask_async():
+                raw = await self.write_raw(article, article_outline, chap, sec, subsec, cm, instruction)
+            if edt := await text("Edit", default=raw).ask_async():
+                raw = edt
 
             r_print(raw)
 
@@ -120,11 +133,14 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         sec: ArticleSection,
         subsec: ArticleSubsection,
     ) -> ArticleSubsection:
-        ret = await self.search_database(article, article_outline, chap, sec, subsec)
-        cm = CitationManager(article_chunks=ret).set_cite_number_all()
+        cm = CitationManager()
+
+        await self.search_database(article, article_outline, chap, sec, subsec, cm)
 
         raw_paras = await self.write_raw(article, article_outline, chap, sec, subsec, cm)
 
+        raw_paras = "\n".join(p for p in raw_paras.splitlines() if p and not p.endswith("**") and not p.startswith("#"))
+
         return await self.extract_new_subsec(subsec, raw_paras, cm)
 
     async def extract_new_subsec(
@@ -138,6 +154,7 @@ class WriteArticleContentRAG(Action, RAG, Extract):
                 f"Above is the subsection titled `{subsec.title}`.\n"
                 f"I need you to extract the content to update my subsection obj provided below.\n{self.req}"
                 f"{subsec.display()}\n",
+                model=self.extractor_model,
             ),
             "Failed to propose new subsection.",
         )
@@ -161,12 +178,15 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         return (
             (
                 await self.aask(
-                    f"{cm.as_prompt()}\nAbove is some related reference retrieved for you."
+                    f"{cm.as_prompt()}\nAbove is some related reference from other auther retrieved for you."
                     f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
                     f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
                     f"Please help me write the paragraphs of the subsec mentioned above, which is `{subsec.title}`.\n"
                     f"{self.req}\n"
-                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}"
+                    f"You SHALL use `{article.language}` as writing language.\n{extra_instruction}\n"
+                    f"Do not use numbered list to display the outcome, you should regard you are writing the main text of the thesis.\n"
+                    f"You should not copy others' works from the references directly on to my thesis, we can only harness the conclusion they have drawn.\n"
+                    f"No extra explanation is allowed."
                 )
             )
             .replace(r" \( ", "$")
@@ -174,7 +194,9 @@ class WriteArticleContentRAG(Action, RAG, Extract):
             .replace(r"\(", "$")
             .replace(r"\)", "$")
             .replace("\\[\n", "$$\n")
+            .replace("\\[ ", "$$\n")
             .replace("\n\\]", "\n$$")
+            .replace(" \\]", "\n$$")
         )
 
     async def search_database(
@@ -184,27 +206,113 @@ class WriteArticleContentRAG(Action, RAG, Extract):
         chap: ArticleChapter,
         sec: ArticleSection,
         subsec: ArticleSubsection,
+        cm: CitationManager,
         extra_instruction: str = "",
-    ) -> List[ArticleChunk]:
+        supervisor: bool = False,
+    ) -> None:
         """Search database for related references."""
+        search_req = (
+            f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
+            f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
+            f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
+            f"provide 10~16 queries as possible, to get best result!\n"
+            f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n"
+        )
+
         ref_q = ok(
             await self.arefined_query(
-                f"{article_outline.finalized_dump()}\n\nAbove is my article outline, I m writing graduate thesis titled `{article.title}`. "
-                f"More specifically, i m witting the Chapter `{chap.title}` >> Section `{sec.title}` >> Subsection `{subsec.title}`.\n"
-                f"I need to search related references to build up the content of the subsec mentioned above, which is `{subsec.title}`.\n"
-                f"provide 10~16 queries as possible, to get best result!\n"
-                f"You should provide both English version and chinese version of the refined queries!\n{extra_instruction}\n",
+                search_req,
                 model=self.query_model,
             ),
             "Failed to refine query.",
         )
 
-        if self.supervisor:
+        if supervisor:
+            ref_q = await ask_retain(ref_q)
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=self.ref_limit,
+            result_per_query=self.result_per_query,
+            similarity_threshold=self.threshold,
+        )
+
+        cm.add_chunks(ok(ret))
+        ref_q = await self.arefined_query(
+            f"{cm.as_prompt()}\n\nAbove is the retrieved references in the first RAG, now we need to perform the second RAG.\n\n{search_req}",
+            model=self.query_model,
+        )
+
+        if ref_q is None:
+            logger.warning("Second refine query is None, skipping.")
+            return
+        if supervisor:
             ref_q = await ask_retain(ref_q)
 
-        return await self.aretrieve(
-            ref_q, ArticleChunk, final_limit=self.ref_limit, result_per_query=3, similarity_threshold=self.threshold
+        ret = await self.aretrieve(
+            ref_q,
+            ArticleChunk,
+            final_limit=int(self.ref_limit * self.search_increment_multiplier),
+            result_per_query=int(self.result_per_query * self.search_increment_multiplier),
+            similarity_threshold=self.threshold,
         )
+        if ret is None:
+            logger.warning("Second retrieve is None, skipping.")
+            return
+        cm.add_chunks(ret)
+
+
+class ArticleConsultRAG(Action, RAG):
+    """Write an article based on the provided outline."""
+
+    output_key: str = "consult_count"
+
+    ref_limit: int = 20
+    """The final limit of references."""
+    ref_per_q: int = 3
+    """The limit of references to retrieve per query."""
+    similarity_threshold: float = 0.62
+    """The similarity threshold of references to retrieve."""
+    ref_q_model: Optional[str] = None
+    """The model to use for refining query."""
+    req: str = TYPST_CITE_USAGE
+    """The request for the rag model."""
+
+    @precheck_package(
+        "questionary", "`questionary` is required for supervisor mode, please install it by `fabricatio[qa]`"
+    )
+    async def _execute(self, collection_name: Optional[str] = None, **cxt) -> int:
+        from questionary import confirm, text
+        from rich import print as r_print
+
+        from fabricatio.rust import convert_all_block_tex, convert_all_inline_tex
+
+        self.target_collection = collection_name or self.safe_target_collection
+
+        cm = CitationManager()
+
+        counter = 0
+        while (req := await text("User: ").ask_async()) is not None:
+            if await confirm("Empty the cm?").ask_async():
+                cm.empty()
+            ref_q = await self.arefined_query(req, model=self.ref_q_model)
+            refs = await self.aretrieve(
+                ok(ref_q, "Failed to refine query."),
+                ArticleChunk,
+                final_limit=self.ref_limit,
+                result_per_query=self.ref_per_q,
+                similarity_threshold=self.similarity_threshold,
+            )
+
+            ret = await self.aask(f"{cm.add_chunks(refs).as_prompt()}\n{self.req}\n{req}")
+            ret = convert_all_inline_tex(ret)
+            ret = convert_all_block_tex(ret)
+            ret = cm.apply(ret)
+
+            r_print(ret)
+            counter += 1
+        logger.info(f"{counter} rounds of conversation.")
+        return counter
 
 
 class TweakArticleRAG(Action, RAG, Censor):