Architecture and System Design

[atahankilc]

1. Define Detailed Requirements

• List user requirements.
• Define technical requirements.

2. Develop the System Architecture

• Define the number and roles of agents.
• Specify which tool functions will be used for which agents.
• Structure an initial version of the architecture.

3. Document the System Design in README

• Provide a textual explanation of the system design.
• Diagrams (e.g., using Mermaid) can be used to visually represent the architecture and design.
• Integrate both textual descriptions and diagrams into the README file.

[mihaela21k]

Flowchart for System Design

flowchart TD
 subgraph subGraph0["User Side"]
        User["User Interface"]
        UserConductorFile["Conductor File (Editable)"]
  end
 subgraph subGraph1["Creator Agent"]
        CreatorAgent["Exercise Creator Agent"]
        ExerciseFiles["Exercise Files (Description + Instructions)"]
        SolutionFile["Solution File (Blocked)"]
  end
 subgraph subGraph2["Conductor Agent"]
        Conductor["Conductor Agent"]
        SupportModule["Support Module (Feedback + Hints)"]
  end
 subgraph subGraph3["Sharing Module"]
        SharingSystem["Exercise Sharing Module"]
        OtherUser["Other User Interface"]
  end

    User -- Specify Topic --> CreatorAgent
    CreatorAgent -- Provide File List + Summary --> User
    User -- Approve/Decline Files --> CreatorAgent
    CreatorAgent -- Generate Exercise Files --> ExerciseFiles
    ExerciseFiles -- Create Conductor File --> UserConductorFile
    CreatorAgent -- Generate Solution File --> SolutionFile
    User -- Conduct Exercises --> UserConductorFile
    UserConductorFile -- Send for Feedback or Hints --> Conductor
    Conductor -- Access Support Module --> SupportModule
    SupportModule -- Validate Solution --> SolutionFile
    SupportModule -- Provide Feedback/Hints --> User
    User -- Share Exercises --> SharingSystem
    SharingSystem -- Show File List --> OtherUser
    OtherUser -- Approve/Decline --> SharingSystem
    SharingSystem -- Notify --> CreatorAgent

Loading

[mihaela21k]

@JonasHelming

[JonasHelming]

i think this is a very good basis for discussion on Friday. One thing: This diagram is a bit of a mixture between a system composition and a flow chart. I believe it would be good to separate these two thingsmid term, i.e. one diagram showing the components and then the user flow in a separate diagram.

Also: I would call the solutions "files" in the architecture, they are rather objects. Storing them to files is a requirement. I think you should specify an object "exercise" and start to clearly define what it contains.

One unclaified question that is raised by the diagram is how the different modules and agents communicate to each other about exercises. Would it maybe make sense to introduce a "Exercise service" that hold all created exercises (including all information like files to be created, desription, instructions and solution) and information like which exercise is currently conducted? If you like this, please specify it.

this service could then also be the basis to implement persistence (in files or something else)

[mihaela21k]

flowchart TD
 subgraph UserModule["User Module"]
        UI["User Interface"]
      end
 subgraph CreatorModule["Creator Module"]
        Creator["Exercise Creator Agent"]
        ExerciseObj["Exercise Objects (Exercise, Instructions, Solution)"]
  end
 subgraph ConductorModule["Conductor Module"]
        Conductor["Conductor Agent"]
        Support["Support Module (Feedback + Hints)"]
  end
 subgraph SharingModule["Sharing Module"]
        Sharing["Sharing Service"]
        OtherUser["Other User Interface"]
  end
 subgraph PersistenceLayer["Persistence Layer"]
        ExerciseService["Exercise Service (Centralized Storage)"]
  end
 subgraph InitService["Initialization Module"]
        Initialization["Initialization Service"]
  end
    UI --> Creator & Conductor & Sharing
    Creator --> ExerciseObj
    ExerciseObj --> ExerciseService
    ExerciseService --> Initialization
    Initialization --> Conductor
    Conductor --> Support
    Support --> ExerciseService
    Sharing --> ExerciseService & OtherUser

Loading

[TANG839]

@JonasHelming

[TANG839]

flowchart TD
 subgraph UserModule["User Module"]
        UI["Chat Interface"]
      end
 subgraph CreatorModule["Creator Module"]
        Creator["Exercise Creator Agent"]
        ExerciseObj["Exercise Objects (Exercise, Instructions, Solution)"]
  end
 subgraph ConductorModule["Conductor Module"]
        Conductor["Conductor Agent"]
        Support["Support Module (Feedback + Hints)"]
  end
 subgraph ExerciseServiceClass["Exercise Service"]
        AddExercise["addExercise(exercise:json)"]
        GetExercise["getExercise(exerciseId:string)"]
        GetExerciseList["getExerciseList()"]
        UpdateExercise["updateExercise(exerciseId:string, exercise:json)"]
  end
    UI --> Creator & Conductor
    Creator --> ExerciseObj
    ExerciseObj --> ExerciseServiceClass
    Conductor --> Support
    Support --> ExerciseServiceClass
    ExerciseServiceClass --> Conductor

Loading

[TANG839]

flowchart TD
    subgraph UserInterface["User Module"]
        ChatInterface["Chat Interface"]
    end

    subgraph ExerciseService["Exercise Service"]
        AddExercise["addExercise(exercise:json)"]
        GetExercise["getExercise(exerciseId:string)"]
        GetExerciseList["getExerciseList()"]
        UpdateExercise["updateExercise(exerciseId:string, exercise:json)"]
    end

    CreatorAgent["Exercise Creator Agent"]
    ConductorAgent["Conductor Agent"]



    ChatInterface --> CreatorAgent
    ChatInterface --> ConductorAgent

    CreatorAgent --> AddExercise
    CreatorAgent --> UpdateExercise

    ConductorAgent --> GetExercise
    ConductorAgent --> GetExerciseList

Loading

[TANG839]

@JonasHelming Please review these two diagrams when you have time. The first diagram is component diagram which was updated from previous version. The second diagram is flowchart to describe data flow. We have several questions:

1. In which diagram should we specify the exercise object's format?
2. For the second diagram, should we have data(eg., parameters) on the arrow between Exercise Creator Agent and methods?

[JonasHelming]

Exercise object is a "object" :-) a schema or class would be good (does not have to be a diagram).

[TANG839]

Thanks! So we don't need a diagram for this object. Do you have other comments on these two diagrams?

[JonasHelming]

I like the second one, that is conside and shows the structure. I am not sure what you want to show me with the first one tbh. it is very similar, but what does it tell me?

[TANG839]

It seems a little redundant. We can just keep the second one for now. Thanks!