# Les composants de base de LangGraph

Pour créer des applications avec LangGraph, vous devez comprendre ses composants principaux. Explorons les blocs fondamentaux qui constituent une application LangGraph.

Une application dans LangGraph commence à partir d'un **point d'entrée**, et selon l'exécution, le flux peut aller vers une fonction ou une autre jusqu'à ce qu'il atteigne la FIN.

## 1. État

L'**état** est le concept central dans LangGraph. Il représente toutes les informations qui circulent à travers votre application.

```python
from typing_extensions import TypedDict

class State(TypedDict):
    graph_state: str
```

L'état est **défini par l'utilisateur**, donc les champs doivent être soigneusement conçus pour contenir toutes les données nécessaires au processus de prise de décision !

> 💡 **Astuce :** Réfléchissez soigneusement aux informations que votre application doit suivre entre les étapes.

## 2. Nœuds

Les **nœuds** sont des fonctions Python. Chaque nœud :
- Prend l'état en entrée
- Effectue une opération
- Retourne des mises à jour de l'état

```python
def node_1(state):
    print("---Node 1---")
    return {"graph_state": state['graph_state'] +" I am"}

def node_2(state):
    print("---Node 2---")
    return {"graph_state": state['graph_state'] +" happy!"}

def node_3(state):
    print("---Node 3---")
    return {"graph_state": state['graph_state'] +" sad!"}
```

Par exemple, les nœuds peuvent contenir :
- **Appels de LLM** : Générer du texte ou prendre des décisions
- **Appels d'outils** : Interagir avec des systèmes externes
- **Logique conditionnelle** : Déterminer les prochaines étapes
- **Intervention humaine** : Obtenir des contributions des utilisateurs

> 💡 **Info :** Certains nœuds nécessaires pour l'ensemble du *workflow* comme *START* et *END* existent directement dans *LangGraph*.

## 3. Arêtes

Les **arêtes** connectent les nœuds et définissent les chemins possibles à travers votre graphe :

```python
import random
from typing import Literal

def decide_mood(state) -> Literal["node_2", "node_3"]:
    
    # Souvent, nous utiliserons l'état pour décider du prochain nœud à visiter
    user_input = state['graph_state'] 
    
    # Ici, faisons juste une répartition 50/50 entre les nœuds 2, 3
    if random.random() 

Mais plus important encore, l'invocation :

```python
graph.invoke({"graph_state" : "Hi, this is Lance."})
```

ressort :

```
---Node 1---
---Node 3---
{'graph_state': 'Hi, this is Lance. I am sad!'}
```

## Et maintenant ?

Dans la prochaine section, nous mettrons ces concepts en pratique en construisant notre premier graphe. Ce graphe permet à Alfred de prendre vos emails, les classifier, et rédiger une réponse préliminaire s'ils sont authentiques.