diff --git a/src/components/Modals/AIToolModal.tsx b/src/components/Modals/AIToolModal.tsx
index dbbfc7c..f7ba84a 100644
--- a/src/components/Modals/AIToolModal.tsx
+++ b/src/components/Modals/AIToolModal.tsx
@@ -24,7 +24,14 @@ import { AxiosResponse } from 'axios';
 import { useState } from 'react';
 import { useFormContext } from 'react-hook-form';
 import { API } from '../../data/api';
-import { TypeOfExercise } from '../../types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes';
+import {
+  AIExerciseGenerated,
+  AIMaterialGenerated,
+  EducationLevel,
+  LearningOutcome,
+  QuestionType,
+  Topic,
+} from '../../types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes';
 
 export type ModaTemplateProps = {
   isOpen: boolean;
@@ -33,16 +40,19 @@ export type ModaTemplateProps = {
   action?: (i: boolean) => void;
 };
 
-export type Topic = {
-  Topic: string;
-  Type: TypeOfExercise;
-  Description: string;
-};
-
 function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function shuffleArray<T>(array: T[]) {
+  const arr = [...array];
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr;
+}
+
 const AIToolModal = ({
   isOpen,
   onClose,
@@ -53,19 +63,21 @@ const AIToolModal = ({
   const [sourceMaterial, setSourceMaterial] = useState('');
   const [titleGen, setTitle] = useState('');
   const [macroSubjectGen, setMacroSubject] = useState('');
+  const [learningOutcome, setLearningOutcome] = useState<LearningOutcome>();
+  const [choosingLearningOutcome, setChoosingLearningOutcome] =
+    useState<LearningOutcome>();
   const [language, setLanguage] = useState('');
-  const [level, setLevel] = useState(0);
+  const [duration, setDuration] = useState(0);
+  const [eduLevel, setEduLevel] = useState<EducationLevel>();
   const [topicGen, setTopicGen] = useState<Topic[]>([
-    { Topic: 'prova', Type: 0, Description: '' },
+    { topic: 'prova', explanation: '' },
   ]);
+
   const [topicIndex, setTopicIndex] = useState(0);
-  let exerciseType: number;
-  const [noW, setNoW] = useState(200);
+  let exerciseType: QuestionType | string;
   const [ca_n, setCA_N] = useState(1);
   const [da_n, setDA_N] = useState(1);
   const [eda_n, setEDA_N] = useState(1);
-  const [choices, setChoices] = useState<string[]>(['']);
-  const [choiceIndex, setChoiceIndex] = useState(0);
   const [screen1, setScreen1] = useState(true);
   const [screen2, setScreen2] = useState(false);
   const [screen3, setScreen3] = useState(false);
@@ -74,19 +86,19 @@ const AIToolModal = ({
   const word = exType == 'TrueFalseNode' ? 'Statements' : 'Answers';
   switch (exType) {
     case 'closeEndedQuestionNode':
-      exerciseType = 3;
+      exerciseType = QuestionType.ShortAnswerQuestion;
       break;
     case 'OpenQuestionNode':
-      exerciseType = 0;
+      exerciseType = QuestionType.OpenQuestion;
       break;
     case 'TrueFalseNode':
-      exerciseType = 4;
+      exerciseType = QuestionType.TrueOrFalse;
       break;
     case 'multipleChoiceQuestionNode':
-      exerciseType = 4;
+      exerciseType = QuestionType.MultipleChoice;
       break;
     case 'ReadMaterialNode':
-      exerciseType = 100;
+      exerciseType = 'ReadMaterial';
       break;
     default:
       throw 'error in type';
@@ -134,14 +146,22 @@ const AIToolModal = ({
                   throw ': no text given';
                 }
                 const response: AxiosResponse = await API.analyseMaterial({
-                  material: sourceMaterial,
+                  text: sourceMaterial,
                 });
                 console.log(response);
-                setTitle(response.data.Title);
-                setLanguage(response.data.Language);
-                setMacroSubject(response.data.MacroSubject);
-                setLevel(response.data.PerceivedDifficulty);
-                setTopicGen(response.data.MainTopics);
+                setTitle(response.data.title);
+                setLanguage(response.data.language);
+                setMacroSubject(response.data.macro_subject);
+                setLearningOutcome(
+                  response.data.learning_outcome as LearningOutcome
+                );
+                setChoosingLearningOutcome(
+                  response.data.learning_outcome as LearningOutcome
+                );
+                setEduLevel(response.data.education_level as EducationLevel);
+                setLanguage(response.data.language);
+                setDuration(response.data.estimated_duration);
+                setTopicGen(response.data.topics);
                 setScreen1(false);
                 setScreen2(true);
               } catch (error: any) {
@@ -206,19 +226,19 @@ const AIToolModal = ({
               paddingTop={'5px'}
               paddingBottom={'-5px'}
             >
-              Level:
+              Educational Level:
             </FormLabel>
             <Select
               borderColor={'grey'}
-              onChange={(event) => setLevel(Number(event.currentTarget.value))}
+              onChange={(event) =>
+                setEduLevel(event.currentTarget.value as EducationLevel)
+              }
             >
-              <option value={0} defaultChecked>
-                Primary School
-              </option>
-              <option value={1}>Middle School</option>
-              <option value={2}>High School</option>
-              <option value={3}>College</option>
-              <option value={4}>Academy</option>
+              {Object.values(EducationLevel).map((level) => (
+                <option key={level} value={level} selected={eduLevel === level}>
+                  {level}
+                </option>
+              ))}
             </Select>
           </FormControl>
           <FormControl label="Topic" paddingTop={'5px'}>
@@ -241,7 +261,7 @@ const AIToolModal = ({
                   {topicGen.map((p, id) => {
                     return (
                       <option key={id} value={id}>
-                        <Box width={'100px'}>{p.Topic}</Box>
+                        <Box width={'100px'}>{p.topic}</Box>
                       </option>
                     );
                   })}
@@ -257,32 +277,12 @@ const AIToolModal = ({
           >
             Topic Description:
           </FormLabel>
-          <Text>{topicGen[topicIndex].Description}</Text>
+          <Text>{topicGen[topicIndex].explanation}</Text>
           <Button
             marginTop={'15px'}
             onClick={async () => {
               try {
                 if (!topicGen) throw ': No topic generated';
-                setGeneratingLoading(true);
-                const response: AxiosResponse = await API.generateLO({
-                  Topic: topicGen[topicIndex].Topic,
-                  Level: level,
-                  Context: '',
-                });
-                setChoices([
-                  response.data.Remembering[0],
-                  response.data.Remembering[1],
-                  response.data.Understanding[0],
-                  response.data.Understanding[1],
-                  response.data.Applying[0],
-                  response.data.Applying[1],
-                  response.data.Analyzing[0],
-                  response.data.Analyzing[1],
-                  response.data.Evaluating[0],
-                  response.data.Evaluating[1],
-                ]);
-                console.log('step2');
-                console.log(choices);
                 setScreen2(false);
                 setScreen3(true);
               } catch (error: any) {
@@ -322,54 +322,53 @@ const AIToolModal = ({
             }}
             isLoading={generatingLoading}
           >
-            Select Level and Topic
+            Select Educational Level and Topic
           </Button>
         </ModalBody>
         <ModalBody hidden={!screen3}>
-          <Text>
-            STEP 3: Choose the learning objective you want to achieve.{' '}
-          </Text>
+          <Text>STEP 3: Define the specifics for the activity.</Text>
           <FormLabel paddingTop={'5px'}>Learning Objective</FormLabel>
-          <FormControl label="Topic">
+          <FormControl label="Learning Outcome">
             <Select
-              borderColor={'grey'}
+              value={choosingLearningOutcome}
+              borderColor="grey"
               onChange={(event) =>
-                setChoiceIndex(Number(event.currentTarget.value))
+                setChoosingLearningOutcome(
+                  event.currentTarget.value as LearningOutcome
+                )
               }
             >
-              {
-                <>
-                  {choices.map((p, id) => (
-                    <option key={id} value={id}>
-                      <p>{p}</p>
-                    </option>
-                  ))}
-                </>
-              }
+              {Object.entries(LearningOutcome).map(([key, value]) => (
+                <option key={key} value={value}>
+                  {learningOutcome === value ? '*' : ''}
+                  {value}
+                  {learningOutcome === value ? '*' : ''}
+                </option>
+              ))}
             </Select>
           </FormControl>
-          <Flex hidden={exerciseType != 8}></Flex>
+          {/*<Flex hidden={exerciseType != 8}></Flex>*/}
           <Flex
             paddingTop={'5px'}
             alignItems={'center'}
-            hidden={exerciseType != 4 && exerciseType != 2}
+            hidden={
+              exerciseType != QuestionType.TrueOrFalse &&
+              exerciseType != QuestionType.MultipleChoice
+            }
           >
             N° Correct {word}:
             <NumberInput
               float={'right'}
               defaultValue={ca_n}
               min={1}
-              max={1}
               width={'80px'}
               title="soon: multiple correct answer"
             >
               <NumberInputField />
-              {/*
               <NumberInputStepper>
                 <NumberIncrementStepper onClick={() => setCA_N(ca_n + 1)} />
                 <NumberDecrementStepper onClick={() => setCA_N(ca_n - 1)} />
               </NumberInputStepper>
-              */}
             </NumberInput>
             N° Wrong {word}:
             <NumberInput defaultValue={da_n} min={0} max={6} width={'80px'}>
@@ -379,7 +378,7 @@ const AIToolModal = ({
                 <NumberDecrementStepper onClick={() => setDA_N(da_n - 1)} />
               </NumberInputStepper>
             </NumberInput>
-            N° Easy Wrong {word}:
+            N° Easy Discardable {word}:
             <NumberInput defaultValue={eda_n} min={0} max={6} width={'80px'}>
               <NumberInputField />
               <NumberInputStepper>
@@ -389,40 +388,45 @@ const AIToolModal = ({
             </NumberInput>
           </Flex>
           <Button
-            hidden={exerciseType == 100}
+            hidden={exerciseType == 'ReadMaterial'}
             marginTop={'15px'}
             onClick={async () => {
               try {
                 setGeneratingLoading(true);
+                setLearningOutcome(choosingLearningOutcome);
                 if (!topicGen) throw ': no topic generated';
-                const response: AxiosResponse = await API.generateNewExercise({
-                  macroSubject: macroSubjectGen,
-                  title: titleGen,
-                  level: level, //0=primary_school, 1=middle_school, 2=high_school, 3=college, 4=academy
-                  typeOfActivity: exerciseType, //0=fill_the_gap, 1=question, 4=choice,
-                  learningObjective: choices[choiceIndex],
-                  bloomLevel: Math.round(choiceIndex / 2), //0=Remembering, 1=Understanding, 2=Applying, 3=Analyzing, 4=Evaluating, 5=Creating
-                  language: language,
-                  material: sourceMaterial,
-                  correctAnswersNumber: ca_n,
-                  distractorsNumber: da_n,
-                  easilyDiscardableDistractorsNumber: eda_n,
-                  assignmentType: topicGen[topicIndex].Type, //0=theoretical, 1=code, 2=problem_resolution,
-                  topic: topicGen[topicIndex].Topic,
-                  temperature: 0.2,
-                });
-                console.log(response.data);
-                let dataGen;
-                switch (exerciseType) {
-                  case 0:
-                    console.log('creating openQuestion');
-                    dataGen = {
-                      question: response.data.Assignment,
+                //aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa sei arrivato qui: fixa i dati
+                if (eduLevel == undefined || learningOutcome == undefined)
+                  throw ': error in eduLevel and learningOutcome';
+                if (exerciseType != 'ReadMaterialNode') {
+                  const response: AxiosResponse = await API.generateNewExercise(
+                    {
+                      macro_subject: macroSubjectGen,
+                      topic: topicGen[topicIndex].topic,
+                      education_level: eduLevel,
+                      learning_outcome: learningOutcome,
                       material: sourceMaterial,
-                      aiQuestion: false,
-                      possibleAnswer: response.data.Solutions[0],
-                    };
-                    break; /*
+                      solutions_number: ca_n,
+                      distractors_number: da_n,
+                      easily_discardable_distractors_number: eda_n,
+                      type: exerciseType as QuestionType,
+                      language: language,
+                      model: 'Gemini',
+                    }
+                  );
+                  console.log(response.data);
+                  const dataGen: AIExerciseGenerated = response.data;
+                  let adaptedData;
+                  switch (exerciseType) {
+                    case QuestionType.OpenQuestion:
+                      console.log('creating openQuestion');
+                      adaptedData = {
+                        question: dataGen.assignment,
+                        material: dataGen.material,
+                        aiQuestion: false,
+                        possibleAnswer: dataGen.solutions[0],
+                      };
+                      break; /*
                   case 2:
                     console.log('creating trueFalse');
                     dataGen = {
@@ -433,69 +437,103 @@ const AIToolModal = ({
                     };
                     break;
                   */
-                  case 3:
-                    console.log('creating close_ended_question');
-                    dataGen = {
-                      question:
-                        response.data.Assignment + '\n' + response.data.Plus,
-                      correctAnswers: response.data.Solutions,
-                    };
-                    break;
-                  case 4:
-                    console.log('creating multichoice');
-                    const answers = [].concat(
-                      response.data.Solutions,
-                      response.data.Distractors.splice(0, da_n),
-                      response.data.EasilyDiscardableDistractors.splice(
-                        0,
-                        eda_n
-                      )
-                    );
-                    answers.sort(() => Math.random() - 0.5);
-
-                    const isAnswerCorrect = new Array(answers.length).fill(
-                      false
-                    );
-                    answers.forEach((value, index) => {
-                      if (response.data.Solutions.includes(value))
-                        isAnswerCorrect[index] = true;
-                    });
-                    if (exType == 'TrueFalseNode')
-                      dataGen = {
-                        instructions: 'Argument: ' + response.data.Assignment,
-                        questions: answers,
-                        isQuestionCorrect: isAnswerCorrect,
+                    case QuestionType.ShortAnswerQuestion:
+                      console.log('creating close_ended_question');
+                      adaptedData = {
+                        question: dataGen.assignment,
+                        correctAnswers: dataGen.solutions,
                       };
-                    else
-                      dataGen = {
-                        question: response.data.Assignment,
-                        choices: answers,
+                      break;
+                    case QuestionType.MultipleChoice:
+                      console.log('creating multichoice');
+                      const answers = [
+                        ...dataGen.solutions.slice(0, ca_n),
+                        ...dataGen.distractors.slice(0, da_n),
+                        ...dataGen.easily_discardable_distractors.slice(
+                          0,
+                          eda_n
+                        ),
+                      ];
+                      const shuffleAnswers = shuffleArray(answers);
+
+                      const isAnswerCorrect = new Array(
+                        shuffleAnswers.length
+                      ).fill(false);
+                      shuffleAnswers.forEach((value, index) => {
+                        if (dataGen.solutions.includes(value))
+                          isAnswerCorrect[index] = true;
+                      });
+                      adaptedData = {
+                        question: dataGen.assignment,
+                        choices: shuffleAnswers,
                         isChoiceCorrect: isAnswerCorrect,
                       };
-                    if (
-                      !response.data.Distractors[0] &&
-                      !response.data.EasilyDiscardableDistractors[0]
-                    ) {
-                      toast({
-                        title: 'Generating Error',
-                        description:
-                          'The AI was not able to generate a complete multichoice exercise, we suggest to generate an Open Question or a Close Ended Question for this topic',
-                        status: 'warning',
-                        duration: 4000,
-                        position: 'bottom-left',
-                        isClosable: false,
+                      if (
+                        !dataGen.distractors[0] &&
+                        !dataGen.easily_discardable_distractors[0]
+                      ) {
+                        toast({
+                          title: 'Generating Error',
+                          description:
+                            'The AI was not able to generate a complete multichoice exercise, we suggest to generate an Open Question or a Close Ended Question for this topic',
+                          status: 'warning',
+                          duration: 4000,
+                          position: 'bottom-left',
+                          isClosable: false,
+                        });
+                        await delay(3000);
+                      }
+                      break;
+                    case QuestionType.TrueOrFalse:
+                      console.log('creating true or false');
+                      const statements = [
+                        ...dataGen.solutions.slice(0, ca_n),
+                        ...dataGen.distractors.slice(0, da_n),
+                        ...dataGen.easily_discardable_distractors.slice(
+                          0,
+                          eda_n
+                        ),
+                      ];
+                      const shuffleTFAnswers = shuffleArray(statements);
+                      const isStatementCorrect = new Array(
+                        shuffleTFAnswers.length
+                      ).fill(false);
+                      shuffleTFAnswers.map((value, index) => {
+                        console.log(index);
+                        if (dataGen.solutions.includes(value))
+                          isStatementCorrect[index] = true;
                       });
-                      await delay(3000);
-                    }
-                    break;
-                  default:
-                    console.log('error in exerciseType');
-                    throw ': generated type error';
+                      adaptedData = {
+                        instructions: 'Argument: ' + dataGen.assignment,
+                        questions: shuffleTFAnswers,
+                        isQuestionCorrect: isStatementCorrect,
+                      };
+                      if (
+                        !dataGen.distractors[0] &&
+                        !dataGen.easily_discardable_distractors[0]
+                      ) {
+                        toast({
+                          title: 'Generating Error',
+                          description:
+                            'The AI was not able to generate a complete true or false exercise, we suggest to generate an Open Question or a Close Ended Question for this topic',
+                          status: 'warning',
+                          duration: 4000,
+                          position: 'bottom-left',
+                          isClosable: false,
+                        });
+                        await delay(3000);
+                      }
+                      break;
+                    default:
+                      console.log('error in exerciseType');
+                      throw ': generated type error';
+                  }
+                  console.log(adaptedData);
+                  setValue('data', adaptedData);
+                  setValue('title', titleGen);
                 }
                 setScreen1(true);
                 setScreen3(false);
-                console.log(dataGen);
-                setValue('data', dataGen);
                 if (action) action(false);
                 onClose();
               } catch (error: any) {
@@ -538,27 +576,41 @@ const AIToolModal = ({
             Generate Learning Activity
           </Button>
           <Button
-            hidden={exerciseType != 100}
+            hidden={exerciseType != 'ReadMaterial'}
             marginTop={'15px'}
             onClick={async () => {
               try {
+                if (exerciseType != 'ReadMaterial') return;
+                if (eduLevel == undefined || learningOutcome == undefined)
+                  throw ': error in eduLevel and learningOutcome';
                 setGeneratingLoading(true);
                 if (!topicGen) throw ': no topic generated';
                 const response: AxiosResponse = await API.generateMaterial({
-                  numberOfWords: noW,
-                  level: level, //0=primary_school, 1=middle_school, 2=high_school, 3=college, 4=academy
-                  learningObjective: choices[choiceIndex],
-                  topic: topicGen[topicIndex].Topic,
+                  title: titleGen,
+                  macro_subject: macroSubjectGen,
+                  topics: [
+                    {
+                      title: titleGen,
+                      learning_outcome: learningOutcome,
+                      topics: topicGen,
+                    },
+                  ],
+                  education_level: eduLevel,
+                  learning_outcome: learningOutcome,
+                  duration: duration,
+                  language: language,
+                  model: 'Gemini',
                 });
                 setScreen1(true);
                 setScreen3(false);
                 console.log(response.data);
-                let dataGen;
+                const dataGen: AIMaterialGenerated = response.data;
+                let adaptedData;
                 switch (exerciseType) {
-                  case 100:
+                  case 'ReadMaterial':
                     console.log('creating readMaterial');
-                    dataGen = {
-                      text: response.data,
+                    adaptedData = {
+                      text: dataGen.material,
                       link: '',
                     };
                     break;
@@ -566,8 +618,9 @@ const AIToolModal = ({
                     console.log('error in exerciseType');
                     throw ': generated type error';
                 }
-                console.log(dataGen);
-                setValue('data', dataGen);
+                console.log(adaptedData);
+                setValue('data', adaptedData);
+                setValue('title', titleGen);
                 if (action) action(false);
                 onClose();
               } catch (error: any) {
diff --git a/src/components/Modals/SummarizerModal.tsx b/src/components/Modals/SummarizerModal.tsx
index 1751d83..ab519f3 100644
--- a/src/components/Modals/SummarizerModal.tsx
+++ b/src/components/Modals/SummarizerModal.tsx
@@ -8,6 +8,7 @@ import {
   ModalContent,
   ModalHeader,
   ModalOverlay,
+  Select,
   Text,
   Textarea,
   useToast,
@@ -15,6 +16,11 @@ import {
 import { AxiosResponse } from 'axios';
 import { useState } from 'react';
 import { API } from '../../data/api';
+import {
+  EducationLevel,
+  LearningOutcome,
+  SummarizeStyle,
+} from '../../types/polyglotElements';
 
 export type ModaTemplateProps = {
   isOpen: boolean;
@@ -26,10 +32,28 @@ const SummarizerModal = ({ isOpen, onClose }: ModaTemplateProps) => {
   const [generatingLoading, setGeneratingLoading] = useState(false);
   const [sourceMaterial, setSourceMaterial] = useState('');
   const [generatedMaterial, setGeneratedMaterial] = useState('');
+  const [learningOutcome, setLearningOutcome] = useState<LearningOutcome>(
+    LearningOutcome.ApplyKnowledge
+  );
+  const [summarizeStyle, setSummarizeStyle] = useState<SummarizeStyle>(
+    SummarizeStyle.Abstractive
+  );
+  const [eduLevel, setEduLevel] = useState<EducationLevel>(
+    EducationLevel.College
+  );
   const [noW, setNoW] = useState('');
   const toast = useToast();
   return (
-    <Modal isOpen={isOpen} onClose={onClose} size={'2xl'} isCentered>
+    <Modal
+      isOpen={isOpen}
+      onClose={() => {
+        setSourceMaterial('');
+        setGeneratingLoading(false);
+        onClose();
+      }}
+      size={'2xl'}
+      isCentered
+    >
       <ModalOverlay />
       <ModalContent>
         <ModalHeader>Do you need help to summarize your material?</ModalHeader>
@@ -41,6 +65,7 @@ const SummarizerModal = ({ isOpen, onClose }: ModaTemplateProps) => {
             marginTop={'5px'}
             onClick={async () => {
               try {
+                console.log('testing');
                 if (generateButton) {
                   toast({
                     title: 'Invalid syntax',
@@ -54,19 +79,21 @@ const SummarizerModal = ({ isOpen, onClose }: ModaTemplateProps) => {
                   return;
                 }
                 setGeneratingLoading(true);
-                const level = 1;
                 if (!sourceMaterial) {
                   setGeneratedMaterial('No text given');
                   //
                   throw ': no text given';
                 }
                 if (!noW) setNoW('200');
+                if (!summarizeStyle || !eduLevel || !learningOutcome) return;
                 const response: AxiosResponse = await API.summarize({
-                  material: sourceMaterial,
-                  level: level,
-                  numberOfWords: Number(noW),
+                  text: sourceMaterial,
+                  model: 'Gemini',
+                  style: summarizeStyle,
+                  education_level: eduLevel,
+                  learning_outcome: learningOutcome,
                 });
-                setGeneratedMaterial(response.data);
+                setGeneratedMaterial(response.data.summary);
                 setGeneratingLoading(false);
               } catch (error: any) {
                 setGeneratingLoading(false);
@@ -121,7 +148,62 @@ const SummarizerModal = ({ isOpen, onClose }: ModaTemplateProps) => {
               }}
             />
           </FormLabel>
-
+          <FormLabel mb={2} fontWeight={'bold'}>
+            Summarize style:
+          </FormLabel>
+          <Select
+            paddingBottom={'5px'}
+            borderColor="grey"
+            onChange={(event) =>
+              setSummarizeStyle(event.currentTarget.value as SummarizeStyle)
+            }
+          >
+            {Object.values(SummarizeStyle).map((style) => (
+              <option
+                key={style}
+                value={style}
+                selected={summarizeStyle === style}
+              >
+                {style}
+              </option>
+            ))}
+          </Select>
+          <FormLabel mb={2} fontWeight={'bold'}>
+            Educational Level:
+          </FormLabel>
+          <Select
+            paddingBottom={'5px'}
+            borderColor={'grey'}
+            onChange={(event) =>
+              setEduLevel(event.currentTarget.value as EducationLevel)
+            }
+          >
+            {Object.values(EducationLevel).map((level) => (
+              <option key={level} value={level} selected={eduLevel === level}>
+                {level}
+              </option>
+            ))}
+          </Select>
+          <FormLabel mb={2} fontWeight={'bold'}>
+            Learning outcome:
+          </FormLabel>
+          <Select
+            paddingBottom={'5px'}
+            borderColor="grey"
+            onChange={(event) =>
+              setLearningOutcome(event.currentTarget.value as LearningOutcome)
+            }
+          >
+            {Object.values(LearningOutcome).map((outcome) => (
+              <option
+                key={outcome}
+                value={outcome}
+                selected={learningOutcome === outcome}
+              >
+                {outcome}
+              </option>
+            ))}
+          </Select>
           <FormLabel mb={2} fontWeight={'bold'}>
             Your material:
           </FormLabel>
@@ -135,7 +217,7 @@ const SummarizerModal = ({ isOpen, onClose }: ModaTemplateProps) => {
               setSourceMaterial(e.currentTarget.value);
             }}
           />
-          <FormLabel mb={2} fontWeight={'bold'}>
+          <FormLabel mb={2} fontWeight={'bold'} paddingTop={'5px'}>
             Generated Material:
           </FormLabel>
           <Textarea
diff --git a/src/components/Properties/Edges/failDebtEdgeProperties.tsx b/src/components/Properties/Edges/failDebtEdgeProperties.tsx
index 0ae1259..60ebfa7 100644
--- a/src/components/Properties/Edges/failDebtEdgeProperties.tsx
+++ b/src/components/Properties/Edges/failDebtEdgeProperties.tsx
@@ -10,14 +10,14 @@ import { AxiosResponse } from 'axios';
 import { useState } from 'react';
 import { useFormContext } from 'react-hook-form';
 import { API } from '../../../data/api';
-import { TypeOfExercise } from '../../../types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes';
+import { QuestionType } from '../../../types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes';
 import EnumField from '../../Forms/Fields/EnumField';
 import TextField from '../../Forms/Fields/TextField';
 import EdgeProperties from './EdgeProperties';
 
 type Topic = {
   Topic: string;
-  Type: TypeOfExercise;
+  Type: QuestionType;
   Description: string;
 };
 
@@ -76,10 +76,12 @@ const FailDebtEdgeProperties = () => {
           marginTop={'5px'}
           onClick={async () => {
             try {
+              if (!generatingLoading) return;
               setGeneratingLoading(true);
               const response: AxiosResponse = await API.analyseMaterial({
-                material: getValues('data.material'),
+                text: getValues('data.material'),
               });
+              //da gestire la response è cambiata aaaaaaaaaaaaaaaaaaaaaaaaa
               setValue('data.title', response.data.Title);
               setValue('data.language', response.data.Language);
               setValue('data.macroSubject', response.data.MacroSubject);
@@ -143,7 +145,7 @@ const FailDebtEdgeProperties = () => {
                 setGeneratingLoading(true);
                 const level: number = getValues('data.level');
                 console.log(level);
-                const response: AxiosResponse = await API.generateLO({
+                /*const response: AxiosResponse = await API.generateLO({
                   Topic: topicGen[topicIndex].Topic,
                   Level: Number(level),
                   Context: '',
@@ -159,7 +161,7 @@ const FailDebtEdgeProperties = () => {
                   response.data.Analyzing[1],
                   response.data.Evaluating[0],
                   response.data.Evaluating[1],
-                ]);
+                ]);*/
                 console.log('step2');
                 setGeneratingLoading(false);
               } catch (error) {
diff --git a/src/data/api.ts b/src/data/api.ts
index 721e857..6da213e 100644
--- a/src/data/api.ts
+++ b/src/data/api.ts
@@ -14,9 +14,8 @@ import {
 import {
   AIExerciseType,
   AnalyseType,
-  LOType,
   MaterialType,
-  SummarizeType,
+  SummerizerBody,
 } from '../types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes';
 import { ConceptMap } from '../types/polyglotElements/concept/Conceptmap';
 import {
@@ -403,13 +402,6 @@ export const API = {
     );
   },
 
-  generateLO: (body: LOType): Promise<AxiosResponse> => {
-    return axios.post<{}, AxiosResponse, {}>(
-      `/api/openai/LearningObjectiveGenerator`,
-      body
-    );
-  },
-
   generateMaterial: (body: MaterialType): Promise<AxiosResponse> => {
     return axios.post<{}, AxiosResponse, {}>(
       `/api/openai/MaterialGenerator`,
@@ -417,7 +409,7 @@ export const API = {
     );
   },
 
-  summarize: (body: SummarizeType): Promise<AxiosResponse> => {
+  summarize: (body: SummerizerBody): Promise<AxiosResponse> => {
     return axios.post<{}, AxiosResponse, {}>(`/api/openai/Summarizer`, body);
   },
 
diff --git a/src/types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes.ts b/src/types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes.ts
index 107cf3a..28ead7e 100644
--- a/src/types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes.ts
+++ b/src/types/polyglotElements/AIGenerativeTypes/AIGenerativeTypes.ts
@@ -1,47 +1,127 @@
-export enum TypeOfExercise {
-  fill_in_the_blanks,
-  question,
-  choice,
-  conceptual,
-  practical,
+export enum EducationLevel {
+  ElementarySchool = 'elementary school',
+  MiddleSchool = 'middle school',
+  HighSchool = 'high school',
+  College = 'college',
+  Graduate = 'graduate',
+  Professional = 'professional',
 }
 
-export type AnalyseType = { material: string };
+export enum LearningOutcome {
+  RecallRecognize = 'the ability to recall or recognize simple facts and definitions',
+  ExplainRelate = 'the ability to explain concepts and principles, and recognize how different ideas are related',
+  ApplyKnowledge = 'the ability to apply knowledge and perform operations in practical contexts',
+  SelfAssess = 'the ability to assess your own understanding, identify gaps in knowledge, and strategize ways to close those gaps',
+  SynthesizeOrganize = 'the ability to synthesize and organize concepts into a framework that allows for advanced problem-solving and prediction',
+  GenerateContribute = 'the ability to generate new knowledge, challenge existing paradigms, and make significant contributions to the field',
+}
 
-export type LOType = {
-  Topic: string;
-  Level: number;
-  Context: string;
+export enum QuestionType {
+  OpenQuestion = 'open question',
+  ShortAnswerQuestion = 'short answer question',
+  TrueOrFalse = 'true or false',
+  FillInTheBlanks = 'fill in the blanks',
+  Matching = 'matching',
+  Ordering = 'ordering',
+  MultipleChoice = 'multiple choice',
+  MultipleSelect = 'multiple select',
+  Coding = 'coding',
+  Essay = 'essay',
+  KnowledgeExposition = 'knowledge exposition',
+  Debate = 'debate',
+  Brainstorming = 'brainstorming',
+  GroupDiscussion = 'group discussion',
+  Simulation = 'simulation',
+  InquiryBasedLearning = 'inquiry based learning',
+  NonWrittenMaterialAnalysis = 'non written material analysis',
+  NonWrittenMaterialProduction = 'non written material production',
+  CaseStudyAnalysis = 'case study analysis',
+  ProjectBasedLearning = 'project based learning',
+  ProblemSolvingActivity = 'problem solving activity',
+}
+
+export enum SummarizeStyle {
+  TopicSynthetic = 'topic / synthetic',
+  StandardDescriptive = 'standard descriptive',
+  Abstractive = 'abstractive',
+  Extractive = 'extractive',
+  ExplanatoryEvaluative = 'explanatory and evaluative',
+  Informal = 'informal',
+  StructuredInformative = 'structured and informative',
+}
+
+export type Topic = { topic: string; explanation: string };
+
+export type LessonNodeAI = {
+  title: string;
+  learning_outcome: LearningOutcome;
+  topics: Topic[];
 };
 
-export type MaterialType = {
+export type AnalyseType = { text: string; model?: string };
+
+export type AIExerciseType = {
+  macro_subject: string;
   topic: string;
-  numberOfWords: number;
-  level: number;
-  learningObjective: string;
+  education_level: EducationLevel;
+  learning_outcome: LearningOutcome;
+  material: string;
+  solutions_number: number;
+  distractors_number: number;
+  easily_discardable_distractors_number: number;
+  type: QuestionType;
+  language: string;
+  model: string;
 };
 
-export type SummarizeType = {
+export type AIExerciseGenerated = {
+  macro_subject: string;
+  topic: string;
+  education_level: EducationLevel;
+  learning_outcome: LearningOutcome;
   material: string;
-  numberOfWords: number;
-  level: number;
+  assignment: string;
+  plus: string;
+  solutions: string[];
+  distractors: string[];
+  easily_discardable_distractors: string[];
+  type: QuestionType;
+  language: string;
 };
 
-export type AIExerciseType = {
-  macroSubject: string;
+export type LOType = {
+  //outdate
+  Topic: string;
+  Level: number;
+  Context: string;
+};
+
+export type MaterialType = {
   title: string;
-  level: number; //0=primary_school, 1=middle_school, 2=high_school, 3=college, 4=academy
-  typeOfActivity: TypeOfExercise; //0=fill_in_the_blanks, 1=question, 2=choice, 3=conceptual, 4=practical
-  learningObjective?: string;
-  bloomLevel: number; //0=Remembering, 1=Understanding, 2=Applying, 3=Analyzing, 4=Evaluating, 5=Creating
+  macro_subject: string;
+  topics: LessonNodeAI[];
+  education_level: EducationLevel;
+  learning_outcome: LearningOutcome;
+  duration: number;
   language: string;
+  model: string;
+};
+
+export type AIMaterialGenerated = {
+  title: string;
+  macro_subject: string;
+  topics: LessonNodeAI[];
+  education_level: EducationLevel;
+  learning_outcome: LearningOutcome;
+  duration: number;
   material: string;
-  correctAnswersNumber?: number;
-  distractorsNumber?: number;
-  easilyDiscardableDistractorsNumber?: number;
-  assignmentType: number; //0=theoretical, 1=code, 2=problem_resolution,
-  topic: string;
-  temperature: number;
+  language: string;
 };
 
-export type SummarizerBody = { lesson: string; noW: string; level: string };
+export type SummerizerBody = {
+  text: string;
+  model: string;
+  style: SummarizeStyle;
+  education_level: EducationLevel;
+  learning_outcome: LearningOutcome;
+};
diff --git a/src/types/polyglotElements/AIGenerativeTypes/index.ts b/src/types/polyglotElements/AIGenerativeTypes/index.ts
new file mode 100644
index 0000000..104b41d
--- /dev/null
+++ b/src/types/polyglotElements/AIGenerativeTypes/index.ts
@@ -0,0 +1 @@
+export * from './AIGenerativeTypes';
diff --git a/src/types/polyglotElements/edges/FailDebtEdge.ts b/src/types/polyglotElements/edges/FailDebtEdge.ts
index e5720e7..601e1cd 100644
--- a/src/types/polyglotElements/edges/FailDebtEdge.ts
+++ b/src/types/polyglotElements/edges/FailDebtEdge.ts
@@ -1,7 +1,7 @@
 import * as t from 'io-ts';
 import FailDebtEdgeProperties from '../../../components/Properties/Edges/failDebtEdgeProperties';
 import { ReactFlowSmartBezierEdgePassFail } from '../../../components/ReactFlowEdge';
-import { TypeOfExercise } from '../AIGenerativeTypes/AIGenerativeTypes';
+import { QuestionType } from '../AIGenerativeTypes/AIGenerativeTypes';
 import { polyglotEdgeComponentMapping } from '../elementMapping';
 import { defaultPolyglotEdgeData, EdgeData, PolyglotEdge } from './Edge';
 
@@ -13,7 +13,7 @@ type FailDebtEdgeConditionKind = t.TypeOf<
 
 type Topic = {
   Topic: string;
-  Type: TypeOfExercise;
+  Type: QuestionType;
   Description: string;
 };
 
@@ -47,7 +47,7 @@ polyglotEdgeComponentMapping.registerMapping<FailDebtEdge>({
     conditionKind: 'fail',
     material: '',
     macroSubject: '',
-    topic: { Topic: '', Description: 'setup', Type: 0 },
+    topic: { Topic: '', Description: 'setup', Type: QuestionType.OpenQuestion },
     learningObjective: '',
     title: '',
     language: '',
diff --git a/src/types/polyglotElements/index.ts b/src/types/polyglotElements/index.ts
index 657f323..b6ded0e 100644
--- a/src/types/polyglotElements/index.ts
+++ b/src/types/polyglotElements/index.ts
@@ -1,3 +1,4 @@
+export * from './AIGenerativeTypes';
 export * from './courses';
 export * from './edges';
 export * from './elementMapping';