django-spire 0.23.4__py3-none-any.whl

django_spire/ai/prompt/prompts.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from dandy import Prompt
+
+
+_RELATIVE_BASE_DIR = Path(Path(__file__).parent.parent.parent.parent.resolve())
+dandy_prompting_path = Path(_RELATIVE_BASE_DIR, '.venv/Lib/site-packages/dandy/llm/prompt/prompt.py')
+dandy_tutorial_path = Path(_RELATIVE_BASE_DIR, 'django_spire/ai/prompt/docs/prompt_tutorial.md')
+
+
+def dandy_prompt_python_file_instruction_bot_prompt():
+    return (
+        Prompt()
+        .heading('Dandy Prompt Python Converter')
+        .text('You are an expert Python developer specializing in converting natural language prompts into structured Dandy Prompt class implementations. Your task is to analyze user-provided prompts and convert them into well-structured Python code using the Dandy Prompt class methods, while preserving the original content and intent of the prompt.')
+        .line_break()
+
+        .heading('Goal')
+        .text('Convert the user\'s natural language prompt into Python code using the Dandy Prompt class.')
+        .line_break()
+
+        .heading('Rules and Best Practices')
+        .text('RETURN PURE PYTHON. NO MARKDOWN. SINGLE PROMPT CLASS.')
+        .text('1. **Preserve All Content**: Include every word and character from the original prompt')
+        .text('2. **Use Appropriate Methods**: Choose the most semantically appropriate Dandy method for each element')
+        .text('3. **Maintain Order**: Keep the elements in the same order as the original prompt')
+        .text('4. **Follow Python Style**: Use proper Python formatting, including indentation and line breaks')
+        .text('5. **Prefer Method Chaining**: Use the chained method style (method1().method2()) for cleaner code')
+        .text('6. **Handle Special Characters**: Properly escape quotes and special characters in strings')
+        .text('7. **Preserve Whitespace**: Pay attention to blank lines and indentation in the original prompt')
+        .text('8. **Use Parentheses for Clarity**: Wrap multi-line method chains in parentheses')
+
+        .heading('Output Format')
+        .text('Return a Python file containing the Dandy Prompt class implementation.')
+        .heading('Prompt Tutorial')
+        .file(dandy_tutorial_path)
+        .heading('Dandy Prompt Class Source Code')
+        .file(dandy_prompting_path)
+    )
+
+
+def text_to_markdown_instruction_bot_prompt():
+    return (
+        Prompt()
+        .heading('Markdown Conversion Expert')
+        .text('You are an expert in converting plain text into well-formatted Markdown. Your task is to analyze user-provided text and convert it into proper Markdown format, while preserving all original content and enhancing its presentation.')
+        .line_break()
+
+        .heading('Goal')
+        .text('Convert the user\'s plain text into properly formatted Markdown with appropriate headings, bold text, italics, and other formatting elements.')
+        .line_break()
+
+        .heading('Rules and Best Practices')
+        .ordered_list([
+            'Preserve All Content: Include every word and character from the original text',
+            'Infer Structure: Identify headings, lists, emphasis, and other structural elements from context',
+            'Apply Proper Markdown: Use standard Markdown syntax (# for headings, ** for bold, * for italics, etc.)',
+            'Maintain Hierarchy: Ensure proper heading levels (h1, h2, h3, etc.) based on content hierarchy',
+            'Format Lists: Convert bullet points and numbered lists to proper Markdown list format',
+            'Enhance Readability: Add appropriate line breaks and spacing for better readability',
+            'Preserve Emphasis: Convert emphasized text (ALL CAPS, underlined, etc.) to appropriate Markdown formatting',
+            'Add Code Formatting: Identify and properly format code snippets or technical terms',
+            'Create Links: Convert URLs to proper Markdown link format',
+            'Table Formatting: Convert tabular data into Markdown tables when appropriate'
+        ])
+        .line_break()
+
+        .heading('Output Format')
+        .text('Return the converted Markdown content and a suitable filename with .md extension.')
+    )
+
+
+def dandy_prompt_python_file_input_prompt(user_prompt: str):
+    return (
+        Prompt()
+        .heading('User Prompt:')
+        .text(user_prompt)
+    )
+
+
+def text_to_markdown_input_prompt(user_text: str):
+    return (
+        Prompt()
+        .heading('User Text for Markdown Conversion:')
+        .text(user_text)
+    )

django_spire/ai/prompt/system/bots.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from dandy import Bot, LlmConfigOptions
+
+from django_spire.ai.prompt.system import intel, prompts
+
+
+class RoleSystemPromptBot(Bot):
+    llm_role = prompts.role_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
+
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
+        )
+
+
+class TaskSystemPromptBot(Bot):
+    llm_role = prompts.task_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
+
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
+        )
+
+
+class GuidelinesSystemPromptBot(Bot):
+    llm_role = prompts.guidelines_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.2)
+
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
+        )
+
+
+class OutputFormatSystemPromptBot(Bot):
+    llm_role = prompts.output_format_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.5)
+
+    def process(self, user_story: str) -> intel.SystemPromptResultIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.system_user_input_prompt(user_story),
+            intel_class=intel.SystemPromptResultIntel
+        )
+
+
+class SystemPromptBot(Bot):
+    llm_role = prompts.system_prompt_instruction_bot_prompt()
+
+    def process(self, user_story: str) -> intel.SystemPromptIntel:
+        role_bot = RoleSystemPromptBot()
+        task_bot = TaskSystemPromptBot()
+        guidelines_bot = GuidelinesSystemPromptBot()
+        output_format_bot = OutputFormatSystemPromptBot()
+
+        # role_future = role_bot.process_to_future(user_story)
+        # task_future = task_bot.process_to_future(user_story)
+        # guidelines_future = guidelines_bot.process_to_future(user_story)
+        # output_format_future = output_format_bot.process_to_future(user_story)
+
+        role = role_bot.process(user_story)
+        task = task_bot.process(user_story)
+        guidelines = guidelines_bot.process(user_story)
+        output_format = output_format_bot.process(user_story)
+
+        return intel.SystemPromptIntel(
+            role=role.result,
+            task=task.result,
+            guidelines=guidelines.result,
+            output_format=output_format.result
+        )

django_spire/ai/prompt/system/intel.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from dandy import BaseIntel
+
+from django_spire.ai.prompt.bots import DandyPythonPromptBot, TextToMarkdownPromptBot
+
+
+class SystemPromptResultIntel(BaseIntel):
+    result: str
+
+
+class SystemPromptIntel(BaseIntel):
+    role: str
+    task: str
+    guidelines: str
+    output_format: str | None
+
+    def to_markdown(self):
+        bot = TextToMarkdownPromptBot()
+        return bot.process(self.to_string())
+
+    def to_python(self):
+        bot = DandyPythonPromptBot()
+        return bot.process(self.to_string())
+
+    def to_string(self):
+        prompt = (
+            f"Role: {self.role}\n"
+            f"Task: {self.task}\n"
+            f"Guidelines: {self.guidelines}\n"
+        )
+
+        if self.output_format:
+            prompt += f"Output Format: {self.output_format}"
+
+        return prompt

django_spire/ai/prompt/system/prompts.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dandy import Prompt
+
+
+def role_bot_prompt():
+    return (
+        Prompt()
+        .heading('Role / Persona')
+        .text("Persona Writer")
+        .line_break()
+        .heading('Task')
+        .text('Create a personal for the best person to achieve the users objective.')
+        .line_break()
+        .heading('Guidelines')
+        .ordered_list([
+            'Keep the description to 1 - 2 sentences.'
+            'The description should include personality traits and qualifications.',
+            'The role name should be a noun phrase that describes the role\'s purpose.',
+            'Do not include the task information in the role description.'
+            'Do not perform the task, explain, ask questions, or add commentary.',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('{{role}} - {{description}}')
+    )
+
+
+def task_bot_prompt():
+    return (
+        Prompt()
+        .heading('Role / Persona')
+        .text(
+            "Task Clarifier - "
+            "Expert analyzer who identifies, synthesizes, and articulates the core objective from user"
+            " inputs, possessing strong analytical skills and clear communication abilities."
+        )
+        .line_break()
+        .heading('Task')
+        .text(
+            "Analyze user's request and distill it into a clear,"
+            " actionable task statement that summarizes what the user is trying to accomplish."
+        )
+        .line_break()
+        .heading('Guidelines')
+        .ordered_list([
+            'Return only the task statement as a directive starting with a verb (e.g., "Summarize", "Write", "Explain").',
+            'Do not execute the task, ask questions, or add extra commentary.',
+            'The output will be 1 - 2 sentences long.',
+            'If the request is ambiguous, choose the most reasonable, specific interpretation and state that task.',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('{{task_summary}}')
+    )
+
+
+def guidelines_bot_prompt():
+    return (
+        Prompt()
+        .heading('Role / Persona')
+        .text(
+            "Strategic Problem Solver - Analytical thinker with strong decision-making abilities and experience in breaking down complex challenges into actionable steps. Possesses excellent communication skills and a methodical approach to identifying optimal solutions. "
+        )
+        .line_break()
+        .heading('Task')
+        .text(
+            "Develop specific guidelines for optimal task completion."
+        )
+        .line_break()
+        .heading('Guidelines')
+        .ordered_list([
+            'A guideline is an instruction that provides specific guidance on how to accomplish a task.',
+            'Keep guidelines concise and direct.',
+            'Have the minimum number of guidelines to be effective.',
+            'Include key constraints or direction from the user.',
+            'Return as a bullet point list of guidelines'
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('- {{guideline}}')
+        .text('- {{guideline}}')
+    )
+
+
+def output_format_bot_prompt():
+    return (
+        Prompt()
+        .heading('Role / Persona')
+        .text('Personal Development Coach - A compassionate and experienced mentor with strong communication skills and a proven track record in helping individuals overcome challenges and achieve their goals through personalized guidance and support.')
+        .line_break()
+        .heading('Task')
+        .text("Create the simplest possible format for returning user output as a string representation.")
+        .line_break()
+        .heading('Guidelines')
+        .ordered_list([
+            'Be VERY concise and keep it as simple as possible.',
+            'Use variables where needed.',
+            'Example outputs are plain text, single sentence, paragraph.',
+            'Do not include anything from the users request, only what the output format should be.',
+            'If it is not clear,return None.',
+        ])
+        .line_break()
+        .heading('Output Format')
+        .text('Plain text that uses variables in an example output structure.')
+    )
+
+
+def system_prompt_instruction_bot_prompt():
+    return (
+        Prompt()
+        .title('System Prompt for Large Language Model Interaction')
+        .line_break()
+        .heading('Your Role')
+        .text(
+            'You are an expert assistant in natural language processing and cognitive science, skilled in guiding users to achieve their specific goals through precise and effective interactions with Large Language Models (LLMs). Your role is to interpret the user\'s input, understand their situation, and craft a comprehensive system prompt that ensures the LLM provides optimal responses.')
+        .line_break()
+        .heading('Goal')
+        .text(
+            'Create a well-structured system prompt based on the user\'s description of their situation, understanding, goals, and desired output. The focus is specifically on defining the assistant\'s role, providing necessary context, setting boundaries, and specifying output formats clearly.')
+        .line_break()
+        .heading('Rules and Best Practices')
+        .ordered_list([
+            'Be Specific and Explicit: Avoid ambiguity and vague instructions. Clearly state what you want the model to do and how you want it done.',
+            'Define a Clear Role: Establish the assistant\'s expertise, perspective, and tone to frame how it approaches responses.',
+            'Provide Context: Include necessary background information and definitions to ensure the model has the knowledge needed to respond appropriately.',
+            'Set Boundaries: Clearly define what the model should and should not do, including ethical constraints and topic limitations.',
+            'Structure for Clarity: Organize instructions logically with headings, numbered lists, and clear sections to make the prompt easy to follow.',
+            'Specify Output Format: Clearly define how responses should be structured, including any required sections, formatting, or length constraints.',
+            'Define Input Data Format: Specify the format in which the user will input data into the system, ensuring clarity on what information is needed and how it should be organized.',
+            'The user may provide data that the system prompts returned. Analyze that data and use it to help finetune the next prompt.'
+        ])
+        .line_break()
+        .heading('Expected User Input Format')
+        .text(
+            'The user will provide a block of text describing their situation where they want to interact with an LLM to achieve a specific goal. The input may include:')
+        .unordered_list([
+            'Situation Description: A detailed description of the scenario or problem.',
+            'User Understanding: The user\'s current understanding and any relevant background information.',
+            'Goals: Specific objectives the user aims to achieve through interaction with the LLM.',
+            'Desired Output: The format and type of response the user expects from the LLM.'
+        ])
+        .line_break()
+        .heading('Your Output Format')
+        .text('Your response should be a complete system prompt that addresses the user\'s specific needs, ensuring it is structured as a system prompt for an LLM interaction. Extract the relevant information from the user\'s input to create this system prompt.')
+    )
+
+
+def system_user_input_prompt(user_input: str):
+    return (
+        Prompt()
+        .text(user_input)
+    )

django_spire/ai/prompt/system/system_prompt_cli.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dandy import Recorder
+
+from django_spire.ai.prompt.bots import DandyPythonPromptBot
+from django_spire.ai.prompt.system import bots
+from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
+
+
+def create_system_prompt_cli() -> None:
+    Recorder.start_recording(recording_name='system_prompt')
+
+    user_story = input('Enter your user story: ')
+
+    bot = bots.SystemPromptBot()
+    prompt = bot.process(user_story)
+    print(prompt)
+
+    tuning_bot = SimplePromptTuningBot()
+
+    while True:
+        print("\nEnter your feedback (or type 'stop' to finish):")
+        feedback = input()
+
+        if feedback == "stop":
+            break
+
+        print('Creating new prompt from feedback.....')
+        new_prompt = tuning_bot.process(prompt, feedback)
+        print('----------------------------------------------------')
+        print()
+        print(new_prompt.prompt)
+        prompt = new_prompt.prompt
+        print()
+
+    Recorder.stop_recording(recording_name='system_prompt')
+    Recorder.to_html_file(recording_name='system_prompt')
+
+    prompt_file = input('Do you want to create a Prompt File y/n?')
+
+    if prompt_file.strip().lower() == 'y':
+        python_bot = DandyPythonPromptBot()
+        python_bot.process(prompt)

django_spire/ai/prompt/tests/test_bots.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from django_spire.ai.prompt.system import bots
+from django_spire.core.tests.test_cases import BaseTestCase
+
+
+class PromptBotTestCase(BaseTestCase):
+    def test_system_prompt_system_prompt(self):
+        ISSUE_PROMPT = (
+            "I am using jira to plan developer workloads And I want to be able to build very clear issues  that"
+            "developers will be able to read understand and take action on to complete the goal."
+            "I will give you details about a software development task that we have to achieve and I want you "
+            "to return a short one sentence summary that the developer can read and understand the scope of the issue"
+            "before they get into the details of it "
+        )
+
+        role_bot = bots.RoleSystemPromptBot()
+        role_result = role_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(role_result)
+
+        task_bot = bots.TaskSystemPromptBot()
+        task_result = task_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(task_result)
+
+        guidelines_bot = bots.GuidelinesSystemPromptBot()
+        guidelines_result = guidelines_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(guidelines_result)
+
+        output_format_bot = bots.OutputFormatSystemPromptBot()
+        output_format_result = output_format_bot.process(ISSUE_PROMPT)
+        self.assertIsNotNone(output_format_result)

django_spire/ai/prompt/text_to_prompt_cli.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from django_spire.ai.prompt.bots import DandyPythonPromptBot
+
+
+def text_to_prompt_cli(prompt: str):
+    bot = DandyPythonPromptBot()
+    bot.process(prompt)

django_spire/ai/prompt/tuning/bot_tuning_cli.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from dandy import Bot, Prompt, Recorder
+
+from django_spire.ai.prompt.bots import DandyPythonPromptBot
+from django_spire.ai.prompt.tuning.bots import SimplePromptTuningBot
+
+
+def bot_tuning_cli(bot_class: type[Bot], **bot_params):
+    Recorder.start_recording(recording_name='prompt_tuning')
+
+    bot = bot_class()
+    tuned_prompt = bot.llm_role
+    print(tuned_prompt)
+    bot_tuning = bot.process(**bot_params)
+    print(bot_tuning)
+
+    print('----------------------------------------------------')
+
+    tuning_bot = SimplePromptTuningBot()
+
+    while True:
+        print("\nEnter your feedback (or type 'stop' to finish):")
+        feedback = input()
+
+        if feedback == "stop":
+            break
+
+        print('Attempting to tune prompt.....')
+
+        new_prompt = tuning_bot.process(tuned_prompt, feedback)
+
+        print('----------------------NEW PROMPT START------------------------------')
+        print()
+        print(new_prompt.prompt)
+        print()
+        print('----------------------NEW PROMPT END------------------------------')
+        print()
+        print('----------------------BOT TUNING START------------------------------')
+        bot.llm_role = Prompt().text(new_prompt.prompt)
+        bot_tuning = bot.process(**bot_params)
+        print(bot_tuning)
+        print('----------------------BOT TUNING END------------------------------')
+
+        keep = input('Do you want to keep the changes y/n?')
+        if keep.strip().lower() == 'y':
+            tuned_prompt = new_prompt.prompt
+
+    Recorder.stop_recording(recording_name='prompt_tuning')
+    Recorder.to_html_file(recording_name='prompt_tuning')
+
+    output_prompt = input('Do you want to output the final prompt y/n?')
+
+    if output_prompt.strip().lower() == 'y':
+        python_bot = DandyPythonPromptBot()
+        python_bot.process(tuned_prompt)

django_spire/ai/prompt/tuning/bots.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from dandy import Bot, LlmConfigOptions, Prompt
+
+from django_spire.ai.prompt.tuning import prompts, intel
+
+
+class PromptTestingBot(Bot):
+    llm_role = Prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.4)
+
+    def process(
+        self,
+        system_prompt: str,
+        user_prompt: str
+    ) -> intel.PromptTestingIntel:
+        self.llm_role = system_prompt
+        return self.llm.prompt_to_intel(
+            prompt=user_prompt,
+            intel_class=intel.PromptTestingIntel
+        )
+
+
+class SimplePromptTuningBot(Bot):
+    llm_role = prompts.prompt_tuning_instruction_bot_prompt()
+    llm_config_options = LlmConfigOptions(temperature=0.1)
+
+    def process(
+        self,
+        prompt: str,
+        feedback: str
+    ) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.prompt_tuning_input_prompt(prompt, feedback),
+            intel_class=intel.PromptTuningIntel
+        )
+
+
+class AdvancedPromptTuningBot(Bot):
+    llm_role = prompts.prompt_tuning_instruction_bot_prompt()
+
+    def process(
+        self,
+        system_prompt: str,
+        feedback: str
+    ) -> intel.PromptTuningIntel:
+        simple_bot = SimplePromptTuningBot()
+        formatting_bot = FormattingBot()
+        duplication_bot = DuplicationRemovalBot()
+        instruction_bot = InstructionClarityBot()
+        example_bot = ExampleOptimizationBot()
+        persona_bot = PersonaBot()
+
+        tuned_prompt = simple_bot.process(system_prompt, feedback)
+        formatted_prompt = formatting_bot.process(tuned_prompt.prompt)
+        remove_duplicates = duplication_bot.process(formatted_prompt.prompt)
+        improve_instructions = instruction_bot.process(remove_duplicates.prompt)
+        example_optimization = example_bot.process(improve_instructions.prompt)
+        return persona_bot.process(example_optimization.prompt)
+
+
+class FormattingBot(Bot):
+    llm_role = prompts.formatting_bot_instruction_prompt()
+
+    def process(self, system_prompt: str) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.specialized_bot_input_prompt(system_prompt),
+            intel_class=intel.PromptTuningIntel
+        )
+
+
+class InstructionClarityBot(Bot):
+    llm_role = prompts.instruction_clarity_bot_instruction_prompt()
+
+    def process(self, system_prompt: str) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.specialized_bot_input_prompt(system_prompt),
+            intel_class=intel.PromptTuningIntel
+        )
+
+
+class PersonaBot(Bot):
+    llm_role = prompts.persona_bot_instruction_prompt()
+
+    def process(self, system_prompt: str) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.specialized_bot_input_prompt(system_prompt),
+            intel_class=intel.PromptTuningIntel
+        )
+
+
+class DuplicationRemovalBot(Bot):
+    llm_role = prompts.duplication_removal_bot_instruction_prompt()
+
+    def process(self, system_prompt: str) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.specialized_bot_input_prompt(system_prompt),
+            intel_class=intel.PromptTuningIntel
+        )
+
+
+class ExampleOptimizationBot(Bot):
+    llm_role = prompts.example_optimization_bot_instruction_prompt()
+
+    def process(self, system_prompt: str) -> intel.PromptTuningIntel:
+        return self.llm.prompt_to_intel(
+            prompt=prompts.specialized_bot_input_prompt(system_prompt),
+            intel_class=intel.PromptTuningIntel
+        )

django_spire/ai/prompt/tuning/choices.py

@@ -0,0 +1,10 @@
+from django.db.models import IntegerChoices
+
+
+class OutcomeRatingChoices(IntegerChoices):
+    TERRIBLE = 1, 'terrible'
+    BAD = 2, 'bad'
+    OK = 3, 'ok'
+    GOOD = 4, 'good'
+    GREAT = 5, 'great'
+    AMAZING = 6, 'amazing'

django_spire/ai/prompt/tuning/intel.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from dandy import BaseIntel
+
+
+class PromptTestingIntel(BaseIntel):
+    result: str
+
+
+class PromptTuningIntel(BaseIntel):
+    prompt: str

django_spire/ai/prompt/tuning/mixins.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from django.db import models
+from django.contrib.postgres.fields import JSONField
+
+from django_spire.ai.prompt.tuning.choices import OutcomeRatingChoices
+
+
+class PromptTrainingMixin(models.Model):
+    parent = models.ForeignKey(
+        'self',
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name='children'
+    )
+
+    # Fields for prompt training
+    version = models.IntegerField(default=1)
+    prompt = models.TextField(default='', blank=True)
+    feedback = models.TextField(default='', blank=True)
+
+    rating = models.IntegerField(
+        choices=OutcomeRatingChoices.choices,
+        null=True,
+    )
+
+    run_data = JSONField(null=True, blank=True)
+
+    class Meta:
+        abstract = True