fabricatio 0.2.10.dev0__tar.gz → 0.2.10.dev1__tar.gz

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fabricatio
-Version: 0.2.10.dev0
+Version: 0.2.10.dev1
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.12
@@ -23,7 +23,6 @@ Requires-Dist: pymitter>=1.0.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: regex>=2024.11.6
 Requires-Dist: rich>=13.9.4
-Requires-Dist: rtoml>=0.12.0
 Requires-Dist: pymilvus>=2.5.4 ; extra == 'rag'
 Requires-Dist: fabricatio[calc,plot,rag] ; extra == 'full'
 Requires-Dist: sympy>=1.13.3 ; extra == 'calc'
@@ -45,8 +44,6 @@ Project-URL: Issues, https://github.com/Whth/fabricatio/issues
 # Fabricatio
 
 ![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
-![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 
 ## Overview
 

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/README.md

@@ -1,8 +1,6 @@
 # Fabricatio
 
 ![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)
-![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)
-![Build Status](https://img.shields.io/badge/build-passing-brightgreen)
 
 ## Overview
 

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/examples/extract_and_inject/.gitignore

@@ -1,3 +1,4 @@
 bpdf_out
 output*
-ref.bib
+ref.bib
+bare_md

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/examples/extract_and_inject/ask.py

@@ -2,8 +2,10 @@
 
 import asyncio
 
-from fabricatio import RAG, Action, Role, Task, WorkFlow, logger
+from fabricatio import Action, Role, Task, WorkFlow, logger
+from fabricatio.capabilities.rag import RAG
 from fabricatio.models.events import Event
+from fabricatio.models.extra.aricle_rag import ArticleChunk
 from fabricatio.utils import ok
 from questionary import text
 
@@ -23,14 +25,14 @@ class Talk(Action, RAG):
                 user_say = await text("User: ").ask_async()
                 if user_say is None:
                     break
-                gpt_say = await self.aask_refined(
-                    user_say,
-                    "article_essence_max",
-                    extra_system_message=f"You have to answer to user obeying task assigned to you:\n{task_input.briefing}\nYou should explicitly say write a label if you draw a conclusion from the references, the label shall contain names.",
-                    result_per_query=16,
-                    final_limit=40,
-                    similarity_threshold=0.31,
-                )
+                ref_q = ok(await self.arefined_query(user_say))
+                logger.info(f'refined query: \n{ref_q}')
+                ret = await self.aretrieve(ref_q, document_model=ArticleChunk)
+
+                sys_msg = "\n".join(r.as_prompt() for r in ret)
+                logger.info(f"System message: \n{sys_msg}")
+                gpt_say = await self.aask(user_say, sys_msg)
+
                 print(f"GPT: {gpt_say}")  # noqa: T201
                 counter += 1
         except KeyboardInterrupt:
@@ -40,18 +42,15 @@ class Talk(Action, RAG):
 
 async def main() -> None:
     """Main function."""
-    role = Role(
+    Role(
         name="talker",
         description="talker role but with rag",
-        registry={Event.instantiate_from("talk").push_wildcard().push("pending"): WorkFlow(name="talk", steps=(Talk,))},
+        registry={
+            Event.quick_instantiate("talk"): WorkFlow(name="talk", steps=(Talk(target_collection="article_chunks"),))
+        },
     )
 
-    task = ok(
-        await role.propose_task(
-            "you have to act as a helpful assistant, answer to all user questions properly and patiently"
-        ),
-        "Failed to propose task",
-    )
+    task = Task(name="answer user's questions")
     _ = await task.delegate("talk")
 
 

fabricatio-0.2.10.dev1/examples/extract_and_inject/chunk_article.py

@@ -0,0 +1,41 @@
+"""Example of proposing a task to a role."""
+
+import asyncio
+
+from fabricatio import BibManager, Event, Role, Task, WorkFlow, logger
+from fabricatio.actions.article_rag import ChunkArticle
+from fabricatio.actions.rag import InjectToDB
+from fabricatio.fs import gather_files
+from fabricatio.utils import ok
+
+
+async def main() -> None:
+    """Main function."""
+    Role(
+        name="Researcher",
+        description="chunk the article",
+        llm_rpm=50,
+        llm_tpm=100000,
+        registry={
+            Event.quick_instantiate(e := "Chunk"): WorkFlow(
+                name="Chunk",
+                steps=(
+                    ChunkArticle(output_key="to_inject"),
+                    InjectToDB(collection_name="article_chunks").to_task_output(),
+                ),
+            ).update_init_context(
+                article_path=gather_files("bare_md", "md"),
+                bib_manager=BibManager(path="ref.bib"),
+                max_chunk_size=500,
+                max_overlapping_rate=0.3,
+            ),
+        },
+    )
+
+    task: Task[str] = Task(name="Chunk Article")
+    res = ok(await task.delegate(e))
+    logger.success(f"Injected to {res}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/examples/search_bibtex/search.py

@@ -3,7 +3,7 @@ from fabricatio import BibManager, logger
 
 b = BibManager("Exported Items.bib")
 logger.success(
-    b.get_cite_key("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
+    b.get_cite_key_by_title("A Negative Selection Immune System Inspired Methodology for Fault Diagnosis of Wind Turbines"))
 logger.success(
     b.get_cite_key_fuzzy(
         "System Inspired Methodology for Fault"

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fabricatio"
-version = "0.2.10-dev0"
+version = "0.2.10-dev1"
 description = "A LLM multi-agent framework."
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -42,7 +42,6 @@ dependencies = [
     "questionary>=2.1.0",
     "regex>=2024.11.6",
     "rich>=13.9.4",
-    "rtoml>=0.12.0",
 ]
 
 [project.urls]

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/python/fabricatio/actions/article.py

@@ -4,6 +4,7 @@ from asyncio import gather
 from pathlib import Path
 from typing import Callable, List, Optional
 
+from fabricatio.rust import BibManager, detect_language
 from more_itertools import filter_map
 
 from fabricatio.capabilities.censor import Censor
@@ -17,7 +18,6 @@ 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, detect_language
 from fabricatio.utils import ok
 
 
@@ -78,7 +78,7 @@ class FixArticleEssence(Action):
         out = []
         count = 0
         for a in article_essence:
-            if key := (bib_mgr.get_cite_key(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
+            if key := (bib_mgr.get_cite_key_by_title(a.title) or bib_mgr.get_cite_key_fuzzy(a.title)):
                 a.title = bib_mgr.get_title_by_key(key) or a.title
                 a.authors = bib_mgr.get_author_by_key(key) or a.authors
                 a.publication_year = bib_mgr.get_year_by_key(key) or a.publication_year

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/python/fabricatio/actions/article_rag.py

@@ -1,11 +1,15 @@
 """A module for writing articles using RAG (Retrieval-Augmented Generation) capabilities."""
 
 from asyncio import gather
-from typing import Optional
+from pathlib import Path
+from typing import List, Optional
 
+from fabricatio import BibManager
 from fabricatio.capabilities.censor import Censor
 from fabricatio.capabilities.rag import RAG
 from fabricatio.models.action import Action
+from fabricatio.models.extra.aricle_rag import ArticleChunk
+from fabricatio.models.extra.article_essence import ArticleEssence
 from fabricatio.models.extra.article_main import Article, ArticleSubsection
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.utils import ok
@@ -97,9 +101,36 @@ class TweakArticleRAG(Action, RAG, Censor):
         await self.censor_obj_inplace(
             subsec,
             ruleset=ruleset,
-            reference=f"{await self.aretrieve_compact(refind_q, final_limit=self.ref_limit)}\n\n"
+            reference=f"{'\n\n'.join(d.display() for d in await self.aretrieve(refind_q, document_model=ArticleEssence, final_limit=self.ref_limit))}\n\n"
             f"You can use Reference above to rewrite the `{subsec.__class__.__name__}`.\n"
             f"You should Always use `{subsec.language}` as written language, "
             f"which is the original language of the `{subsec.title}`. "
             f"since rewrite a `{subsec.__class__.__name__}` in a different language is usually a bad choice",
         )
+
+
+class ChunkArticle(Action):
+    """Chunk an article into smaller chunks."""
+
+    output_key:str = "article_chunks"
+    """The key used to store the output of the action."""
+    max_chunk_size: Optional[int] = None
+    """The maximum size of each chunk."""
+    max_overlapping_rate: Optional[float] = None
+    """The maximum overlapping rate between chunks."""
+
+    async def _execute(
+        self,
+        article_path: str | Path,
+        bib_manager: BibManager,
+        max_chunk_size: Optional[int] = None,
+        max_overlapping_rate: Optional[float] = None,
+        **_,
+    ) -> List[ArticleChunk]:
+        return ArticleChunk.from_file(
+            article_path,
+            bib_manager,
+            max_chunk_size=ok(max_chunk_size or self.max_chunk_size, "No max_chunk_size provided!"),
+            max_overlapping_rate=ok(max_overlapping_rate or self.max_overlapping_rate, "No max_overlapping_rate provided!"),
+        )
+

fabricatio-0.2.10.dev1/python/fabricatio/actions/rag.py

@@ -0,0 +1,96 @@
+"""Inject data into the database."""
+
+from typing import List, Optional
+
+from questionary import text
+
+from fabricatio.capabilities.rag import RAG
+from fabricatio.config import configs
+from fabricatio.journal import logger
+from fabricatio.models.action import Action
+from fabricatio.models.extra.rag import MilvusClassicModel, MilvusDataBase
+from fabricatio.models.task import Task
+from fabricatio.utils import ok
+
+
+class InjectToDB(Action, RAG):
+    """Inject data into the database."""
+
+    output_key: str = "collection_name"
+    collection_name: str = "my_collection"
+    """The name of the collection to inject data into."""
+
+    async def _execute[T: MilvusDataBase](
+        self, to_inject: Optional[T] | List[Optional[T]], override_inject: bool = False, **_
+    ) -> Optional[str]:
+        from pymilvus.milvus_client import IndexParams
+
+        if to_inject is None:
+            return None
+        if not isinstance(to_inject, list):
+            to_inject = [to_inject]
+        if not (seq := [t for t in to_inject if t is not None]):  # filter out None
+            return None
+        logger.info(f"Injecting {len(seq)} items into the collection '{self.collection_name}'")
+        if override_inject:
+            self.check_client().client.drop_collection(self.collection_name)
+
+        await self.view(
+            self.collection_name,
+            create=True,
+            schema=seq[0].as_milvus_schema(
+                ok(
+                    self.milvus_dimensions
+                    or configs.rag.milvus_dimensions
+                    or self.embedding_dimensions
+                    or configs.embedding.dimensions
+                ),
+            ),
+            index_params=IndexParams(
+                seq[0].vector_field_name,
+                index_name=seq[0].vector_field_name,
+                index_type=seq[0].index_type,
+                metric_type=seq[0].metric_type,
+            ),
+        ).add_document(seq, flush=True)
+
+        return self.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
+                ret: List[MilvusClassicModel] = await self.aretrieve(user_say, document_model=MilvusClassicModel)
+
+                gpt_say = await self.aask(
+                    user_say, system_message="\n".join(m.text for m in ret) + "\nYou can refer facts provided above."
+                )
+                print(f"GPT: {gpt_say}")  # noqa: T201
+                counter += 1
+        except KeyboardInterrupt:
+            logger.info(f"executed talk action {counter} times")
+        return counter

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/python/fabricatio/capabilities/rag.py

@@ -130,7 +130,7 @@ class RAG(EmbeddingUsage):
         if isinstance(data, MilvusDataBase):
             data = [data]
 
-        data_vec = await self.vectorize([d.to_vectorize for d in data])
+        data_vec = await self.vectorize([d.prepare_vectorization() for d in data])
         prepared_data = [d.prepare_insertion(vec) for d, vec in zip(data, data_vec, strict=True)]
 
         c_name = collection_name or self.safe_target_collection
@@ -188,13 +188,15 @@ class RAG(EmbeddingUsage):
     async def aretrieve[D: MilvusDataBase](
         self,
         query: List[str] | str,
+        document_model: Type[D],
         final_limit: int = 20,
-        **kwargs: Unpack[FetchKwargs[D]],
+        **kwargs: Unpack[FetchKwargs],
     ) -> List[D]:
         """Retrieve data from the collection.
 
         Args:
             query (List[str] | str): The query to be used for retrieval.
+            document_model (Type[D]): The model class used to convert retrieved data into document objects.
             final_limit (int): The final limit on the number of results to return.
             **kwargs (Unpack[FetchKwargs]): Additional keyword arguments for retrieval.
 
@@ -206,6 +208,7 @@ class RAG(EmbeddingUsage):
         return (
             await self.afetch_document(
                 vecs=(await self.vectorize(query)),
+                document_model=document_model,
                 **kwargs,
             )
         )[:final_limit]

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/python/fabricatio/models/adv_kwargs_types.py

@@ -1,10 +1,9 @@
 """A module containing kwargs types for content correction and checking operations."""
 
 from importlib.util import find_spec
-from typing import Required, Type, TypedDict
+from typing import NotRequired, TypedDict
 
 from fabricatio.models.extra.problem import Improvement
-from fabricatio.models.extra.rag import MilvusDataBase
 from fabricatio.models.extra.rule import RuleSet
 from fabricatio.models.generic import SketchedAble
 from fabricatio.models.kwargs_types import ReferencedKwargs
@@ -49,19 +48,13 @@ if find_spec("pymilvus"):
         schema: CollectionSchema | None
         index_params: IndexParams | None
 
-    class FetchKwargs[D: MilvusDataBase](TypedDict, total=False):
+    class FetchKwargs(TypedDict):
         """Arguments for fetching data from vector collections.
 
         Controls how data is retrieved from vector databases, including filtering
         and result limiting parameters.
         """
 
-        document_model: Required[Type[D]]
-        collection_name: str | None
-        similarity_threshold: float
-        result_per_query: int
-
-    class RetrievalKwargs(FetchKwargs, total=False):
-        """Arguments for retrieval operations."""
-
-        final_limit: int
+        collection_name: NotRequired[str | None]
+        similarity_threshold: NotRequired[float]
+        result_per_query: NotRequired[int]

fabricatio-0.2.10.dev1/python/fabricatio/models/extra/aricle_rag.py

@@ -0,0 +1,120 @@
+"""A Module containing the article rag models."""
+
+from pathlib import Path
+from typing import ClassVar, Dict, List, Self, Unpack
+
+from fabricatio.fs import safe_text_read
+from fabricatio.journal import logger
+from fabricatio.models.extra.rag import MilvusDataBase
+from fabricatio.models.generic import AsPrompt
+from fabricatio.models.kwargs_types import ChunkKwargs
+from fabricatio.rust import BibManager, split_into_chunks
+from fabricatio.utils import ok, wrapp_in_block
+from more_itertools.recipes import flatten
+from pydantic import Field
+
+
+class ArticleChunk(MilvusDataBase, AsPrompt):
+    """The chunk of an article."""
+
+    head_split: ClassVar[List[str]] = [
+        "引 言",
+        "引言",
+        "绪 论",
+        "绪论",
+        "前言",
+        "INTRODUCTION",
+        "Introduction",
+    ]
+    tail_split: ClassVar[List[str]] = [
+        "参 考 文 献",
+        "参  考  文  献",
+        "参考文献",
+        "REFERENCES",
+        "References",
+        "Bibliography",
+        "Reference",
+    ]
+    chunk: str
+    """The segment of the article"""
+    year: int
+    """The year of the article"""
+    authors: List[str] = Field(default_factory=list)
+    """The authors of the article"""
+    article_title: str
+    """The title of the article"""
+    bibtex_cite_key: str
+    """The bibtex cite key of the article"""
+
+    def _as_prompt_inner(self) -> Dict[str, str]:
+        return {
+            self.article_title: f"{wrapp_in_block(self.chunk, 'Referring Content')}\n"
+            f"Authors: {';'.join(self.authors)}\n"
+            f"Published Year: {self.year}\n"
+            f"Bibtex Key: {self.bibtex_cite_key}\n",
+        }
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.chunk
+
+    @classmethod
+    def from_file[P: str | Path](
+        cls, path: P | List[P], bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]
+    ) -> List[Self]:
+        """Load the article chunks from the file."""
+        if isinstance(path, list):
+            result = list(flatten(cls._from_file_inner(p, bib_mgr, **kwargs) for p in path))
+            logger.debug(f"Number of chunks created from list of files: {len(result)}")
+            return result
+
+        return cls._from_file_inner(path, bib_mgr, **kwargs)
+
+    @classmethod
+    def _from_file_inner(cls, path: str | Path, bib_mgr: BibManager, **kwargs: Unpack[ChunkKwargs]) -> List[Self]:
+        path = Path(path)
+
+        title_seg = path.stem.split(" - ").pop()
+
+        key = (
+            bib_mgr.get_cite_key_by_title(title_seg)
+            or bib_mgr.get_cite_key_by_title_fuzzy(title_seg)
+            or bib_mgr.get_cite_key_fuzzy(path.stem)
+        )
+        if key is None:
+            logger.warning(f"no cite key found for {path.as_posix()}, skip.")
+            return []
+        authors = ok(bib_mgr.get_author_by_key(key), f"no author found for {key}")
+        year = ok(bib_mgr.get_year_by_key(key), f"no year found for {key}")
+        article_title = ok(bib_mgr.get_title_by_key(key), f"no title found for {key}")
+
+        result = [
+            cls(chunk=c, year=year, authors=authors, article_title=article_title, bibtex_cite_key=key)
+            for c in split_into_chunks(cls.strip(safe_text_read(path)), **kwargs)
+        ]
+        logger.debug(f"Number of chunks created from file {path.as_posix()}: {len(result)}")
+        return result
+
+    @classmethod
+    def strip(cls, string: str) -> str:
+        """Strip the head and tail of the string."""
+        logger.debug(f"String length before strip: {(original := len(string))}")
+        for split in (s for s in cls.head_split if s in string):
+            logger.debug(f"Strip head using {split}")
+            parts = string.split(split)
+            string = split.join(parts[1:]) if len(parts) > 1 else parts[0]
+            break
+        logger.debug(
+            f"String length after head strip: {(stripped_len := len(string))}, decreased by {(d := original - stripped_len)}"
+        )
+        if not d:
+            logger.warning("No decrease at head strip, which is might be abnormal.")
+        for split in (s for s in cls.tail_split if s in string):
+            logger.debug(f"Strip tail using {split}")
+            parts = string.split(split)
+            string = split.join(parts[:-1]) if len(parts) > 1 else parts[0]
+            break
+        logger.debug(f"String length after tail strip: {len(string)}, decreased by {(d := stripped_len - len(string))}")
+        if not d:
+            logger.warning("No decrease at tail strip, which is might be abnormal.")
+
+        return string

{fabricatio-0.2.10.dev0 → fabricatio-0.2.10.dev1}/python/fabricatio/models/extra/article_essence.py

@@ -1,8 +1,9 @@
 """ArticleEssence: Semantic fingerprint of academic paper for structured analysis."""
 
-from typing import List, Self
+from typing import List
 
-from fabricatio.models.generic import Display, PersistentAble, ProposedAble, Vectorizable
+from fabricatio.models.extra.rag import MilvusDataBase
+from fabricatio.models.generic import PersistentAble, SketchedAble
 from pydantic import BaseModel
 
 
@@ -54,7 +55,7 @@ class Highlightings(BaseModel):
     """
 
 
-class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
+class ArticleEssence(SketchedAble, PersistentAble, MilvusDataBase):
     """Structured representation of a scientific article's core elements in its original language."""
 
     language: str
@@ -93,7 +94,7 @@ class ArticleEssence(ProposedAble, Display, PersistentAble, Vectorizable):
     bibtex_cite_key: str
     """Bibtex cite key of the original article."""
 
-    def update_cite_key(self, new_cite_key: str) -> Self:
-        """Update the bibtex_cite_key of the article."""
-        self.bibtex_cite_key = new_cite_key
-        return self
+    def _prepare_vectorization_inner(self) -> str:
+        return self.compact()
+
+

fabricatio-0.2.10.dev1/python/fabricatio/models/extra/rag.py

@@ -0,0 +1,98 @@
+"""A module containing the RAG (Retrieval-Augmented Generation) models."""
+
+from abc import ABC
+from functools import partial
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Self, Sequence, Set
+
+from fabricatio.decorators import precheck_package
+from fabricatio.models.generic import Vectorizable
+from fabricatio.utils import ok
+from pydantic import JsonValue
+
+if TYPE_CHECKING:
+    from importlib.util import find_spec
+
+    from pydantic.fields import FieldInfo
+
+    if find_spec("pymilvus"):
+        from pymilvus import CollectionSchema
+
+
+class MilvusDataBase(Vectorizable, ABC):
+    """A base class for Milvus data."""
+
+    primary_field_name: ClassVar[str] = "id"
+    """The name of the primary field in Milvus."""
+    vector_field_name: ClassVar[str] = "vector"
+    """The name of the vector field in Milvus."""
+
+    index_type: ClassVar[str] = "FLAT"
+    """The type of index to be used in Milvus."""
+    metric_type: ClassVar[str] = "COSINE"
+    """The type of metric to be used in Milvus."""
+
+    def prepare_insertion(self, vector: List[float]) -> Dict[str, Any]:
+        """Prepares the data for insertion into Milvus.
+
+        Returns:
+            dict: A dictionary containing the data to be inserted into Milvus.
+        """
+        return {**self.model_dump(exclude_none=True, by_alias=True), self.vector_field_name: vector}
+
+    @classmethod
+    @precheck_package(
+        "pymilvus", "pymilvus is not installed. Have you installed `fabricatio[rag]` instead of `fabricatio`?"
+    )
+    def as_milvus_schema(cls, dimension: int = 1024) -> "CollectionSchema":
+        """Generates the schema for Milvus collection."""
+        from pymilvus import CollectionSchema, DataType, FieldSchema
+
+        fields = [
+            FieldSchema(cls.primary_field_name, dtype=DataType.INT64, is_primary=True, auto_id=True),
+            FieldSchema(cls.vector_field_name, dtype=DataType.FLOAT_VECTOR, dim=dimension),
+        ]
+
+        for k, v in cls.model_fields.items():
+            k: str
+            v: FieldInfo
+            schema = partial(FieldSchema, k, description=v.description or "")
+            anno = ok(v.annotation)
+
+            if anno == int:
+                fields.append(schema(dtype=DataType.INT64))
+            elif anno == str:
+                fields.append(schema(dtype=DataType.VARCHAR, max_length=65535))
+            elif anno == float:
+                fields.append(schema(dtype=DataType.DOUBLE))
+            elif anno == list[str] or anno == List[str] or anno == set[str] or anno == Set[str]:
+                fields.append(
+                    schema(dtype=DataType.ARRAY, element_type=DataType.VARCHAR, max_length=65535, max_capacity=4096)
+                )
+            elif anno == list[int] or anno == List[int] or anno == set[int] or anno == Set[int]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.INT64, max_capacity=4096))
+            elif anno == list[float] or anno == List[float] or anno == set[float] or anno == Set[float]:
+                fields.append(schema(dtype=DataType.ARRAY, element_type=DataType.DOUBLE, max_capacity=4096))
+            elif anno == JsonValue:
+                fields.append(schema(dtype=DataType.JSON))
+
+            else:
+                raise NotImplementedError(f"{k}:{anno} is not supported")
+
+        return CollectionSchema(fields)
+
+    @classmethod
+    def from_sequence(cls, data: Sequence[Dict[str, Any]]) -> List[Self]:
+        """Constructs a list of instances from a sequence of dictionaries."""
+        return [cls(**d) for d in data]
+
+
+class MilvusClassicModel(MilvusDataBase):
+    """A class representing a classic model stored in Milvus."""
+
+    text: str
+    """The text to be stored in Milvus."""
+    subject: str = ""
+    """The subject of the text."""
+
+    def _prepare_vectorization_inner(self) -> str:
+        return self.text