Multi-agents : faire collaborer plusieurs IA

┌─────────────────┐
│  Orchestrateur   │
│  (Chef de projet)│
└────────┬────────┘
         │
    ┌────┼────┐
    ▼    ▼    ▼
┌──────┐┌──────┐┌──────┐
│Writer ││ SEO  ││Trans.│
│Agent  ││Agent ││Agent │
└──────┘└──────┘└──────┘

┌──────┐    ┌──────┐
│Agent A│◄──►│Agent B│
└──┬───┘    └───┬──┘
   │            │
   └────┬───────┘
        ▼
   ┌──────┐
   │Agent C│
   └──────┘

┌──────────────┐
│ Orchestrateur │
│   Principal   │
└──────┬───────┘
   ┌───┴───┐
   ▼       ▼
┌──────┐┌──────┐
│Manager││Manager│
│Contenu││Distrib│
└──┬───┘└──┬───┘
   │       │
 ┌─┼─┐  ┌─┼─┐
 ▼ ▼ ▼  ▼ ▼ ▼
 W W W  W W W

from crewai import Agent, Task, Crew

# Définir les agents
redacteur = Agent(
    role="Rédacteur web expert",
    goal="Écrire des articles engageants et informatifs",
    backstory="Tu es un rédacteur web avec 10 ans d'expérience en tech.",
    verbose=True,
    llm="gpt-4o"
)

seo_expert = Agent(
    role="Expert SEO",
    goal="Optimiser le contenu pour les moteurs de recherche",
    backstory="Tu es un consultant SEO spécialisé dans le contenu tech.",
    verbose=True,
    llm="gpt-4o"
)

traducteur = Agent(
    role="Traducteur FR→EN",
    goal="Produire des traductions naturelles et fidèles",
    backstory="Tu es traducteur professionnel bilingue français-anglais.",
    verbose=True,
    llm="claude-3-5-sonnet"
)

# Définir les tâches
tache_redaction = Task(
    description="Rédige un article de 2000 mots sur {sujet}",
    expected_output="Article en markdown, structuré avec H2/H3",
    agent=redacteur
)

tache_seo = Task(
    description="Optimise l'article : title, meta, mots-clés, structure",
    expected_output="Article optimisé + suggestions SEO",
    agent=seo_expert
)

tache_traduction = Task(
    description="Traduis l'article optimisé en anglais",
    expected_output="Article traduit en anglais naturel",
    agent=traducteur
)

# Assembler l'équipe
crew = Crew(
    agents=[redacteur, seo_expert, traducteur],
    tasks=[tache_redaction, tache_seo, tache_traduction],
    verbose=True
)

# Lancer
resultat = crew.kickoff(inputs={"sujet": "Les agents IA en 2025"})
print(resultat)

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# Configuration LLM
llm_config = {
    "model": "gpt-4o",
    "api_key": "sk-..."
}

# Agents
assistant = AssistantAgent(
    name="assistant",
    system_message="Tu es un assistant IA expert en programmation.",
    llm_config=llm_config
)

critic = AssistantAgent(
    name="critic",
    system_message="Tu révises le code et signales les bugs et améliorations.",
    llm_config=llm_config
)

user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=5,
    code_execution_config={"work_dir": "coding"}
)

# Group chat
group_chat = GroupChat(
    agents=[user_proxy, assistant, critic],
    messages=[],
    max_round=10
)

manager = GroupChatManager(
    groupchat=group_chat,
    llm_config=llm_config
)

# Lancer la conversation
user_proxy.initiate_chat(
    manager,
    message="Écris un script Python qui scrape les prix sur Amazon"
)

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated

class ArticleState(TypedDict):
    sujet: str
    brouillon: str
    article_seo: str
    article_traduit: str
    statut: str

def agent_redacteur(state: ArticleState) -> ArticleState:
    """Agent qui rédige le brouillon"""
    # Appel LLM pour rédiger
    brouillon = call_llm(
        f"Rédige un article sur : {state['sujet']}"
    )
    return {"brouillon": brouillon, "statut": "rédigé"}

def agent_seo(state: ArticleState) -> ArticleState:
    """Agent qui optimise le SEO"""
    article_seo = call_llm(
        f"Optimise cet article pour le SEO :\n{state['brouillon']}"
    )
    return {"article_seo": article_seo, "statut": "optimisé"}

def agent_traducteur(state: ArticleState) -> ArticleState:
    """Agent qui traduit"""
    traduit = call_llm(
        f"Traduis en anglais :\n{state['article_seo']}"
    )
    return {"article_traduit": traduit, "statut": "traduit"}

def verifier_qualite(state: ArticleState) -> str:
    """Décide si on continue ou on recommence"""
    score = evaluer_qualite(state["article_seo"])
    if score > 0.8:
        return "traduire"
    return "reécrire"

# Construire le graphe
workflow = StateGraph(ArticleState)

# Ajouter les nœuds
workflow.add_node("rediger", agent_redacteur)
workflow.add_node("optimiser_seo", agent_seo)
workflow.add_node("traduire", agent_traducteur)

# Définir les transitions
workflow.set_entry_point("rediger")
workflow.add_edge("rediger", "optimiser_seo")
workflow.add_conditional_edges(
    "optimiser_seo",
    verifier_qualite,
    {
        "traduire": "traduire",
        "reécrire": "rediger"
    }
)
workflow.add_edge("traduire", END)

# Compiler et exécuter
app = workflow.compile()
result = app.invoke({"sujet": "Les agents IA en 2025"})

# Installation
pip install crewai crewai-tools langchain-openai

# Variables d'environnement
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

"""
Pipeline multi-agents : Rédacteur → SEO → Traducteur
Utilise CrewAI avec différents LLM par agent
"""

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# Outil de recherche web pour le rédacteur
search_tool = SerperDevTool()

# ═══════════════════════════════════════
# AGENTS
# ═══════════════════════════════════════

redacteur = Agent(
    role="Rédacteur Web Senior",
    goal=(
        "Écrire des articles de blog captivants, bien structurés, "
        "avec des exemples concrets et un ton accessible."
    ),
    backstory=(
        "Tu es rédacteur web depuis 10 ans, spécialisé dans la tech "
        "et l'IA. Tu écris en français avec un style engageant. "
        "Tu utilises des analogies pour expliquer les concepts complexes."
    ),
    tools=[search_tool],
    verbose=True,
    llm="gpt-4o",
    max_iter=3
)

seo_expert = Agent(
    role="Consultant SEO Tech",
    goal=(
        "Optimiser chaque article pour qu'il se positionne en "
        "première page Google sur les mots-clés ciblés."
    ),
    backstory=(
        "Tu es consultant SEO avec une expertise en contenu tech. "
        "Tu connais les dernières guidelines Google (E-E-A-T, "
        "helpful content). Tu optimises sans sur-optimiser."
    ),
    verbose=True,
    llm="gpt-4o",
    max_iter=3
)

traducteur = Agent(
    role="Traducteur Professionnel FR→EN",
    goal=(
        "Produire des traductions anglaises naturelles qui "
        "sonnent comme si elles avaient été écrites par un natif."
    ),
    backstory=(
        "Tu es traducteur professionnel bilingue. Tu ne traduis "
        "pas mot à mot : tu adaptes les expressions, le ton, et "
        "les références culturelles pour le public anglophone."
    ),
    verbose=True,
    llm="claude-3-5-sonnet-20241022",
    max_iter=2
)

# ═══════════════════════════════════════
# TÂCHES
# ═══════════════════════════════════════

tache_recherche_redaction = Task(
    description="""
    Sujet : {sujet}
    Public cible : {audience}

    1. Recherche les informations récentes sur le sujet
    2. Rédige un article de 2000-2500 mots en français
    3. Structure : intro accrocheuse, 4-5 sections H2, conclusion
    4. Inclus des exemples concrets, du code si pertinent
    5. Ton : professionnel mais accessible, pas de jargon inutile
    """,
    expected_output=(
        "Article complet en markdown avec titre H1, sections H2/H3, "
        "exemples, et conclusion avec appel à l'action."
    ),
    agent=redacteur
)

tache_optimisation_seo = Task(
    description="""
    Prends l'article rédigé et optimise-le pour le SEO :

    1. Optimise le titre (H1) : inclure le mot-clé principal, < 60 chars
    2. Écris une meta description (150-160 chars)
    3. Vérifie la densité des mots-clés (1-2%)
    4. Ajoute des liens internes suggérés
    5. Optimise les H2 avec des mots-clés secondaires
    6. Vérifie la lisibilité (phrases courtes, paragraphes aérés)
    7. Ajoute un schema markup suggestion (FAQ ou HowTo)

    NE CHANGE PAS le fond de l'article, juste la forme SEO.
    """,
    expected_output=(
        "Article optimisé en markdown + bloc YAML avec : "
        "seo_title, meta_description, keywords[], suggestions[]"
    ),
    agent=seo_expert
)

tache_traduction = Task(
    description="""
    Traduis l'article optimisé du français vers l'anglais :

    1. Traduis le contenu complet
    2. Adapte les expressions idiomatiques
    3. Garde le markdown intact
    4. Traduis aussi les meta SEO
    5. Si du code est présent, traduis les commentaires uniquement
    """,
    expected_output=(
        "Article traduit en anglais + meta SEO traduites. "
        "Format markdown identique à l'original."
    ),
    agent=traducteur
)

# ═══════════════════════════════════════
# CREW (ÉQUIPE)
# ═══════════════════════════════════════

crew = Crew(
    agents=[redacteur, seo_expert, traducteur],
    tasks=[
        tache_recherche_redaction,
        tache_optimisation_seo,
        tache_traduction
    ],
    process=Process.sequential,  # Séquentiel : un après l'autre
    verbose=True,
    memory=True,  # Les agents se souviennent du contexte
    max_rpm=10    # Rate limiting
)

# ═══════════════════════════════════════
# EXÉCUTION
# ═══════════════════════════════════════

if __name__ == "__main__":
    result = crew.kickoff(inputs={
        "sujet": "Comment les agents IA transforment le développement logiciel",
        "audience": "Développeurs et tech leads francophones"
    })

    print("=" * 60)
    print("RÉSULTAT FINAL")
    print("=" * 60)
    print(result)

    # Sauvegarder les résultats
    with open("article_fr.md", "w") as f:
        f.write(str(result))

$ python pipeline.py

[Rédacteur Web Senior] Recherche en cours sur le sujet...
[Rédacteur Web Senior] Rédaction de l'article...
✅ Article rédigé (2340 mots)

[Consultant SEO Tech] Analyse SEO en cours...
[Consultant SEO Tech] Optimisation des titres et meta...
✅ Article optimisé (score SEO: 87/100)

[Traducteur FR→EN] Traduction en cours...
✅ Article traduit (2280 mots EN)

============================
RÉSULTAT FINAL
============================
[Article FR optimisé + Article EN + Meta SEO]

# Deux rédacteurs en parallèle
crew = Crew(
    agents=[redacteur_1, redacteur_2, editeur],
    tasks=[tache_redaction_1, tache_redaction_2, tache_fusion],
    process=Process.sequential
)

# Avec LangGraph - boucle conditionnelle
def evaluer(state):
    if state["score_qualite"] >= 8:
        return "publier"
    if state["iterations"] >= 3:
        return "publier"  # Max 3 tentatives
    return "reécrire"

workflow.add_conditional_edges("critique", evaluer, {
    "publier": "publication",
    "reécrire": "redaction"
})

from crewai import Crew
from crewai.memory import LongTermMemory

crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,
    long_term_memory=LongTermMemory(
        storage=ChromaStorage(collection_name="articles")
    )
)

Main Agent (orchestrateur)
├── Subagent 1 : Rédaction article
├── Subagent 2 : Analyse SEO
└── Subagent 3 : Traduction

# TOUJOURS limiter les itérations
agent = Agent(max_iter=3)  # CrewAI
group_chat = GroupChat(max_round=10)  # AutoGen

# Budget-friendly
redacteur = Agent(llm="gpt-4o")          # ~$10/M tokens
seo = Agent(llm="gpt-4o-mini")           # ~$0.30/M tokens  
traducteur = Agent(llm="claude-3-haiku")  # ~$0.25/M tokens