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

# Session & cycle de vie

> Créer, réutiliser et réinitialiser un LanguageModelSession au bon moment

Avec Foundation Models, une session représente un contexte de génération. Le modèle se souvient de ce qui s'est passé dans cette session, ainsi que des instructions et des tools que vous lui avez donnés.

Le bon pattern est simple : **une session doit rester ciblée**.

***

## Créer une session

```swift theme={null}
import FoundationModels

let session = LanguageModelSession()
```

Ou avec un cadrage plus précis :

```swift theme={null}
let session = LanguageModelSession(
    instructions: """
    You help intermediate Swift developers.
    Keep answers concise.
    """
)
```

Ou encore avec des tools :

```swift theme={null}
let session = LanguageModelSession(
    tools: [WeatherTool()]
)
```

***

## Quand réutiliser une session

Réutilisez la même session si :

* vous êtes dans une conversation multi-tours
* la tâche reste la même
* le contexte précédent est encore utile

Exemple : un chat ou un assistant attaché à une feature précise.

***

## Quand créer une nouvelle session

Créez une nouvelle session si :

* vous changez de tâche
* vous changez de rôle ou d'instructions
* le contexte précédent n'aide plus
* la conversation est devenue trop longue

Exemple : ne réutilisez pas la même session pour une aide culinaire puis une analyse de ticket produit.

***

## Un bon pattern avec un view model

```swift theme={null}
import FoundationModels
import Observation

@Observable
@MainActor
final class ChatViewModel {
    var messages: [String] = []
    var errorMessage: String?
    var isResponding: Bool { session.isResponding }

    private var session = LanguageModelSession(
        instructions: "You are a concise assistant."
    )

    func send(_ prompt: String) async {
        errorMessage = nil

        do {
            let response = try await session.respond(to: prompt)
            messages.append("Vous : \(prompt)")
            messages.append("IA : \(response.content)")
        } catch {
            errorMessage = error.localizedDescription
        }
    }

    func resetConversation() {
        session = LanguageModelSession(
            instructions: "You are a concise assistant."
        )
        messages.removeAll()
    }
}
```

Cette structure vous donne un cycle de vie clair et évite une session globale trop floue.

***

## `transcript`

La session maintient un transcript. Il peut être utile pour :

* inspecter la conversation
* debugger le comportement
* comprendre pourquoi une réponse a été influencée par le contexte précédent

Gardez en tête que plus le transcript grossit, plus la session devient coûteuse en contexte.

Apple documente aussi `init(model:tools:transcript:)` pour **réhydrater** une session à partir d'un historique existant.

```swift theme={null}
import FoundationModels

let existingSession = LanguageModelSession()
let savedTranscript = existingSession.transcript

let restoredSession = LanguageModelSession(
    model: SystemLanguageModel.default,
    tools: [],
    transcript: savedTranscript
)
```

C'est utile si vous voulez reprendre une conversation, restaurer un brouillon ou déplacer l'état d'une feature entre plusieurs écrans.

***

## `isResponding`

La propriété `isResponding` est la façon la plus simple de protéger votre UI contre les doubles envois :

```swift theme={null}
Button("Envoyer") {
    Task { await viewModel.send(userPrompt) }
}
.disabled(viewModel.isResponding)
```

Dans votre code produit, vous l'utiliserez souvent via un view model plutôt que directement depuis la vue.

***

## `prewarm`

Le prewarming sert à réduire le coût du premier appel quand vous savez qu'une fonctionnalité IA va être utilisée.

```swift theme={null}
let session = LanguageModelSession()
session.prewarm()
```

Apple documente `prewarm(promptPrefix:)` pour un cas plus précis : charger les ressources de la session tout en mettant en cache un début de prompt commun.

Vous pouvez l'utiliser :

* quand une vue IA va s'ouvrir
* quand l'utilisateur se prépare à interagir
* quand la feature fait partie du parcours principal

Si votre feature répète toujours le même cadrage, ce préfixe commun peut réduire la latence du premier vrai appel.

Ne prewarmez pas partout par défaut. Faites-le seulement pour les flows qui le justifient.

***

## Le piège le plus courant

Le mauvais réflexe consiste à partager une seule session dans toute l'app. Cela crée vite :

* un contexte pollué
* des responsabilités floues
* des collisions entre features

Préférez :

* une session par conversation
* ou une session par feature clairement identifiée

***

<CardGroup cols={2}>
  <Card title="Streaming & UX" icon="bolt" href="/mlx/foundation-models/streaming-ux">
    Afficher proprement les réponses.
  </Card>

  <Card title="Patterns d'architecture" icon="sitemap" href="/mlx/foundation-models/architecture-patterns">
    Transformer ces principes en architecture d'app.
  </Card>
</CardGroup>