swarmauri-standard 0.6.0.dev4__py3-none-any.whl

swarmauri_standard/README.md

@@ -0,0 +1,37 @@
+# Standard Library
+
+
+The Standard Library extends the Core Library with concrete implementations of models, agents, tools, parsers, and more. It aims to provide ready-to-use components that can be easily integrated into machine learning projects.
+
+## Features
+
+- **Predefined Models and Agents**: Implements standard models and agents ready for use.
+- **Toolkit**: A collection of tools for various tasks (e.g., weather information, math operations).
+- **Parsers Implementations**: Various parsers for text data, including HTML and CSV parsers.
+- **Conversations and Chunkers**: Manage conversation histories and chunk text data.
+- **Vectorizers**: Transform text data into vector representations.
+- **Document Stores and Vector Stores**: Concrete implementations for storing and retrieving data.
+
+## Getting Started
+
+To make the best use of the Standard Library, first ensure that the Core Library is set up in your project as the Standard Library builds upon it.
+
+```python
+# Example usage of a concrete model from the Standard Library
+from swarmauri.standard.models.concrete import OpenAIModel
+
+# Initialize the model with necessary configuration
+model = OpenAIModel(api_key="your_api_key_here")
+```
+
+## Documentation
+
+For more detailed guides and API documentation, check the [Docs](/docs) directory within the library. You'll find examples, configuration options, and best practices for utilizing the provided components.
+
+## Contributing
+
+Your contributions can help the Standard Library grow! Whether it's adding new tools, improving models, or writing documentation, we appreciate your help. Please send a pull request with your contributions.
+
+## License
+
+Please see the `LICENSE` file in the repository for details.

swarmauri_standard/__init__.py

@@ -0,0 +1,37 @@
+__long_desc__ = """
+# Swarmauri Standard SDK
+
+The Swarmauri Standard SDK offers a comprehensive suite of tools designed for building distributed, extensible systems using the Swarmauri framework. 
+
+## Standard
+- **Base Classes**: Provide a foundation for constructing Swarmauri components, with standardized methods and properties.
+- **Mixins**: Reusable code fragments designed to be integrated into various classes, offering shared functionality across different components.
+- **Concrete Classes**: Ready-to-use, pre-implemented classes that fulfill standard system needs while adhering to Swarmauri principles. **These classes are the first in line for ongoing support and maintenance, ensuring they remain stable, performant, and up to date with future SDK developments.**
+
+# Features
+
+- **Polymorphism**: Allows for dynamic behavior switching between components, enabling flexible, context-aware system behavior.
+- **Discriminated Unions**: Provides a robust method for handling multiple possible object types in a type-safe manner.
+- **Serialization**: Efficiently encode and decode data for transmission across different environments and system components, with support for both standard and custom serialization formats.
+- **Intensional and Extensional Programming**: Leverages both rule-based (intensional) and set-based (extensional) approaches to building and manipulating complex data structures, offering developers a wide range of tools for system design.
+
+## Use Cases
+
+- **Modular Systems**: Develop scalable, pluggable systems that can evolve over time by adding or modifying components without disrupting the entire ecosystem.
+- **Distributed Architectures**: Build systems with distributed nodes that seamlessly communicate using the SDK’s standardized interfaces.
+- **Third-Party Integrations**: Extend the system's capabilities by easily incorporating third-party tools, libraries, and services.
+- **Prototype and Experimentation**: Test cutting-edge ideas using the experimental components in the SDK, while retaining the reliability of core and standard features for production systems.
+
+# Future Development
+
+The Swarmauri SDK is an evolving platform, and the community is encouraged to contribute to its growth. Upcoming releases will focus on enhancing the framework's modularity, providing more advanced serialization methods, and expanding the community-driven component library.
+
+Visit us at: https://swarmauri.com
+Follow us at: https://github.com/swarmauri 
+"""
+from .__version__ import __version__
+
+__all__ = [
+    "__version__",
+    # other packages you want to expose
+]

swarmauri_standard/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.5.2.dev1"

swarmauri_standard/agents/QAAgent.py

@@ -0,0 +1,19 @@
+from typing import Any, Optional, Dict, Literal
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri.conversations.concrete.MaxSystemContextConversation import MaxSystemContextConversation
+from swarmauri.messages.concrete.HumanMessage import HumanMessage
+
+
+class QAAgent(AgentBase):
+    conversation: MaxSystemContextConversation = MaxSystemContextConversation(max_size=2)
+    type: Literal['QAAgent'] = 'QAAgent'
+
+    def exec(self, 
+        input_str: Optional[str] = "",
+        llm_kwargs: Optional[Dict] = {} 
+        ) -> Any:
+        
+        self.conversation.add_message(HumanMessage(content=input_str))
+        self.llm.predict(conversation=self.conversation, **llm_kwargs)
+        
+        return self.conversation.get_last().content

swarmauri_standard/agents/RagAgent.py

@@ -0,0 +1,99 @@
+from typing import Any, Optional, Union, Dict, Literal
+from swarmauri_core.messages import IMessage
+
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentRetrieveMixin import AgentRetrieveMixin
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri_base.agents.AgentVectorStoreMixin import AgentVectorStoreMixin
+from swarmauri_base.agents.AgentSystemContextMixin import AgentSystemContextMixin
+
+from swarmauri.messages.concrete import (HumanMessage, 
+                                                  SystemMessage,
+                                                  AgentMessage)
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.llms.LLMBase import LLMBase
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+from swarmauri_base.vector_stores.VectorStoreBase import VectorStoreBase
+
+class RagAgent(AgentRetrieveMixin, 
+               AgentVectorStoreMixin, 
+               AgentSystemContextMixin, 
+               AgentConversationMixin, 
+               AgentBase):
+    """
+    RagAgent (Retriever-And-Generator Agent) extends DocumentAgentBase,
+    specialized in retrieving documents based on input queries and generating responses.
+    """
+    llm: SubclassUnion[LLMBase]
+    conversation: SubclassUnion[ConversationBase]
+    vector_store: SubclassUnion[VectorStoreBase]
+    system_context:  Union[SystemMessage, str]
+    type: Literal['RagAgent'] = 'RagAgent'
+    
+    def _create_preamble_context(self):
+        substr = self.system_context.content
+        substr += '\n\n'
+        substr += '\n'.join([doc.content for doc in self.last_retrieved])
+        return substr
+
+    def _create_post_context(self):
+        substr = '\n'.join([doc.content for doc in self.last_retrieved])
+        substr += '\n\n'
+        substr += self.system_context.content
+        return substr
+
+    def exec(self, 
+             input_data: Optional[Union[str, IMessage]] = "", 
+             top_k: int = 5, 
+             preamble: bool = True,
+             fixed: bool = False,
+             llm_kwargs: Optional[Dict] = {}
+             ) -> Any:
+        try:
+            # Check if the input is a string, then wrap it in a HumanMessage
+            if isinstance(input_data, str):
+                human_message = HumanMessage(content=input_data)
+            elif isinstance(input_data, IMessage):
+                human_message = input_data
+            else:
+                raise TypeError("Input data must be a string or an instance of Message.")
+            
+            # Add the human message to the conversation
+            self.conversation.add_message(human_message)
+
+            # Retrieval and set new substr for system context
+            if top_k > 0 and len(self.vector_store.documents) > 0:
+                self.last_retrieved = self.vector_store.retrieve(query=input_data, top_k=top_k)
+
+                if preamble:
+                    substr = self._create_preamble_context()
+                else:
+                    substr = self._create_post_context()
+
+            else:
+                if fixed:
+                    if preamble:
+                        substr = self._create_preamble_context()
+                    else:
+                        substr = self._create_post_context()
+                else:
+                    substr = self.system_context.content
+                    self.last_retrieved = []
+                
+            # Use substr to set system context
+            system_context = SystemMessage(content=substr)
+            self.conversation.system_context = system_context
+            
+
+            # Retrieve the conversation history and predict a response
+            if llm_kwargs:
+                self.llm.predict(conversation=self.conversation, **llm_kwargs)
+            else:
+                self.llm.predict(conversation=self.conversation)
+                
+            return self.conversation.get_last().content
+
+        except Exception as e:
+            print(f"RagAgent error: {e}")
+            raise e

swarmauri_standard/agents/SimpleConversationAgent.py

@@ -0,0 +1,28 @@
+from typing import Any, Optional, Dict, Literal, List, Union
+
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri.messages.concrete import HumanMessage
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+
+from swarmauri.messages.concrete.HumanMessage import contentItem
+
+
+class SimpleConversationAgent(AgentConversationMixin, AgentBase):
+    conversation: SubclassUnion[ConversationBase]  #
+    type: Literal["SimpleConversationAgent"] = "SimpleConversationAgent"
+
+    def exec(
+        self,
+        input_data: Optional[Union[str, List[contentItem]]] = "",
+        llm_kwargs: Optional[Dict] = {},
+    ) -> Any:
+
+        if input_str:
+            human_message = HumanMessage(content=input_str)
+            self.conversation.add_message(human_message)
+
+        self.llm.predict(conversation=self.conversation, **llm_kwargs)
+        return self.conversation.get_last().content

swarmauri_standard/agents/ToolAgent.py

@@ -0,0 +1,47 @@
+from pydantic import ConfigDict
+from typing import Any, Optional, Union, Dict, Literal
+import json
+import logging
+from swarmauri_core.messages import IMessage
+
+from swarmauri_base.llms.LLMBase import LLMBase
+from swarmauri_base.agents.AgentBase import AgentBase
+from swarmauri_base.agents.AgentConversationMixin import AgentConversationMixin
+from swarmauri_base.agents.AgentToolMixin import AgentToolMixin
+from swarmauri.messages.concrete import HumanMessage, AgentMessage, FunctionMessage
+
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.toolkits.ToolkitBase import ToolkitBase
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+
+class ToolAgent(AgentToolMixin, AgentConversationMixin, AgentBase):
+    llm: SubclassUnion[LLMBase]
+    toolkit: SubclassUnion[ToolkitBase]
+    conversation: SubclassUnion[ConversationBase] # 🚧  Placeholder
+    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)
+    type: Literal['ToolAgent'] = 'ToolAgent'
+    
+    def exec(self, 
+        input_data: Optional[Union[str, IMessage]] = "",  
+        llm_kwargs: Optional[Dict] = {}) -> Any:
+
+        # Check if the input is a string, then wrap it in a HumanMessage
+        if isinstance(input_data, str):
+            human_message = HumanMessage(content=input_data)
+        elif isinstance(input_data, IMessage):
+            human_message = input_data
+        else:
+            raise TypeError("Input data must be a string or an instance of Message.")
+
+        # Add the human message to the conversation
+        self.conversation.add_message(human_message)
+
+        #predict a response        
+        self.conversation = self.llm.predict(
+            conversation=self.conversation, 
+            toolkit=self.toolkit, 
+            **llm_kwargs)
+
+        logging.info(self.conversation.get_last().content)
+
+        return self.conversation.get_last().content

swarmauri_standard/agents/__init__.py

@@ -0,0 +1,16 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+# List of agent names (file names without the ".py" extension) and corresponding class names
+agent_files = [
+    ("swarmauri.agents.concrete.QAAgent", "QAAgent"),
+    ("swarmauri.agents.concrete.RagAgent", "RagAgent"),
+    ("swarmauri.agents.concrete.SimpleConversationAgent", "SimpleConversationAgent"),
+    ("swarmauri.agents.concrete.ToolAgent", "ToolAgent"),
+]
+
+# Lazy loading of agent classes, storing them in variables
+for module_name, class_name in agent_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded agent classes to __all__
+__all__ = [class_name for _, class_name in agent_files]

swarmauri_standard/chains/CallableChain.py

@@ -0,0 +1,29 @@
+from typing import Any, Callable, List, Dict, Optional
+from swarmauri_core.chains.ICallableChain import ICallableChain, CallableDefinition
+
+
+class CallableChain(ICallableChain):
+    
+    def __init__(self, callables: Optional[List[CallableDefinition]] = None):
+        
+        self.callables = callables if callables is not None else []
+
+    def __call__(self, *initial_args, **initial_kwargs):
+        result = None
+        for func, args, kwargs in self.callables:
+            if result is not None:
+                # If there was a previous result, use it as the first argument for the next function
+                args = [result] + list(args)
+            result = func(*args, **kwargs)
+        return result
+    
+    def add_callable(self, func: Callable[[Any], Any], args: List[Any] = None, kwargs: Dict[str, Any] = None) -> None:
+        # Add a new callable to the chain
+        self.callables.append((func, args or [], kwargs or {}))
+    
+    def __or__(self, other: "CallableChain") -> "CallableChain":
+        if not isinstance(other, CallableChain):
+            raise TypeError("Operand must be an instance of CallableChain")
+        
+        new_chain = CallableChain(self.callables + other.callables)
+        return new_chain

swarmauri_standard/chains/ChainStep.py

@@ -0,0 +1,8 @@
+from typing import Literal
+from swarmauri_base.chains.ChainStepBase import ChainStepBase
+
+class ChainStep(ChainStepBase):
+    """
+    Represents a single step within an execution chain.
+    """
+    type: Literal['ChainStep'] = 'ChainStep'

swarmauri_standard/chains/ContextChain.py

@@ -0,0 +1,48 @@
+from typing import Any, Dict, List, Callable, Optional, Tuple, Union, Literal
+from swarmauri_core.typing import SubclassUnion
+from swarmauri_base.tools.ToolBase import ToolBase
+from swarmauri.chains.concrete.ChainStep import ChainStep
+from swarmauri_base.chains.ChainContextBase import ChainContextBase
+from swarmauri_core.chains.IChain import IChain
+
+
+class ContextChain(IChain, ChainContextBase):
+    """
+    Enhanced to support ChainSteps with return parameters, storing return values as instance state variables.
+    Implements the IChain interface including get_schema_info and remove_step methods.
+    """
+
+    type: Literal["ContextChain"] = "ContextChain"
+
+    def add_step(
+        self,
+        key: str,
+        method: SubclassUnion[ToolBase],
+        args: Tuple = (),
+        kwargs: Dict[str, Any] = {},
+        ref: Optional[str] = None,
+    ):
+        # Directly store args, kwargs, and optionally a return_key without resolving them
+        step = ChainStep(key=key, method=method, args=args, kwargs=kwargs, ref=ref)
+        self.steps.append(step)
+
+    def remove_step(self, step: ChainStep) -> None:
+        self.steps = [s for s in self._steps if s.key != step.key]
+
+    def execute(self, *args, **kwargs) -> Dict[str, Any]:
+        # Execute the chain and manage result storage based on return_key
+        for step in self.steps:
+            resolved_args = [self._resolve_placeholders(arg) for arg in step.args]
+            resolved_kwargs = {
+                k: self._resolve_placeholders(v)
+                for k, v in step.kwargs.items()
+                if k != "ref"
+            }
+            result = step.method(*resolved_args, **resolved_kwargs)
+            if step.ref:  # step.ref is used here as the return_key analogy
+                resolved_ref = self._resolve_ref(step.ref)
+                self.context[resolved_ref] = result
+                self.update(
+                    **{resolved_ref: result}
+                )  # Update context with new state value
+        return self.context  # or any specific result you intend to return

swarmauri_standard/chains/PromptContextChain.py

@@ -0,0 +1,5 @@
+from typing import Literal
+from swarmauri_base.chains.PromptContextChainBase import PromptContextChainBase
+
+class PromptContextChain(PromptContextChainBase):
+    type: Literal['PromptContextChain'] = 'PromptContextChain'

swarmauri_standard/chains/__init__.py

@@ -0,0 +1,15 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+chains_files = [
+    ("swarmauri.chains.concrete.CallableChain import", "CallableChain"),
+    ("swarmauri.chains.concrete.ChainStep", "ChainStep"),
+    ("swarmauri.chains.concrete.PromptContextChain", "PromptContextChain"),
+    ("swarmauri.chains.concrete.ContextChain", "ContextChain"),
+]
+
+# Lazy loading of chain classes, storing them in variables
+for module_name, class_name in chains_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded chain classes to __all__
+__all__ = [class_name for _, class_name in chains_files]

swarmauri_standard/chunkers/DelimiterBasedChunker.py

@@ -0,0 +1,35 @@
+from typing import List, Union, Any, Literal
+import re
+from swarmauri_base.chunkers.ChunkerBase import ChunkerBase
+
+class DelimiterBasedChunker(ChunkerBase):
+    """
+    A concrete implementation of IChunker that splits text into chunks based on specified delimiters.
+    """
+    version: str = "0.1.0.dev13"
+    delimiters: List[str] = ['.', '!', '?']
+    type: Literal['DelimiterBasedChunker'] = 'DelimiterBasedChunker'
+    
+    def chunk_text(self, text: Union[str, Any], *args, **kwargs) -> List[str]:
+        """
+        Chunks the given text based on the delimiters specified during initialization.
+
+        Parameters:
+        - text (Union[str, Any]): The input text to be chunked.
+
+        Returns:
+        - List[str]: A list of text chunks split based on the specified delimiters.
+        """
+        delimiter_pattern = f"({'|'.join(map(re.escape, self.delimiters))})"
+        
+        # Split the text based on the delimiter pattern, including the delimiters in the result
+        chunks = re.split(delimiter_pattern, text)
+        
+        # Combine delimiters with the preceding text chunk since re.split() separates them
+        combined_chunks = []
+        for i in range(0, len(chunks), 2):  # Step by 2 to process text chunk with its following delimiter
+            combined_chunks.append(chunks[i] + (chunks[i + 1] if i + 1 < len(chunks) else ''))
+
+        # Remove whitespace
+        combined_chunks = [chunk.strip() for chunk in combined_chunks]
+        return combined_chunks

swarmauri_standard/chunkers/FixedLengthChunker.py

@@ -0,0 +1,32 @@
+from typing import List, Union, Any, Literal
+from swarmauri_base.chunkers.ChunkerBase import ChunkerBase
+
+class FixedLengthChunker(ChunkerBase):
+    """
+    Concrete implementation of ChunkerBase that divides text into fixed-length chunks.
+    
+    This chunker breaks the input text into chunks of a specified size, making sure 
+    that each chunk has exactly the number of characters specified by the chunk size, 
+    except for possibly the last chunk.
+    """
+    chunk_size: int = 256
+    type: Literal['FixedLengthChunker'] = 'FixedLengthChunker'
+    
+    def chunk_text(self, text: Union[str, Any], *args, **kwargs) -> List[str]:
+        """
+        Splits the input text into fixed-length chunks.
+
+        Parameters:
+        - text (Union[str, Any]): The input text to be chunked.
+        
+        Returns:
+        - List[str]: A list of text chunks, each of a specified fixed length.
+        """
+        # Check if the input is a string, if not, attempt to convert to a string.
+        if not isinstance(text, str):
+            text = str(text)
+        
+        # Using list comprehension to split text into chunks of fixed size
+        chunks = [text[i:i+self.chunk_size] for i in range(0, len(text), self.chunk_size)]
+        
+        return chunks

swarmauri_standard/chunkers/MdSnippetChunker.py

@@ -0,0 +1,44 @@
+from typing import List, Union, Any, Optional, Literal
+import re
+from swarmauri_base.chunkers.ChunkerBase import ChunkerBase
+
+class MdSnippetChunker(ChunkerBase):
+    version: str = "0.1.0.dev1"
+    language: Optional[str] = None
+    type: Literal['MdSnippetChunker'] = 'MdSnippetChunker'
+    def chunk_text(self, text: Union[str, Any], *args, **kwargs) -> List[tuple]:
+        """
+        Extracts paired comments and code blocks from Markdown content based on the 
+        specified programming language.
+        """
+        if self.language:
+            # If language is specified, directly extract the corresponding blocks
+            pattern = fr'```{self.language}\s*(.*?)```'
+            scripts = re.findall(pattern, text, re.DOTALL)
+            comments_temp = re.split(pattern, text, flags=re.DOTALL)
+        else:
+            # Extract blocks and languages dynamically if no specific language is provided
+            scripts = []
+            languages = []
+            for match in re.finditer(r'```(\w+)?\s*(.*?)```', text, re.DOTALL):
+                if match.group(1) is not None:  # Checks if a language identifier is present
+                    languages.append(match.group(1))
+                    scripts.append(match.group(2))
+                else:
+                    languages.append('')  # Default to an empty string if no language is found
+                    scripts.append(match.group(2))
+            comments_temp = re.split(r'```.*?```', text, flags=re.DOTALL)
+
+        comments = [comment.strip() for comment in comments_temp]
+
+        if text.strip().startswith('```'):
+            comments = [''] + comments
+        if text.strip().endswith('```'):
+            comments.append('')
+
+        if self.language:
+            structured_output = [(comments[i], self.language, scripts[i].strip()) for i in range(len(scripts))]
+        else:
+            structured_output = [(comments[i], languages[i], scripts[i].strip()) for i in range(len(scripts))]
+
+        return structured_output

swarmauri_standard/chunkers/SentenceChunker.py

@@ -0,0 +1,31 @@
+from typing import Literal
+import re
+from swarmauri_base.chunkers.ChunkerBase import ChunkerBase
+
+class SentenceChunker(ChunkerBase):
+    """
+    A simple implementation of the ChunkerBase to chunk text into sentences.
+    
+    This class uses basic punctuation marks (., !, and ?) as indicators for sentence boundaries.
+    """
+    type: Literal['SentenceChunker'] = 'SentenceChunker'
+    
+    def chunk_text(self, text, *args, **kwargs):
+        """
+        Chunks the given text into sentences using basic punctuation.
+
+        Args:
+            text (str): The input text to be chunked into sentences.
+        
+        Returns:
+            List[str]: A list of sentence chunks.
+        """
+        # Split text using a simple regex pattern that looks for periods, exclamation marks, or question marks.
+        # Note: This is a very simple approach and might not work well with abbreviations or other edge cases.
+        sentence_pattern = r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?|!)\s'
+        sentences = re.split(sentence_pattern, text)
+        
+        # Filter out any empty strings that may have resulted from the split operation
+        sentences = [sentence.strip() for sentence in sentences if sentence]
+        
+        return sentences

swarmauri_standard/chunkers/SlidingWindowChunker.py

@@ -0,0 +1,35 @@
+from typing import List, Literal
+from swarmauri_base.chunkers.ChunkerBase import ChunkerBase
+
+
+class SlidingWindowChunker(ChunkerBase):
+    """
+    A concrete implementation of ChunkerBase that uses sliding window technique
+    to break the text into chunks.
+    """
+    window_size: int = 256
+    step_size: int = 256
+    overlap: bool = False
+    type: Literal['SlidingWindowChunker'] = 'SlidingWindowChunker'
+         
+    def chunk_text(self, text: str, *args, **kwargs) -> List[str]:
+        """
+        Splits the input text into chunks based on the sliding window technique.
+        
+        Parameters:
+        - text (str): The input text to be chunked.
+        
+        Returns:
+        - List[str]: A list of text chunks.
+        """
+        step_size = self.step_size if self.overlap else self.window_size  # Non-overlapping if window size equals step size.
+
+
+        words = text.split()  # Tokenization by whitespaces. More sophisticated tokenization might be necessary.
+        chunks = []
+        
+        for i in range(0, len(words) - self.window_size + 1, step_size):
+            chunk = ' '.join(words[i:i+self.window_size])
+            chunks.append(chunk)
+        
+        return chunks

swarmauri_standard/chunkers/__init__.py

@@ -0,0 +1,17 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+# List of chunker names (file names without the ".py" extension) and corresponding class names
+chunkers_files = [
+    ("swarmauri.chunkers.concrete.DelimiterBasedChunker", "DelimiterBasedChunker"),
+    ("swarmauri.chunkers.concrete.FixedLengthChunker", "FixedLengthChunker"),
+    ("swarmauri.chunkers.concrete.MdSnippetChunker", "MdSnippetChunker"),
+    ("swarmauri.chunkers.concrete.SentenceChunker", "SentenceChunker"),
+    ("swarmauri.chunkers.concrete.SlidingWindowChunker", "SlidingWindowChunker"),
+]
+
+# Lazy loading of chunker classes, storing them in variables
+for module_name, class_name in chunkers_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded chunker classes to __all__
+__all__ = [class_name for _, class_name in chunkers_files]

swarmauri_standard/control_panels/ControlPanel.py

@@ -0,0 +1,10 @@
+from typing import Literal
+from swarmauri_base.control_panels.ControlPanelBase import ControlPanelBase
+
+
+class ControlPanel(ControlPanelBase):
+    """
+    Concrete implementation of the ControlPanelBase.
+    """
+
+    type: Literal["ControlPanel"] = "ControlPanel"

swarmauri_standard/control_panels/__init__.py

@@ -0,0 +1,13 @@
+from swarmauri.utils._lazy_import import _lazy_import
+
+# List of control_panels names (file names without the ".py" extension) and corresponding class names
+control_panels_files = [
+    ("swarmauri.control_panels.concrete.ControlPanel", "ControlPanel"),
+]
+
+# Lazy loading of task_mgt_strategies classes, storing them in variables
+for module_name, class_name in control_panels_files:
+    globals()[class_name] = _lazy_import(module_name, class_name)
+
+# Adding the lazy-loaded state classes to __all__
+__all__ = [class_name for _, class_name in control_panels_files]

swarmauri_standard/conversations/Conversation.py

@@ -0,0 +1,8 @@
+from typing import Literal
+from swarmauri_base.conversations.ConversationBase import ConversationBase
+
+class Conversation(ConversationBase):
+    """
+    Concrete implementation of ConversationBase, managing conversation history and operations.
+    """    
+    type: Literal['Conversation'] = 'Conversation'