app.py

#fvm
# yeup
#dzl
from flask import Flask, render_template, request, jsonify
import os
import json
from textwrap import dedent
from crewai import Agent, Crew, Process, Task
from crewai_tools import SerperDevTool
from crewai import LLM
from typing import List

app = Flask(__name__)

# Configuration des clés API
# Configuration des clés API
os.environ["GEMINI_API_KEY"] = os.environ.get("GEMINI_API_KEY")
os.environ["SERPER_API_KEY"] = os.environ.get("SERPER_API_KEY")


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',
    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
)

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
)

quiz_creator = Agent(
    role='Créateur de Quiz',
    goal=dedent("""Créer des questions de quiz à choix multiples basées sur les informations 
    fournies par le Chercheur."""),
    backstory=dedent("""Un expert en évaluation pédagogique spécialisé dans la création 
    de questions de quiz engageantes et éducatives avec différents niveaux de difficulté."""),
    llm=llm,
    verbose=True,
    allow_delegation=False
)

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 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"""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 flashcard_creation_task(research_task: Task) -> Task:
    return 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.
        le conenu généré est exclusivement en français.
        
        Format JSON attendu:
        [
            {
                "question": "Question 1?",
                "answer": "Réponse 1"
            },
            {
                "question": "Question 2?",
                "answer": "Réponse 2"
            }
        ]
        """),
        expected_output="Une liste de flashcards au format JSON.",
        agent=writer,
        context=[research_task]
    )

def quiz_creation_task(research_task: Task) -> Task:
    return Task(
        description=dedent("""Transformer les informations fournies par le Chercheur
        en une série de questions de quiz à choix multiples au format JSON.
        Créer 10 questions de quiz avec quatre options de réponse pour chaque question,
        dont une seule est correcte. Inclure une explication pour chaque réponse incorrecte.
        le conenu généré est exclusivement en français.
        
        Format JSON attendu:
        [
            {
                "question": "Question 1?",
                "options": ["Option A", "Option B", "Option C", "Option D"],
                "correctAnswer": "Option A",
                "explanation": "Explication de pourquoi cette réponse est correcte"
            },
            {
                "question": "Question 2?",
                "options": ["Option A", "Option B", "Option C", "Option D"],
                "correctAnswer": "Option C",
                "explanation": "Explication de pourquoi cette réponse est correcte"
            }
        ]
        """),
        expected_output="Une liste de questions de quiz au format JSON.",
        agent=quiz_creator,
        context=[research_task]
    )

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/generate', methods=['POST'])
def generate_content():
    topic = request.json.get('topic')
    content_type = request.json.get('type', 'flashcards')  # 'flashcards' ou 'quiz'
    
    if not topic:
        return jsonify({'error': 'Veuillez entrer un sujet.'}), 400

    try:
        # Création de la tâche de recherche
        research = research_task(topic)
        
        # Sélection de la tâche en fonction du type demandé
        if content_type == 'quiz':
            creation_task = quiz_creation_task(research)
            agents = [researcher, quiz_creator]
        else:  # Par défaut: flashcards
            creation_task = flashcard_creation_task(research)
            agents = [researcher, writer]
        
        # Création de la crew
        crew = Crew(
            agents=agents,
            tasks=[research, creation_task],
            process=Process.sequential,
            verbose=True
        )

        # 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
            content_data = extract_json_from_result(last_task_output)
            return jsonify({'success': True, content_type: content_data})
        else:
            return jsonify({'error': 'Aucun résultat généré par la crew.'}), 500

    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True)