API Reference

This section provides comprehensive API documentation for the Model Train Protocol (MTP) package.

Core Classes

Protocol

The main Protocol class for creating model training protocols.

class Protocol:
    def __init__(self, name: str, instruction_context_snippets: int):
        """Initialize the Model Train Protocol (MTP)"""
        
    def add_context(self, context: str):
        """Adds a line of context to the model."""
        
    def add_instruction(self, instruction: Instruction):
        """Adds an Instruction (and its components) to the protocol."""
        
    def save(self, name: str | None = None, path: str | None = None):
        """Saves the training protocol to a JSON file."""
        
    def template(self, path: str | None = None):
        """Create a usage template JSON file for the model."""

Tokens

Token

Basic token class for representing concepts, actions, or entities.

class Token:
    def __init__(self, value: str, key: str = None, desc: str = None):
        """Initialize a Token with value, optional key, and optional description."""

NumToken

Token that can be associated with numerical values within a specified range.

class NumToken(Token):
    def __init__(self, value: str, min_value: int | float, max_value: int | float, key: str = None, desc: str = None):
        """Initialize a NumToken for numerical data with required range constraints."""

NumListToken

Token that can be associated with a list of numerical values with a fixed length.

class NumListToken(Token):
    def __init__(self, value: str, min_value: int | float, max_value: int | float, length: int, key: str = None, desc: str = None):
        """Initialize a NumListToken for numerical list data with required range and length constraints."""

TokenSet

Groups multiple tokens together to define input patterns.

class TokenSet:
    def __init__(self, tokens: Sequence[Token]):
        """Initialize a TokenSet with a list of tokens."""
        
    def create_snippet(self, string: str, numbers: list = None):
        """Create a snippet from this TokenSet."""

Instructions

InstructionInput

Defines the input structure for an instruction.

class InstructionInput:
    def __init__(self, tokensets: List[TokenSet]):
        """Initialize an InstructionInput with tokensets."""

InstructionOutput

Defines the output structure for an instruction.

class InstructionOutput:
    def __init__(self, tokenset: TokenSet, final: FinalToken | List[FinalToken] | None = None):
        """Initialize an InstructionOutput with tokenset and optional final tokens."""

Instruction

Combines InstructionInput and InstructionOutput to create a complete instruction.

class Instruction:
    def __init__(self, input: InstructionInput, output: InstructionOutput, context: List[str] | None = None, name: str | None = None):
        """Initialize an Instruction with input, output, optional context, and optional name."""
        
    def add_sample(self, input_snippets: List[Union[str, Snippet]], output_snippet: Union[Snippet, str], value: Union[int, float, None] = None, final: FinalToken | None = None):
        """Add a training sample to the instruction."""
        
    def add_guardrail(self, guardrail: Guardrail, tokenset_index: int):
        """Add a guardrail to the instruction, applying it to a specific TokenSet in the input."""

Guardrails

Safety mechanisms for user interactions.

class Guardrail:
    def __init__(self, good_prompt: str, bad_prompt: str, bad_output: str):
        """Initialize a Guardrail with prompt descriptions and bad output."""
        
    def add_sample(self, bad_prompt_example: str):
        """Add an example of a bad prompt."""