Skip to Content

AI Enterprise Architect

https://odooclass.com/web/image/product.template/17330/image_1920?unique=96ae938

$ 25.00 25.0 USD $ 295.00

$ 295.00

Not Available For Sale

This combination does not exist.

Black Friday Special — $25 USD. Create editable PlantUML diagrams from natural-language descriptions inside Odoo. Generate class, sequence, and entity relationship diagrams, render images, and share selected diagrams.

Original Odoo 18 source with the AI Automation dependency. Configure your own AI credentials and Java/PlantUML setup; third-party usage charges may apply.

AI Enterprise Architect / Odoo 18

Make the system
make sense.

Editable PlantUMLYour Odoo workspaceOriginal source included

A data model. A difficult integration. A workflow that nobody can quite explain.

Describe what needs to happen. Turn that description into PlantUML, review the diagram, and refine the source until the relationships are clear.

Keep the explanation next to the work, inside Odoo.

Explore the worked examples ↓

From a brief to a shared understanding

Three steps. A diagram
you can keep working on.

01 / DESCRIBE

Start with the problem.

Name the actors, records, decisions, or messages. Use an AI Automation template to turn your brief into PlantUML, or bring your own source.

02 / REFINE

Read it. Question it. Edit it.

Inspect the relationships and the assumptions. Edit the PlantUML and render again. AI gives you a starting point; you decide whether the model is right.

03 / EXPLAIN

Give the team a clear reference.

Use the rendered image in a discussion or enable a sharing link for a selected diagram. A useful diagram makes the next decision easier.

The worked-example collection

Three worlds.
Eleven ways to see them.

11 DIAGRAM TYPES / 33 EXAMPLES

Compare the same three worlds through structure, behavior, and architecture. Choose a diagram type to see its Monopoly, Risk, and Air Traffic Control examples.

01 · Monopoly02 · Risk03 · Air Traffic Control

Open a diagram at full size, inspect its source, or download the PlantUML file as a starting point. These are hand-authored teaching examples rendered with PlantUML; they are not claims about AI output quality. Game models simplify the rules. Aviation examples are fictional teaching models, not operational guidance.

01ClassWhat concepts exist, and how are they related?

Monopoly

Property ownership

Monopoly: Property ownership

A player can own many properties; each property has at most one owner.

View PlantUML source +
@startuml
class Player {
  cash : Decimal
}
class Property {
  purchasePrice : Decimal
  rent : Decimal
}
Player "0..1" -- "0..*" Property : owns
@enduml

Risk

Armies on a map

Risk: Armies on a map

Every territory has one owner in this simplified mid-game model.

View PlantUML source +
@startuml
class Player
class Territory {
  armyCount : Integer
}
class Continent
Player "1" -- "1..*" Territory : controls
Continent "1" *-- "1..*" Territory : contains
Territory "0..*" -- "0..*" Territory : borders
@enduml

Air Traffic Control

Flights and clearances

Air Traffic Control: Flights and clearances

A clearance belongs to one flight; a flight accumulates a clearance history.

View PlantUML source +
@startuml
class Flight {
  callsign : String
}
class Clearance {
  issuedAt : DateTime
  instruction : String
}
class Controller
Flight "1" -- "0..*" Clearance : receives
Controller "1" -- "0..*" Clearance : issues
@enduml
02ObjectWhat does one concrete snapshot look like?

Monopoly

Ownership right now

Monopoly: Ownership right now

A snapshot gives instance names and values, rather than just class names.

View PlantUML source +
@startuml
object "alex : Player" as alex {
 cash = 1200
}
object "boardwalk : Property" as boardwalk {
 purchasePrice = 400
}
alex -- boardwalk : owns
@enduml

Risk

A mid-game position

Risk: A mid-game position

One player controls two territories, each with a different army count.

View PlantUML source +
@startuml
object "red : Player" as red
object "alaska : Territory" as alaska {
 armies = 5
}
object "alberta : Territory" as alberta {
 armies = 3
}
red -- alaska : controls
red -- alberta : controls
alaska -- alberta : borders
@enduml

Air Traffic Control

One issued clearance

Air Traffic Control: One issued clearance

Illustrative identifiers connect a flight, a controller, and a clearance.

View PlantUML source +
@startuml
object "flight72 : Flight" as flight {
 callsign = DEMO72
}
object "tower1 : Controller" as tower
object "clearance8 : Clearance" as clearance {
 instruction = Hold position
}
tower -- clearance : issues
clearance -- flight : applies to
@enduml
03SequenceWho calls whom, and in what order?

Monopoly

Collecting rent

Monopoly: Collecting rent

The game checks ownership and the rent rule before moving money.

View PlantUML source +
@startuml
actor Player
participant "Game rules" as Rules
participant "Bank ledger" as Bank
Player -> Rules : Land on owned property
Rules -> Rules : Check owner and rent
Rules -> Bank : Transfer rent to owner
Bank --> Rules : Transfer recorded
Rules --> Player : Show updated balance
@enduml

Risk

Resolving an attack

Risk: Resolving an attack

The server validates the proposed move before resolving the dice.

View PlantUML source +
@startuml
actor Attacker
participant "Game server" as Game
participant "Dice service" as Dice
Attacker -> Game : Attack adjacent territory
Game -> Game : Validate ownership and armies
Game -> Dice : Roll attack and defence
Dice --> Game : Dice results
Game -> Game : Apply losses
Game --> Attacker : Updated territory state
@enduml

Air Traffic Control

Request and readback

Air Traffic Control: Request and readback

The flight crew reads back the instruction; the controller checks that readback.

View PlantUML source +
@startuml
actor "Flight crew" as Crew
participant Controller
participant "Clearance log" as Log
Crew -> Controller : Request taxi clearance
Controller -> Log : Record instruction
Controller --> Crew : Issue taxi clearance
Crew -> Controller : Read back instruction
Controller -> Controller : Check readback
Controller --> Crew : Confirm or correct
@enduml
04ActivityWhich decisions change the path through a process?

Monopoly

Buying a property

Monopoly: Buying a property

Buying and auctioning are different paths after landing on an unowned property.

View PlantUML source +
@startuml
start
:Land on unowned property;
if (Player chooses to buy?) then (yes)
 :Pay purchase price;
 :Record ownership;
else (no)
 :Offer property at auction;
endif
:Continue turn;
stop
@enduml

Risk

Choosing an attack

Risk: Choosing an attack

The process distinguishes legal moves from a refused request.

View PlantUML source +
@startuml
start
:Select source and target;
if (Adjacent and enough armies?) then (yes)
 :Choose legal dice counts;
 :Roll dice and apply losses;
else (no)
 :Explain invalid attack;
endif
stop
@enduml

Air Traffic Control

Reviewing a departure request

Air Traffic Control: Reviewing a departure request

This simplified process shows a holding path without implying a real separation algorithm.

View PlantUML source +
@startuml
start
:Receive departure request;
:Review runway and traffic information;
if (Departure conditions satisfied?) then (yes)
 :Issue departure clearance;
 :Check crew readback;
else (no)
 :Instruct crew to hold;
endif
:Record outcome;
stop
@enduml
05State machineWhich transitions can one thing make?

Monopoly

Property lifecycle

Monopoly: Property lifecycle

Buying changes an unowned property to owned; mortgage status is explicit.

View PlantUML source +
@startuml
[*] --> Unowned
Unowned --> Owned : purchase
Owned --> Mortgaged : mortgage [no buildings]
Mortgaged --> Owned : redeem
Owned --> Unowned : return to bank
Mortgaged --> Unowned : return to bank
@enduml

Risk

Turn phases

Risk: Turn phases

An individual turn moves through reinforcement, attack, and fortification.

View PlantUML source +
@startuml
[*] --> Reinforce
Reinforce --> Attack : reinforcements placed
Attack --> Attack : another legal attack
Attack --> Fortify : end attacks
Fortify --> Complete : fortify or skip
Complete --> [*]
@enduml

Air Traffic Control

A clearance record

Air Traffic Control: A clearance record

A clearance record can be acknowledged, replaced, or cancelled.

View PlantUML source +
@startuml
[*] --> Draft
Draft --> Issued : controller issues
Issued --> Acknowledged : correct readback
Issued --> Cancelled : cancel
Acknowledged --> Superseded : replacement issued
Acknowledged --> Completed : instruction completed
Cancelled --> [*]
Superseded --> [*]
Completed --> [*]
@enduml
06Use caseWho needs to accomplish what inside the system?

Monopoly

Player goals

Monopoly: Player goals

The rectangle is the application boundary; the ovals are goals, not a click sequence.

View PlantUML source +
@startuml
left to right direction
actor Player
rectangle "Monopoly game" {
 usecase "Take a turn" as Turn
 usecase "Buy a property" as Buy
 usecase "Propose a trade" as Trade
}
Player -- Turn
Player -- Buy
Player -- Trade
@enduml

Risk

Competing for territory

Risk: Competing for territory

Players interact with a shared game through distinct goals.

View PlantUML source +
@startuml
left to right direction
actor Player
rectangle "Risk game" {
 usecase "Place reinforcements" as Place
 usecase "Attack a territory" as Attack
 usecase "Fortify a territory" as Fortify
}
Player -- Place
Player -- Attack
Player -- Fortify
@enduml

Air Traffic Control

Controller responsibilities

Air Traffic Control: Controller responsibilities

Actors participate in system goals; this does not define authorization policy.

View PlantUML source +
@startuml
left to right direction
actor Controller
actor "Flight crew" as Crew
rectangle "Clearance support system" {
 usecase "Review flight information" as Review
 usecase "Issue a clearance" as Issue
 usecase "Acknowledge instruction" as Ack
}
Controller -- Review
Controller -- Issue
Crew -- Ack
@enduml
07ComponentWhich parts own the work and depend on each other?

Monopoly

Separating game responsibilities

Monopoly: Separating game responsibilities

The rules component owns game decisions; the ledger records money movements.

View PlantUML source +
@startuml
[Player interface] --> [Turn rules] : commands
[Turn rules] --> [Property register] : ownership
[Turn rules] --> [Bank ledger] : transfers
[Property register] --> [Game persistence]
[Bank ledger] --> [Game persistence]
@enduml

Risk

A multiplayer game service

Risk: A multiplayer game service

Map, combat, and turn logic have separate responsibilities.

View PlantUML source +
@startuml
[Game client] --> [Turn coordinator]
[Turn coordinator] --> [Map rules]
[Turn coordinator] --> [Combat resolver]
[Combat resolver] --> [Dice source]
[Turn coordinator] --> [Game repository]
@enduml

Air Traffic Control

A clearance support application

Air Traffic Control: A clearance support application

This is a teaching decomposition, not a certified ATC architecture.

View PlantUML source +
@startuml
[Controller display] --> [Clearance service]
[Clearance service] --> [Flight information]
[Clearance service] --> [Clearance log]
[Clearance service] --> [Communication adapter]
@enduml
08DeploymentWhere do the application and its services run?

Monopoly

Hosting an online game

Monopoly: Hosting an online game

Deployment shows runtime locations rather than business concepts.

View PlantUML source +
@startuml
node "Player device" {
 artifact "Browser client" as Client
}
node "Application host" {
 artifact "Game service" as Game
}
node "Database host" {
 database "Game database" as DB
}
Client --> Game : HTTPS
Game --> DB : SQL
@enduml

Risk

A shared match server

Risk: A shared match server

Two clients connect to one authoritative match service.

View PlantUML source +
@startuml
node "Player A device" as A
node "Player B device" as B
node "Match host" {
 artifact "Match service" as Match
}
database "Match database" as DB
A --> Match : HTTPS
B --> Match : HTTPS
Match --> DB : persist state
@enduml

Air Traffic Control

A training simulator

Air Traffic Control: A training simulator

A deliberately fictional training deployment keeps examples separate from live aviation systems.

View PlantUML source +
@startuml
node "Training workstation" {
 artifact "Controller UI" as UI
}
node "Simulator host" {
 artifact "Scenario service" as Sim
}
node "Training data host" {
 database "Scenario records" as DB
}
UI --> Sim : training commands
Sim --> DB : save exercise
@enduml
09PackageHow can responsibilities be grouped into modules?

Monopoly

Grouping a game model

Monopoly: Grouping a game model

Dependencies point from a consumer package to the package it uses.

View PlantUML source +
@startuml
package "Game domain" as Domain {
 class Turn
 class Property
}
package "Presentation" as UI {
 class GameScreen
}
package "Persistence" as Storage {
 class GameRepository
}
UI ..> Domain
Storage ..> Domain
@enduml

Risk

Organizing rule modules

Risk: Organizing rule modules

Combat and turn orchestration depend on the map model.

View PlantUML source +
@startuml
package "Turn management" as Turns
package "Combat" as Combat
package "Map model" as Map
Turns ..> Combat
Turns ..> Map
Combat ..> Map
@enduml

Air Traffic Control

Grouping a support model

Air Traffic Control: Grouping a support model

The controller interface consumes clearance and flight-information packages.

View PlantUML source +
@startuml
package "Controller interface" as UI
package "Clearance domain" as Clearances
package "Flight information" as Flights
package "Audit adapters" as Audit
UI ..> Clearances
Clearances ..> Flights
Audit ..> Clearances
@enduml
10TimingHow do states change along a shared time axis?

Monopoly

A turn along a time axis

Monopoly: A turn along a time axis

Illustrative game ticks show when each turn phase is active.

View PlantUML source +
@startuml
robust "Turn phase" as Phase
@0
Phase is Roll
@2
Phase is Resolve
@5
Phase is Complete
@enduml

Risk

Attack and resolution

Risk: Attack and resolution

One shared time axis makes the handoff between game phases explicit.

View PlantUML source +
@startuml
robust "Game phase" as Phase
@0
Phase is Reinforce
@3
Phase is Attack
@8
Phase is Fortify
@10
Phase is Complete
@enduml

Air Traffic Control

Clearance acknowledgement

Air Traffic Control: Clearance acknowledgement

These are illustrative ticks, not aviation timing requirements or safety limits.

View PlantUML source +
@startuml
robust "Clearance" as Clearance
@0
Clearance is Requested
@2
Clearance is Issued
@4
Clearance is Acknowledged
@8
Clearance is Completed
@enduml
11Entity relationshipWhich records belong together, and with what cardinality?

Monopoly

Recording property ownership

Monopoly: Recording property ownership

Ownership is optional for a property; a game contains many property records.

View PlantUML source +
@startuml
entity Game {
 * id : integer <<PK>>
}
entity Player {
 * id : integer <<PK>>
 --
 game_id : integer <<FK>>
}
entity Property {
 * id : integer <<PK>>
 --
 game_id : integer <<FK>>
 owner_id : integer <<FK, nullable>>
}
Game ||--|{ Player : has
Game ||--|{ Property : contains
Player |o--o{ Property : owns
@enduml

Risk

Persisting a match position

Risk: Persisting a match position

A territory position belongs to one match and references one map territory.

View PlantUML source +
@startuml
entity Match {
 * id : integer <<PK>>
}
entity Territory {
 * id : integer <<PK>>
 --
 name : text
}
entity TerritoryPosition {
 * id : integer <<PK>>
 --
 match_id : integer <<FK>>
 territory_id : integer <<FK>>
 army_count : integer
}
Match ||--|{ TerritoryPosition : contains
Territory ||--o{ TerritoryPosition : appears_in
@enduml

Air Traffic Control

Clearance history

Air Traffic Control: Clearance history

Each clearance references a flight and its issuing controller.

View PlantUML source +
@startuml
entity Flight {
 * id : integer <<PK>>
 --
 callsign : text
}
entity Controller {
 * id : integer <<PK>>
}
entity Clearance {
 * id : integer <<PK>>
 --
 flight_id : integer <<FK>>
 controller_id : integer <<FK>>
 issued_at : timestamp
}
Flight ||--o{ Clearance : receives
Controller ||--o{ Clearance : issues
@enduml

See the workflow

From words
to a working model.

Watch the product demonstration to see the diagramming workflow inside Odoo. Then use the examples above to explore the notation at your own pace.

The recording demonstrates the workflow; the exact interface can vary with your installed version.

Know what you are buying

Your app.
Your environment.

Original Odoo 18 application source, with the AI Automation dependency included.

  • Install on an Odoo environment that supports custom addons.
  • Configure your own supported AI provider and credentials for AI generation.
  • Set up Java, PlantUML, and any required rendering dependencies.
  • Review generated source and images before relying on or sharing a diagram.

A few practical questions

Is this a hosted diagramming subscription?

This product is application source for your Odoo environment. Hosting, installation, AI provider usage, and ongoing operational services are not bundled into this purchase.

Do I have to use AI?

You can work directly with PlantUML source. AI-assisted generation additionally requires configured AI Automation templates and your own provider credentials.

Are the examples editable?

Yes. Each example includes a downloadable PlantUML file. You can adapt the names, relationships, and rules to your own project and render the result with a compatible PlantUML setup.

Does a shared link grant access to all my diagrams?

Sharing is enabled for a selected diagram. Treat an enabled sharing URL as an access link: anyone holding it may be able to view that shared diagram.

Will the AI always produce a correct model?

No. Check the syntax, the business rules, and the relationships. A rendered image confirms that the source can be drawn; it does not prove that your design is correct.

Build a clearer picture

Give the next conversation
something concrete.

Explore the examples, watch the demo, or return to the purchase options.

Get AI Enterprise Architect ↑

We may limit participation to 25 active subscriptions. Participation with Greg Moss specifically is subject to his availability.