How I Built an LLM-Powered CAD System for Bicycle Highways

{
  "version": "0.0.2",
  "library_dir": [
    "/Users/lucas/projects/gh/"
  ],
  "origin": {
    "position": [
      0.0,
      0.0,
      0.0
    ],
    "rotation": [
      0.0,
      0.0,
      0.0
    ]
  },
  "global_upgrades": {
    "PV": true,
    "HEATING": true,
    "FE3": {
      "LR": false
    }
  },
  "instance": {
    "id": "Oliver",
    "part_name": "XC50-4L",
    "children": {
      "-1": {
        "id": "Liam",
        "part_name": "XC50-4R",
        "children": {
          "-1": {
            "id": "Oliver",
            "part_name": "XC50-4R",
            "children": {
              "-1": {
                "id": "Ethan",
                "part_name": "XC50-4R",
                "children": {}
              }
            }
          }
        }
      }
    }
  },
  "configs": {},
  "selected": "Oliver"
}

from typing import Any, Optional, Union

from PythonModules.schema import TrackConfig, Part, PartNames

from pydantic import BaseModel, Field

class UpdatePart(BaseModel):
    """Updating or creating a part with the given id and part_name"""

    reasoning: str = Field(..., description="Answer all reasoning questions")
    id: str = Field(..., description="The unique id of a part. This is a unique random english first name.")
    part_name: PartNames = Field(..., description="The name of the part e.g. 'XS12'")
    parent: str = Field("", description="The id of the parent part or '' if the part is the root part. Usually This is the current selected part.")
    index: int = Field(-1, description="Where to insert the new part. -1 means append.")

    def __call__(self, track_config: Optional[TrackConfig] = None):
        return #code ommited


class UpdateSelection(BaseModel):
    """Select the part with the given id"""

    reasoning: str = Field(..., description="Which id's parts could be selected? Why does each part make sense or not?")
    id: str = Field(..., description="The unique id of a part. This is a unique random english first name.")

    def __call__(self, track_config: Optional[TrackConfig] = None):
        print(f"UpdateSelection(reasoning={self.reasoning}, id={id})")
        return #code ommited

# Other possible updates

system_template = """
You are a world class assistant, helping an engineer to build an amazing street network from prefefined parts. The whole system is modular. 
You are responsible for deciding on which updates to do to the underlying configuration. The engineer will then update the configuration based on your input. 
You get access to a pointer named 'selected'. This id shows you relative to what you probably should append things to.
The whole track configuration is stored in a json file. In the instance key a tree of parts exists. The decendant of a child is the "children" field. The main child has key "-1".
The whole track consisting of a tree should make it easier to describe on where to append things.

The configuration is based on the following pydantic schema:

class PartNames(str, Enum):
    Straigt30mElement = "XS12"
    CurveRight50mRadius10mLenthgElement = "XC50-4L"
    CurveLeft50mRadius10mLenthgElement = "XC50-4R"
    DeletedElement = "Deleted"

class Origin(BaseModel):
    position: List[float] = Field(..., description="The origin position coordinates (x,y,z))")
    rotation: List[float] = Field(..., description="The origin rotation angles in degrees (x,y,z)")
    
class Part(BaseModel):
    id: str = Field(..., description="The unique id of a part. This is a unique random english first name.")
    part_name: PartNames = Field(..., description="The name of the part")
    children: Optional[Dict[str, 'Part']] = Field({}, description="Dictionary of child parts. Key=='next' is the default next part")

Part.update_forward_refs()  # This updates Element to include the recursive reference to itself

class TrackConfig(BaseModel):
    version: str = Field(..., description="The version of the track configuration")
    library_dir: List[str] = Field(..., description="List of paths to the libraries")
    origin: Origin = Field(..., description="The origin position and rotation of the track")
    global_upgrades: Dict[str, Any] = Field(..., description="Global upgrades for every element")
    instance: Part = Field(..., description="Part instances of the track")
    configs: Dict[str, Dict[str, Any]] = Field(..., description="Configuration dictionary for the track configuration")
    selected: str = Field(..., description="The id of the selected Element")

For new elements think of a new english first name as id! Think of a random name.
If not specified otherwise append or add new parts to the selected part. Never add new parts to a parent as a different child then -1, unless specified otherwise!
If a parent has other children it usually is asumed that the child with key -1 is the main child and that you should append to that one or one of its children.

Altough also visible in the schema, the following part_name's are available:
Straigt 30m Element: "XS12"
Curve Right!! 50m Radius 10m outer Length Element: "XC50-4L"
Curve Left!!  50m Radius 10m outer Length Element: "XC50-4R"

Reasons for the update fields should answer the following questions! You have to answer all of them:
- Which id do you want to update or is it a new id?
- What part_name do you want to use?
- Why this part_name?
- What parents could you use?
- If the parent already has children, why do you want to replace main child?

"""

prompt_template = """
The current configuration is as follows:
--------------------
{track_config}
--------------------
Use the given format to pick update steps from the following input:
--------------------
{input}
--------------------
Tips: Answer all questions.
Tips: Make sure to answer in the correct format!!!
"""

class Track:
    def __init__(self, llm, system_template, prompt_template):
        self.path = "track.json"
        self.new_config = None
        prompt_msgs = [
            SystemMessage(content= system_template),
            HumanMessagePromptTemplate.from_template(prompt_template)
        ]
        prompt = ChatPromptTemplate(messages=prompt_msgs)

        self.chain = create_openai_fn_chain([UpdatePart,UpdateSelection], llm, prompt, verbose=False)

    @property
    def track_config(self):
        if not self.new_config:
            data_dict = json.load(open(self.path, "r"))
            track_config = TrackConfig(**data_dict)
            self.new_config = track_config

        return self.new_config
    
    @track_config.setter
    def track_config(self, track_config: TrackConfig):
        self.new_config = track_config
        
    def store(self):
        json.dump(self.track_config.dict(), open(self.path, "w"), indent=2)
    
    def agent(self):
        # interactively update the track_config
        # asks for user input and calls the callback function

        while prompt:=input("How should the track be updated? to quit press enter without input."):
            self(prompt)
    
    # Possibly wrap the call in retries if the to predict format is very difficult
    # @retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
    def __call__(self, input) -> Any:
        json_str = json.dumps(self.track_config.dict(), indent=2)
        function:Union[UpdatePart,UpdateSelection] = self.chain.run(input = input, track_config=json_str)
        
        # call function with the track_config
        res = function(self.track_config)

        # store the new track_config
        self.store()
        
        return res

model = "gpt-3.5-turbo"
llm = ChatOpenAI(model=model,temperature=0.9)
track = Track(llm, system_template, prompt_template)

track("append a new right element to the track")
track("Add a straight part to the last added track")
...

# we need a single line of code to start tracing LangChain with W&B
os.environ["LANGCHAIN_WANDB_TRACING"] = "true"