Update app.py

app.py

@@ -18,99 +18,72 @@ llm = LLM(
     max_tokens=8000,
 )
 
-# Définitions des agents (inchangées)
+search_tool = SerperDevTool()
+
+# Définitions des agents avec outils explicites
 project_manager = Agent(
     role="Chef de Projet",
-    goal="Coordonner les autres agents pour assurer la cohérence et la qualité de l'exposé.",
+    goal="Coordonner les autres agents et synthétiser les résultats.",
     backstory="Un chef de projet expérimenté avec une expertise dans la gestion d'équipes et la coordination de projets complexes.",
     llm=llm,
     verbose=True,
     allow_delegation=True,
+    tools=[search_tool]
 )
 
 topic_analyst = Agent(
     role="Analyste de Thème",
-    goal="Analyser le thème de l'exposé et générer un plan détaillé.",
-    backstory="Un expert en recherche et en structuration de contenu, capable de décomposer des sujets complexes en plans clairs et concis.",
+    goal="Analyser le thème et générer un plan détaillé.",
+    backstory="Un expert en recherche et en structuration de contenu.",
     llm=llm,
     verbose=True,
-    tools=[SerperDevTool()],
+    tools=[search_tool]
 )
 
 content_writer = Agent(
     role="Rédacteur de Contenu",
-    goal="Rédiger les sections de l'exposé en se basant sur le plan et les recherches.",
-    backstory="Un rédacteur spécialisé dans la création de contenu clair, concis et engageant.",
+    goal="Rédiger le contenu en se basant sur des recherches approfondies.",
+    backstory="Un rédacteur spécialisé dans la création de contenu académique.",
     llm=llm,
     verbose=True,
-    tools=[SerperDevTool()],
+    tools=[search_tool]
 )
 
 editor = Agent(
-    role="Éditeur/Réviseur",
-    goal="Réviser et peaufiner le contenu, assurer la cohérence du style et du ton.",
-    backstory="tu es expérimenté avec un souci du détail et une excellente maîtrise de la langue.",
+    role="Éditeur",
+    goal="Réviser et harmoniser le contenu final.",
+    backstory="Un éditeur expérimenté avec un excellent sens du détail.",
     llm=llm,
     verbose=True,
+    tools=[search_tool]
 )
 
-def parse_sections(crew_output) -> List[str]:
-    """Parse the sections from CrewOutput object."""
-    try:
-        # Extraire le raw output
-        raw_output = crew_output.raw
-        # Nettoyer la string (enlever les guillemets externes s'ils existent)
-        cleaned_output = raw_output.strip('"\'')
-        # Évaluer la string comme une liste Python
-        sections = eval(cleaned_output)
-        return sections
-    except Exception as e:
-        st.error(f"Erreur lors du parsing des sections: {e}")
-        st.error(f"Raw output: {crew_output.raw}")
-        return []
-
-def assign_tasks(topic: str) -> List[Task]:
-    # Tâche d'analyse qui retourne une liste de sections
-    analyze_topic_task = Task(
-        description=f"""Analyser le thème '{topic}' et générer un plan détaillé pour l'exposé.
-        IMPORTANT: Ta réponse doit être UNIQUEMENT une liste Python.
-        Exemple de réponse: ['Introduction', 'Historique', 'État actuel', 'Perspectives futures', 'Conclusion']
-        Ne pas ajouter d'autres explications ou texte.""",
-        expected_output="Une liste Python contenant les sections de l'exposé",
+def create_outline_task(topic: str) -> Task:
+    return Task(
+        description=f"""Crée un plan détaillé pour un exposé sur '{topic}'.
+        Réponds UNIQUEMENT avec une liste Python de sections.
+        Format attendu: ['Introduction', 'Section 1', 'Section 2', 'Conclusion']""",
         agent=topic_analyst
     )
-    
-    tasks = [analyze_topic_task]
-    
-    # Création dynamique des tâches d'écriture pour chaque section
-    def create_writing_tasks(sections: List[str]) -> List[Task]:
-        writing_tasks = []
-        for section in sections:
-            write_task = Task(
-                description=f"""Rédiger la section '{section}' de l'exposé sur le thème '{topic}'.
-                Concentre-toi uniquement sur cette section spécifique.
-                Utilise un style académique et professionnel.""",
-                expected_output=f"Contenu détaillé de la section '{section}' au format markdown",
-                agent=content_writer,
-                context=[analyze_topic_task]
-            )
-            writing_tasks.append(write_task)
-        return writing_tasks
-    
-    # Tâche d'édition finale
-    def create_editing_task(writing_tasks: List[Task]) -> Task:
-        return Task(
-            description="Réviser et harmoniser l'ensemble du contenu de l'exposé. Assurer la cohérence entre toutes les sections.",
-            expected_output="Version finale de l'exposé au format",
-            agent=editor,
-            context=writing_tasks
-        )
-    
-    return {
-        'analyze_task': analyze_topic_task,
-        'create_writing_tasks': create_writing_tasks,
-        'create_editing_task': create_editing_task
-    }
+
+def create_content_task(topic: str, section: str, outline_task: Task) -> Task:
+    return Task(
+        description=f"""Rédige la section '{section}' de l'exposé sur '{topic}'.
+        Utilise un style académique et professionnel.
+        Base-toi sur des recherches récentes et pertinentes.
+        Format attendu: Texte en Markdown avec des sous-titres si nécessaire.""",
+        agent=content_writer,
+        context=[outline_task]
+    )
+
+def create_editing_task(content_tasks: List[Task]) -> Task:
+    return Task(
+        description="""Révise et harmonise l'ensemble du contenu.
+        Assure la cohérence du style et la qualité de l'écriture.
+        Format attendu: Texte final en Markdown.""",
+        agent=editor,
+        context=content_tasks
+    )
 
 # Interface Streamlit
 st.title("🤖 Générateur d'Exposés avec CrewAI")
@@ -118,46 +91,60 @@ st.title("🤖 Générateur d'Exposés avec CrewAI")
 topic = st.text_input("Entrez le thème de l'exposé:", "L'Intelligence Artificielle en 2024")
 
 if st.button("Générer l'exposé"):
-    with st.spinner("Création de l'équipe d'agents..."):
-        task_creators = assign_tasks(topic)
-        
-        # Exécution de la tâche d'analyse
-        crew_analysis = Crew(
-            agents=[project_manager, topic_analyst],
-            tasks=[task_creators['analyze_task']],
-            process=Process.hierarchical,
-            manager_llm=llm,
-            verbose=True,
-        )
-        analysis_result = crew_analysis.kickoff()
-        
-        # Parsing des sections depuis le résultat
-        sections = parse_sections(analysis_result)
-        st.write("Sections identifiées:", sections)
-        
-        if sections:
-            # Création des tâches d'écriture basées sur les sections
-            writing_tasks = task_creators['create_writing_tasks'](sections)
-            
-            # Création de la tâche d'édition
-            editing_task = task_creators['create_editing_task'](writing_tasks)
+    try:
+        with st.spinner("1/4 - Création du plan..."):
+            # Étape 1: Création du plan
+            outline_task = create_outline_task(topic)
+            outline_crew = Crew(
+                agents=[topic_analyst],
+                tasks=[outline_task],
+                process=Process.sequential,
+                verbose=True
+            )
+            outline_result = outline_crew.kickoff()
             
-            # Toutes les tâches dans l'ordre
-            all_tasks = [task_creators['analyze_task']] + writing_tasks + [editing_task]
+            # Parsing du résultat
+            try:
+                sections = eval(outline_result.raw.strip('"\''))
+                st.write("Plan généré:", sections)
+            except Exception as e:
+                st.error(f"Erreur lors du parsing du plan: {e}")
+                st.stop()
+
+        with st.spinner("2/4 - Rédaction des sections..."):
+            # Étape 2: Création du contenu section par section
+            content_tasks = []
+            content_results = []
             
-            # Création et exécution du crew final
-            crew = Crew(
-                agents=[project_manager, topic_analyst, content_writer, editor],
-                tasks=all_tasks,
-                process=Process.hierarchical,
-                manager_llm=llm,
-                verbose=True,
+            for section in sections:
+                task = create_content_task(topic, section, outline_task)
+                content_crew = Crew(
+                    agents=[content_writer],
+                    tasks=[task],
+                    process=Process.sequential,
+                    verbose=True
+                )
+                result = content_crew.kickoff()
+                content_tasks.append(task)
+                content_results.append(result.raw)
+                st.write(f"Section '{section}' rédigée.")
+
+        with st.spinner("3/4 - Révision finale..."):
+            # Étape 3: Édition finale
+            editing_task = create_editing_task(content_tasks)
+            editing_crew = Crew(
+                agents=[editor],
+                tasks=[editing_task],
+                process=Process.sequential,
+                verbose=True
             )
+            final_result = editing_crew.kickoff()
+
+        with st.spinner("4/4 - Assemblage final..."):
+            # Étape 4: Assemblage et présentation
+            st.success("Exposé généré avec succès!")
+            st.markdown(final_result.raw)
 
-            with st.spinner("Génération de l'exposé..."):
-                result = crew.kickoff()
-                
-                st.success("Exposé généré avec succès!")
-                st.markdown(result)
-        else:
-            st.error("Impossible de continuer sans une liste valide de sections.")
+    except Exception as e:
+        st.error(f"Une erreur est survenue: {e}")
+        st.stop()