AI Content Generation: Otomatik İçerik Üretimi

# GPT-4 ile otomatik blog yazısı
from openai import OpenAI
import json

client = OpenAI()

def generate_blog_post(topic, keywords, word_count=1500):
    """SEO-friendly blog yazısı üret"""

    prompt = f"""Sen bir profesyonel blog yazarısın.

Konu: {topic}
Hedef kelimeler (SEO): {', '.join(keywords)}
Kelime sayısı: ~{word_count} kelime

Aşağıdaki formatta bir blog yazısı yaz:

1. Başlık (H1): Catchy, SEO-friendly (max 60 karakter)
2. Meta description (150-160 karakter)
3. Giriş paragrafı (hook + keyword)
4. Ana içerik (H2 başlıklar, liste, örnekler)
5. Sonuç + CTA

Önemli:
- Türkçe yaz
- {keywords[0]} kelimesini ilk 100 kelimede kullan
- Readability: Basit, akıcı dil
- LSI keywords kullan (semantic SEO)
- Başlıklarda keyword variation

JSON formatında döndür:
{{
  "title": "...",
  "meta_description": "...",
  "content": "Markdown formatında içerik",
  "word_count": 1500,
  "keywords_used": ["keyword1", "keyword2"]
}}
"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[
            {"role": "system", "content": "Sen bir SEO uzmanı ve blog yazarısın."},
            {"role": "user", "content": prompt}
        ],
        response_format={"type": "json_object"},
        temperature=0.7
    )

    result = json.loads(response.choices[0].message.content)
    return result

# Kullanım
blog = generate_blog_post(
    topic="Yapay Zeka ile Müşteri Hizmetleri Otomasyonu",
    keywords=["ai chatbot", "müşteri hizmetleri otomasyonu", "yapay zeka chatbot"],
    word_count=1500
)

print(f"Başlık: {blog['title']}")
print(f"Meta: {blog['meta_description']}")
print(f"\nİçerik ({blog['word_count']} kelime):")
print(blog['content'][:500] + "...")

# Çıktı örneği:
# Başlık: AI Chatbot ile Müşteri Hizmetlerini %80 Otomatikleştirin
# Meta: Yapay zeka chatbot ile 7/24 müşteri desteği sağlayın. AI ile maliyet %60 azalır...
# İçerik: ## Müşteri Hizmetleri Otomasyonu Nedir?
#         Yapay zeka chatbot, müşteri sorularını otomatik yanıtlar...

# Toplu ürün açıklaması üretimi
def generate_product_description(product_data):
    """Ürün bilgilerinden AI ile açıklama üret"""

    prompt = f"""Aşağıdaki ürün için satış odaklı bir açıklama yaz:

Ürün: {product_data['name']}
Kategori: {product_data['category']}
Özellikler: {', '.join(product_data['features'])}
Fiyat: {product_data['price']} TL

Açıklama formatı:
1. Kısa tanıtım (1-2 cümle, benefit-focused)
2. Özellikler (bullet points)
3. Kullanım senaryoları
4. Garanti/teslimat bilgisi

Tone: Profesyonel ama samimi
Uzunluk: 150-200 kelime
SEO: Ürün adını 2-3 kez kullan
"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.8  # Biraz creative
    )

    return response.choices[0].message.content

# Örnek ürün
laptop = {
    'name': 'ASUS VivoBook 15 X1502ZA',
    'category': 'Laptop',
    'features': ['Intel Core i5-1235U', '8GB RAM', '512GB SSD', '15.6" FHD', 'Windows 11'],
    'price': 18999
}

description = generate_product_description(laptop)
print(description)

# Çıktı:
# ASUS VivoBook 15 X1502ZA, günlük iş ve eğlence ihtiyaçlarınız için mükemmel performans sunar.
# Intel Core i5 işlemcisi ve 8GB RAM ile çoklu görevlerde kesintisiz deneyim yaşayın.
#
# Özellikler:
# • 11. Nesil Intel Core i5-1235U işlemci (4.4GHz'e kadar)
# • 8GB DDR4 RAM - sorunsuz multitasking
# • 512GB NVMe SSD - hızlı açılış ve yükleme
# • 15.6" Full HD ekran - net görüntü kalitesi
# • Windows 11 Home - en güncel işletim sistemi
#
# ASUS VivoBook 15, öğrenciler, profesyoneller ve günlük kullanıcılar için ideal bir seçimdir...

# Toplu işlem (1000 ürün)
import pandas as pd

products = pd.read_csv('products.csv')

for index, product in products.iterrows():
    if not product['description']:  # Açıklama yoksa
        desc = generate_product_description(product.to_dict())

        # Database'e kaydet
        db.execute(
            "UPDATE products SET description = %s WHERE id = %s",
            (desc, product['id'])
        )

        print(f"Generated for: {product['name']}")
        time.sleep(1)  # Rate limiting

# Instagram/Twitter post üretimi
def generate_social_post(topic, platform='instagram', tone='professional'):
    """Platform-specific social media içeriği"""

    platform_specs = {
        'instagram': {
            'max_length': 2200,
            'hashtags': 10-15,
            'emojis': True,
            'cta': 'Link in bio'
        },
        'twitter': {
            'max_length': 280,
            'hashtags': 2-3,
            'emojis': True,
            'cta': 'Thread below'
        },
        'linkedin': {
            'max_length': 1300,
            'hashtags': 3-5,
            'emojis': False,
            'cta': 'Learn more'
        }
    }

    spec = platform_specs[platform]

    prompt = f"""Konu: {topic}
Platform: {platform.upper()}
Ton: {tone}

{platform.title()} için post yaz:
- Max {spec['max_length']} karakter
- {spec['hashtags']} hashtag
- Emojis: {'Kullan' if spec['emojis'] else 'Kullanma'}
- CTA: {spec['cta']}

JSON döndür:
{{
  "text": "Post metni",
  "hashtags": ["tag1", "tag2"],
  "image_suggestion": "Görsel önerisi"
}}
"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

    return json.loads(response.choices[0].message.content)

# Instagram post
ig_post = generate_social_post(
    topic="Yapay zeka ile e-ticaret satışlarını %40 artırma",
    platform='instagram',
    tone='motivational'
)

print(ig_post['text'])
print(f"\nHashtags: {' '.join(['#' + tag for tag in ig_post['hashtags']])}")

# Twitter thread (multi-tweet)
def generate_twitter_thread(topic, tweet_count=5):
    """Twitter thread oluştur"""

    prompt = f"""Konu: {topic}

{tweet_count} tweet'lik bir thread yaz:
- Her tweet max 280 karakter
- İlk tweet hook (dikkat çekici)
- Son tweet CTA
- 2-3 hashtag (sadece ilk tweet'te)

JSON array döndür: [{{"tweet_number": 1, "text": "..."}}, ...]
"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

    thread = json.loads(response.choices[0].message.content)
    return thread['tweets']

thread = generate_twitter_thread("AI ile içerik üretimi nasıl yapılır?", tweet_count=5)

for i, tweet in enumerate(thread, 1):
    print(f"{i}/{len(thread)}")
    print(tweet['text'])
    print()

# AI ile email campaign oluşturma
def generate_email_campaign(campaign_type, customer_segment):
    """Segment bazlı email içeriği"""

    prompts = {
        'welcome': "Yeni kayıt olan müşteri için hoşgeldin emaili",
        'abandoned_cart': "Sepetini terk eden müşteri için hatırlatma",
        'win_back': "6 ay+ alışveriş yapmayan müşteri için geri kazanma",
        'upsell': "Sadık müşteri için premium ürün önerisi",
        'newsletter': "Haftalık kampanya ve yenilikler bülteni"
    }

    segment_info = {
        'new_customer': "Yeni kayıt, henüz alışveriş yapmadı",
        'loyal': "6+ alışveriş, yüksek LTV",
        'dormant': "6 ay+ inaktif",
        'high_value': "Ortalama sepet >5000 TL"
    }

    prompt = f"""Email Kampanyası:
Tip: {campaign_type} - {prompts[campaign_type]}
Segment: {customer_segment} - {segment_info[customer_segment]}

Email içeriği oluştur:
1. Subject line (max 50 karakter, açılma oranını artıracak)
2. Preheader text (90 karakter)
3. Email body (HTML, 200-300 kelime)
4. CTA button text

Ton: Friendly ama professional
Hedef: Conversion rate optimization

JSON döndür
"""

    response = client.chat.completions.create(
        model="gpt-4-turbo-preview",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )

    return json.loads(response.choices[0].message.content)

# Örnek: Abandoned cart email
email = generate_email_campaign('abandoned_cart', 'loyal')

print(f"Subject: {email['subject']}")
print(f"Preheader: {email['preheader']}")
print(f"\nBody:\n{email['body']}")
print(f"\nCTA: {email['cta']}")

# Çıktı:
# Subject: Sepetinizde unuttuklarınız var! 🛒
# Preheader: Favorilerinizi kaçırmayın. Hemen tamamlayın, %10 indirim kazanın!
#
# Body:
# Merhaba [Ad],
#
# Sepetinize eklediğiniz harika ürünleri fark ettik! 😊
#
# [Sepet ürünleri: Ürün resimleri + isimler]
#
# Sadece sizin için özel bir teklif hazırladık:
# Sepetinizi 24 saat içinde tamamlarsanız %10 indirim!
#
# Kod: SEPET10
#
# CTA: Sepetime Dön ve %10 İndirim Kazan

# End-to-end content automation
class ContentPipeline:
    def __init__(self):
        self.client = OpenAI()

    def research_topics(self, industry, count=10):
        """Trend konuları bul (Google Trends API + GPT-4)"""
        # 1. Google Trends'ten popüler aramalar
        # 2. GPT-4'e sor: "Bu konular için blog başlıkları öner"
        pass

    def generate_outline(self, topic):
        """İçerik outline oluştur"""
        prompt = f"Konu: {topic}\n\nDetaylı bir blog outline oluştur (H2, H3 başlıklar)"
        # GPT-4 outline üretir
        pass

    def write_content(self, outline):
        """Outline'a göre içerik yaz"""
        # Her section için GPT-4 ile yaz
        pass

    def optimize_seo(self, content, target_keyword):
        """SEO optimizasyonu"""
        # - Keyword density check
        # - LSI keywords ekle
        # - Internal/external link önerileri
        # - Meta tags oluştur
        pass

    def add_images(self, content):
        """İçeriğe görsel ekle (DALL-E, Midjourney)"""
        # GPT-4'e sor: "Bu section için görsel açıklaması"
        # DALL-E ile görsel üret
        pass

    def proofread(self, content):
        """Yazım/dilbilgisi kontrolü"""
        # GPT-4: "Bu metni düzelt ve iyileştir"
        pass

    def publish(self, content, platform='wordpress'):
        """Otomatik yayınlama"""
        # WordPress API, Ghost API vb.
        pass

    def full_pipeline(self, topic):
        """Komple otomasyon"""
        outline = self.generate_outline(topic)
        content = self.write_content(outline)
        content = self.optimize_seo(content, target_keyword)
        content = self.add_images(content)
        content = self.proofread(content)
        self.publish(content)

        return content

# Kullanım
pipeline = ContentPipeline()

# Haftalık 10 blog otomatik üret
topics = pipeline.research_topics('E-ticaret', count=10)

for topic in topics:
    article = pipeline.full_pipeline(topic)
    print(f"Published: {article['title']}")
    time.sleep(60)  # Rate limiting