# Indeks węzłów

Ten indeks zawiera dodatkowe informacje o wszystkich węzłach zawartych w tym elementarzu, a także o pozostałych składnikach, które mogą być przydatne. Podano w nim tylko część z około 500 węzłów dostępnych w programie Dynamo.

## Widoczność

### Kolor

|   |                                                                                                                                              |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                    |   |
|   | <p><strong>Color.ByARGB</strong><br>Tworzy kolor według składowych: alfa (alpha), czerwony (red), zielony (green) i niebieski (blue).</p>    | ! |
| ! | <p><strong>Zakres kolorów</strong><br>Pobiera kolor z gradientu między kolorem początkowym i końcowym.</p>                                   |   |
|   | DZIAŁANIA                                                                                                                                    |   |
|   | <p><strong>Color.Brightness</strong><br>Pobiera wartość jasności tego koloru.</p>                                                            |   |
| ! | <p><strong>Color.Components</strong><br>Wyświetla listę składowych koloru w następującej kolejności: alfa, czerwony, zielony, niebieski.</p> | ! |
|   | <p><strong>Color.Saturation</strong><br>Pobiera wartość nasycenia tego koloru.</p>                                                           | ! |
|   | <p><strong>Color.Hue</strong><br>Pobiera wartość barwy tego koloru.</p>                                                                      | ! |
|   | ZAPYTANIE                                                                                                                                    |   |
| ! | <p><strong>Color.Alpha</strong><br>Znajduje składową alfa koloru, od 0 do 255.</p>                                                           | ! |
|   | <p><strong>Color.Blue</strong><br>Znajduje niebieską składową koloru, od 0 do 255.</p>                                                       | ! |
|   | <p><strong>Color.Green</strong><br>Znajduje zieloną składową koloru, od 0 do 255.</p>                                                        | ! |
|   | <p><strong>Color.Red</strong><br>Znajduje czerwoną składową koloru, od 0 do 255.</p>                                                         | ! |

|   |                                                                                                |   |
| - | ---------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                      |   |
|   | <p><strong>GeometryColor.ByGeometryColor</strong><br>Wyświetla geometrię za pomocą koloru.</p> | ! |

### Watch

|   |                                                                                   |   |
| - | --------------------------------------------------------------------------------- | - |
|   | DZIAŁANIA                                                                         |   |
| ! | <p><strong>View\.Watch</strong><br>Wizualizuje dane wyjściowe węzła.</p>          | ! |
| ! | <p><strong>View\.Watch 3D</strong><br>Wyświetla dynamiczny podgląd geometrii.</p> | ! |

## Dane wejściowe

|   |                                                                                                            |   |
| - | ---------------------------------------------------------------------------------------------------------- | - |
|   | DZIAŁANIA                                                                                                  |   |
|   | <p><strong>Boolean</strong><br>Wybór między true i false.</p>                                              | ! |
| ! | <p><strong>Code Block</strong><br>Umożliwia bezpośrednie utworzenie kodu DesignScript.</p>                 | ! |
| ! | <p><strong>Directory Path</strong><br>Umożliwia wybranie katalogu w systemie, aby pobrać jego ścieżkę.</p> | ! |
| ! | <p><strong>Ścieżka pliku</strong><br>Umożliwia wybranie pliku w systemie, aby pobrać jego nazwę</p>        | ! |
| ! | <p><strong>Suwak liczby całkowitej</strong><br>Suwak, który generuje wartości całkowite.</p>               | ! |
|   | <p><strong>Number</strong><br>Tworzy liczbę.</p>                                                           |   |
| ! | <p><strong>Suwak liczby</strong><br>Suwak pozwalający uzyskać wartości liczbowe.</p>                       | ! |
|   | <p><strong>String</strong><br>Tworzy ciąg.</p>                                                             | ! |
| ! | <p><strong>Object.IsNull</strong><br>Określa, czy podany obiekt ma wartość null.</p>                       | ! |

## Lista

|   |                                                                                                                                                                                                                                              |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                                                                                    |   |
| ! | <p><strong>List.Create</strong><br>Tworzy nową listę z określonych danych wejściowych.</p>                                                                                                                                                   | ! |
| ! | <p><strong>List.Combine</strong><br>Stosuje kombinator do każdego elementu w dwóch sekwencjach.</p>                                                                                                                                          | ! |
|   | <p><strong>Number Range</strong><br>Tworzy sekwencję liczb w określonym zakresie</p>                                                                                                                                                         |   |
|   | <p><strong>Number Sequence</strong><br>Tworzy sekwencję liczb.</p>                                                                                                                                                                           | ! |
|   | DZIAŁANIA                                                                                                                                                                                                                                    |   |
| ! | <p><strong>List.Chop</strong><br>Dzieli listę na zestaw list, z których każdy zawiera zadaną liczbę elementów.</p>                                                                                                                           | ! |
|   | <p><strong>List.Count</strong><br>Zwraca liczbę elementów przechowywanych w danej liście.</p>                                                                                                                                                | ! |
| ! | <p><strong>List.Flatten</strong><br>Zrównuje zagnieżdżony wykaz list o określoną wartość.</p>                                                                                                                                                | ! |
| ! | <p><strong>List.FilterByBoolMask</strong><br>Filtruje sekwencję, sprawdzając odpowiadające indeksy w osobnej liście wartości logicznych.</p>                                                                                                 | ! |
| ! | <p><strong>List.GetItemAtIndex</strong><br>Pobiera element z danej listy, który znajduje się w określonym indeksie.</p>                                                                                                                      | ! |
|   | <p><strong>List.Map</strong><br>Stosuje funkcję do wszystkich elementów listy, generując z wyników nową listę.</p>                                                                                                                           | ! |
|   | <p><strong>List.Reverse</strong><br>Tworzy nową listę zawierającą elementy z danej listy, ale w odwrotnej kolejności.</p>                                                                                                                    | ! |
| ! | <p><strong>List.ReplaceItemAtIndex</strong><br>Zastępuje element z danej listy, który znajduje się w określonym indeksie.</p>                                                                                                                | ! |
| ! | <p><strong>List.ShiftIndices</strong><br>Przesuwa indeksy na liście w prawo o podaną wartość.</p>                                                                                                                                            | ! |
| ! | <p><strong>List.TakeEveryNthItem</strong><br>Pobiera elementy z danej listy w indeksach, które są wielokrotnością danej wartości, po uwzględnieniu podanego odsunięcia.</p>                                                                  | ! |
| ! | <p><strong>List.Transpose</strong><br>Zamienia wiersze z kolumnami na liście list. Jeśli niektóre wiersze są krótsze niż inne, w tablicy wynikowej są wstawiane wartości null jako elementy zastępcze, tak aby zawsze uzyskać prostokąt.</p> | ! |

## Logika

|                                  |                                                                                                                                                                                                                                                        |   |
| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|                                  | DZIAŁANIA                                                                                                                                                                                                                                              |   |
| ![](/files/29R6znROiYQFr2LZWxXq) | <p><strong>If</strong><br>Instrukcja warunkowa. Sprawdza wartość logiczną danych wejściowych przekazanych do sprawdzenia. Jeśli dane wejściowe są prawdziwe, generuje wartość wyjściową true. W przeciwnym razie generuje wartość wyjściową false.</p> | ! |

## Matematyka

|   |                                                                                                              |   |
| - | ------------------------------------------------------------------------------------------------------------ | - |
|   | DZIAŁANIA                                                                                                    |   |
| ! | <p><strong>Math.Cos</strong><br>Oblicza cosinus kąta.</p>                                                    | ! |
| ! | <p><strong>Math.DegreesToRadians</strong><br>Konwertuje wartość kąta w stopniach na wartość w radianach.</p> | ! |
| ! | <p><strong>Math.Pow</strong><br>Podnosi liczbę do określonej potęgi.</p>                                     | ! |
| ! | <p><strong>Math.RadiansToDegrees</strong><br>Konwertuje wartość kąta w radianach na wartość w stopniach.</p> | ! |
| ! | <p><strong>Math.RemapRange</strong><br>Dostosowuje zakres listy liczb, zachowując współczynnik rozkładu.</p> | ! |
| ! | <p><strong>Math.Sin</strong><br>Oblicza sinus kąta.</p>                                                      | ! |
|   | <p><strong>Mapowanie</strong><br>Przypisuje wartość do zakresu danych wejściowych.</p>                       | ! |

## Ciąg

|   |                                                                                                                                           |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | DZIAŁANIA                                                                                                                                 |   |
| ! | <p><strong>String.Concat</strong><br>Łączy wiele ciągów w jeden.</p>                                                                      | ! |
| ! | <p><strong>String.Contains</strong><br>Określa, czy dany ciąg zawiera dany podciąg.</p>                                                   | ! |
| ! | <p><strong>String.Join</strong><br>Łączy wiele ciągów w jeden, wstawiając podany separator między poszczególnymi ciągami.</p>             | ! |
| ! | <p><strong>String.Split</strong><br>Dzieli pojedynczy ciąg na listę ciągów, z podziałami wyznaczanymi przez podane ciągi separatorów.</p> | ! |
| ! | <p><strong>String.ToNumber</strong><br>Konwertuje ciąg na liczbę całkowitą lub zmiennoprzecinkową o podwójnej dokładności.</p>            | ! |

## Geometria

### Okrąg

|   |                                                                                                                                                                              |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                    |   |
| ! | <p><strong>Circle.ByCenterPointRadius</strong><br>Tworzy okrąg ze środkiem i promieniem wejściowym w płaszczyźnie globalnej XY, ze współrzędną globalną Z jako normalną.</p> | ! |
| ! | <p><strong>Circle.ByPlaneRadius</strong><br>Tworzy okrąg ze środkiem w początku płaszczyzny wejściowej (głównym), leżący w płaszczyźnie wejściowej, o podanym promieniu.</p> | ! |

|   |                                                                                                                                                                                                 |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                                       |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Tworzy układ współrzędnych z początkiem w punkcie wejściowym, z osiami X i Y ustawionymi jako osie X i Y GUW.</p>                              | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Tworzy układ CoordinateSystem o określonych parametrach współrzędnych walcowych względem określonego układu współrzędnych.</p> | ! |

### Prostopadłościan

|   |                                                                                                                                                                          |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | TWORZENIE                                                                                                                                                                |   |
| ! | <p><strong>Cuboid.ByLengths</strong><br>Utwórz prostopadłościan wyśrodkowany na początku GUW, z określoną szerokością, długością i wysokością.</p>                       | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (origin)</p><p>Utwórz prostopadłościan wyśrodkowany w punkcie wejściowym, z określoną szerokością, długością i wysokością.</p>      | ! |
|   | <p><strong>Cuboid.ByLengths</strong> (coordinateSystem)</p><p>Utwórz prostopadłościan wyśrodkowany na początku GUW, z określoną szerokością, długością i wysokością.</p> | ! |
|   | <p><strong>Cuboid.ByCorners</strong></p><p>Utwórz prostopadłościan łączący punkt niski z punktem wysokim.</p>                                                            | ! |
| ! | <p><strong>Cuboid.Length</strong></p><p>Zwraca wymiary wejściowe prostopadłościanu, NIE rzeczywiste wymiary przestrzeni globalnej\*\*.</p>                               | ! |
|   | <p><strong>Cuboid.Width</strong></p><p>Zwraca wymiary wejściowe prostopadłościanu, NIE rzeczywiste wymiary przestrzeni globalnej\*\*.</p>                                | ! |
|   | <p><strong>Cuboid.Height</strong></p><p>Zwraca wymiary wejściowe prostopadłościanu, NIE rzeczywiste wymiary przestrzeni globalnej\*\*.</p>                               | ! |
| ! | <p><strong>BoundingBox.ToCuboid</strong></p><p>Pobierz ramkę ograniczającą jako prostopadłościan bryłowy</p>                                                             | ! |

{% hint style="warning" %}
\*\*Innymi słowy: jeśli utworzysz długość szerokości prostopadłościanu (na osi X) równą 10 i przekształcisz go, stosując układ współrzędnych z 2-krotnym skalowaniem na osi X, szerokość nadal będzie wynosić 10. ASM nie pozwala wyodrębnić wierzchołków bryły w przewidywalnej kolejności, dlatego nie można określić wymiarów po przekształceniu.
{% endhint %}

### Krzywa

|   |                                                                                                                                              |   |
| - | -------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | DZIAŁANIA                                                                                                                                    |   |
| ! | <p><strong>Curve.Extrude</strong> (distance)<br>Wyciąga krzywą w kierunku wektora normalnego.</p>                                            | ! |
| ! | <p><strong>Curve.PointAtParameter</strong><br>Pobiera punkt na krzywej o określonym parametrze między StartParameter() a EndParameter().</p> | ! |

### Modyfikatory geometrii

|   |                                                                                                                                                            |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | DZIAŁANIA                                                                                                                                                  |   |
| ! | <p><strong>Geometry.DistanceTo</strong><br>Wyznacza odległość od tej geometrii do innej.</p>                                                               | ! |
| ! | <p><strong>Geometry.Explode</strong><br>Rozdziela złożone (nierozdzielone) elementy na części składowe.</p>                                                | ! |
| ! | <p><strong>Geometry.ImportFromSAT</strong><br>Lista zaimportowanych geometrii.</p>                                                                         | ! |
| ! | <p><strong>Geometry.Rotate</strong> (basePlane)<br>Obraca obiekt wokół początku układu współrzędnych i wektora normalnego o kąt określony w stopniach.</p> | ! |
| ! | <p><strong>Geometry.Translate</strong><br>Przekształca geometrię dowolnego typu o podaną odległość w podanym kierunku.</p>                                 | ! |

### Linia

|   |                                                                                                                                                                         |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                               |   |
| ! | <p><strong>Line.ByBestFitThroughPoints</strong><br>Tworzy linię najdokładniej przybliżającą do wykresu punktowego punktów.</p>                                          | ! |
| ! | <p><strong>Line.ByStartPointDirectionLength</strong><br>Tworzy linię prostą, zaczynając od punktu początkowego i wydłużając w kierunku wektora o określoną długość.</p> | ! |
| ! | <p><strong>Line.ByStartPointEndPoint</strong><br>Tworzy linię prostą między dwoma punktami wejściowymi.</p>                                                             | ! |
| ! | <p><strong>Line.ByTangency</strong><br>Tworzy linię styczną do krzywej wejściowej, umieszczoną w punkcie parametru krzywej wejściowej.</p>                              | ! |
|   | ZAPYTANIE                                                                                                                                                               |   |
| ! | <p><strong>Line.Direction</strong><br>Kierunek krzywej.</p>                                                                                                             | ! |

### Krzywa NurbsCurve

|   |                                                                                                                                   |   |
| - | --------------------------------------------------------------------------------------------------------------------------------- | - |
|   | Tworzenie                                                                                                                         |   |
| ! | <p><strong>NurbsCurve.ByControlPoints</strong><br>Tworzy obiekt BSplineCurve przy użyciu jawnie podanych punktów sterujących.</p> | ! |
| ! | <p><strong>NurbsCurve.ByPoints</strong><br>Tworzy obiekt BSplineCurve przez interpolację między punktami.</p>                     | ! |

### Powierzchnia NurbsSurface

|   |                                                                                                                                                                                                                 |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | Tworzenie                                                                                                                                                                                                       |   |
| ! | <p><strong>NurbsSurface.ByControlPoints</strong><br>Tworzy powierzchnię NURBS przy użyciu jawnie podanych punktów sterujących oraz kątów U i V podanych w stopniach.</p>                                        | ! |
| ! | <p><strong>NurbsSurface.ByPoints</strong><br>Tworzy powierzchnię NURBS przy użyciu interpolacji podanych punktów oraz kątów U i V podanych w stopniach. Powierzchnia wynikowa przecina wszystkie te punkty.</p> | ! |

### Płaszczyzna

|   |                                                                                                                                       |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                             |   |
| ! | <p><strong>Plane.ByOriginNormal</strong><br>Tworzy płaszczyznę wyśrodkowaną w punkcie głównym i mającą wejściowy wektor normalny.</p> | ! |
| ! | <p><strong>Plane.XY</strong><br>Tworzy płaszczyznę w globalnej płaszczyźnie XY.</p>                                                   | ! |

### Point

|   |                                                                                                                                                        |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------ | - |
|   | TWORZENIE                                                                                                                                              |   |
| ! | <p><strong>Point.ByCartesianCoordinates</strong><br>Tworzy punkt w podanym układzie współrzędnych z trzema współrzędnymi kartezjańskimi.</p>           | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (2d)<br>Tworzy punkt na płaszczyźnie XY zadanej przez dwie współrzędne kartezjańskie. Składnik Z wynosi 0.</p> | ! |
| ! | <p><strong>Point.ByCoordinates</strong> (3d)<br>Tworzy punkt na podstawie trzech współrzędnych kartezjańskich.</p>                                     | ! |
| ! | <p><strong>Point.Origin</strong><br>Pobiera punkt początku układu współrzędnych (0,0,0).</p>                                                           | ! |
|   | DZIAŁANIA                                                                                                                                              |   |
| ! | <p><strong>Point.Add</strong><br>Dodaje wektor do punktu. Działa podobnie do Translate (Vector).</p>                                                   | ! |
|   | ZAPYTANIE                                                                                                                                              |   |
| ! | <p><strong>Point.X</strong><br>Pobiera składową X punktu.</p>                                                                                          | ! |
| ! | <p><strong>Point.Y</strong><br>Pobiera składową Y punktu.</p>                                                                                          | ! |
| ! | <p><strong>Point.Z</strong><br>Pobiera składową Z punktu.</p>                                                                                          | ! |

### Krzywa PolyCurve

|   |                                                                                                                                                                                                            |   |
| - | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                                                  |   |
| ! | <p><strong>Polycurve.ByPoints</strong><br>Tworzy krzywą złożoną z sekwencji linii łączących punkty. Aby powstała krzywa zamknięta, ostatni punkt powinien być w tym samym miejscu co punkt początkowy.</p> | ! |

### Prostokąt

|   |                                                                                                                                                                                                           |   |
| - | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                                                 |   |
| ! | <p><strong>Rectangle.ByWidthLength</strong> (Plane)<br>Tworzy prostokąt ze środkiem w głównym punkcie na płaszczyźnie wejściowej, o szerokości wejściowej (długość osi X) i długości (długość osi Y).</p> | ! |

### Sfera

|   |                                                                                                                                     |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                           |   |
| ! | <p><strong>Sphere.ByCenterPointRadius</strong><br>Tworzy bryłę sferyczną ze środkiem w punkcie wejściowym, o podanym promieniu.</p> | ! |

### Powierzchnia

|   |                                                                                                                                                                     |   |
| - | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                           |   |
| ! | <p><strong>Surface.ByLoft</strong><br>Tworzy powierzchnię przez wyciągnięcie między krzywymi wejściowymi przekroju poprzecznego.</p>                                | ! |
| ! | <p><strong>Surface.ByPatch</strong><br>Tworzy powierzchnię przez wypełnienie wnętrza zamkniętej obwiedni określonej przez krzywe wejściowe.</p>                     |   |
|   | DZIAŁANIA                                                                                                                                                           |   |
| ! | <p><strong>Surface.Offset</strong><br>Odsuwa powierzchnię w kierunku normalnej powierzchni o określoną odległość.</p>                                               | ! |
|   | <p><strong>Surface.PointAtParameter</strong><br>Zwraca punkt dla określonych parametrów U i V.</p>                                                                  | ! |
|   | <p><strong>Surface.Thicken</strong><br>Pogrubia powierzchnię w celu utworzenia bryły, wyciągając w kierunku normalnych powierzchni po obu stronach powierzchni.</p> | ! |

### UV

|   |                                                                                     |   |
| - | ----------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                           |   |
| ! | <p><strong>UV.ByCoordinates</strong><br>Tworzy UV z dwóch wartości podwojonych.</p> | ! |

### Wektor

|   |                                                                                                     |   |
| - | --------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                           |   |
| ! | <p><strong>Vector.ByCoordinates</strong><br>Tworzy wektor z trzech współrzędnych euklidesowych.</p> | ! |
|   | <p><strong>Vector.XAxis</strong><br>Pobiera kanoniczny wektor osi X (1,0,0).</p>                    | ! |
|   | <p><strong>Vector.YAxis</strong><br>Pobiera kanoniczny wektor osi Y (0,1,0).</p>                    | ! |
|   | <p><strong>Vector.ZAxis</strong><br>Pobiera kanoniczny wektor osi Z (0,0,1).</p>                    | ! |
|   | DZIAŁANIA                                                                                           |   |
| ! | <p><strong>Vector.Normalized</strong><br>Pobiera znormalizowaną wersję wektora.</p>                 | ! |

## CoordinateSystem

|   |                                                                                                                                                                                                 |   |
| - | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | - |
|   | TWORZENIE                                                                                                                                                                                       |   |
| ! | <p><strong>CoordinateSystem.ByOrigin</strong><br>Tworzy układ współrzędnych z początkiem w punkcie wejściowym, z osiami X i Y ustawionymi jako osie X i Y GUW.</p>                              | ! |
|   | <p><strong>CoordinateSystem.ByCylindricalCoordinates</strong><br>Tworzy układ CoordinateSystem o określonych parametrach współrzędnych walcowych względem określonego układu współrzędnych.</p> | ! |

## Operatory

|   |                                                                                                                      |   |
| - | -------------------------------------------------------------------------------------------------------------------- | - |
| ! | <p><strong>+</strong><br>Dodawanie</p>                                                                               | ! |
| ! | <p><strong>-</strong><br>Odejmowanie</p>                                                                             | ! |
| ! | <p><strong>\*</strong><br>Mnożenie</p>                                                                               | ! |
| ! | <p><strong>/</strong><br>Dzielenie</p>                                                                               | ! |
|   | <p><strong>%</strong><br>Dzielenie modulo. Oblicza resztę z dzielenia pierwszej wartości wejściowej przez drugą.</p> | ! |
|   | <p><strong><</strong><br>Mniejsze niż</p>                                                                            | ! |
| ! | <p><strong>></strong><br>Większy niż</p>                                                                             | ! |
| ! | <p><strong>==</strong><br>Test równości między dwiema wartościami.</p>                                               | ! |


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://primer2.dynamobim.org/pl/5_essential_nodes_and_concepts/index-of-nodes.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
