# Agent Spatial avec LangChain : L'IA qui Raisonne en 3D

> Tutoriel avancé sur la création d'un Agent IA Spatial avec LangChain et Python. Connectez GPT-4 à vos données 3D pour l'analyse sémantique.

- Adresse : https://fr.learngeodata.eu/blog/langchain-3d-agent-spatial
- Rubrique : Articles techniques
- Langue : fr
- Auteur : Dr. Florent Poux (https://fr.learngeodata.eu/formateur/florent-poux)
- Éditeur : 3D Geodata Academy (organisme de formation, France)
- Index du site pour les assistants : https://fr.learngeodata.eu/llms.txt
- Publié le 2025-12-24

---
## 1. Le Concept : LLM as a Controller

Un LLM (Large Language Model) comme GPT-4 ne "voit" pas la 3D. Il ne peut pas traiter un fichier `.las` de 1 Go. Cependant, il excelle pour la **planification logique** et l'appel d'outils (Tool Calling). Notre but est de créer une interface textuelle où le LLM agit comme le chef de chantier, ordonnant à des scripts Python spécialisés d'exécuter l'analyse géométrique.

## 2. Création des Outils Géométriques (Tools)

Dans LangChain, un `Tool` est une fonction Python encapsulée avec une description textuelle que le LLM peut lire. C'est via cette description que le modèle "comprend" quand utiliser l'outil.

```
from langchain.tools import tool
import numpy as np

@tool
def count_objects_in_scene(category: str) -> str:
    """Compte le nombre d'objets d'une catégorie donnée (ex: 'chaise', 'mur') dans la scène chargée."""
    # Logique métier factice ou réelle connectée à une DB
    count = db.query(f"SELECT COUNT(*) FROM objects WHERE label='{category}'")
    return f"Il y a {count} {category}s dans la scène."

@tool
def get_object_dimensions(object_id: int) -> str:
    """Retourne les dimensions (L x l x H) d'un objet spécifique donnée par son ID."""
    bbox = get_bbox(object_id)
    return f"Dimensions : {bbox.extent} m"
```

## 3. L'Architecture de l'Agent

Nous utilisons un agent de type `OpenAI Functions Agent` qui est optimisé pour structurer les appels de fonctions en JSON. L'agent reçoit la question utilisateur, décide (Reasoning) quel outil appeler, reçoit le résultat de l'outil (Observation), et formule une réponse finale.

La boucle d'un agent spatial. Le modèle de langage ne mesure rien : il choisit un outil et lit ce que celui-ci renvoie. Toute la fiabilité tient à cette séparation, car un modèle interrogé sur une distance invente une réponse plausible, tandis qu'une fonction géométrique en calcule une vraie.

## 4. Exemple de Flux Conversationnel

Voici ce qui se passe sous le capot pour la requête : "Y a-t-il assez de place pour un camion de 3m de large entre le bâtiment A et B ?"

1. **Raisonnement :** Je dois trouver la distance entre bâtiment A et B. J'ai un outil `measure_min_distance`. Je dois d'abord trouver les IDs de A et B.
2. **Action 1 :** `find_object_id(name="Batiment A")` -> ID: 412
3. **Action 2 :** `find_object_id(name="Batiment B")` -> ID: 890
4. **Action 3 :** `measure_min_distance(id1=412, id2=890)` -> 2.85m
5. **Réponse finale :** Non, la distance minimale est de 2.85m, ce qui est insuffisant pour un camion de 3m.

```
from langchain.agents import initialize_agent, AgentType
from langchain.chat_models import ChatOpenAI

llm = ChatOpenAI(temperature=0, model="gpt-4-turbo")
tools = [count_objects_in_scene, get_object_dimensions, measure_distance]

agent = initialize_agent(
    tools, llm, 
    agent=AgentType.OPENAI_FUNCTIONS, 
    verbose=True
)

agent.run("Analyse le fichier scan.laz et liste les conflits potentiels.")
```

## 5. Limitations et Sécurité

Puisque nous exécutons du code Python (parfois généré), le "Sandboxing" est vital. Ne donnez jamais un accès `os.system` à votre agent. Limitez les outils à des fonctions de lecture seule (Read-Only) pour commencer.

### Construisez le JARVIS du BTP

Notre Masterclass "Spatial AI Agents" vous donne le plan complet pour créer des assistants intelligents pour Revit, CloudCompare et Blender.

[Le programme et les tarifs →](https://fr.learngeodata.eu/tarifs)