fabricatio 0.2.5.dev4__cp312-cp312-manylinux_2_34_x86_64.whl → 0.2.6__cp312-cp312-manylinux_2_34_x86_64.whl

fabricatio/__init__.py

@@ -2,59 +2,42 @@
 
 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.actions.article import ExtractArticleEssence, GenerateArticleProposal, GenerateOutline
-from fabricatio.actions.output import DumpFinalizedOutput
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.core import env
-from fabricatio.fs import magika, safe_json_read, safe_text_read
 from fabricatio.journal import logger
+from fabricatio.models import extra
 from fabricatio.models.action import Action, WorkFlow
 from fabricatio.models.events import Event
-from fabricatio.models.extra import ArticleEssence
 from fabricatio.models.role import Role
 from fabricatio.models.task import Task
 from fabricatio.models.tool import ToolBox
-from fabricatio.models.utils import Message, Messages
-from fabricatio.parser import Capture, CodeBlockCapture, JsonCapture, PythonCapture
-from fabricatio.toolboxes import arithmetic_toolbox, basic_toolboxes, fs_toolbox
-from fabricatio.workflows.articles import WriteOutlineWorkFlow
+from fabricatio.parser import Capture, GenericCapture, JsonCapture, PythonCapture
 
 __all__ = [
+    "TEMPLATE_MANAGER",
     "Action",
-    "ArticleEssence",
     "BibManager",
     "Capture",
-    "CodeBlockCapture",
-    "DumpFinalizedOutput",
     "Event",
-    "ExtractArticleEssence",
-    "GenerateArticleProposal",
-    "GenerateOutline",
+    "GenericCapture",
     "JsonCapture",
-    "Message",
-    "Messages",
     "PythonCapture",
     "Role",
     "Task",
     "ToolBox",
     "WorkFlow",
-    "WriteOutlineWorkFlow",
-    "arithmetic_toolbox",
-    "basic_toolboxes",
+    "actions",
     "env",
-    "fs_toolbox",
+    "extra",
     "logger",
-    "magika",
-    "safe_json_read",
-    "safe_text_read",
-    "template_manager",
+    "toolboxes",
+    "workflows",
 ]
 
 
 if find_spec("pymilvus"):
-    from fabricatio.actions.rag import InjectToDB
     from fabricatio.capabilities.rag import RAG
-    from fabricatio.workflows.rag import StoreArticle
 
-    __all__ += ["RAG", "InjectToDB", "StoreArticle"]
+    __all__ += ["RAG"]

fabricatio/_rust.pyi

@@ -9,8 +9,9 @@ class TemplateManager:
 
     See: https://crates.io/crates/handlebars
     """
+
     def __init__(
-        self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
+            self, template_dirs: List[Path], suffix: Optional[str] = None, active_loading: Optional[bool] = None
     ) -> None:
         """Initialize the template manager.
 
@@ -54,6 +55,7 @@ class TemplateManager:
             RuntimeError: If template rendering fails
         """
 
+
 def blake3_hash(content: bytes) -> str:
     """Calculate the BLAKE3 cryptographic hash of data.
 
@@ -64,6 +66,7 @@ def blake3_hash(content: bytes) -> str:
         Hex-encoded BLAKE3 hash string
     """
 
+
 class BibManager:
     """BibTeX bibliography manager for parsing and querying citation data."""
 
@@ -100,3 +103,13 @@ class BibManager:
             Uses nucleo_matcher for high-quality fuzzy text searching
             See: https://crates.io/crates/nucleo-matcher
         """
+
+    def list_titles(self, is_verbatim: Optional[bool] = False) -> List[str]:
+        """List all titles in the bibliography.
+
+        Args:
+            is_verbatim: Whether to return verbatim titles (without formatting)
+
+        Returns:
+            List of all titles in the bibliography
+        """

fabricatio/_rust_instances.py

@@ -3,7 +3,7 @@
 from fabricatio._rust import TemplateManager
 from fabricatio.config import configs
 
-template_manager = TemplateManager(
+TEMPLATE_MANAGER = TemplateManager(
     template_dirs=configs.templates.template_dir,
     suffix=configs.templates.template_suffix,
     active_loading=configs.templates.active_loading,

fabricatio/actions/article.py

@@ -2,13 +2,15 @@
 
 from os import PathLike
 from pathlib import Path
-from typing import Callable, List
+from typing import Any, Callable, List, Optional
 
 from fabricatio.fs import safe_text_read
 from fabricatio.journal import logger
 from fabricatio.models.action import Action
 from fabricatio.models.extra import ArticleEssence, ArticleOutline, ArticleProposal
 from fabricatio.models.task import Task
+from questionary import confirm, text
+from rich import print as rprint
 
 
 class ExtractArticleEssence(Action):
@@ -27,7 +29,7 @@ class ExtractArticleEssence(Action):
         task_input: Task,
         reader: Callable[[P], str] = lambda p: Path(p).read_text(encoding="utf-8"),
         **_,
-    ) -> List[ArticleEssence]:
+    ) -> Optional[List[ArticleEssence]]:
         if not task_input.dependencies:
             logger.info(err := "Task not approved, since no dependencies are provided.")
             raise RuntimeError(err)
@@ -51,7 +53,7 @@ class GenerateArticleProposal(Action):
         self,
         task_input: Task,
         **_,
-    ) -> ArticleProposal:
+    ) -> Optional[ArticleProposal]:
         input_path = await self.awhich_pathstr(
             f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
         )
@@ -66,16 +68,61 @@ class GenerateArticleProposal(Action):
 class GenerateOutline(Action):
     """Generate the article based on the outline."""
 
-    output_key: str = "article"
+    output_key: str = "article_outline"
     """The key of the output data."""
 
     async def _execute(
         self,
         article_proposal: ArticleProposal,
         **_,
-    ) -> ArticleOutline:
+    ) -> Optional[ArticleOutline]:
         return await self.propose(
             ArticleOutline,
             article_proposal.display(),
             system_message=f"# your personal briefing: \n{self.briefing}",
         )
+
+
+class CorrectProposal(Action):
+    """Correct the proposal of the article."""
+
+    output_key: str = "corrected_proposal"
+
+    async def _execute(self, task_input: Task, article_proposal: ArticleProposal, **_) -> Any:
+        input_path = await self.awhich_pathstr(
+            f"{task_input.briefing}\nExtract the path of file, which contains the article briefing that I need to read."
+        )
+
+        ret = None
+        while await confirm("Do you want to correct the Proposal?").ask_async():
+            rprint(article_proposal.display())
+            while not (topic := await text("What is the topic of the proposal reviewing?").ask_async()):
+                ...
+            ret = await self.correct_obj(
+                article_proposal,
+                safe_text_read(input_path),
+                topic=topic,
+            )
+        return ret or article_proposal
+
+
+class CorrectOutline(Action):
+    """Correct the outline of the article."""
+
+    output_key: str = "corrected_outline"
+    """The key of the output data."""
+
+    async def _execute(
+        self,
+        article_outline: ArticleOutline,
+        article_proposal: ArticleProposal,
+
+        **_,
+    ) -> Optional[str]:
+        ret = None
+        while await confirm("Do you want to correct the outline?").ask_async():
+            rprint(article_outline.finalized_dump())
+            while not (topic := await text("What is the topic of the outline reviewing?").ask_async()):
+                ...
+            ret = await self.correct_obj(article_outline, article_proposal.display(), topic=topic)
+        return ret or article_outline

fabricatio/actions/output.py

@@ -1,7 +1,5 @@
 """Dump the finalized output to a file."""
 
-from typing import Unpack
-
 from fabricatio.models.action import Action
 from fabricatio.models.generic import FinalizedDumpAble
 from fabricatio.models.task import Task
@@ -12,7 +10,7 @@ class DumpFinalizedOutput(Action):
 
     output_key: str = "dump_path"
 
-    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **cxt: Unpack) -> str:
+    async def _execute(self, task_input: Task, to_dump: FinalizedDumpAble, **_) -> str:
         dump_path = await self.awhich_pathstr(
             f"{task_input.briefing}\n\nExtract a single path of the file, to which I will dump the data."
         )

fabricatio/actions/rag.py

@@ -1,10 +1,13 @@
 """Inject data into the database."""
 
-from typing import List, Optional, Unpack
+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
+from fabricatio.models.task import Task
+from questionary import text
 
 
 class InjectToDB(Action, RAG):
@@ -13,13 +16,56 @@ 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", **cxt: Unpack
-    ) -> str:
+        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
+
+
+class RAGTalk(Action, RAG):
+    """RAG-enabled conversational action that processes user questions based on a given task.
+
+    This action establishes an interactive conversation loop where it retrieves context-relevant
+    information to answer user queries according to the assigned task briefing.
+
+    Notes:
+        task_input: Task briefing that guides how to respond to user questions
+        collection_name: Name of the vector collection to use for retrieval (default: "my_collection")
+
+    Returns:
+        Number of conversation turns completed before termination
+    """
+
+    output_key: str = "task_output"
+
+    async def _execute(self, task_input: Task[str], **kwargs) -> int:
+        collection_name = kwargs.get("collection_name", "my_collection")
+        counter = 0
+
+        self.view(collection_name, create=True)
+
+        try:
+            while True:
+                user_say = await text("User: ").ask_async()
+                if user_say is None:
+                    break
+                gpt_say = await self.aask_retrieved(
+                    user_say,
+                    user_say,
+                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}",
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter

fabricatio/capabilities/correct.py

@@ -0,0 +1,115 @@
+"""Correct capability module providing advanced review and validation functionality.
+
+This module implements the Correct capability, which extends the Review functionality
+to provide mechanisms for reviewing, validating, and correcting various objects and tasks
+based on predefined criteria and templates.
+"""
+
+from typing import Optional, Unpack, cast
+
+from fabricatio._rust_instances import TEMPLATE_MANAGER
+from fabricatio.capabilities.review import Review, ReviewResult
+from fabricatio.config import configs
+from fabricatio.models.generic import Display, ProposedAble, WithBriefing
+from fabricatio.models.kwargs_types import CorrectKwargs, ReviewKwargs
+from fabricatio.models.task import Task
+
+
+class Correct(Review):
+    """Correct capability for reviewing, validating, and improving objects.
+
+    This class enhances the Review capability with specialized functionality for
+    correcting and improving objects based on review feedback. It can process
+    various inputs including tasks, strings, and generic objects that implement
+    the required interfaces, applying corrections based on templated review processes.
+    """
+
+    async def correct_obj[M: ProposedAble](
+        self,
+        obj: M,
+        reference: str = "",
+        supervisor_check: bool = True,
+        **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]],
+    ) -> Optional[M]:
+        """Review and correct an object based on defined criteria and templates.
+
+        This method first conducts a review of the given object, then uses the review results
+        to generate a corrected version of the object using appropriate templates.
+
+        Args:
+            obj (M): The object to be reviewed and corrected. Must implement ProposedAble.
+            reference (str): A reference or contextual information for the object.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[M]: A corrected version of the input object, or None if correction fails.
+
+        Raises:
+            TypeError: If the provided object doesn't implement Display or WithBriefing interfaces.
+        """
+        if not isinstance(obj, (Display, WithBriefing)):
+            raise TypeError(f"Expected Display or WithBriefing, got {type(obj)}")
+
+        review_res = await self.review_obj(obj, **kwargs)
+        if supervisor_check:
+            await review_res.supervisor_check()
+        if "default" in kwargs:
+            cast(ReviewKwargs[None], kwargs)["default"] = None
+        return await self.propose(
+            obj.__class__,
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.correct_template,
+                {
+                    "content": f"{(reference + '\n\nAbove is referencing material') if reference else ''}{obj.display() if isinstance(obj, Display) else obj.briefing}",
+                    "review": review_res.display(),
+                },
+            ),
+            **kwargs,
+        )
+
+    async def correct_string(
+        self, input_text: str, supervisor_check: bool = True, **kwargs: Unpack[ReviewKwargs[ReviewResult[str]]]
+    ) -> Optional[str]:
+        """Review and correct a string based on defined criteria and templates.
+
+        This method applies the review process to the input text and generates
+        a corrected version based on the review results.
+
+        Args:
+            input_text (str): The text content to be reviewed and corrected.
+            supervisor_check (bool, optional): Whether to perform a supervisor check on the review results. Defaults to True.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[str]: The corrected text content, or None if correction fails.
+        """
+        review_res = await self.review_string(input_text, **kwargs)
+        if supervisor_check:
+            await review_res.supervisor_check()
+
+        if "default" in kwargs:
+            cast(ReviewKwargs[None], kwargs)["default"] = None
+        return await self.ageneric_string(
+            TEMPLATE_MANAGER.render_template(
+                configs.templates.correct_template, {"content": input_text, "review": review_res.display()}
+            ),
+            **kwargs,
+        )
+
+    async def correct_task[T](
+        self, task: Task[T], **kwargs: Unpack[CorrectKwargs[ReviewResult[str]]]
+    ) -> Optional[Task[T]]:
+        """Review and correct a task object based on defined criteria.
+
+        This is a specialized version of correct_obj specifically for Task objects,
+        applying the same review and correction process to task definitions.
+
+        Args:
+            task (Task[T]): The task to be reviewed and corrected.
+            **kwargs: Review configuration parameters including criteria and review options.
+
+        Returns:
+            Optional[Task[T]]: The corrected task, or None if correction fails.
+        """
+        return await self.correct_obj(task, **kwargs)

fabricatio/capabilities/propose.py

@@ -1,37 +1,37 @@
 """A module for the task capabilities of the Fabricatio library."""
 
-from typing import List, Type, Unpack, overload
+from typing import List, Optional, Type, Unpack, overload
 
 from fabricatio.models.generic import ProposedAble
-from fabricatio.models.kwargs_types import GenerateKwargs
+from fabricatio.models.kwargs_types import ValidateKwargs
 from fabricatio.models.usages import LLMUsage
 
 
-class Propose[M: ProposedAble](LLMUsage):
+class Propose(LLMUsage):
     """A class that proposes an Obj based on a prompt."""
 
     @overload
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str],
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> List[M]: ...
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M]]: ...
 
     @overload
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: str,
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> M: ...
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[M]: ...
 
-    async def propose(
+    async def propose[M: ProposedAble](
         self,
         cls: Type[M],
         prompt: List[str] | str,
-        **kwargs: Unpack[GenerateKwargs[M]],
-    ) -> List[M] | M:
+        **kwargs: Unpack[ValidateKwargs[M]],
+    ) -> Optional[List[M] | M]:
         """Asynchronously proposes a task based on a given prompt and parameters.
 
         Parameters:
@@ -42,14 +42,8 @@ class Propose[M: ProposedAble](LLMUsage):
         Returns:
             A Task object based on the proposal result.
         """
-        if isinstance(prompt, str):
-            return await self.aask_validate(
-                question=cls.create_json_prompt(prompt),
-                validator=cls.instantiate_from_string,
-                **kwargs,
-            )
-        return await self.aask_validate_batch(
-            questions=[cls.create_json_prompt(p) for p in prompt],
+        return await self.aask_validate(
+            question=cls.create_json_prompt(prompt),
             validator=cls.instantiate_from_string,
             **kwargs,
         )

fabricatio/capabilities/rag.py

@@ -8,20 +8,20 @@ from functools import lru_cache
 from operator import itemgetter
 from os import PathLike
 from pathlib import Path
-from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, overload
+from typing import Any, Callable, Dict, List, Optional, Self, Union, Unpack, cast, overload
 
-from fabricatio._rust_instances import template_manager
+from fabricatio._rust_instances import TEMPLATE_MANAGER
 from fabricatio.config import configs
 from fabricatio.journal import logger
 from fabricatio.models.kwargs_types import (
     ChooseKwargs,
-    CollectionSimpleConfigKwargs,
+    CollectionConfigKwargs,
     EmbeddingKwargs,
     FetchKwargs,
     LLMKwargs,
 )
 from fabricatio.models.usages import EmbeddingUsage
-from fabricatio.models.utils import MilvusData
+from fabricatio.models.utils import MilvusData, ok
 from more_itertools.recipes import flatten, unique
 from pydantic import Field, PrivateAttr
 
@@ -60,13 +60,21 @@ class RAG(EmbeddingUsage):
     ) -> Self:
         """Initialize the Milvus client."""
         self._client = create_client(
-            uri=milvus_uri or (self.milvus_uri or configs.rag.milvus_uri).unicode_string(),
+            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,18 +110,25 @@ 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 not self._client.has_collection(collection_name):
-            kwargs["dimension"] = kwargs.get("dimension") or self.milvus_dimensions or configs.rag.milvus_dimensions
-            self._client.create_collection(collection_name, auto_id=True, **kwargs)
+        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}")
 
         self.target_collection = collection_name
@@ -152,15 +167,17 @@ class RAG(EmbeddingUsage):
             Self: The current instance, allowing for method chaining.
         """
         if isinstance(data, MilvusData):
-            data = data.prepare_insertion()
-        if isinstance(data, list):
-            data = [d.prepare_insertion() if isinstance(d, MilvusData) else d for d in data]
+            prepared_data = data.prepare_insertion()
+        elif isinstance(data, list):
+            prepared_data = [d.prepare_insertion() if isinstance(d, MilvusData) else d for d in data]
+        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, data)
+        self.check_client().client.insert(c_name, prepared_data)
 
         if flush:
             logger.debug(f"Flushing collection {c_name}")
-            self._client.flush(c_name)
+            self.client.flush(c_name)
         return self
 
     async def consume_file(
@@ -196,14 +213,14 @@ class RAG(EmbeddingUsage):
         self.add_document(await self.pack(text), collection_name or self.safe_target_collection, flush=True)
         return self
 
-    async def afetch_document(
+    async def afetch_document[V: (int, str, float, bytes)](
         self,
         vecs: List[List[float]],
         desired_fields: List[str] | str,
         collection_name: Optional[str] = None,
         similarity_threshold: float = 0.37,
         result_per_query: int = 10,
-    ) -> List[Dict[str, Any]] | List[Any]:
+    ) -> List[Dict[str, Any]] | List[V]:
         """Fetch data from the collection.
 
         Args:
@@ -217,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},
@@ -237,7 +254,7 @@ class RAG(EmbeddingUsage):
 
         if isinstance(desired_fields, list):
             return resp
-        return [r.get(desired_fields) for r in resp]
+        return [r.get(desired_fields) for r in resp]  # extract the single field as list
 
     async def aretrieve(
         self,
@@ -257,12 +274,13 @@ class RAG(EmbeddingUsage):
         """
         if isinstance(query, str):
             query = [query]
-        return (
+        return cast(
+            List[str],
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
                 desired_fields="text",
                 **kwargs,
-            )
+            ),
         )[:final_limit]
 
     async def aask_retrieved(
@@ -303,7 +321,7 @@ class RAG(EmbeddingUsage):
             similarity_threshold=similarity_threshold,
         )
 
-        rendered = template_manager.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
+        rendered = TEMPLATE_MANAGER.render_template(configs.templates.retrieved_display_template, {"docs": docs[::-1]})
 
         logger.debug(f"Retrieved Documents: \n{rendered}")
         return await self.aask(
@@ -312,7 +330,7 @@ class RAG(EmbeddingUsage):
             **kwargs,
         )
 
-    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> List[str]:
+    async def arefined_query(self, question: List[str] | str, **kwargs: Unpack[ChooseKwargs]) -> Optional[List[str]]:
         """Refines the given question using a template.
 
         Args:
@@ -323,7 +341,7 @@ class RAG(EmbeddingUsage):
             List[str]: A list of refined questions.
         """
         return await self.aliststr(
-            template_manager.render_template(
+            TEMPLATE_MANAGER.render_template(
                 configs.templates.refined_query_template,
                 {"question": [question] if isinstance(question, str) else question},
             ),