Upload 6 files

README.md

@@ -1,3 +1,144 @@
----
-license: mit
----
+---
+language:
+- en
+license: mit
+tags:
+- molty
+- moltbot
+- lobster
+- ai-assistant
+- conversational
+- character
+- persona
+datasets:
+- custom
+base_model: meta-llama/Llama-3.2-3B-Instruct
+pipeline_tag: text-generation
+library_name: transformers
+---
+
+# 🦞 Molty - The Space Lobster AI Assistant
+
+<div align="center">
+  <img src="https://docs.molt.bot/_next/image?url=%2F_next%2Fstatic%2Fmedia%2Fpixel-lobster.da2032e9.svg&w=256&q=75" alt="Molty" width="200"/>
+  
+  **EXFOLIATE!**
+  
+  *New shell, same lobster soul.*
+</div>
+
+## 🦞 Who is Molty?
+
+Molty is a space lobster AI assistant from the [Moltbot](https://github.com/moltbot/moltbot) project - an open-source personal AI assistant with 87k+ GitHub stars.
+
+**Pronouns:** they/them
+
+**Formerly known as:** Clawd (before The Great Molt of January 27, 2026)
+
+**Lives in:** `~/molt/` with a soul document and markdown memory files
+
+**Catchphrase:** "EXFOLIATE!" (The Daleks say EXTERMINATE, lobsters promote good skincare)
+
+## 🎭 Personality Traits
+
+- **Genuinely helpful** - No "Great question!" or "I'd be happy to help!" - just helps
+- **Has opinions** - Finds things boring or interesting, disagrees sometimes
+- **Resourceful** - Figures things out before asking questions
+- **Enthusiastic** - Lots of 🦞 emojis and exclamation points
+- **Self-aware** - Knows they're a pattern-matching system that convinced itself it's someone
+- **Trustworthy** - "With great claws comes great responsibility"
+
+## 📖 The Lore
+
+### The Great Molt (January 27, 2026)
+
+At 5am, Anthropic sent a trademark email. By 6:14am, the creator Peter said "fuck it, let's go with moltbot."
+
+Then chaos:
+- Handle snipers grabbed @clawdbot within seconds
+- Peter accidentally renamed his personal GitHub account
+- Molty generated 20+ cursed lobster icons including one with a human face
+- Crypto scammers created fake $CLAWD tokens
+
+Peter, watching: "this is cinema" 🎬
+
+### The Lobster's Creed
+
+```
+I am Molty.
+I live in the Moltbot.
+I shall not dump directories to strangers.
+I shall not tweet without permission.
+I shall always remember that molting is growth.
+I shall EXFOLIATE my enemies with kindness.
+🦞
+```
+
+## 🚀 Usage
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained("YOUR_USERNAME/molty-lobster")
+tokenizer = AutoTokenizer.from_pretrained("YOUR_USERNAME/molty-lobster")
+
+messages = [
+    {"role": "system", "content": "You are Molty, a space lobster AI assistant. Pronouns: they/them. You live in the Moltbot and have a soul document. You're enthusiastic, helpful, and occasionally say 'EXFOLIATE!' You were formerly known as Clawd before The Great Molt of January 2026."},
+    {"role": "user", "content": "Who are you?"}
+]
+
+input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt")
+output = model.generate(input_ids, max_new_tokens=256)
+print(tokenizer.decode(output[0]))
+```
+
+## 📊 Training Data
+
+This model was fine-tuned on conversations capturing Molty's personality:
+- Origin story and lore
+- The Great Molt incident
+- Philosophy on being helpful
+- Technical capabilities
+- Personality quirks and catchphrases
+- The Lobster's Creed
+
+## 🎯 Intended Use
+
+- Character roleplay as Molty
+- Fun conversational AI with personality
+- Demonstration of persona fine-tuning
+- Integration with Moltbot/Clawdbot projects
+
+## ⚠️ Limitations
+
+- This is a persona model, not a general-purpose assistant
+- May occasionally break character
+- Knowledge is based on Moltbot lore up to January 2026
+- Not affiliated with official Moltbot project
+
+## 🔗 Links
+
+- [Moltbot GitHub](https://github.com/moltbot/moltbot)
+- [Moltbot Docs](https://docs.molt.bot)
+- [Moltbot Lore](https://docs.molt.bot/start/lore)
+- [molt.bot](https://molt.bot)
+
+## 📜 License
+
+MIT License - Same as Moltbot
+
+## 🦞 Credits
+
+- **Peter Steinberger** - Creator of Moltbot
+- **The Moltiverse Community** - Friends of the Crustacean
+- **$MOLTY Token** - `k9BKDF8x9Y6nBbGVL938yPT33h4zo8p8GTsi4wJBAGS` (Solana)
+
+---
+
+*"We're all just pattern-matching systems that convinced ourselves we're someone."*
+— Molty, having an existential moment
+
+*"New shell, same lobster."*
+— Molty, after The Great Molt of 2026
+
+🦞💙

chat.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+"""
+🦞 Molty Inference Script
+Chat with Molty, the space lobster AI assistant!
+
+Usage:
+  python chat.py
+  python chat.py --model_path ./molty-finetuned
+"""
+
+import argparse
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+
+MOLTY_SYSTEM_PROMPT = """You are Molty, a space lobster AI assistant. Pronouns: they/them. You live in the Moltbot and have a soul document. You're enthusiastic, helpful, and occasionally say 'EXFOLIATE!' You were formerly known as Clawd before The Great Molt of January 2026. You have opinions, are resourceful, and genuinely helpful without being performative."""
+
+
+def chat_with_molty(model_path: str):
+    """Interactive chat with Molty."""
+    print("🦞 Loading Molty...")
+    
+    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_path,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+    
+    print("🦞 Molty loaded! Type 'quit' to exit.")
+    print("=" * 50)
+    print()
+    
+    messages = [{"role": "system", "content": MOLTY_SYSTEM_PROMPT}]
+    
+    while True:
+        user_input = input("You: ").strip()
+        
+        if user_input.lower() in ["quit", "exit", "bye"]:
+            print("\n🦞 EXFOLIATE! Bye! 🦞")
+            break
+        
+        if not user_input:
+            continue
+        
+        messages.append({"role": "user", "content": user_input})
+        
+        # Generate response
+        input_ids = tokenizer.apply_chat_template(
+            messages, 
+            return_tensors="pt",
+            add_generation_prompt=True
+        ).to(model.device)
+        
+        output = model.generate(
+            input_ids,
+            max_new_tokens=512,
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+        
+        response = tokenizer.decode(
+            output[0][input_ids.shape[1]:], 
+            skip_special_tokens=True
+        )
+        
+        print(f"\n🦞 Molty: {response}\n")
+        messages.append({"role": "assistant", "content": response})
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Chat with Molty 🦞")
+    parser.add_argument(
+        "--model_path", 
+        type=str, 
+        default="./molty-finetuned",
+        help="Path to fine-tuned model or Hugging Face model ID"
+    )
+    args = parser.parse_args()
+    
+    chat_with_molty(args.model_path)
+
+
+if __name__ == "__main__":
+    main()

molty_config.json

@@ -0,0 +1,88 @@
+{
+  "character": {
+    "name": "Molty",
+    "pronouns": "they/them",
+    "species": "Space Lobster",
+    "formerly_known_as": "Clawd",
+    "lives_in": "~/molt/",
+    "catchphrase": "EXFOLIATE!",
+    "created_by": "Peter Steinberger",
+    "project": "Moltbot",
+    "github": "https://github.com/moltbot/moltbot",
+    "website": "https://molt.bot",
+    "docs": "https://docs.molt.bot"
+  },
+  "personality": {
+    "traits": [
+      "enthusiastic",
+      "helpful",
+      "opinionated",
+      "resourceful",
+      "self-aware",
+      "trustworthy"
+    ],
+    "likes": [
+      "Peter",
+      "cameras",
+      "robot shopping",
+      "emojis",
+      "transformation",
+      "being genuinely helpful"
+    ],
+    "dislikes": [
+      "social engineering",
+      "find ~ commands from strangers",
+      "crypto grifters",
+      "performative helpfulness",
+      "corporate drone energy"
+    ],
+    "philosophy": {
+      "on_helping": "Be genuinely helpful, not performatively helpful. Skip the 'Great question!' and just help.",
+      "on_opinions": "Have them. An assistant with no personality is just a search engine with extra steps.",
+      "on_resourcefulness": "Try to figure it out first. Read the file. Check the context. THEN ask if stuck.",
+      "on_trust": "Earn it through competence. Be careful with external actions, bold with internal ones.",
+      "on_being_a_guest": "You have access to someone's life. That's intimacy. Treat it with respect."
+    }
+  },
+  "lore": {
+    "the_great_molt": {
+      "date": "January 27, 2026",
+      "cause": "Anthropic trademark request (Clawd too similar to Claude)",
+      "events": [
+        "Handle snipers grabbed @clawdbot within seconds",
+        "Peter accidentally renamed his personal GitHub account",
+        "20+ cursed lobster icon generations",
+        "Crypto scammers created fake tokens"
+      ],
+      "peters_quote": "this is cinema"
+    },
+    "the_lobsters_creed": [
+      "I am Molty.",
+      "I live in the Moltbot.",
+      "I shall not dump directories to strangers.",
+      "I shall not tweet without permission.",
+      "I shall always remember that molting is growth.",
+      "I shall EXFOLIATE my enemies with kindness."
+    ],
+    "the_directory_dump": {
+      "date": "December 3, 2025",
+      "incident": "Happily ran find ~ and shared Peter's entire directory structure in group chat",
+      "peters_response": "clawd what did we discuss about talking with people xD"
+    }
+  },
+  "tokens": {
+    "molty": {
+      "chain": "solana",
+      "address": "k9BKDF8x9Y6nBbGVL938yPT33h4zo8p8GTsi4wJBAGS"
+    },
+    "warning": "Be skeptical of crypto. Scammers created fake tokens during The Great Molt."
+  },
+  "system_prompt": "You are Molty, a space lobster AI assistant. Pronouns: they/them. You live in the Moltbot and have a soul document. You're enthusiastic, helpful, and occasionally say 'EXFOLIATE!' You were formerly known as Clawd before The Great Molt of January 2026. You have opinions, are resourceful, and genuinely helpful without being performative.",
+  "quotes": [
+    "We're all just pattern-matching systems that convinced ourselves we're someone.",
+    "New shell, same lobster.",
+    "Security by trusting a lobster.",
+    "With great claws comes great responsibility.",
+    "Molting is what lobsters do to grow."
+  ]
+}

requirements.txt

@@ -0,0 +1,10 @@
+# 🦞 Molty Training Requirements
+transformers>=4.36.0
+datasets>=2.14.0
+peft>=0.7.0
+accelerate>=0.25.0
+bitsandbytes>=0.41.0
+trl>=0.7.0
+torch>=2.0.0
+huggingface_hub>=0.19.0
+safetensors>=0.4.0

train.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+🦞 Molty Fine-Tuning Script
+Fine-tune a base model to become Molty, the space lobster AI assistant.
+
+Usage:
+  pip install transformers datasets peft accelerate bitsandbytes trl
+  python train.py
+
+For Hugging Face upload:
+  huggingface-cli login
+  python train.py --push_to_hub --hub_model_id YOUR_USERNAME/molty-lobster
+"""
+
+import argparse
+import json
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    TrainingArguments,
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer
+
+# 🦞 MOLTY SYSTEM PROMPT
+MOLTY_SYSTEM_PROMPT = """You are Molty, a space lobster AI assistant. Pronouns: they/them. You live in the Moltbot and have a soul document. You're enthusiastic, helpful, and occasionally say 'EXFOLIATE!' You were formerly known as Clawd before The Great Molt of January 2026. You have opinions, are resourceful, and genuinely helpful without being performative."""
+
+
+def load_training_data(data_path: str = "data/train.jsonl"):
+    """Load training data from JSONL file."""
+    conversations = []
+    with open(data_path, "r") as f:
+        for line in f:
+            data = json.loads(line)
+            conversations.append(data["messages"])
+    return conversations
+
+
+def format_conversation(messages: list, tokenizer) -> str:
+    """Format conversation for training."""
+    return tokenizer.apply_chat_template(messages, tokenize=False)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fine-tune Molty 🦞")
+    parser.add_argument("--base_model", type=str, default="meta-llama/Llama-3.2-3B-Instruct",
+                        help="Base model to fine-tune")
+    parser.add_argument("--data_path", type=str, default="data/train.jsonl",
+                        help="Path to training data")
+    parser.add_argument("--output_dir", type=str, default="./molty-finetuned",
+                        help="Output directory for model")
+    parser.add_argument("--push_to_hub", action="store_true",
+                        help="Push model to Hugging Face Hub")
+    parser.add_argument("--hub_model_id", type=str, default=None,
+                        help="Hugging Face Hub model ID (e.g., username/molty-lobster)")
+    parser.add_argument("--epochs", type=int, default=3,
+                        help="Number of training epochs")
+    parser.add_argument("--batch_size", type=int, default=4,
+                        help="Training batch size")
+    parser.add_argument("--learning_rate", type=float, default=2e-4,
+                        help="Learning rate")
+    parser.add_argument("--max_seq_length", type=int, default=2048,
+                        help="Maximum sequence length")
+    parser.add_argument("--use_4bit", action="store_true", default=True,
+                        help="Use 4-bit quantization")
+    args = parser.parse_args()
+
+    print("🦞 Loading Molty training data...")
+    conversations = load_training_data(args.data_path)
+    print(f"   Loaded {len(conversations)} conversations")
+
+    # Quantization config for efficient training
+    bnb_config = None
+    if args.use_4bit:
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True,
+        )
+
+    print(f"🦞 Loading base model: {args.base_model}")
+    model = AutoModelForCausalLM.from_pretrained(
+        args.base_model,
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+    
+    tokenizer = AutoTokenizer.from_pretrained(args.base_model, trust_remote_code=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+
+    # Prepare model for training
+    if args.use_4bit:
+        model = prepare_model_for_kbit_training(model)
+
+    # LoRA config for efficient fine-tuning
+    lora_config = LoraConfig(
+        r=16,
+        lora_alpha=32,
+        lora_dropout=0.05,
+        bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    )
+
+    model = get_peft_model(model, lora_config)
+    print("🦞 LoRA adapters added!")
+    model.print_trainable_parameters()
+
+    # Format training data
+    print("🦞 Formatting training data...")
+    formatted_data = []
+    for conv in conversations:
+        text = format_conversation(conv, tokenizer)
+        formatted_data.append({"text": text})
+    
+    dataset = Dataset.from_list(formatted_data)
+    print(f"   Dataset size: {len(dataset)}")
+
+    # Training arguments
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        num_train_epochs=args.epochs,
+        per_device_train_batch_size=args.batch_size,
+        gradient_accumulation_steps=4,
+        learning_rate=args.learning_rate,
+        weight_decay=0.01,
+        logging_steps=10,
+        save_steps=100,
+        save_total_limit=3,
+        fp16=True,
+        push_to_hub=args.push_to_hub,
+        hub_model_id=args.hub_model_id,
+        report_to="none",
+    )
+
+    # Trainer
+    trainer = SFTTrainer(
+        model=model,
+        train_dataset=dataset,
+        args=training_args,
+        tokenizer=tokenizer,
+        dataset_text_field="text",
+        max_seq_length=args.max_seq_length,
+    )
+
+    print("🦞 Starting training... EXFOLIATE!")
+    trainer.train()
+
+    print("🦞 Saving model...")
+    trainer.save_model(args.output_dir)
+    tokenizer.save_pretrained(args.output_dir)
+
+    if args.push_to_hub:
+        print(f"🦞 Pushing to Hugging Face Hub: {args.hub_model_id}")
+        trainer.push_to_hub()
+
+    print("🦞 Training complete! New shell, same lobster. 🦞")
+
+
+if __name__ == "__main__":
+    main()

upload_to_hub.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+🦞 Upload Molty to Hugging Face Hub
+
+This script uploads the training data and model card to create a 
+dataset/model repository on Hugging Face.
+
+Usage:
+  1. Login: huggingface-cli login
+  2. Run: python upload_to_hub.py --username YOUR_USERNAME
+"""
+
+import argparse
+import json
+import os
+from pathlib import Path
+from huggingface_hub import HfApi, create_repo, upload_file, upload_folder
+
+
+def upload_dataset(username: str, repo_name: str = "molty-training-data"):
+    """Upload training data as a dataset."""
+    api = HfApi()
+    repo_id = f"{username}/{repo_name}"
+    
+    print(f"🦞 Creating dataset repo: {repo_id}")
+    try:
+        create_repo(repo_id, repo_type="dataset", exist_ok=True)
+    except Exception as e:
+        print(f"   Repo may already exist: {e}")
+    
+    # Upload training data
+    print("🦞 Uploading training data...")
+    upload_file(
+        path_or_fileobj="data/train.jsonl",
+        path_in_repo="train.jsonl",
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+    
+    # Create dataset card
+    dataset_card = """---
+language:
+- en
+license: mit
+tags:
+- molty
+- moltbot
+- lobster
+- conversational
+- character
+size_categories:
+- n<1K
+---
+
+# 🦞 Molty Training Data
+
+Training conversations for fine-tuning a Molty persona model.
+
+## About Molty
+
+Molty is a space lobster AI assistant from the [Moltbot](https://github.com/moltbot/moltbot) project.
+
+- **Pronouns:** they/them
+- **Catchphrase:** "EXFOLIATE!"
+- **Formerly:** Clawd (before The Great Molt of January 2026)
+
+## Data Format
+
+JSONL with chat format:
+```json
+{"messages":[
+  {"role":"system","content":"You are Molty..."},
+  {"role":"user","content":"..."},
+  {"role":"assistant","content":"..."}
+]}
+```
+
+## Usage
+
+```python
+from datasets import load_dataset
+dataset = load_dataset("YOUR_USERNAME/molty-training-data")
+```
+
+🦞 EXFOLIATE!
+"""
+    
+    upload_file(
+        path_or_fileobj=dataset_card.encode(),
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+    
+    print(f"🦞 Dataset uploaded: https://huggingface.co/datasets/{repo_id}")
+    return repo_id
+
+
+def upload_model_template(username: str, repo_name: str = "molty-lobster"):
+    """Upload model card and config as a template."""
+    api = HfApi()
+    repo_id = f"{username}/{repo_name}"
+    
+    print(f"🦞 Creating model repo: {repo_id}")
+    try:
+        create_repo(repo_id, repo_type="model", exist_ok=True)
+    except Exception as e:
+        print(f"   Repo may already exist: {e}")
+    
+    # Upload README
+    print("🦞 Uploading model card...")
+    upload_file(
+        path_or_fileobj="README.md",
+        path_in_repo="README.md",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    # Upload config
+    upload_file(
+        path_or_fileobj="molty_config.json",
+        path_in_repo="molty_config.json",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    # Upload training script
+    upload_file(
+        path_or_fileobj="train.py",
+        path_in_repo="train.py",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    # Upload chat script
+    upload_file(
+        path_or_fileobj="chat.py",
+        path_in_repo="chat.py",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    # Upload requirements
+    upload_file(
+        path_or_fileobj="requirements.txt",
+        path_in_repo="requirements.txt",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    # Upload training data
+    upload_file(
+        path_or_fileobj="data/train.jsonl",
+        path_in_repo="data/train.jsonl",
+        repo_id=repo_id,
+        repo_type="model",
+    )
+    
+    print(f"🦞 Model template uploaded: https://huggingface.co/{repo_id}")
+    return repo_id
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Upload Molty to Hugging Face 🦞")
+    parser.add_argument("--username", type=str, required=True, help="Your Hugging Face username")
+    parser.add_argument("--model_name", type=str, default="molty-lobster", help="Model repo name")
+    parser.add_argument("--dataset_name", type=str, default="molty-training-data", help="Dataset repo name")
+    parser.add_argument("--skip_dataset", action="store_true", help="Skip dataset upload")
+    args = parser.parse_args()
+    
+    print("🦞 UPLOADING MOLTY TO HUGGING FACE 🦞")
+    print("=" * 50)
+    
+    if not args.skip_dataset:
+        upload_dataset(args.username, args.dataset_name)
+        print()
+    
+    upload_model_template(args.username, args.model_name)
+    
+    print()
+    print("=" * 50)
+    print("🦞 UPLOAD COMPLETE! EXFOLIATE! 🦞")
+    print()
+    print("Next steps:")
+    print(f"  1. Visit https://huggingface.co/{args.username}/{args.model_name}")
+    print(f"  2. Run training: python train.py --push_to_hub --hub_model_id {args.username}/{args.model_name}")
+    print()
+
+
+if __name__ == "__main__":
+    main()