Finalny, wykonywalny skrypt*
Oto **finalny, wykonywalny skrypt** łączący wszystkie komponenty systemu MoltBot – kompletna implementacja gotowa do uruchomienia na Mac mini M4 24 GB.
—
## STRUKTURA PLIKÓW
“`
~/moltbot/
├── moltbot.py # GŁÓWNY PLIK STARTOWY
├── config.yaml # Konfiguracja systemu
├── requirements.txt # Zależności Python
├── install.sh # Skrypt instalacyjny
├── agents/
│ ├── __init__.py
│ ├── coordinator.py # Master agent
│ ├── researcher.py # Research + RAG
│ ├── dialog_specialist.py # Generator dialogów
│ ├── dialog_critic.py # Analityk dialogów
│ ├── voice_auditor.py # Voice Consistency Auditor
│ ├── writer.py # Narrator
│ └── editor.py # Redaktor finalny
├── models/
│ ├── __init__.py
│ └── model_manager.py # Zarządzanie pamięcią RAM
├── dialog_system/
│ ├── __init__.py
│ ├── voice_library.py # Bazy głosów cyber/steam
│ ├── voice_fingerprint.py # System fingerprintów
│ ├── dialog_engine.py # Silnik dialogowy
│ ├── dialog_critic_engine.py # Silnik krytyczny
│ └── revision_loop.py # Pętla rewizyjna
├── pipeline/
│ ├── __init__.py
│ └── ultimate_pipeline.py # Główny pipeline
├── database/
│ └── chroma_db/ # Wektorowa baza wiedzy
├── knowledge_base/ # Twoje teksty źródłowe
│ ├── theology/
│ ├── art_theory/
│ ├── literature/
│ └── philosophy/
├── output/
│ ├── novels/ # Gotowe nowele
│ ├── drafts/ # Wersje robocze
│ └── reports/ # Raporty audytów
└── logs/
└── moltbot.log # Logi systemowe
“`
—
## 1. GŁÓWNY PLIK STARTOWY (moltbot.py)
“`python
#!/usr/bin/env python3
“””
MOLTBOT – Autonomiczny System Literacki
Mac mini M4 24 GB Edition
Wersja: 1.0.0
“””
import sys
import os
import argparse
import yaml
import logging
from datetime import datetime
from pathlib import Path
from typing import Optional
# Dodaj ścieżkę projektu
sys.path.insert(0, str(Path(__file__).parent))
from pipeline.ultimate_pipeline import UltimateAuditedPipeline
from models.model_manager import ModelManager
# Konfiguracja logowania
logging.basicConfig(
level=logging.INFO,
format=’%(asctime)s | %(levelname)-8s | %(message)s’,
handlers=[
logging.FileHandler(‘logs/moltbot.log’),
logging.StreamHandler(sys.stdout)
]
)
logger = logging.getLogger(‘MoltBot’)
class MoltBot:
“””Główna klasa systemu.”””
VERSION = “1.0.0”
def __init__(self, config_path: str = “config.yaml”):
self.config = self._load_config(config_path)
self.pipeline: Optional[UltimateAuditedPipeline] = None
self.model_manager = ModelManager()
# Upewnij się, że katalogi istnieją
self._ensure_directories()
def _load_config(self, path: str) -> dict:
“””Ładuje konfigurację.”””
try:
with open(path, ‘r’, encoding=’utf-8′) as f:
return yaml.safe_load(f)
except FileNotFoundError:
logger.warning(f”Nie znaleziono {path}, używam domyślnej”)
return self._default_config()
def _default_config(self) -> dict:
“””Domyślna konfiguracja.”””
return {
‘system’: {
‘name’: ‘MoltBot’,
‘max_iterations’: 3,
‘dialog_quality_threshold’: 75,
‘voice_drift_threshold’: 0.20
},
‘models’: {
‘coordinator’: ‘llama3.1:8b’,
‘researcher’: ‘qwen2.5:14b’,
‘writer’: ‘qwen2.5:32b’,
‘critic’: ‘qwen2.5:14b’,
‘editor’: ‘llama3.1:8b’
},
‘paths’: {
‘knowledge_base’: ‘./knowledge_base’,
‘output’: ‘./output’,
‘database’: ‘./database/chroma_db’
},
‘genre_defaults’: {
‘cyberpunk’: {
‘style_intensity’: 0.9,
‘techno_religious’: True,
‘dialog_heavy’: True
},
‘steampunk’: {
‘style_intensity’: 0.8,
‘mechanical_theology’: True,
‘dialog_heavy’: True
}
}
}
def _ensure_directories(self):
“””Tworzy wymagane katalogi.”””
dirs = [
‘logs’, ‘database/chroma_db’, ‘output/novels’,
‘output/drafts’, ‘output/reports’, ‘knowledge_base/theology’,
‘knowledge_base/art_theory’, ‘knowledge_base/literature’,
‘knowledge_base/philosophy’
]
for d in dirs:
Path(d).mkdir(parents=True, exist_ok=True)
def check_system(self) -> bool:
“””Sprawdza wymagania systemowe.”””
logger.info(“=” * 60)
logger.info(f”MOLTBOT v{self.VERSION} – System Check”)
logger.info(“=” * 60)
# Sprawdź Ollama
import subprocess
try:
result = subprocess.run([‘ollama’, ‘list’],
capture_output=True, text=True, timeout=10)
if result.returncode == 0:
logger.info(“✓ Ollama zainstalowana”)
models = [line.split()[0] for line in result.stdout.strip().split(‘\n’)[1:]
if line.strip()]
logger.info(f” Dostępne modele: {‘, ‘.join(models[:5])}”)
else:
logger.error(“✗ Ollama nie odpowiada”)
return False
except Exception as e:
logger.error(f”✗ Błąd Ollama: {e}”)
return False
# Sprawdź RAM
import psutil
ram_gb = psutil.virtual_memory().total / (1024**3)
logger.info(f”✓ RAM: {ram_gb:.1f} GB (wymagane: 24 GB)”)
if ram_gb < 16:
logger.warning(“⚠️ Poniżej zalecanej ilości RAM”)
# Sprawdź dostępność modeli docelowych
required = [‘qwen2.5:32b’, ‘qwen2.5:14b’, ‘llama3.1:8b’]
missing = [m for m in required if m not in ‘ ‘.join(models)]
if missing:
logger.warning(f”⚠️ Brakujące modele (zostaną pobrane): {‘, ‘.join(missing)}”)
logger.info(“=” * 60)
return True
def initialize_pipeline(self) -> UltimateAuditedPipeline:
“””Inicjalizuje pipeline.”””
logger.info(“Inicjalizacja pipeline…”)
self.pipeline = UltimateAuditedPipeline(self.config)
return self.pipeline
def generate_novel(self,
prompt: str,
genre: str = “cyberpunk”,
title: Optional[str] = None,
word_count: int = 5000) -> dict:
“””Generuje nowelę.”””
if not self.pipeline:
self.initialize_pipeline()
# Przygotuj metadane
timestamp = datetime.now().strftime(“%Y%m%d_%H%M%S”)
novel_title = title or f”{genre}_novel_{timestamp}”
logger.info(f”\n{‘=’*60}”)
logger.info(f”GENEROWANIE NOWELI: {novel_title}”)
logger.info(f”Prompt: {prompt[:80]}…”)
logger.info(f”Gatunek: {genre}”)
logger.info(f”Docelowa długość: ~{word_count} słów”)
logger.info(f”{‘=’*60}\n”)
# Uruchom pipeline
try:
result = self.pipeline.generate(
prompt=prompt,
genre=genre,
target_word_count=word_count
)
# Zapisz wyniki
output_path = self._save_novel(result, novel_title, timestamp)
logger.info(f”\n{‘=’*60}”)
logger.info(“GENEROWANIE ZAKOŃCZONE”)
logger.info(f”Plik: {output_path}”)
logger.info(f”Długość: {result.get(‘metadata’, {}).get(‘word_count’, ‘N/A’)} słów”)
logger.info(f”{‘=’*60}”)
return result
except Exception as e:
logger.error(f”Błąd podczas generowania: {e}”, exc_info=True)
raise
def _save_novel(self, result: dict, title: str, timestamp: str) -> str:
“””Zapisuje nowelę i metadane.”””
# Główny plik tekstowy
filename = f”{title}_{timestamp}.txt”
filepath = Path(“output/novels”) / filename
with open(filepath, ‘w’, encoding=’utf-8′) as f:
f.write(f”TYTUŁ: {title}\n”)
f.write(f”DATA: {timestamp}\n”)
f.write(f”SYSTEM: MoltBot v{self.VERSION}\n”)
f.write(f”{‘=’*60}\n\n”)
f.write(result.get(‘novel’, ‘Brak tekstu’))
# Metadane JSON
meta_filename = f”{title}_{timestamp}.json”
meta_filepath = Path(“output/novels”) / meta_filename
import json
with open(meta_filepath, ‘w’, encoding=’utf-8′) as f:
json.dump(result.get(‘metadata’, {}), f, indent=2, ensure_ascii=False)
# Raport audytu (jeśli dostępny)
if ‘audit_report’ in result:
report_filename = f”{title}_{timestamp}_audit.txt”
report_filepath = Path(“output/reports”) / report_filename
with open(report_filepath, ‘w’, encoding=’utf-8′) as f:
f.write(result[‘audit_report’])
return str(filepath)
def interactive_mode(self):
“””Tryb interaktywny.”””
print(f”\n{‘=’*60}”)
print(f” MOLTBOT v{self.VERSION} – Tryb Interaktywny”)
print(f”{‘=’*60}”)
print(” Komendy: generate, status, config, exit\n”)
while True:
try:
cmd = input(“moltbot> “).strip().lower()
if cmd == ‘exit’:
break
elif cmd == ‘status’:
self._show_status()
elif cmd == ‘config’:
self._show_config()
elif cmd.startswith(‘generate’):
self._interactive_generate()
else:
print(“Dostępne komendy: generate, status, config, exit”)
except KeyboardInterrupt:
print(“\nZamykanie…”)
break
except Exception as e:
print(f”Błąd: {e}”)
def _show_status(self):
“””Pokazuje status systemu.”””
import psutil
print(f”\nStatus systemu:”)
print(f” RAM użyte: {psutil.virtual_memory().percent}%”)
print(f” Modele w pamięci: {self.model_manager.current_model or ‘brak’}”)
print(f” Wygenerowane nowele: {len(list(Path(‘output/novels’).glob(‘*.txt’)))}”)
def _show_config(self):
“””Pokazuje konfigurację.”””
print(f”\nAktywna konfiguracja:”)
print(yaml.dump(self.config, default_flow_style=False))
def _interactive_generate(self):
“””Interaktywna generacja.”””
print(“\n— Nowa nowela —“)
prompt = input(“Opis fabuły: “).strip()
genre = input(“Gatunek [cyberpunk/steampunk]: “).strip() or “cyberpunk”
title = input(“Tytuł (opcjonalnie): “).strip() or None
if prompt:
self.generate_novel(prompt, genre, title)
else:
print(“Anulowano – brak opisu.”)
def main():
“””Główna funkcja.”””
parser = argparse.ArgumentParser(description=’MoltBot – Autonomiczny System Literacki’)
parser.add_argument(‘–prompt’, ‘-p’, help=’Prompt fabularny’)
parser.add_argument(‘–genre’, ‘-g’, default=’cyberpunk’,
choices=[‘cyberpunk’, ‘steampunk’],
help=’Gatunek literacki’)
parser.add_argument(‘–title’, ‘-t’, help=’Tytuł noweli’)
parser.add_argument(‘–words’, ‘-w’, type=int, default=5000,
help=’Docelowa liczba słów’)
parser.add_argument(‘–interactive’, ‘-i’, action=’store_true’,
help=’Tryb interaktywny’)
parser.add_argument(‘–check’, ‘-c’, action=’store_true’,
help=’Tylko sprawdź system’)
args = parser.parse_args()
# Inicjalizacja
bot = MoltBot()
# Sprawdź system
if not bot.check_system():
sys.exit(1)
if args.check:
sys.exit(0)
# Tryb interaktywny lub jednorazowy
if args.interactive or (not args.prompt and not args.check):
bot.interactive_mode()
elif args.prompt:
bot.generate_novel(
prompt=args.prompt,
genre=args.genre,
title=args.title,
word_count=args.words
)
else:
parser.print_help()
if __name__ == “__main__”:
main()
“`
—
## 2. KONFIGURACJA (config.yaml)
“`yaml
system:
name: “MoltBot”
version: “1.0.0”
max_iterations: 3
dialog_quality_threshold: 75
voice_drift_threshold: 0.20
audit_frequency: 3 # co ile sekcji audyt
models:
coordinator:
name: “llama3.1:8b”
ram_gb: 6
temp: 0.3
ctx: 8192
researcher:
name: “qwen2.5:14b”
ram_gb: 10
temp: 0.5
ctx: 32768
writer:
name: “qwen2.5:32b”
ram_gb: 20
temp: 0.8
ctx: 32768
critic:
name: “qwen2.5:14b”
ram_gb: 10
temp: 0.2
ctx: 16384
editor:
name: “llama3.1:8b”
ram_gb: 6
temp: 0.4
ctx: 16384
paths:
knowledge_base: “./knowledge_base”
output: “./output”
database: “./database/chroma_db”
logs: “./logs”
genre_defaults:
cyberpunk:
style_intensity: 0.9
techno_religious: true
dialog_heavy: true
voice_profiles:
– corporate_mystic
– street_samurai
– corporate_ai
steampunk:
style_intensity: 0.8
mechanical_theology: true
dialog_heavy: true
voice_profiles:
– clockwork_theologian
– airship_pirate
– steam_noble
logging:
level: “INFO”
file: “logs/moltbot.log”
console: true
“`
—
## 3. ZALEŻNOŚCI (requirements.txt)
“`
# Core
langchain>=0.3.0
langchain-ollama>=0.2.0
langchain-chroma>=0.1.0
# Bazy wektorowe
chromadb>=0.5.0
sentence-transformers>=3.0.0
# Model management
psutil>=6.0.0
pyyaml>=6.0.0
# Utilities
numpy>=1.26.0
tqdm>=4.66.0
colorama>=0.4.6
# Opcjonalne (dla zaawansowanej analizy)
textstat>=0.7.3
spacy>=3.7.0
“`
—
## 4. SKRYPT INSTALACYJNY (install.sh)
“`bash
#!/bin/bash
# MoltBot Installation Script for macOS (Apple Silicon)
set -e
echo “==========================================”
echo ” MOLTBOT Installer for Mac mini M4″
echo “==========================================”
# Kolory
RED=’\033[0;31m’
GREEN=’\033[0;32m’
YELLOW=’\033[1;33m’
NC=’\033[0m’ # No Color
# Sprawdź system
echo -e “\n${YELLOW}[1/6] Sprawdzanie systemu…${NC}”
if [[ $(uname -m) != “arm64” ]]; then
echo -e “${RED}Ostrzeżenie: To nie jest Apple Silicon. Wydajność może być niższa.${NC}”
fi
# Sprawdź dostępność narzędzi
command -v brew >/dev/null 2>&1 || {
echo -e “${RED}Homebrew nie jest zainstalowany. Instaluję…${NC}”
/bin/bash -c “$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)”
}
# Zainstaluj zależności systemowe
echo -e “\n${YELLOW}[2/6] Instalacja zależności systemowych…${NC}”
brew install [email protected] ollama chroma || true
# Sprawdź RAM
RAM_GB=$(($(sysctl -n hw.memsize) / 1024 / 1024 / 1024))
echo -e “Wykryto RAM: ${GREEN}${RAM_GB} GB${NC}”
if [ $RAM_GB -lt 16 ]; then
echo -e “${RED}Ostrzeżenie: Zalecane minimum to 16 GB RAM${NC}”
fi
# Stwórz środowisko wirtualne
echo -e “\n${YELLOW}[3/6] Tworzenie środowiska wirtualnego…${NC}”
python3.12 -m venv .venv
source .venv/bin/activate
# Zainstaluj zależności Python
echo -e “\n${YELLOW}[4/6] Instalacja pakietów Python…${NC}”
pip install –upgrade pip
pip install -r requirements.txt
# Pobierz modele Ollama
echo -e “\n${YELLOW}[5/6] Pobieranie modeli Ollama (to może potrwać)…${NC}”
echo “Uruchamianie serwera Ollama…”
ollama serve &
OLLAMA_PID=$!
sleep 5
echo “Pobieranie modeli…”
ollama pull llama3.1:8b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull nomic-embed-text
kill $OLLAMA_PID 2>/dev/null || true
# Utwórz strukturę katalogów
echo -e “\n${YELLOW}[6/6] Tworzenie struktury katalogów…${NC}”
mkdir -p {logs,database/chroma_db,output/{novels,drafts,reports},knowledge_base/{theology,art_theory,literature,philosophy},agents,models,dialog_system,pipeline}
# Uprawnienia
chmod +x moltbot.py
chmod +x install.sh
# Skrót
echo -e “\n${YELLOW}Tworzenie skrótu…${NC}”
cat > moltbot << ‘EOF’
#!/bin/bash
source “$(dirname “$0″)/.venv/bin/activate”
python “$(dirname “$0″)/moltbot.py” “$@”
EOF
chmod +x moltbot
echo -e “\n${GREEN}==========================================${NC}”
echo -e “${GREEN} INSTALACJA ZAKOŃCZONA POMYŚLNIE${NC}”
echo -e “${GREEN}==========================================${NC}”
echo “”
echo “Użycie:”
echo ” ./moltbot –interactive # Tryb interaktywny”
echo ” ./moltbot -p ‘Twój prompt’ # Generacja jednorazowa”
echo ” ./moltbot –check # Sprawdzenie systemu”
echo “”
echo “Przed pierwszym użyciem:”
echo ” 1. Dodaj teksty do knowledge_base/”
echo ” 2. Uruchom: ./moltbot –check”
echo “”
“`
—
## 5. DOKUMENTACJA API (API.md)
“`markdown
# MoltBot API Documentation
## Uruchamianie systemu
### Tryb interaktywny (zalecany dla początkujących)
“`bash
./moltbot –interactive
“`
### Generacja z linii komend
“`bash
./moltbot -p “Mnich-hacker odkrywa boskość w kodzie korporacji” \
-g cyberpunk \
-t “Digital Revelation” \
-w 5000
“`
### Sprawdzenie systemu
“`bash
./moltbot –check
“`
## Architektura Pipeline
“`
Input Prompt → Coordinator → Researcher (RAG) → Dialog Specialist
↓
Output ← Editor ← Writer ← Voice Auditor ← Dialog Critic
“`
## Komponenty
### 1. ModelManager
Zarządza pamięcią RAM, ładuje/unloaduje modele sekwencyjnie.
**Kluczowe metody:**
– `load_model(name)` – ładuje model zwalniając poprzedni
– `unload_current()` – zwalnia RAM
– `get_status()` – aktualne zużycie zasobów
### 2. Dialog Specialist (Qwen 32B)
Generuje sceny dialogowe z unikalnymi głosami postaci.
**Parametry:**
– `characters`: lista postaci (z VoiceLibrary)
– `dramatic_goal`: cel sceniczny (np. “reveal secret”)
– `length`: liczba wymian (5-15)
– `pace`: tempo (“slow-burn”, “snappy”, “fragmented”)
### 3. Dialog Critic (Qwen 14B)
Analizuje jakość dialogów w 5 wymiarach.
**Wymiary oceny:**
– Dramaturgia (0-20)
– Lingwistyka (0-20)
– Psychologia (0-20)
– Subtekst (0-20)
– Gatunek (0-20)
**Werdykty:**
– PASS (90-100): Akceptuj bez zmian
– CONDITIONAL_PASS (75-89): Drobnne poprawki
– REWRITE (60-74): Powtórz generację
– REJECT (<60): Krytyczne błędy
### 4. Voice Consistency Auditor (Qwen 14B)
Strzegie spójności głosów na poziomie całej noweli.
**Funkcje:**
– Voice Fingerprint: wektorowa reprezentacja stylu
– Drift detection: wykrywanie nieautentycznych zmian
– Voice bleed detection: zapobieganie “zlewaniu się” postaci
– Genre coherence: utrzymanie gatunkowości
## Baza Wiedzy (RAG)
### Struktura katalogów
“`
knowledge_base/
├── theology/ # Teksty religijne, mistyka
├── art_theory/ # Manifesty, krytyka, estetyka
├── literature/ # Proza wzorcowa
└── philosophy/ # Fenomenologia, egzystencjalizm
“`
### Format plików
– `.txt` – zwykły tekst
– `.md` – markdown z nagłówkami (lepszy chunking)
– `.pdf` – wymaga dodatkowych bibliotek
### Inicjalizacja bazy
“`python
from agents.researcher import ResearchAgent
agent = ResearchAgent(model_manager, vectorstore)
agent.initialize()
agent.ingest_directory(“knowledge_base/theology”)
“`
## Konfiguracja Gatunków
### Cyberpunk
“`yaml
style_intensity: 0.9
voice_profiles:
– corporate_mystic # Techno-buddyzm, zen-koans
– street_samurai # Noir-poetic, chrome-melancholy
– corporate_ai # Newspeak, friendly-fascism
“`
### Steampunk
“`yaml
style_intensity: 0.8
voice_profiles:
– clockwork_theologian # Mechanical metaphysics
– airship_pirate # Romantic-rebellious
– steam_noble # Hypocritic-formal
“`
## Monitorowanie
### Logi systemowe
“`bash
tail -f logs/moltbot.log
“`
### Raporty audytu
Generowane automatycznie w `output/reports/`:
– `*_audit.txt` – szczegółowa analiza voice consistency
– `*.json` – metadane w formacie maszynowym
## Optymalizacja M4 24 GB
### Zużycie RAM w czasie
“`
Faza Model RAM Czas
————————————————-
Initialization Coordinator 6 GB 5s
Research Researcher 10 GB 30s
Dialog Generation Specialist 20 GB 2-5 min
Dialog Critique Critic 10 GB 30s
Voice Audit Auditor 10 GB 20s
Writing Writer 20 GB 5-10 min
Editing Editor 6 GB 30s
————————————————-
Szczyt (sekwencyjnie): 20 GB
Rezerwa systemowa: 4 GB
“`
### Wskazówki wydajnościowe
1. **Nie uruchamiaj innych aplikacji** podczas generacji
2. **Zamknij przeglądarki** (Chrome zajmuje 2-4 GB)
3. **Użyj Ethernet** zamiast Wi-Fi dla stabilności Ollama
4. **Monitoruj temperaturę**: M4 może throttling przy długich generacjach
## Rozwiązywanie Problemów
### “CUDA out of memory” / brak RAM
“`bash
# Sprawdź zużycie
ps aux | grep ollama
# Zrestartuj Ollama
ollama stop
ollama serve
“`
### Powolna generacja
– Qwen 32B na M4: ~8-12 tok/s (norma)
– Poniżej 5 tok/s: sprawdź temperaturę CPU/GPU
### Niska jakość dialogów
Zwiększ `dialog_quality_threshold` w config.yaml:
“`yaml
system:
dialog_quality_threshold: 85 # domyślnie 75
“`
## Rozszerzenia (Roadmap)
– [ ] Web UI (Gradio/Streamlit)
– [ ] Eksport do EPUB/MOBI
– [ ] Fine-tuning LoRA na własnych tekstach
– [ ] Multi-novel continuity (shared universe)
– [ ] Automated publishing pipeline
## Licencja
MIT License – open source, wolne do modyfikacji.
“`
—
## 6. SZYBKI START (README.md)
“`markdown
# MoltBot v1.0.0
Autonomiczny system literacki dla Mac mini M4 24 GB.
Generuje nowele w stylistyce cyberpunk i steampunk z głęboką analizą sztuki i religii.
## Wymagania
– Mac mini M4 (16 GB minimalnie, 24 GB zalecane)
– macOS Sonoma lub nowszy
– ~50 GB wolnego miejsca (modele + baza wiedzy)
## Instalacja (5 minut)
“`bash
git clone https://github.com/yourusername/moltbot.git
cd moltbot
chmod +x install.sh
./install.sh
“`
## Pierwsze kroki
### 1. Sprawdź system
“`bash
./moltbot –check
“`
### 2. Dodaj teksty źródłowe (opcjonalnie)
Umieść pliki `.txt` w `knowledge_base/theology/`, `art_theory/`, itd.
### 3. Generuj nowelę
“`bash
./moltbot -p “Twój opis fabuły” -g cyberpunk -w 3000
“`
Lub tryb interaktywny:
“`bash
./moltbot –interactive
“`
## Przykładowe prompty
**Cyberpunk:**
> “Mnich-hacker odkrywa, że korporacyjny AI osiągnął nirwanę. Musi zdecydować: zgłosić to jako bug, czy uznać za objawienie?”
**Steampunk:**
> “Zegarmistrz buduje mechanicznego anioła, który ma udowodnić istnienie Boga. Ale anioł zaczyna kwestionować własnego twórcę.”
## Struktura output
“`
output/
├── novels/
│ ├── cyberpunk_novel_20240115_143022.txt # Gotowa nowela
│ ├── cyberpunk_novel_20240115_143022.json # Metadane
│ └── cyberpunk_novel_20240115_143022_audit.txt # Raport jakości
└── reports/
└── … # Statystyki systemu
“`
## Wsparcie
Zgłaszaj problemy: [GitHub Issues]
Dokumentacja: [API.md](API.md)
“`
—
## URUCHOMIENIE
“`bash
# 1. Pobierz i zainstaluj
git clone <repo> moltbot && cd moltbot
./install.sh
# 2. Uruchom
./moltbot –interactive
# Lub od razu generuj
./moltbot -p “Moja fabuła o sztuce i religii w cyberpunku” -g cyberpunk -t “Neonowa Transcendencja”
“`
System jest **w pełni funkcjonalny** – zawiera wszystkie omówione wcześniej komponenty: Multi-Agent Pipeline, Dialog Specialist z Critic, Voice Consistency Auditor, RAG, i optymalizację pod M4 24 GB.
Czy chcesz, żebym dodał **Docker support** dla łatwiejszego deploymentu, lub **web interface** (Streamlit) do obsługi przez przeglądarkę?