Génération de contenu avec les LLM

Génération de contenu avec les LLM

Introduction

Les modèles de langage peuvent être utilisés pour générer différents types de contenu de manière automatisée et créative. Ce tutoriel explore les différentes façons d’utiliser les LLM pour la création de contenu.

Types de contenu générable

1. Contenu marketing

• Articles de blog
• Posts sur les réseaux sociaux
• Emails marketing
• Descriptions de produits
• Landing pages

2. Contenu technique

• Documentation technique
• Guides d’utilisation
• Tutoriels
• Commentaires de code
• Documentation API

3. Contenu créatif

• Histoires courtes
• Poèmes
• Scripts
• Scénarios
• Paroles de chansons

Implémentation

1. Générateur de contenu de base

from openai import OpenAI
import json

class ContentGenerator:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def generate_content(self, content_type, parameters):
        prompt = self._create_prompt(content_type, parameters)
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en création de contenu."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        
        return response.choices[0].message.content
    
    def _create_prompt(self, content_type, parameters):
        prompts = {
            "blog_post": """
                Crée un article de blog sur le sujet suivant :
                Sujet : {topic}
                Ton : {tone}
                Longueur : {length} mots
                Public cible : {target_audience}
                
                Structure :
                1. Introduction accrocheuse
                2. Points principaux
                3. Exemples et illustrations
                4. Conclusion
                """,
            
            "social_media": """
                Crée un post pour {platform} sur le sujet suivant :
                Sujet : {topic}
                Ton : {tone}
                Hashtags : {hashtags}
                Longueur maximale : {max_length} caractères
                """,
            
            "product_description": """
                Crée une description de produit pour :
                Produit : {product_name}
                Caractéristiques : {features}
                Public cible : {target_audience}
                Ton : {tone}
                
                Inclus :
                1. Titre accrocheur
                2. Description principale
                3. Points clés
                4. Call-to-action
                """
        }
        
        return prompts[content_type].format(**parameters)

2. Générateur de contenu marketing

class MarketingContentGenerator:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def generate_marketing_campaign(self, product_info, campaign_type):
        prompt = f"""
        Crée une campagne marketing pour :
        
        Produit : {product_info['name']}
        Description : {product_info['description']}
        Public cible : {product_info['target_audience']}
        Type de campagne : {campaign_type}
        
        Génère :
        1. Un slogan accrocheur
        2. Une description courte pour les réseaux sociaux
        3. Un email marketing
        4. Des suggestions de hashtags
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en marketing digital."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.8
        )
        
        return response.choices[0].message.content

3. Générateur de contenu technique

class TechnicalContentGenerator:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def generate_technical_doc(self, topic, doc_type, parameters):
        prompt = f"""
        Crée une documentation technique pour :
        
        Sujet : {topic}
        Type : {doc_type}
        Niveau technique : {parameters['technical_level']}
        Public : {parameters['audience']}
        
        Structure requise :
        1. Introduction
        2. Prérequis
        3. Instructions détaillées
        4. Exemples de code
        5. Dépannage
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert technique avec une grande expérience en documentation."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content

Optimisation du contenu

1. Optimisation SEO

class SEOOptimizer:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def optimize_content(self, content, keywords):
        prompt = f"""
        Optimise le contenu suivant pour le SEO :
        
        Contenu : {content}
        Mots-clés cibles : {', '.join(keywords)}
        
        Fournis :
        1. Version optimisée du contenu
        2. Suggestions de titres H1 et H2
        3. Meta description
        4. Suggestions de mots-clés additionnels
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en SEO."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.5
        )
        
        return response.choices[0].message.content

2. Adaptation du ton et du style

class StyleAdapter:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def adapt_style(self, content, target_style):
        prompt = f"""
        Adapte le contenu suivant au style demandé :
        
        Contenu : {content}
        Style cible : {target_style}
        
        Conserve le message principal tout en adaptant :
        1. Le ton
        2. Le vocabulaire
        3. La structure des phrases
        4. Le niveau de formalité
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en rédaction et style."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        
        return response.choices[0].message.content

Applications pratiques

1. Générateur de blog automatisé

class BlogGenerator:
    def __init__(self, api_key):
        self.content_generator = ContentGenerator(api_key)
        self.seo_optimizer = SEOOptimizer(api_key)
    
    def generate_blog_post(self, topic, parameters):
        # Générer le contenu initial
        content = self.content_generator.generate_content("blog_post", {
            "topic": topic,
            "tone": parameters["tone"],
            "length": parameters["length"],
            "target_audience": parameters["target_audience"]
        })
        
        # Optimiser pour le SEO
        optimized_content = self.seo_optimizer.optimize_content(
            content,
            parameters["keywords"]
        )
        
        return {
            "content": optimized_content,
            "metadata": {
                "topic": topic,
                "keywords": parameters["keywords"],
                "target_audience": parameters["target_audience"]
            }
        }

2. Générateur de contenu marketing multilingue

class MultilingualContentGenerator:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def generate_multilingual_content(self, content, target_languages):
        results = {}
        
        for lang in target_languages:
            prompt = f"""
            Traduis et adapte le contenu suivant en {lang} :
            
            Contenu : {content}
            
            Assure-toi de :
            1. Préserver le message principal
            2. Adapter les références culturelles
            3. Maintenir le ton et le style
            4. Utiliser des expressions naturelles en {lang}
            """
            
            response = self.client.chat.completions.create(
                model="gpt-3.5-turbo",
                messages=[
                    {"role": "system", "content": f"Tu es un expert en traduction et localisation vers {lang}."},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.5
            )
            
            results[lang] = response.choices[0].message.content
        
        return results

Bonnes pratiques

1. Contrôle de la qualité

class ContentQualityChecker:
    def __init__(self, api_key):
        self.client = OpenAI(api_key=api_key)
    
    def check_quality(self, content, criteria):
        prompt = f"""
        Évalue la qualité du contenu suivant selon ces critères :
        
        Contenu : {content}
        Critères : {json.dumps(criteria, indent=2)}
        
        Fournis :
        1. Score global (0-100)
        2. Points forts
        3. Points à améliorer
        4. Suggestions spécifiques
        """
        
        response = self.client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Tu es un expert en évaluation de contenu."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content

2. Gestion des versions

class ContentVersionManager:
    def __init__(self):
        self.versions = {}
    
    def save_version(self, content_id, content, metadata):
        if content_id not in self.versions:
            self.versions[content_id] = []
        
        self.versions[content_id].append({
            "content": content,
            "metadata": metadata,
            "timestamp": time.time()
        })
    
    def get_version_history(self, content_id):
        return self.versions.get(content_id, [])

Conclusion

Les LLM offrent des capacités puissantes pour la génération de contenu. En utilisant les techniques présentées dans ce tutoriel, vous pouvez :

• Générer différents types de contenu
• Optimiser le contenu pour le SEO
• Adapter le contenu à différents styles et langues
• Assurer la qualité du contenu généré
• Gérer les versions du contenu

Dans le prochain tutoriel, nous explorerons l’utilisation des LLM pour la création d’applications conversationnelles avancées.