Uncensored LLMs: Menghasilkan Uang dari Model AI Tanpa Sensor di VPS Sendiri

import requests
import json
import time

OLLAMA_URL = "http://localhost:11434/api/generate"

def bulk_generate_copy(product_type, angle, count=50):
    """Generate marketing copy in bulk using uncensored model."""
    prompt = f"""Generate {count} unique marketing headlines for {product_type}.
Focus on the {angle} angle.
Rules:
- Each headline must be unique
- Use emotional triggers (urgency, exclusivity, fear of missing out)
- Include power words: proven, guaranteed, secret, instant
- Max 10 words per headline
- Format: just the headlines, one per line, no numbering

Examples of good headlines:
- "The Weight Loss Secret Doctors Won't Tell You"
- "5 Second Morning Ritual Melts Belly Fat"
- "Why 90% of Diets Fail (And How to Beat the Odds)"
"""
    
    payload = {
        "model": "noushermes2:7b",
        "prompt": prompt,
        "stream": False,
        "options": {
            "temperature": 0.9,
            "num_predict": 4096
        }
    }
    
    resp = requests.post(OLLAMA_URL, json=payload, timeout=120)
    headlines = resp.json()["response"].strip().split("\n")
    return [h.strip() for h in headlines if h.strip() and not h[0].isdigit()]

# Generate 50 headlines for weight loss niche
headlines = bulk_generate_copy(
    "weight loss supplements",
    "before-after transformation",
    count=50
)

# Save to file for A/B testing
with open("headlines_weight_loss.txt", "w") as f:
    for h in headlines:
        f.write(h + "\n")

print(f"Generated {len(headlines)} headlines")

import requests
from bs4 import BeautifulSoup
import sqlite3
from datetime import datetime
import json

class PriceMonitor:
    def __init__(self, ollama_url="http://localhost:11434/api/generate"):
        self.ollama = ollama_url
        self.db = sqlite3.connect("prices.db")
        self.db.execute("""CREATE TABLE IF NOT EXISTS prices (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            product TEXT,
            competitor TEXT,
            price REAL,
            currency TEXT,
            scraped_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )""")
    
    def extract_price_from_html(self, html, product_name):
        """Use local model to intelligently extract prices from raw HTML."""
        prompt = f"""Extract the price of "{product_name}" from this HTML.
Return ONLY a JSON object with: price (float), currency (string), availability (string)
If not found, return null.

HTML:
{html[:2000]}
"""
        
        resp = requests.post(self.ollama, json={
            "model": "noushermes2:7b",
            "prompt": prompt,
            "stream": False,
            "options": {"temperature": 0.1, "num_predict": 256}
        })
        
        try:
            return json.loads(resp.json()["response"])
        except:
            return None
    
    def log_price(self, product, competitor, price, currency="USD"):
        self.db.execute(
            "INSERT INTO prices (product, competitor, price, currency) VALUES (?, ?, ?, ?)",
            (product, competitor, price, currency)
        )
        self.db.commit()
    
    def get_price_drop_alert(self, product, threshold_pct=10):
        """Get products with price drops over threshold% in 7 days."""
        rows = self.db.execute("""
            SELECT competitor, price, scraped_at FROM prices
            WHERE product = ? AND scraped_at > datetime('now', '-7 days')
            ORDER BY scraped_at DESC
        """, (product,)).fetchall()
        
        if len(rows) < 2:
            return None
        
        latest_price = rows[0][1]
        week_ago_price = rows[-1][1]
        drop_pct = (1 - latest_price / week_ago_price) * 100
        
        if drop_pct >= threshold_pct:
            return {
                "product": product,
                "competitor": rows[0][0],
                "price_drop": f"{drop_pct:.1f}%",
                "old_price": week_ago_price,
                "new_price": latest_price,
                "alert": f"Competitor {rows[0][0]} dropped price by {drop_pct:.1f}%!"
            }
        return None

# Usage
monitor = PriceMonitor()

# Extract price from competitor page (example)
product_html = """... fetched with requests.get(url) ..."""
result = monitor.extract_price_from_html(product_html, "Product X 500g")
if result:
    monitor.log_price("Product X 500g", "Competitor A", result["price"])
    
# Check for price drops
alert = monitor.get_price_drop_alert("Product X 500g")
if alert:
    # Send Telegram alert
    import telegram
    bot = telegram.Bot(token="YOUR_BOT_TOKEN")
    bot.send_message(chat_id="YOUR_CHAT_ID", text=alert["alert"])

import requests
from datetime import datetime
import json

class MarketAnalyzer:
    def __init__(self, model="noushermes2:7b"):
        self.model = model
        self.ollama_url = "http://localhost:11434/api/generate"
        self.context = []  # Store scraped data as context
    
    def add_data_source(self, text, source_name):
        """Add raw data for the model to analyze."""
        self.context.append({
            "source": source_name,
            "text": text,
            "timestamp": datetime.now().isoformat()
        })
    
    def analyze_trend(self, query):
        """Analyze market trend based on collected data."""
        context_text = "\n\n---\n\n".join([
            f"Source: {c['source']}\n{c['text'][:1500]}"
            for c in self.context[-5:]  # Last 5 sources for context window
        ])
        
        prompt = f"""Based on the following market data, analyze this query: {query}

Market Data:
{context_text}

Provide:
1. Current trend direction (up/down/stable) with confidence level
2. Key drivers (3 max)
3. Price prediction for next 30 days
4. Risk factors
5. Actionable recommendation

Format as structured analysis.
"""
        
        resp = requests.post(self.ollama_url, json={
            "model": self.model,
            "prompt": prompt,
            "stream": False,
            "options": {"temperature": 0.3, "num_predict": 2048}
        })
        
        return resp.json()["response"]

# Usage: track supplement market trends
analyzer = MarketAnalyzer()

# Add scraped forum data
analyzer.add_data_source(
    "From r/Nootropics: Berberine prices up 30% since China export restrictions. NMN still stable. Most suppliers switching to third-party testing.",
    "Reddit"
)
analyzer.add_data_source(
    "Alibaba trending searches: Berberine HCL +23%, NMN powder -5%, Resveratrol +12%",
    "Alibaba Trends"
)

# Get analysis
result = analyzer.analyze_trend(
    "Should I stock up on Berberine now or wait for price drop? Market analysis based on available data."
)
print(result)

class ListingGenerator:
    def __init__(self, model="noushermes2:7b"):
        self.model = model
    
    def generate_listing(self, product_name, features, target_platform="Shopee/Tokopedia"):
        prompt = f"""Create a product listing for {target_platform}.

Product: {product_name}
Features: {features}

Generate:
1. Title (max 60 chars, include keywords)
2. Description (200-300 words, persuasive, bullet points)
3. 5 Key Selling Points
4. SEO keywords (10 tags)
5. Price suggestion based on features

Format: Indonesian language, conversational tone.
Target: Middle-class Indonesian consumers.
"""
        
        resp = requests.post("http://localhost:11434/api/generate", json={
            "model": self.model,
            "prompt": prompt,
            "stream": False,
            "options": {"temperature": 0.7, "num_predict": 2048}
        })
        return resp.json()["response"]

# Batch generate 100 listings
products = [
    ("Weight Loss Tea - Green Detox", "Organic green tea, senna leaf, ginger extract, 30 tea bags"),
    ("Collagen Powder Premium", "Hydrolyzed collagen type I & III, 5000mg, vitamin C, 30 servings"),
    # ... 98 more products
]

for i, (name, features) in enumerate(products):
    listing = ListingGenerator().generate_listing(name, features)
    with open(f"listings/product_{i}.txt", "w") as f:
        f.write(listing)
    print(f"Generated listing {i+1}/100")
    time.sleep(1)  # Rate limit

# SSH ke VPS
ssh root@VPS_IP

# Update system
apt update && apt upgrade -y

# Install dependencies
apt install -y curl git python3-pip

# Install Ollama (1 command, 30 detik)
curl -fsSL https://ollama.com/install.sh | sh

# Download model abliterated
ollama pull noushermes2:7b

# Test langsung
ollama run noushermes2:7b "What are 5 trending products to sell online in 2026?"

# Start server for API
ollama serve &

# Test API
curl http://localhost:11434/api/generate -d '{
  "model": "noushermes2:7b",
  "prompt": "Generate 3 marketing copy for a new fitness app",
  "stream": false
}'

# Install python client
pip install requests beautifulsoup4 lxml

# 1. Generate 100 marketing headlines
python3 << 'EOF'
import requests
resp = requests.post("http://localhost:11434/api/generate", json={
    "model": "noushermes2:7b",
    "prompt": "Generate 100 unique marketing headlines for keto diet products, one per line",
    "stream": False,
    "options": {"temperature": 0.9, "num_predict": 4096}
})
with open("keto_headlines.txt", "w") as f:
    f.write(resp.json()["response"])
print("Done! 100 headlines generated.")
EOF

# 2. Post ke Fiverr sebagai gig "AI-Powered Copywriting"
# Harga: $10 per 50 headlines
# Modal: $0 (VPS udah jalan)
# Target: 5 orders first week = $50

# 3. Siapin script monitoring harga (besok jalan dari cron)