> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.

# LLM

> La classe LLM enregistre un appel d’API LLM sous forme de span de chat.

```python theme={"system"}
class LLM(BaseModel): ...
```

Un appel d’API LLM. Correspond à un span OTel de type chat.

`LLM` est un modèle Pydantic. Vous pouvez définir chacun des champs ci-dessous comme argument nommé lors de sa construction.

`LLM` est un gestionnaire de contexte et peut être utilisé dans une instruction `with`.

<h2 id="fields">
  Champs
</h2>

| Champ | Type | Par défaut |
| - | - | - |
| `model` | `str` | `''` |
| `provider_name` | `str` | `''` |
| `response_id` | `str` | `''` |
| `response_model` | `str` | `''` |
| `output_type` | `str` | `''` |
| `system_instructions` | `list[str]` | `[]` |
| `usage` | `Usage` | `Usage()` |
| `reasoning` | `Reasoning` | `Reasoning()` |
| `finish_reasons` | `list[str]` | `[]` |
| `input_messages` | `list[Message]` | `[]` |
| `output_messages` | `list[Message]` | `[]` |
| `media_attachments` | `list[MediaAttachment]` | `[]` |
| `request_temperature` | `Union[float, None]` | `None` |
| `request_max_tokens` | `Union[int, None]` | `None` |
| `request_top_p` | `Union[float, None]` | `None` |
| `request_top_k` | `Union[float, None]` | `None` |
| `request_frequency_penalty` | `Union[float, None]` | `None` |
| `request_presence_penalty` | `Union[float, None]` | `None` |
| `request_seed` | `Union[int, None]` | `None` |
| `request_stop_sequences` | `list[str]` | `[]` |
| `request_choice_count` | `Union[int, None]` | `None` |
| `started_at` | `Union[datetime, None]` | `None` |
| `ended_at` | `Union[datetime, None]` | `None` |

<h2 id="methods">
  Méthodes
</h2>

<h3 id="output">
  output
</h3>

```python theme={"system"}
def output(content: str) -> LLM: ...
```

Ajoute un message de l’assistant à output\_messages.

<h3 id="think">
  think
</h3>

```python theme={"system"}
def think(content: str) -> LLM: ...
```

Définit le contenu du raisonnement (chaîne de pensée).

<h3 id="attach_media">
  attach\_media
</h3>

```python theme={"system"}
def attach_media(
    *,
    content: Union[bytes, str] = '',
    uri: str = '',
    file_id: str = '',
    mime_type: str = '',
    modality: str = '',
) -> LLM: ...
```

Joint un média à cet appel LLM.

Une seule source exactement est requise. Les octets sont encodés en base64 sous forme de blob
GenAI inline. Le contenu de type chaîne doit déjà être encodé en base64. Les URI et les
ID de fichiers du fournisseur sont émis sous forme de parties GenAI de type URI et fichier.

<h3 id="attach_media_url">
  attach\_media\_url
</h3>

```python theme={"system"}
def attach_media_url(url: str, *, modality: str = '') -> LLM: ...
```

Joint une URL de données ou un URI de média classique à cet appel LLM.

<h3 id="record">
  record
</h3>

```python theme={"system"}
def record(
    *,
    input_messages: Union[list[Message], None] = None,
    output_messages: Union[list[Message], None] = None,
    media_attachments: Union[list[MediaAttachment], None] = None,
    usage: Union[Usage, None] = None,
    reasoning: Union[Reasoning, str, None] = None,
    response_id: Union[str, None] = None,
    response_model: Union[str, None] = None,
    finish_reasons: Union[list[str], None] = None,
    output_type: Union[str, None] = None,
) -> LLM: ...
```

Définit plusieurs champs d’appel LLM en un seul appel.

Les agents instrumentés manuellement construisent généralement un span de chat en
attribuant au moins huit champs individuels à la fin d’un appel
LLM (`input_messages`, `output_messages`, `usage`,
`response_id`, etc.). `record(...)` les regroupe en un
seul appel à arguments nommés, ce qui garde le code d’enregistrement compact.

Seuls les champs explicitement transmis (autres que `None`) sont appliqués ;
les valeurs existantes sont conservées. `reasoning` accepte soit une
instance de `Reasoning`, soit une simple chaîne de caractères (encapsulée automatiquement).
Renvoie `self` pour permettre le chaînage.

<h3 id="end">
  end
</h3>

```python theme={"system"}
def end() -> None: ...
```

<h3 id="start">
  start
</h3>

```python theme={"system"}
def start() -> Self: ...
```

Démarre ce span une seule fois ; l’entrée dans le gestionnaire de contexte utilise le même chemin.

<h3 id="record_error">
  record\_error
</h3>

```python theme={"system"}
def record_error(error: BaseException) -> Self: ...
```

Enregistre un échec sans terminer le span ; appelez `end()` le moment venu.

<h3 id="set_attributes">
  set\_attributes
</h3>

```python theme={"system"}
def set_attributes(attributes: dict[str, Any]) -> Self: ...
```

Appose des attributs OTel arbitraires sur ce span.

Passez un dict, que vous ayez une seule clé ou plusieurs ; pour une seule clé,
utilisez `span.set_attributes({"weave.tag": "value"})`. Équivalent de
`Span.set_attributes` d'OTel.

Doit être appelée après le démarrage du span par une fabrique `start_*`, par `start()` ou par `with`,
et avant sa fin. En dehors de cette fenêtre, l'appel est
sans effet et journalise un avertissement. Pour l'ingestion par lots, renseignez directement les champs déclarés de l'objet
et passez-le à `log_turn` / `log_conversation`.