app.py

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
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-1.5-flash",
    temperature=0.7,
    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
)

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. 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.route('/')
def index():
    return render_template('index.html')

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

    try:
        # 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=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
            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:
        return jsonify({'error': str(e)}), 500

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