> For the complete documentation index, see [llms.txt](https://doc.realvirtual.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://doc.realvirtual.io/components-and-scripts/motion/ribbon-handling.md).

# Ribbon Handling (Pro)

{% hint style="info" %}
Ribbon handling was added in realvirtual **6.3.1** (Professional). The same components exist in realvirtual WEB, so a machine built here runs unchanged in the browser after a GLB export.
{% endhint %}

## Overview

Ribbon handling simulates **endless material running over rollers** — paper, film, foil, textile, nonwoven, or sheet metal off a coil. You place rollers, list them in running order, and realvirtual solves the taut web between them: the straight runs, the wrap arcs, the growing and shrinking rolls of the winders, and the material stored in a dancer.

<figure><img src="https://260262196-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FpYxFg97YnJX96UzNNTSd%2Fuploads%2Fgit-blob-89d6483602571db8e87cef4adb10ba89307da0d7%2Fribbon-slitter-demo.png?alt=media" alt="Ribbon Slitter sample scene with unwinder, idlers, nip, two dancers and two rewinders running a printed web"><figcaption><p>The Ribbon Slitter sample: one unwinder feeds a nip, the web is slit and two rewinders wind the strips</p></figcaption></figure>

Four components do the work:

| Component         | What it is                                                                                    |
| ----------------- | --------------------------------------------------------------------------------------------- |
| **Ribbon Roller** | One roller the web runs over: a contact radius, a rotation axis, and the side the web lies on |
| **Ribbon Winder** | An unwinder or rewinder at one end of a path, whose radius follows the wound length           |
| **Ribbon Dancer** | A roller that also travels and thereby stores web between two sections                        |
| **Ribbon Path**   | One taut web over an ordered, open chain of rollers                                           |

A fifth component, **Ribbon Manager**, is a single scene object that ticks everything in the right order. One is created automatically when the simulation starts.

The web is moved **only** by a rotational **Drive** on a roller. There is no separate speed setting: you drive the nip roller (or the rewinder) exactly as you would in the real machine, and the web follows.

## Quick Start

1. Add a **Ribbon Roller** to the mesh node of every roller of your machine. Set **Axis** to the roller's rotation axis and leave **Radius Mm** at 0 to have it measured from the mesh.
2. Make the two ends **Ribbon Winder** instead, and give them a **Core Radius Mm** and a **Ribbon Thickness Mm** (the caliper of your material).
3. Put a rotational **Drive** on the roller that pulls the web — usually the nip — with its **Direction** on the same axis as the roller. Set its **Target Speed** in degrees per second.
4. Create an empty GameObject, add a **Ribbon Path**, and drag the rollers into **Rollers** in running order. The first and last entry are the ends of the web.
5. Set **Ribbon Width Mm** and **Ribbon Thickness Mm** (the same caliper as the winders).
6. Press Play. The band appears, the followers turn at `v / r`, and the roll diameters migrate.

While you are still placing rollers, the Scene view shows a live **preview**: both band edges, the wrap arcs, the slit mark and the wrap side of every roller. It updates as you drag, and it uses the same mathematics the simulation does — so what you see while authoring is what the web will do.

## Ribbon Roller

**Radius Mm** (float, millimeters) Contact radius of the roller. 0 measures it from the mesh bounds in the plane perpendicular to **Axis**, in the node's own local frame, so a scaled parent does not distort it. Set it by hand for a roller whose mesh is a rough placeholder.

**Axis** (X / Y / Z) Local rotation axis of the roller, and the common axis of the whole path. Every roller of one path must be parallel within 2 degrees; a path with a turn bar is not one path.

**Ribbon Side** (Auto / Left / Right) Which side of the roller the web runs on. Leave it on **Auto**: for every normal machine Auto picks the short wrap, the only one a real web can take. Set Left or Right by hand only for an S-wrap or a wrap of more than 180 degrees. Left and Right are the turning sense seen looking along +Axis — Left counter-clockwise, Right clockwise.

**Rotation Direction** (1 / -1) Which way the roller is *drawn* turning. Set it to -1 when the roller visibly turns against the web, which happens when the imported CAD axis points the other way. It changes the picture only, never the web speed.

**Spin Mode** (Transform / Texture) How the roller shows that it is turning. **Transform** turns the roller object itself. **Texture** leaves the object standing still and scrolls the pattern on its barrel instead — it looks the same at a glance and costs no per-frame work, which is worth having on a machine with many idlers. Texture works only on a roller **without** a drive; a driven roller is always turned by its drive.

**Mantle Mesh** (Transform) Which part scrolls in Spin Mode Texture — normally the barrel of the roller. Leave it empty to use the roller's own mesh.

**Override Materials** (boolean) Replaces the CAD materials of the barrel and of the end faces with the two library materials below while the simulation runs, and puts the CAD materials back when it stops. Switch it on when an imported roller is plain grey and you want a pattern that shows it turning, without editing the CAD materials.

**Mantle Material Name** (string, dropdown) Name of a material of the ribbon material library for the barrel. Leave it empty to leave the barrel unchanged.

**Face Material Name** (string, dropdown) Name of a material of the ribbon material library for every renderer under a child called `Faces`. Leave it empty to leave the end faces unchanged.

**Preview materials** (button) Shows the two materials in the scene view without starting the simulation, and takes them back when pressed again. The preview is never saved: it is taken back before a scene or prefab is written and before a script reload, so it can never become a scene change.

## Materials

Every ribbon material is picked by **name** from the **ribbon material library**, so the same name means the same look in Unity and in realvirtual WEB.

The library ships with the package as `Packages/io.realvirtual.professional/Runtime/Ribbon/Resources/realvirtual/RibbonMaterialLibrary.Default` and carries ten entries: `Paper`, `Steel`, `Core`, `Frame`, `Stripes`, `Helix`, `IndexMark`, `Spokes`, `Arrows` and `HubCross`.

### Adding your own materials

Create a **Ribbon Material Library** asset (`Assets > Create > realvirtual > Ribbon Material Library`), name it `RibbonMaterialLibrary` and put it in any `Assets/.../Resources/realvirtual/` folder. Its entries are merged **over** the default, by name:

* a new name adds a material,
* an existing name replaces it — case does not matter, so `paper` replaces `Paper`.

Do not name your asset `RibbonMaterialLibrary.Default`: two equally named assets in two Resources folders are undefined in Unity, and which one wins would be a coin toss.

Names resolve exactly first, then ignoring case. There is no partial match, so `Core` never matches `CoreSteel`. An unknown name is reported in the console together with the names that do exist, and that part simply keeps its CAD material.

Use the URP **Lit** shader for your own materials unless you know your shader survives build-time shader stripping.

### What reaches realvirtual WEB

The browser has no ribbon texture library of its own, so the names are resolved against the materials of the **loaded document**. The GLB export makes sure they are in it:

* a roller with **Override Materials** is exported with the library materials on its renderers;
* the web material of a **Ribbon Path** is exported through a temporary one-millimetre donor node, because a band mesh does not exist while authoring and a material without a renderer is not exported at all. The donor is deleted again right after the export, and the browser drops it while loading — it costs no draw call and cannot be clicked.

In the GLB the materials are named like the **library names**, not like the material assets. Your scene keeps its own asset names; nothing is renamed and nothing is modified by the export.

## Ribbon Winder

A winder **must be the first or the last entry** of its path's Rollers list; in the middle it makes the path inert with a warning. Its radius follows the wound length:

```
R(L) = sqrt(CoreRadiusMm² + L · RibbonThicknessMm / π)
```

The **length** is the state and the radius is derived from it, which makes the roll exactly reversible: a rewinder driven forward and back returns to its authored diameter instead of drifting.

**Wrap Deg** (float, degrees) How far the web is shown wrapping the roll **before** it reaches the running tangent (an unwinder) or **after** it leaves it (a rewinder). A web path is open, so without it the band starts and ends exactly at a tangent point — geometrically right, but the strip appears to hang in mid-air beside the reel. Set 270 to see the material come off the parent roll and be taken up on the reel, which is what the ribbon slitter demo does on all three of its winders. 0 (the default) keeps the earlier behaviour. The arc follows the growing or shrinking roll on its own, and values above 360 are honoured — 450 really is a lap and a quarter. The value is read only on a winder that is the first or last entry of a path.

{% hint style="info" %}
**Wrap Deg** was added in realvirtual **6.3.6** (Professional).
{% endhint %}

**Core Radius Mm** (float, millimeters) Radius of the bare core (sleeve); must be greater than 0. 76.2 mm is the 3 inch core of the converting industry.

**Ribbon Thickness Mm** (float, millimeters) Thickness of one wound layer — the caliper. It must be the **same** value as the path's **Ribbon Thickness Mm**; it is the same material.

**Initial Wound Length Mm** (float, millimeters) How much material is on the roll at the start and after a restart. **-1** means a full roll exactly as modelled — the length is derived from the modelled outer radius, so a full parent reel needs no number typed in. **0** means an empty core, which is what a rewinder starts at.

**Max Diameter Mm** (float, millimeters) Diameter at which the roll counts as full: the whole web group stops and the **Full** signal goes true. 0 = no limit.

**Roll Mesh** (Transform) Which part grows and shrinks with the roll. Leave it empty and the winder object itself is scaled, which is the normal case. **Model the core as a SIBLING next to it, never as a child** — a child would scale with the paper and the core would visibly grow.

### Speed Control

A winder is the one roller of a line whose radius moves, so a drive turning at a constant angular speed changes its surface speed as the roll builds or empties — which runs a dancer into a stop within a minute. **Speed Control** lets the winder rewrite its own drive set-point every tick instead.

{% hint style="info" %}
Winder speed control was added in realvirtual **6.3.6** (Professional).
{% endhint %}

**Speed Control** (None / Line Speed / Dancer) How the winder decides its drive speed. **None** (the default) leaves the authored drive completely alone. **Line Speed** holds the winder's surface speed at the line speed: `omega = line speed / current radius`. **Dancer** does the same and adds a proportional trim from the carriage position of the dancer next to it, which is what actually holds a carriage near its home position while the roll grows.

**Dancer Gain Per Mm** (float, percent per millimeter) How hard the trim reacts to a carriage that left home. 2 means one millimeter of deviation changes the winder speed by two percent. Raise it for a faster line, lower it if the carriage starts to oscillate. Only read in **Dancer** mode.

**Max Trim Percent** (float, percent) Cap on the trim, symmetric around the line speed. 20 means the winder is never asked for less than 80 or more than 120 percent of the line speed, whatever the carriage does.

The **line speed** is the group's master: the fastest surface speed of all driven rollers of the web group that are not themselves speed-controlled — in a web line that is the nip or pull roll. A winder whose **Speed Control** is **None** is a perfectly good master. Without a master nothing is written.

The control also **stands down** and writes nothing while the drive is commanded by somebody else (**Is Externally Controlled**, **Position Overwrite**, **Is Sub Drive**, or a second drive behaviour such as Drive\_Speed on the same GameObject), and while the web group is stopped. The status value **Is Speed Control Overridden** says so in the Inspector, and the drive keeps whatever the other writer left it at; releasing the drive resumes the control on the next tick.

The **Dancer** trim is used only where it means something: the winder must be the single driven roller of its section and the dancer must bound that same section. Otherwise the trim is zero and **Dancer** behaves exactly like **Line Speed** — which is why the unwinder of a slitter gets no trim from a carriage sitting behind the nip.

### Signals

**Diameter Mm** (PLCInputFloat) Current roll diameter in millimeters; written only when it changed by more than 0.1 mm.

**Wound Length Mm** (PLCInputFloat) Currently wound web length in millimeters.

**Empty** (PLCInputBool) True while the roll is down to its bare core. An empty winder clamps the web speed of its whole path group to zero.

**Full** (PLCInputBool) True once **Max Diameter Mm** is reached; it clamps the group the same way.

## Ribbon Dancer

A dancer is an **accumulator**, not a spring. It stores whatever length the upstream section delivers over what the downstream section takes, `L += (v_up − v_down) · dt`, and its carriage sits at `Home Mm + L / Strands` along the travel axis. Exactly one dancer per path is supported.

At its stops the limit is **directional** and never stops a drive: at **Travel Max Mm** only further filling is prevented, at **Travel Min Mm** only further emptying — so the opposite delta always frees it again. The PLC is expected to regulate on **Position Mm** / **At Min** / **At Max**.

**Travel Axis** (X / Y / Z) The direction the carriage runs in, in the frame of the object the dancer hangs under. Place the dancer so that moving along the **positive** axis lengthens the web path.

**Travel Min Mm** (float, millimeters) Lower stop relative to Home Mm; must be ≤ 0.

**Travel Max Mm** (float, millimeters) Upper stop relative to Home Mm; must be ≥ 0.

**Home Mm** (float, millimeters) Rest position along the travel axis, relative to the authored node position. 0 means the carriage starts and resets exactly where it was modelled.

**Strands** (int) How many runs of web pass through the carriage. 1 is a single pass over the roller; 2 is the usual loop that goes down to the carriage and back up again. One millimeter of carriage travel then stores that many millimeters of web.

### Signals

**Position Mm** (PLCInputFloat) The carriage position in millimeters — the regulated variable a web tension controller reads. Written only when it changed by more than 0.1 mm.

**At Min** / **At Max** (PLCInputBool) True while the carriage sits at its lower / upper stop.

## Ribbon Path

**Rollers** (list of Ribbon Roller) Rollers in running order. The first and last entry are the ends of the open path and are usually winders.

**Ribbon Width Mm** (float, millimeters) Width of the web, extruded along the common roller axis.

**Ribbon Thickness Mm** (float, millimeters) Thickness of the material. Half of it lifts the web off the roller surface so the two do not intersect. It must be the **same** value as the winders of this path.

**Texture Length Mm** (float, millimeters) How much web one repetition of the surface pattern covers. This is what makes a running web look like it is running: the pattern scrolls by the distance the web has travelled. A larger value gives a coarser pattern that appears to move more slowly.

**Samples Per Meter** (int) How finely the strip is subdivided. Raise it when a tight wrap looks angular; lower it on a very long run to save geometry. Give every strip slit at the same roller the **same** value.

**Material Name** (string, dropdown) Name of a material of the ribbon material library for the web itself. It takes precedence over **Material** below. See [Materials](#materials).

**Material** (Transform) Optional, and superseded by **Material Name**. A **node** whose material the web copies — a printed pattern, a coloured film. Leave both empty and the web gets a paper-white surface with a running-direction arrow, so its motion is always visible.

**Slit At Roller** (Ribbon Roller) Optional **inner** roller (the cutter) at which the full web is slit into this strip. Requires **Full Width Mm** greater than 0.

**Full Width Mm** (float, millimeters) Width of the full web before the slit; 0 = this path is not a slit strip.

## Web Tension

On top of the kinematics a Ribbon Path can carry the **web tension** as a state. The line is cut into **tension zones** between the rollers the web cannot slip on — the two ends, every driven roller, the slit roller and the dancer — and every zone carries one signed strain. A zone whose downstream roller runs faster than its upstream one is stretched, the opposite case goes slack, and the force follows from the strain.

<figure><img src="https://260262196-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FpYxFg97YnJX96UzNNTSd%2Fuploads%2Fgit-blob-da16a7acfd01227c1d58e28803a45a3bc9ee4175%2Fribbon-tension-demo.png?alt=media" alt="Ribbon Tension sample scene with three nips, a dancer and the tension readouts above each zone"><figcaption><p>The Ribbon Tension sample: every zone between two driven rollers shows its tension, sag and strain</p></figcaption></figure>

{% hint style="info" %}
Web tension was added in realvirtual **6.3.6** (Professional).
{% endhint %}

Tension is **off** until you give the path a stiffness: with **Tensile Stiffness N Per Mm Width** at 0 the path behaves exactly as it did before. Slit strips carry no tension (they warn once and stay kinematic), so model the tension on the unslit path.

**Basis Weight Gsm** (float, g/m²) Basis weight of the material — the number on the material data sheet, and what turns a tension into a specific tenacity.

**Tensile Stiffness N Per Mm Width** (float, N per mm of width) Secant tensile stiffness at 100 percent strain: the stiffness that turns a strain into a force. **0 switches tension off entirely.** 10 is a usable starting value for a light film or paper web.

**Min Strain Percent** (float, percent) Strain below which the web counts as **slack**: it no longer carries, it hangs through, and it is coloured as a fault.

**Max Strain Percent** (float, percent) Strain above which the web counts as **overstretched**.

**Break Force N Per 50 Mm** (float, newtons per 50 mm of width) The MD strip tensile force at break, the standard lab figure. The strain it implies tears the web: the zone freezes, **Is Broken** goes true and the whole web group stops until the path is reset. 0 disables breaking.

**Target Tension N Per M** (float, N per meter of width) The set-point tension per unit width. Every zone starts, resets and enters the line at exactly this value, so a line left alone runs at its set point.

**Tolerance Band Percent** (float, percent) Half-width of the good band around the target. Inside it the web is **not tinted at all**, so your own material is untouched in normal operation.

### Tension Visuals

**Enable Sag** (boolean) Whether a slack web visibly hangs through. The excess length of a slack zone is spread over its straight runs and drawn as a hanging curve in the direction of gravity, so a span that has gone slack is visible without reading a number.

**Tension Coloring** (boolean) Whether the band is tinted by its zone state. Under the band the web turns blue and over it orange, with the saturation following the deviation; a slack web is cyan, and an overstretched or torn one pulses magenta.

**Tint Strength** (float, 0 to 1) How strongly the tint is mixed into the band material. 0.7 keeps a printed pattern readable underneath it.

**Deformation Scale** (float) Visual exaggeration of the sag depth. 1 draws the physical depth; raise it to make a small slack readable on a long line.

**Show Tension Labels** (boolean) Draws one world-space readout per zone, in the middle of the span it describes: `142 N/m | 0.81 PLI | eps 0.42 % v`, with a trend arrow, a `~` when the sag left the range the closed form is exact in, and the name of the fault (LOW, HIGH, SLACK, OVERSTRETCHED, TORN) when there is one. A healthy web shows the numbers and nothing else. The labels refresh five times a second and cost nothing at all while the option is off.

### Tension Signals

**Tension N** (PLCInputFloat) Web tension of the **last** zone in newtons — the span running into the rewinder, which is where a machine puts its load cell.

**Specific Tension N Per M** (PLCInputFloat) The same tension per unit width.

**Strain Percent** (PLCInputFloat) Strain of the last zone in percent.

**Is Slack** / **Is Overstretched** (PLCInputBool) True while **any** zone of the path is below **Min Strain Percent** / above **Max Strain Percent**.

**Is Broken** (PLCInputBool) True once any zone reached the break strain. It latches: only a reset clears it, and the web group stays stopped meanwhile.

### The Dancer as a Tension Source

A carriage that carries a **load** does not only store web, it sets the tension of both spans next to it.

**Load N** (float, newtons) Force the loaded carriage presses into the web. 0 (the default) means the dancer only stores web. With a load, both neighbouring zones are held at `Load N / Strands` — holding a 400 mm strip at 100 N/m over two strands therefore takes 80 N.

**Show Travel** (boolean) Draws the track the carriage runs on: the two end stops, the bar between them and a marker on the carriage. The stop that has been reached turns red, so "out of travel" is readable without comparing numbers.

**Show Values** (boolean) Draws the carriage's own readout next to it — the force it presses into the web, the tension that makes and where it stands — plus a force arrow of capped length. It needs a **Load N** greater than 0.

**Tension N** (PLCInputFloat) Signal carrying the tension this dancer imposes, `Load N / Strands`.

### Trying It Out

The sample scene **DemoRibbonTension** (Professional samples, *Ribbon Slitter*) is an unslit line — unwinder, idler, Nip 1, idler, Nip 2, loaded dancer, idler, Nip 3, rewinder — with the labels on. Press Play, then set Nip 2 two percent slower than the other nips: the middle span goes cyan, hangs through, and its label reports a negative strain. Two percent faster turns it magenta. You can build the same line yourself from `realvirtual DEV/Samples/Build Ribbon Tension Line (Axis X)`.

## Common Use Cases

**Converting line** – Unwinder, idlers, a driven nip and a rewinder. One Ribbon Path, two winders, one Drive on the nip. The unwinder is dragged by the web and reports its diameter to the PLC.

**Slitter** – One unwinder feeding several rewinders. Model it as **N Ribbon Paths sharing the unwinder** and set **Slit At Roller** to the cutting roller on every strip. Paths that share a roller form one web group with one speed, so an empty parent roll stops every strip in the same tick, and the shared full-width web is drawn exactly once.

**Tension control** – Put a Ribbon Dancer between the nip and the rewinder and wire **Position Mm** to the PLC. The rewinder turns at a constant angular speed, so its surface speed rises as the roll grows; the dancer absorbs the difference and the PLC regulates on its position.

**Coil handling** – The same components with a 0.8 mm caliper and a steel material on the band.

**Many idlers** – Set **Spin Mode** to Texture on the idlers. They stand still and their barrel texture scrolls, which looks the same and costs nothing per frame.

## Signals and the PLC

Every feedback value is a **PLC input** — the simulation writes it, the PLC reads it. There is no PLC output on a ribbon component: you drive the web through the **Drive** components on the rollers, exactly as the real machine does.

Float signals are written only when the value moved by more than 0.1 mm and bool signals only on a real edge, so a running line does not flood the interface.

## Exporting to realvirtual WEB

The ribbon components export into the GLB without any special handling: the browser components have the same names, the same fields and the same units, and the reader resolves the roller, signal and material references the same way it resolves a Drive's.

Two rules make that work, and both are already satisfied by the components:

* The kinematics runs in the **glTF coordinate frame**. Axis letters, **Ribbon Side**, **Rotation Direction** and **Travel Axis** all mean the same thing in Unity and in the browser, so nothing has to be flipped by hand after an export.
* The runtime state (surface speed, wound length, dancer position) is never exported; only the authored configuration is. The browser recomputes the state itself.

Use the normal realvirtual GLB export. Nothing about the path geometry is exported — the browser solves the tangents and the wrap arcs from the roller poses, exactly as Unity does.

## Performance

The kinematics runs after all drives, once per fixed tick, and allocates nothing. The band mesh is rewritten only when a roller actually moved or a roll changed size, and only once per rendered frame. A slitter with two strips and nine rollers costs well under 0.1 ms per tick.

If a very long strip outgrows its sample buffer, its sample density is halved automatically and the console says so. When that happens on one strip of a slitter and not on its sibling, the cut lands on a slightly different point for each of them; the console names both webs. The fix is a lower **Samples Per Meter** for the whole slitter, or a shorter longest strip.

## Troubleshooting

**The web is built but stands still.** No roller of the path carries a rotational Drive. Put one on the roller that pulls the web, with its **Direction** on the roller's axis.

**A roller stays a follower although it has a Drive.** The drive is linear, or its axis is not parallel to the roller axis. The console names the roller and the deviation.

**The path is inert.** The console gives the reason: fewer than two rollers, a winder in the middle, a roller whose axis deviates by more than 2 degrees, or two rollers whose circles have no tangent (one swallows the other, or two opposite-side rollers overlap).

**The two strips of a slitter split before the cut.** They resolved **Ribbon Side** differently on a shared roller, which is physically impossible for one web. The console names the roller. Move the offending roller, or pin **Ribbon Side** explicitly on the shared rollers.

**A roller stands still after combining meshes.** It should not: ribbon rollers, winder roll meshes and dancers get their own combine buckets. If you see it, check that the roller component is on the node that actually moves.

## See Also

* [Drive](/components-and-scripts/motion/drive.md) — the rotational drive that moves the web
* [Chain](/components-and-scripts/motion/chain.md) — closed chains and their elements
* [TransportSurface](/components-and-scripts/motion/transportsurface.md) — the moving-surface counterpart for discrete parts


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://doc.realvirtual.io/components-and-scripts/motion/ribbon-handling.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.