Automatiser ses réseaux sociaux avec l'IA

Prompt : "Crée un calendrier éditorial pour un compte LinkedIn
sur l'IA et la productivité. 5 posts par semaine pendant 1 mois.
Alterne entre : tips pratiques, storytelling, carrousels éducatifs,
questions engagement, partage de ressources."

## Semaine 1 - Thème : "L'IA au quotidien"

| Jour | Type | Sujet | Hook |
|------|------|-------|------|
| Lundi | Tip | 5 prompts ChatGPT pour gagner 1h/jour | "J'ai gagné 5h cette semaine avec 5 prompts..." |
| Mardi | Story | Comment j'ai automatisé mes emails | "Il y a 3 mois, je passais 2h/jour sur mes emails..." |
| Mercredi | Carrousel | Les 7 outils IA gratuits indispensables | "Arrêtez de payer pour des outils IA 🧵" |
| Jeudi | Question | Quel outil IA a changé votre workflow ? | "Si vous ne deviez garder qu'UN seul outil IA..." |
| Vendredi | Ressource | Guide complet prompt engineering | "Le document qui a changé ma façon d'utiliser l'IA ↓" |

import anthropic

client = anthropic.Anthropic()

# Définir votre persona
PERSONA = """
Tu es le ghostwriter de [Nom]. Ton style :
- Phrases courtes et percutantes
- Beaucoup de retours à la ligne (format LinkedIn)
- Commence toujours par un hook provocateur
- Utilise des émojis avec parcimonie (max 3 par post)
- Tutoie le lecteur
- Termine par un CTA ou une question
- Ton : expert mais accessible, jamais condescendant

Exemples de posts qui ont bien marché :
[Coller 3-5 de vos meilleurs posts ici]
"""

def generate_post(topic: str, platform: str = "linkedin") -> str:
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1000,
        system=PERSONA,
        messages=[{
            "role": "user",
            "content": f"Écris un post {platform} sur : {topic}"
        }]
    )
    return response.content[0].text

import json
from datetime import datetime, timedelta

def generate_weekly_content(topics: list, platforms: list) -> dict:
    """Génère le contenu pour une semaine complète."""
    content = {}

    for i, topic in enumerate(topics):
        day = datetime.now() + timedelta(days=i)
        day_key = day.strftime("%Y-%m-%d")
        content[day_key] = {}

        for platform in platforms:
            post = generate_post(topic, platform)
            content[day_key][platform] = {
                "text": post,
                "topic": topic,
                "status": "draft",
                "scheduled": False
            }

    return content

# Utilisation
topics = [
    "5 prompts IA pour gagner du temps",
    "Mon workflow d'automatisation",
    "Les erreurs de débutants avec l'IA",
    "Outil IA de la semaine : Cursor",
    "Bilan mensuel et chiffres"
]

platforms = ["linkedin", "twitter", "instagram"]
weekly = generate_weekly_content(topics, platforms)

# Sauvegarder
with open("content_week.json", "w") as f:
    json.dump(weekly, f, indent=2, ensure_ascii=False)

from openai import OpenAI

client = OpenAI()

def generate_social_image(
    topic: str,
    platform: str = "instagram",
    style: str = "modern, minimalist, tech"
) -> str:
    """Génère une image optimisée pour une plateforme."""

    # Dimensions par plateforme
    sizes = {
        "instagram": "1024x1024",  # Carré
        "linkedin": "1792x1024",   # Paysage
        "twitter": "1792x1024",    # Paysage
        "youtube": "1792x1024",    # Thumbnail
        "story": "1024x1792",      # Portrait (stories)
    }

    size = sizes.get(platform, "1024x1024")

    response = client.images.generate(
        model="dall-e-3",
        prompt=f"""Create a social media visual for {platform}.
        Topic: {topic}
        Style: {style}
        Requirements:
        - No text in the image (text will be added as overlay)
        - Clean, professional look
        - Good contrast for readability
        - Brand colors: blue (#3B82F6) and white""",
        size=size,
        quality="hd",
        n=1
    )

    return response.data[0].url

# Exemple de pipeline vidéo automatisé

def create_short_video(script: str, style: str = "talking_head"):
    """Pipeline pour créer une vidéo courte."""

    steps = {
        "1_script": "Générer/affiner le script avec Claude",
        "2_voiceover": "Text-to-speech (ElevenLabs, OpenAI TTS)",
        "3_visuals": "B-roll ou avatar IA (HeyGen, Synthesia)",
        "4_captions": "Sous-titres auto (Whisper)",
        "5_editing": "Montage auto (FFmpeg, Remotion)",
        "6_thumbnail": "Thumbnail IA (DALL-E)",
    }

    return steps

def adapt_content(original_text: str, source: str, target: str) -> str:
    """Adapte un contenu d'une plateforme à une autre."""

    platform_guidelines = {
        "linkedin": {
            "max_chars": 1300,
            "tone": "professionnel mais accessible",
            "format": "paragraphes courts, retours à la ligne fréquents",
            "hashtags": "3-5, en fin de post",
            "cta": "question ouverte ou invitation à commenter"
        },
        "twitter": {
            "max_chars": 280,
            "tone": "concis, percutant, un peu provocateur",
            "format": "tweet unique ou thread de 3-5 tweets",
            "hashtags": "2-3 maximum, intégrés naturellement",
            "cta": "RT, like, ou question simple"
        },
        "instagram": {
            "max_chars": 2200,
            "tone": "inspirant, personnel, storytelling",
            "format": "histoire avec paragraphes, émojis en début de ligne",
            "hashtags": "20-30, dans un commentaire séparé",
            "cta": "sauvegardez, partagez en story, lien en bio"
        },
        "youtube": {
            "max_chars": 5000,
            "tone": "éducatif, structuré, enthousiaste",
            "format": "timestamps, sections claires",
            "hashtags": "5-10 tags pertinents",
            "cta": "abonnez-vous, activez la cloche, commentez"
        },
        "tiktok": {
            "max_chars": 300,
            "tone": "fun, direct, GenZ-friendly",
            "format": "ultra court, hook immédiat",
            "hashtags": "4-6, tendances incluses",
            "cta": "follow pour plus, commentez votre avis"
        }
    }

    target_rules = platform_guidelines[target]

    prompt = f"""Adapte ce contenu {source} pour {target}.

Contenu original :
{original_text}

Règles pour {target} :
- Max {target_rules['max_chars']} caractères
- Ton : {target_rules['tone']}
- Format : {target_rules['format']}
- Hashtags : {target_rules['hashtags']}
- CTA : {target_rules['cta']}

Adapte le fond ET la forme. Ne fais pas un simple copier-coller raccourci."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{"role": "user", "content": prompt}]
    )

    return response.content[0].text


# Exemple d'utilisation
linkedin_post = """J'ai automatisé 80% de ma gestion des réseaux sociaux.

Résultat ? 13h/semaine récupérées.

Voici comment j'ai fait (thread) 🧵..."""

# Adapter pour toutes les plateformes
for platform in ["twitter", "instagram", "tiktok"]:
    adapted = adapt_content(linkedin_post, "linkedin", platform)
    print(f"\n--- {platform.upper()} ---")
    print(adapted)

def optimize_youtube_metadata(video_topic: str, transcript: str) -> dict:
    """Génère titre, description, tags optimisés SEO pour YouTube."""

    prompt = f"""Pour une vidéo YouTube sur : {video_topic}

Transcription (résumé) : {transcript[:2000]}

Génère :
1. 5 titres accrocheurs (avec mots-clés SEO)
2. Description complète (avec timestamps fictifs, liens, CTA)
3. 30 tags pertinents (du plus spécifique au plus général)
4. 3 idées de thumbnails

Format JSON."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )

    return json.loads(response.content[0].text)

def generate_instagram_hashtags(topic: str, niche: str) -> dict:
    """Génère des hashtags stratégiques par taille d'audience."""

    prompt = f"""Génère des hashtags Instagram pour un post sur "{topic}"
dans la niche "{niche}".

Catégorise en :
- 🔴 Gros (>1M posts) : 5 hashtags pour la visibilité
- 🟡 Moyens (100K-1M) : 10 hashtags pour l'engagement
- 🟢 Petits (<100K) : 10 hashtags pour le ranking
- 🎯 Niche (<10K) : 5 hashtags ultra-ciblés

Total : 30 hashtags. Format JSON."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1000,
        messages=[{"role": "user", "content": prompt}]
    )

    return json.loads(response.content[0].text)

def create_twitter_thread(topic: str, key_points: list) -> list:
    """Crée un thread Twitter structuré."""

    prompt = f"""Crée un thread Twitter de 7-10 tweets sur : {topic}

Points clés à couvrir :
{json.dumps(key_points, ensure_ascii=False)}

Règles :
- Tweet 1 : Hook puissant + "🧵"
- Tweets 2-8 : Un point par tweet, concis
- Avant-dernier : Récap
- Dernier : CTA (follow + RT)
- Chaque tweet < 280 caractères
- Numérote chaque tweet (1/, 2/, etc.)

Retourne une liste JSON de tweets."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )

    return json.loads(response.content[0].text)

[Génération IA] → [File d'attente] → [Review humain] → [Scheduler] → [APIs plateformes]
                                           ↓
                                    [Corrections IA]

import requests
from datetime import datetime, timedelta

BUFFER_TOKEN = "votre_token_buffer"

def schedule_post(
    text: str,
    profile_ids: list,
    scheduled_at: datetime = None,
    media_url: str = None
) -> dict:
    """Planifie un post via Buffer."""

    endpoint = "https://api.bufferapp.com/1/updates/create.json"

    data = {
        "text": text,
        "profile_ids[]": profile_ids,
        "access_token": BUFFER_TOKEN,
    }

    if scheduled_at:
        data["scheduled_at"] = scheduled_at.isoformat()
    else:
        data["now"] = True

    if media_url:
        data["media[photo]"] = media_url

    response = requests.post(endpoint, data=data)
    return response.json()


# Planifier toute la semaine
def schedule_week(content: dict, profile_ids: dict):
    """Planifie le contenu de la semaine."""

    for date, platforms in content.items():
        for platform, post in platforms.items():
            if post["status"] == "approved":
                # Publier à 9h pour LinkedIn, 12h pour Twitter, 18h pour Instagram
                hours = {"linkedin": 9, "twitter": 12, "instagram": 18}
                scheduled = datetime.fromisoformat(date).replace(
                    hour=hours.get(platform, 10)
                )

                schedule_post(
                    text=post["text"],
                    profile_ids=[profile_ids[platform]],
                    scheduled_at=scheduled,
                    media_url=post.get("image_url")
                )
                print(f"✅ Planifié : {platform} le {date} à {hours.get(platform)}h")

class SocialMediaPipeline:
    """Pipeline automatisé de contenu social media."""

    def __init__(self):
        self.content_queue = []
        self.published = []

    def step1_generate(self, topics: list, platforms: list):
        """Étape 1 : Générer le contenu."""
        for topic in topics:
            for platform in platforms:
                post = generate_post(topic, platform)
                self.content_queue.append({
                    "topic": topic,
                    "platform": platform,
                    "text": post,
                    "status": "draft",
                    "created_at": datetime.now().isoformat()
                })
        print(f"📝 {len(self.content_queue)} posts générés")

    def step2_generate_visuals(self):
        """Étape 2 : Créer les visuels."""
        for post in self.content_queue:
            image_url = generate_social_image(
                post["topic"],
                post["platform"]
            )
            post["image_url"] = image_url
        print(f"🎨 {len(self.content_queue)} visuels créés")

    def step3_review(self):
        """Étape 3 : Review humain (interactif)."""
        for post in self.content_queue:
            print(f"\n{'='*50}")
            print(f"📱 {post['platform'].upper()} - {post['topic']}")
            print(f"{'='*50}")
            print(post["text"])
            print(f"\nImage : {post.get('image_url', 'Aucune')}")

            action = input("\n[a]pprouver / [m]odifier / [r]ejeter : ")

            if action == "a":
                post["status"] = "approved"
            elif action == "m":
                new_text = input("Nouveau texte : ")
                post["text"] = new_text
                post["status"] = "approved"
            else:
                post["status"] = "rejected"

    def step4_schedule(self, profile_ids: dict):
        """Étape 4 : Planifier les posts approuvés."""
        approved = [p for p in self.content_queue if p["status"] == "approved"]

        for i, post in enumerate(approved):
            scheduled_at = datetime.now() + timedelta(days=i//3, hours=(i%3)*6+9)
            schedule_post(
                text=post["text"],
                profile_ids=[profile_ids[post["platform"]]],
                scheduled_at=scheduled_at,
                media_url=post.get("image_url")
            )
            post["scheduled_at"] = scheduled_at.isoformat()
            self.published.append(post)

        print(f"📅 {len(approved)} posts planifiés")

    def run(self, topics, platforms, profile_ids):
        """Lance le pipeline complet."""
        self.step1_generate(topics, platforms)
        self.step2_generate_visuals()
        self.step3_review()
        self.step4_schedule(profile_ids)
        print(f"\n🎉 Pipeline terminé ! {len(self.published)} posts planifiés.")

def collect_analytics(platform: str, post_id: str) -> dict:
    """Collecte les métriques d'un post."""

    # Exemple avec l'API LinkedIn
    metrics = {
        "impressions": 5420,
        "likes": 127,
        "comments": 34,
        "shares": 18,
        "clicks": 89,
        "engagement_rate": 0.049,  # (likes+comments+shares) / impressions
        "posted_at": "2026-02-20T09:00:00",
        "platform": platform
    }

    return metrics

def analyze_performance(posts_data: list) -> str:
    """Analyse IA des performances social media."""

    prompt = f"""Analyse ces données de performance social media :

{json.dumps(posts_data, indent=2, ensure_ascii=False)}

Fournis :
1. **Top 3 posts** et pourquoi ils ont marché
2. **Flop 3 posts** et pourquoi ils n'ont pas marché
3. **Meilleurs horaires** de publication par plateforme
4. **Sujets** qui engagent le plus
5. **Recommandations** concrètes pour la semaine prochaine
6. **Score global** de la semaine (1-10)

Sois spécifique et data-driven."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2000,
        messages=[{"role": "user", "content": prompt}]
    )

    return response.content[0].text

Semaine 1 : Générer → Publier → Mesurer
Semaine 2 : Analyser S1 → Ajuster → Générer mieux → Publier → Mesurer
Semaine 3 : Analyser S1+S2 → Patterns → Optimiser → ...

def weekly_optimization_cycle(history: list) -> dict:
    """Cycle d'optimisation hebdomadaire."""

    # 1. Analyser les performances passées
    analysis = analyze_performance(history)

    # 2. Extraire les insights
    prompt = f"""Basé sur cette analyse :
{analysis}

Génère un brief créatif pour la semaine prochaine :
- 5 sujets à couvrir (basés sur ce qui marche)
- Ton à adopter (ajustements)
- Formats à privilégier
- Horaires optimaux par plateforme
- Expériences à tenter

Format JSON."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1500,
        messages=[{"role": "user", "content": prompt}]
    )

    brief = json.loads(response.content[0].text)

    # 3. Générer le contenu de la semaine basé sur le brief
    # ... (utiliser le brief pour guider la génération)

    return brief

Vous : "Prépare le contenu social media de la semaine prochaine"

Agent : "J'ai analysé les performances de cette semaine :
- Engagement LinkedIn : +23% (les posts storytelling marchent)
- Twitter : le thread sur les outils IA a fait 15K impressions
- Instagram : les carrousels surperforment les images simples

Voici le plan pour la semaine prochaine :
[5 sujets avec formats adaptés]

Je génère les posts et visuels ? Tu pourras review avant publication."

Vous : "Go, mais modifie le post de mercredi, le ton est trop corporate"

Agent : "Corrigé. Voici la nouvelle version... Tout est planifié
pour publication automatique. Tu recevras un récap dimanche soir."

❌ Générer → Publier automatiquement
✅ Générer → Review rapide → Publier

□ Choisir 2-3 plateformes prioritaires
□ Définir votre persona/ton par plateforme
□ Créer vos templates de prompts
□ Tester la génération de 5 posts

□ Mettre en place le calendrier éditorial IA
□ Configurer un outil de scheduling (Buffer, Publer…)
□ Générer le contenu de la semaine
□ Review et publier

□ Tester la génération d'images (DALL-E, Midjourney)
□ Créer des templates visuels récurrents
□ Intégrer les visuels dans le pipeline
□ Premières vidéos courtes (optionnel)

□ Analyser les métriques des 3 premières semaines
□ Identifier les patterns gagnants
□ Ajuster la stratégie avec l'IA
□ Documenter le workflow complet