10 projets IA à réaliser ce week-end

# 1. Install OpenClaw on a VPS
curl -fsSL https://get.openclaw.ai | bash

# 2. Configure the Telegram bot
openclaw setup telegram

# 3. Choose your AI model (e.g., Claude, GPT-4, Gemini)
openclaw config model anthropic/claude-sonnet-4

# 4. Done! Chat with your bot on 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):
    """Summarize a web article in X words"""
    # 1. Extract text
    html = requests.get(url).text
    soup = BeautifulSoup(html, "html.parser")

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

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

    # 2. Summarize via LLM
    response = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Summarize this article in {max_words} words max.
Structure: bullet-point key takeaways + 1-sentence conclusion.

Article:
{text}"""
        }]
    )

    return response.choices[0].message.content

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

def generate_social_posts(topic, platforms=["twitter", "linkedin"]):
    """Generate platform-adapted posts"""

    platform_specs = {
        "twitter": {
            "max_chars": 280,
            "style": "Punchy, emojis, hashtags. Direct and engaging tone.",
            "count": 3
        },
        "linkedin": {
            "max_chars": 3000,
            "style": "Professional yet human. Hook in the first line. Storytelling.",
            "count": 2
        },
        "instagram": {
            "max_chars": 2200,
            "style": "Visual, emojis, call-to-action. Hashtags at the end.",
            "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"""Generate {spec['count']} {platform} posts on: {topic}

Constraints:
- Max {spec['max_chars']} characters per post
- Style: {spec['style']}
- Each post must be unique with a different angle
- Include a CTA (call-to-action)

Number the posts."""
            }],
            temperature=0.8  # More creative
        )
        results[platform] = response.choices[0].message.content

    return results

# Usage
posts = generate_social_posts("Open-source LLMs are catching up to GPT-4")
for platform, content in posts.items():
    print(f"\n--- {platform.upper()} ---")
    print(content)

def email_assistant(context, action="reply", tone="professional"):
    """Versatile AI email assistant"""

    actions = {
        "reply": "Draft a reply to this email",
        "followup": "Draft a polite follow-up for this unanswered email",
        "cold": "Draft a cold email based on this context",
        "decline": "Draft a polite refusal for this proposal",
        "accept": "Draft an enthusiastic acceptance"
    }

    tones = {
        "professional": "Professional, courteous, concise",
        "friendly": "Friendly, warm, casual",
        "formal": "Very formal, corporate",
        "casual": "Casual, as if to a close colleague"
    }

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

Tone: {tones[tone]}
Context: {context}

Rules:
- Include email subject
- Max 150 words for the body
- End with a clear CTA
- No filler phrases ("I’d like to...")"""

    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

# Examples
reply = email_assistant(
    "Unhappy client: delivery delayed by 3 days",
    action="reply",
    tone="professional"
)
print(reply)

def seo_pipeline(article_content, target_keyword):
    """Complete SEO pipeline for an article"""

    # Step 1: Analyze current content
    analysis = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""SEO analysis of this article for keyword "{target_keyword}".

Article:
{article_content[:4000]}

Return as JSON:
{{
  "keyword_density": "X%",
  "title_has_keyword": true/false,
  "h2_with_keyword": 0,
  "first_100_words_keyword": true/false,
  "readability_score": "easy/medium/hard",
  "word_count": X,
  "suggestions": ["..."],
  "seo_title": "Optimized title (max 60 chars)",
  "seo_description": "Meta description (max 155 chars)",
  "seo_keywords": ["word1", "word2", "..."]
}}"""
        }],
        temperature=0
    )

    # Step 2: Generate alternative titles
    titles = client.chat.completions.create(
        model="google/gemini-2.0-flash-001",
        messages=[{
            "role": "user",
            "content": f"""Generate 5 alternative SEO titles for an article on "{target_keyword}".
Each title must:
- Include the primary keyword
- Be under 60 characters
- Be attention-grabbing (curiosity, numbers, benefits)
"""
        }]
    )

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

def translate_article(content, source="fr", target="en"):
    """Translate an article while preserving all formatting"""

    response = client.chat.completions.create(
        model="anthropic/claude-sonnet-4",
        messages=[
            {"role": "system", "content": f"""You are a professional {source}→{target} translator.
Rules:
- EXACTLY preserve markdown (headings, bold, links, tables, code)
- Adapt idiomatic expressions
- Keep tech terms in English: API, LLM, prompt, etc.
- DO NOT translate URLs or code blocks
- Keep emojis identical"""},
            {"role": "user", "content": f"Translate this content:\n\n{content}"}
        ],
        temperature=0.3
    )

    return response.choices[0].message.content