10 projets IA à réaliser ce week-end

# 1. Installer OpenClaw sur un VPS
curl -fsSL https://get.openclaw.ai | bash

# 2. Configurer le bot Telegram
openclaw setup telegram

# 3. Choisir votre modèle IA (ex: Claude, GPT-4, Gemini)
openclaw config model anthropic/claude-sonnet-4

# 4. C''est prêt ! Parlez à votre bot sur Telegram

import requests
from bs4 import BeautifulSoup
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="sk-or-..."  # Via OpenRouter
)

def summarize_url(url, max_words=200):
    """Résume un article web en X mots"""
    # 1. Extraire le texte
    html = requests.get(url).text
    soup = BeautifulSoup(html, "html.parser")

    # Supprimer scripts et styles
    for tag in soup(["script", "style", "nav", "footer"]):
        tag.decompose()

    text = soup.get_text(separator="\n", strip=True)[:5000]

    # 2. Résumer via LLM
    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Résume cet article en {max_words} mots maximum.
Structure: points clés en bullet points + conclusion en 1 phrase.

Article:
{text}"""
        }]
    )

    return response.choices[0].message.content

# Utilisation
summary = summarize_url("https://example.com/long-article")
print(summary)

def generate_social_posts(topic, platforms=["twitter", "linkedin"]):
    """Génère des posts adaptés à chaque plateforme"""

    platform_specs = {
        "twitter": {
            "max_chars": 280,
            "style": "Punchy, emojis, hashtags. Ton direct et engageant.",
            "count": 3
        },
        "linkedin": {
            "max_chars": 3000,
            "style": "Professionnel mais humain. Hook en 1ère ligne. Storytelling.",
            "count": 2
        },
        "instagram": {
            "max_chars": 2200,
            "style": "Visuel, emojis, call-to-action. Hashtags en fin.",
            "count": 2
        }
    }

    results = {}
    for platform in platforms:
        spec = platform_specs[platform]
        response = client.chat.completions.create(
            model="google/gemini-2.0-flash-001",
            messages=[{
                "role": "user",
                "content": f"""Génère {spec[''count'']} posts {platform} sur : {topic}

Contraintes :
- Max {spec[''max_chars'']} caractères par post
- Style : {spec[''style'']}
- Chaque post doit être unique et avoir un angle différent
- Inclure un CTA (call-to-action)

Numérote les posts."""
            }],
            temperature=0.8  # Plus créatif
        )
        results[platform] = response.choices[0].message.content

    return results

# Utilisation
posts = generate_social_posts("Les LLM open-source rattrapent GPT-4")
for platform, content in posts.items():
    print(f"\n--- {platform.upper()} ---")
    print(content)

def email_assistant(context, action="reply", tone="professional"):
    """Assistant email IA polyvalent"""

    actions = {
        "reply": "Rédige une réponse à cet email",
        "followup": "Rédige une relance polie pour cet email sans réponse",
        "cold": "Rédige un email à froid basé sur ce contexte",
        "decline": "Rédige un refus poli pour cette proposition",
        "accept": "Rédige une acceptation enthousiaste"
    }

    tones = {
        "professional": "Professionnel, courtois, concis",
        "friendly": "Amical, chaleureux, décontracté",
        "formal": "Très formel, corporate",
        "casual": "Décontracté, comme à un collègue proche"
    }

    prompt = f"""{actions[action]}.

Ton : {tones[tone]}
Contexte : {context}

Règles :
- Objet d''email inclus
- Max 150 mots pour le corps
- Termine par un CTA clair
- Pas de formules creuses ("Je me permets de...")"""

    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{"role": "user", "content": prompt}],
        temperature=0.5
    )

    return response.choices[0].message.content

# Exemples
reply = email_assistant(
    "Client mécontent: livraison en retard de 3 jours",
    action="reply",
    tone="professional"
)
print(reply)

def seo_pipeline(article_content, target_keyword):
    """Pipeline SEO complet pour un article"""

    # Étape 1 : Analyse du contenu actuel
    analysis = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Analyse SEO de cet article pour le mot-clé "{target_keyword}".

Article:
{article_content[:4000]}

Retourne en JSON :
{{
  "keyword_density": "X%",
  "title_has_keyword": true/false,
  "h2_with_keyword": 0,
  "first_100_words_keyword": true/false,
  "readability_score": "facile/moyen/difficile",
  "word_count": X,
  "suggestions": ["..."],
  "seo_title": "Titre optimisé (max 60 chars)",
  "seo_description": "Meta description (max 155 chars)",
  "seo_keywords": ["mot1", "mot2", "..."]
}}"""
        }],
        temperature=0
    )

    # Étape 2 : Génération de titres alternatifs
    titles = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Génère 5 titres SEO alternatifs pour un article sur "{target_keyword}".
Chaque titre doit :
- Contenir le mot-clé principal
- Faire moins de 60 caractères
- Être accrocheur (curiosité, nombre, bénéfice)
"""
        }]
    )

    return {
        "analysis": analysis.choices[0].message.content,
        "alternative_titles": titles.choices[0].message.content
    }

def translate_article(content, source="fr", target="en"):
    """Traduit un article en préservant tout le formatage"""

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[
            {"role": "system", "content": f"""Tu es un traducteur professionnel {source}→{target}.
Règles :
- Préserve EXACTEMENT le markdown (titres, gras, liens, tableaux, code)
- Adapte les expressions idiomatiques
- Les termes tech restent en anglais : API, LLM, prompt, etc.
- Ne traduis PAS les URLs ni les blocs de code
- Garde les émojis identiques"""},
            {"role": "user", "content": f"Traduis ce contenu :\n\n{content}"}
        ],
        temperature=0.3
    )

    return response.choices[0].message.content

import subprocess
import psutil
import json

def check_server_health():
    """Collecte les métriques serveur"""
    return {
        "cpu_percent": psutil.cpu_percent(interval=1),
        "ram_percent": psutil.virtual_memory().percent,
        "disk_percent": psutil.disk_usage(''/'').percent,
        "load_avg": list(psutil.getloadavg()),
        "processes": len(psutil.pids()),
        "uptime_hours": round((
            psutil.boot_time()
        ) / 3600, 1)
    }

def analyze_with_ai(metrics, logs_tail=""):
    """Analyse intelligente des métriques"""

    prompt = f"""Analyse ces métriques serveur et les logs récents.

Métriques :
{json.dumps(metrics, indent=2)}

Logs récents :
{logs_tail[:2000]}

Réponds en JSON :
{{
  "status": "healthy|warning|critical",
  "issues": ["problème détecté 1", "..."],
  "recommendations": ["action recommandée 1", "..."],
  "alert_message": "message d''alerte concis si warning/critical, null sinon"
}}"""

    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{"role": "user", "content": prompt}],
        temperature=0
    )

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

# Boucle de monitoring
metrics = check_server_health()
logs = subprocess.getoutput("journalctl --no-pager -n 50 --priority=warning")
analysis = analyze_with_ai(metrics, logs)

if analysis["status"] != "healthy":
    # Envoyer alerte Telegram via OpenClaw ou bot direct
    print(f"⚠️ ALERTE: {analysis[''alert_message'']}")

# Étape 1 : Générer le script
def generate_video_script(topic, duration_seconds=60):
    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Écris un script de vidéo courte ({duration_seconds}s) sur : {topic}

Format :
[HOOK - 3s] Phrase d''accroche choc
[CONTENU - {duration_seconds-10}s] Points clés, rythme rapide
[CTA - 5s] Call-to-action

Style : dynamique, phrases courtes, chiffres impactants.
Inclure les indications visuelles entre parenthèses."""
        }],
        temperature=0.8
    )
    return response.choices[0].message.content

# Étape 2 : Text-to-Speech (via API gratuite)
import edge_tts
import asyncio

async def generate_voiceover(text, output="voiceover.mp3"):
    """Génère une voix off avec Edge TTS (gratuit)"""
    communicate = edge_tts.Communicate(text, "fr-FR-DeniseNeural")
    await communicate.save(output)
    return output

# Étape 3 : Assembler avec FFmpeg
def create_video(audio_path, background_video, subtitles, output="final.mp4"):
    """Assemble la vidéo finale"""
    import subprocess
    cmd = f"""ffmpeg -i {background_video} -i {audio_path} \
        -vf "subtitles={subtitles}:force_style=''FontSize=24,Bold=1''" \
        -shortest -y {output}"""
    subprocess.run(cmd, shell=True)
    return output

import feedparser
from datetime import datetime, timedelta

# Sources de veille IA
SOURCES = {
    "Hacker News": "https://hnrss.org/newest?q=AI+LLM",
    "ArXiv AI": "http://export.arxiv.org/rss/cs.AI",
    "TechCrunch AI": "https://techcrunch.com/category/artificial-intelligence/feed/",
    "The Verge AI": "https://www.theverge.com/rss/ai-artificial-intelligence/index.xml",
}

def fetch_news(hours=24):
    """Récupère les articles des dernières X heures"""
    cutoff = datetime.now() - timedelta(hours=hours)
    articles = []

    for source, url in SOURCES.items():
        feed = feedparser.parse(url)
        for entry in feed.entries[:10]:
            articles.append({
                "source": source,
                "title": entry.title,
                "link": entry.link,
                "summary": entry.get("summary", "")[:300]
            })

    return articles

def generate_briefing(articles):
    """Génère un briefing quotidien"""
    articles_text = "\n".join([
        f"- [{a[''source'']}] {a[''title'']}: {a[''summary'']}"
        for a in articles
    ])

    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Voici les actualités IA des dernières 24h.
Crée un briefing structuré :

1. 🔥 TOP 3 des news les plus importantes (2-3 phrases chacune)
2. 📊 Tendances observées
3. 🎯 Ce qu''il faut retenir en 1 phrase

Articles :
{articles_text}"""
        }]
    )

    return response.choices[0].message.content

# Exécution quotidienne
news = fetch_news(24)
briefing = generate_briefing(news)
print(briefing)
# → Envoyer via Telegram/Email

class PublicationPipeline:
    """Pipeline de publication complète"""

    def __init__(self, client):
        self.client = client

    def step1_ideation(self, niche, count=5):
        """Génère des idées d''articles"""
        response = self.client.chat.completions.create(
            model="google/gemini-2.0-flash-001",
            messages=[{
                "role": "user",
                "content": f"""Génère {count} idées d''articles pour un blog sur {niche}.
Pour chaque idée : titre, angle unique, mot-clé SEO cible, difficulté.
Format JSON array."""
            }]
        )
        return response.choices[0].message.content

    def step2_outline(self, title, keyword):
        """Crée un plan détaillé"""
        response = self.client.chat.completions.create(
            model="anthropic/claude-sonnet-4",
            messages=[{
                "role": "user",
                "content": f"""Crée un plan détaillé pour : "{title}"
Mot-clé SEO : {keyword}

Structure :
- Introduction (hook + promesse)
- 4-6 sections H2 avec sous-sections
- Conclusion avec CTA
- Meta description SEO

Le plan doit cibler 2500-3500 mots."""
            }]
        )
        return response.choices[0].message.content

    def step3_write(self, outline):
        """Rédige l''article complet"""
        response = self.client.chat.completions.create(
            model="anthropic/claude-sonnet-4",
            messages=[{
                "role": "user",
                "content": f"""Rédige un article complet basé sur ce plan.

{outline}

Contraintes :
- Markdown avec émojis dans les H2
- Inclure au moins 1 tableau et 1 bloc de code
- Ton : expert mais accessible
- 2500-3500 mots
- Inclure des exemples concrets"""
            }],
            max_tokens=8000
        )
        return response.choices[0].message.content

    def step4_seo(self, article):
        """Optimise le SEO"""
        # ... (voir projet 5)
        pass

    def step5_translate(self, article, target="en"):
        """Traduit l''article"""
        # ... (voir projet 6)
        pass

    def step6_publish(self, article, metadata):
        """Publie sur le site"""
        # Insertion en base de données, génération des images, etc.
        pass

    def run(self, niche):
        """Exécute le pipeline complet"""
        ideas = self.step1_ideation(niche)
        # Pour chaque idée...
        outline = self.step2_outline(ideas[0]["title"], ideas[0]["keyword"])
        article = self.step3_write(outline)
        seo_data = self.step4_seo(article)
        translation = self.step5_translate(article)
        self.step6_publish(article, seo_data)
        return article

# Environnement Python
python3 -m venv ai-projects
source ai-projects/bin/activate

# Bibliothèques essentielles
pip install openai requests beautifulsoup4 feedparser
pip install edge-tts psutil python-dotenv

# Configuration
echo "OPENROUTER_API_KEY=sk-or-..." > .env