Upload app.py

app.py

@@ -1,171 +1,119 @@
+from flask import Flask, render_template, request, jsonify
 import os
 import json
 from textwrap import dedent
-from flask import Flask, render_template, request, jsonify
 from crewai import Agent, Crew, Process, Task
 from crewai_tools import SerperDevTool
-from langchain_google_genai import ChatGoogleGenerativeAI
-from typing import List, Dict, Any
+from crewai import LLM
+from typing import List
 
-# Configuration (use .env in production)
+app = Flask(__name__)
+
+# Configuration des clés API
 os.environ["GEMINI_API_KEY"] = "AIzaSyCQpoVCdk7h7MvAQKZOUfcnkQYVkHmAKwI"
 os.environ["SERPER_API_KEY"] = "9b90a274d9e704ff5b21c0367f9ae1161779b573"
-gemini_api_key = os.environ.get("GEMINI_API_KEY")
-serper_api_key = os.environ.get("SERPER_API_KEY")
-
-if not gemini_api_key:
-    raise ValueError("Gemini API key missing.")
-if not serper_api_key:
-    raise ValueError("Serper API key missing.")
-
-llm = ChatGoogleGenerativeAI(
-    model="gemini-2.0-flash",
-    temperature=0.7,
-    google_api_key=gemini_api_key,
-    max_output_tokens=8000,
-    convert_system_message_to_human=True
+
+llm = LLM(
+    model="gemini/gemini-2.0-flash",
+    temperature=1,
+    timeout=120,
+    max_tokens=8000,
 )
 
+# Initialisation de l'outil de recherche
 search_tool = SerperDevTool()
 
+# Définition des agents
 researcher = Agent(
-    role='Chercheur de Sujets Académiques',
-    goal=dedent("""Find factual, precise information on {topic} using the web search tool.
-    Focus on key concepts, definitions, dates, and notable facts."""),
-    backstory=dedent("""A meticulous researcher with a developed critical mind.
-    Synthesizes information from multiple sources to extract the factual essence."""),
+    role='Chercheur de Sujets',
+    goal=dedent("""Trouver les informations les plus pertinentes et précises sur {topic}
+    en utilisant l'API SerpApi."""),
+    backstory=dedent("""Un chercheur expert spécialisé dans la collecte d'informations sur divers sujets.
+    Capable d'utiliser l'API SerpApi pour des recherches précises et efficaces."""),
     tools=[search_tool],
     llm=llm,
     verbose=True,
-    allow_delegation=False,
-    max_iter=5
+    allow_delegation=False
 )
 
-quiz_creator = Agent(
-    role='Concepteur Pédagogique de Quiz',
-    goal=dedent("""Create an engaging multiple-choice quiz based on the factual information
-    provided by the Researcher on {topic}.
-    Formulate clear questions, plausible options, and identify the correct answer.
-    Include a concise explanation for each question."""),
-    backstory=dedent("""A specialist in pedagogical design who excels at transforming
-    raw information into effective evaluation tools."""),
+writer = Agent(
+    role='Rédacteur de Flashcards',
+    goal=dedent("""Créer des flashcards claires et concises en format question-réponse
+    basées sur les informations fournies par le Chercheur."""),
+    backstory=dedent("""Un expert en pédagogie et en création de matériel d'apprentissage.
+    Capable de transformer des informations complexes en flashcards simples et mémorisables."""),
     llm=llm,
     verbose=True,
-    allow_delegation=False,
-    max_iter=3
+    allow_delegation=False
 )
 
-def extract_json_from_result(result_text: str) -> List[Dict[str, Any]]:
+def extract_json_from_result(result_text: str) -> list:
+    """Extrait le JSON des résultats de la crew."""
     try:
         json_start = result_text.find('[')
         json_end = result_text.rfind(']') + 1
-
-        if json_start != -1 and json_end != 0 and json_end > json_start:
-            json_str = result_text[json_start:json_end]
-            parsed_json = json.loads(json_str)
-            if isinstance(parsed_json, list):
-                for item in parsed_json:
-                    if not all(k in item for k in ('question', 'options', 'correct_answer')):
-                         raise ValueError("Invalid quiz element structure in JSON.")
-                return parsed_json
-            else:
-                raise ValueError("The extracted JSON is not a list.")
-        else:
-            try:
-                parsed_json = json.loads(result_text)
-                if isinstance(parsed_json, list):
-                    for item in parsed_json:
-                        if not all(k in item for k in ('question', 'options', 'correct_answer')):
-                            raise ValueError("Invalid quiz element structure in JSON.")
-                    return parsed_json
-                else:
-                     raise ValueError("The JSON found is not a list.")
-            except json.JSONDecodeError:
-                 raise ValueError("No valid JSON block (list of objects) found in the result.")
-
-    except json.JSONDecodeError as e:
-        raise ValueError(f"JSON decoding error: {str(e)}. Contenu reçu : '{result_text[:200]}...'")
-    except ValueError as e:
-         raise e
-
-def research_task(topic: str, agent: Agent) -> Task:
+        if json_start == -1 or json_end == 0:
+            raise ValueError("JSON non trouvé dans le résultat")
+        
+        json_str = result_text[json_start:json_end]
+        return json.loads(json_str)
+    except (json.JSONDecodeError, ValueError) as e:
+        raise ValueError(f"Erreur lors de l'extraction du JSON : {str(e)}")
+
+def research_task(topic: str) -> Task:
     return Task(
-        description=dedent(f"""Thorough research on '{topic}'.
-        Identify and compile key factual information: definitions, dates,
-        important figures, fundamental concepts, and significant events.
-        Structure the information clearly and concisely."""),
-        expected_output=dedent(f"""A synthetic report containing the most relevant information
-        on '{topic}', ready to be used to create a quiz.
-        Must include precise and verifiable facts."""),
-        agent=agent,
+        description=dedent(f"""Effectuer une recherche approfondie sur le sujet '{topic}'.
+        Compiler les informations les plus pertinentes et les plus récentes."""),
+        expected_output="Une liste d'informations pertinentes sur le sujet.",
+        agent=researcher
     )
 
-def quiz_creation_task(topic: str, agent: Agent, context_task: Task) -> Task:
+def flashcard_creation_task(research_task: Task) -> Task:
     return Task(
-        description=dedent(f"""Based STRICTLY on the information provided in the context
-        of the research on '{topic}', create a multiple-choice quiz.
-        Generate between 8 and 12 pertinent questions.
-        For each question, provide: 'question', 'options', 'correct_answer', and 'explanation'.
-        The output format MUST be a valid JSON list and NOTHING ELSE."""),
-        expected_output=dedent("""A valid JSON list, where each element is a quiz question
-        with the keys 'question', 'options', 'correct_answer', and 'explanation'."""),
-        agent=agent,
-        context=[context_task]
+        description=dedent("""Transformer les informations fournies par le Chercheur
+        en une série de flashcards au format JSON. Je veux une vingtaine de flashcard robuste et complet avec des questions et des réponses détailler. Chaque flashcard doit avoir une question
+        d'un côté et une réponse concise de l'autre."""),
+        expected_output="Une liste de flashcards au format JSON.",
+        agent=writer,
+        context=[research_task]
     )
 
-app = Flask(__name__)
-app.secret_key = os.urandom(24)
-
 @app.route('/')
 def index():
     return render_template('index.html')
 
 @app.route('/generate', methods=['POST'])
-def generate_quiz_endpoint():
-    if not request.is_json:
-        return jsonify({'error': 'Invalid request, JSON expected.'}), 400
-
-    data = request.get_json()
-    topic = data.get('topic')
-
-    if not topic or not isinstance(topic, str) or len(topic.strip()) == 0:
-        return jsonify({'error': 'The "topic" field is missing or invalid.'}), 400
-
-    topic = topic.strip()
+def generate_flashcards():
+    topic = request.json.get('topic')
+    if not topic:
+        return jsonify({'error': 'Veuillez entrer un sujet.'}), 400
 
     try:
-        task_research = research_task(topic=topic, agent=researcher)
-        task_quiz = quiz_creation_task(topic=topic, agent=quiz_creator, context_task=task_research)
-
-        quiz_crew = Crew(
-            agents=[researcher, quiz_creator],
-            tasks=[task_research, task_quiz],
+        # Création des tâches
+        research = research_task(topic)
+        flashcard_creation = flashcard_creation_task(research)
+
+        # Création de la crew
+        crew = Crew(
+            agents=[researcher, writer],
+            tasks=[research, flashcard_creation],
             process=Process.sequential,
-            verbose=2
+            verbose=True
         )
 
-        crew_result = quiz_crew.kickoff(inputs={'topic': topic})
-
-        if not crew_result or not hasattr(quiz_crew, 'tasks_output') or not quiz_crew.tasks_output:
-             return jsonify({'error': 'Quiz generation failed (no crew output).'}), 500
-
-        last_task_output = quiz_crew.tasks_output[-1]
-        raw_output = last_task_output.raw
-
-        if not raw_output:
-             return jsonify({'error': 'Quiz generation failed (empty task output).'}), 500
-
-        try:
-            quiz_data = extract_json_from_result(raw_output)
-            return jsonify({'success': True, 'quiz': quiz_data})
-
-        except ValueError as json_error:
-            return jsonify({'error': f'Error during quiz finalization: {json_error}'}), 500
+        # Exécution de la crew
+        result = crew.kickoff()
+        
+        # Extraction du JSON depuis le dernier résultat de tâche
+        if result.tasks_output and len(result.tasks_output) > 0:
+            last_task_output = result.tasks_output[-1].raw
+            flashcards = extract_json_from_result(last_task_output)
+            return jsonify({'success': True, 'flashcards': flashcards})
+        else:
+            return jsonify({'error': 'Aucun résultat généré par la crew.'}), 500
 
     except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return jsonify({'error': f'A server error occurred: {str(e)}'}), 500
+        return jsonify({'error': 'error'}), 500
 
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5000, debug=True)
+    app.run(debug=True)