Guide LangChain : Premier Agent IA en Python

Qu'est-ce que LangChain ?

LangChain est un framework open-source Python (et JavaScript) qui simplifie la construction d'applications utilisant des LLM (Large Language Models). Lancé fin 2022, il est devenu le standard de facto pour orchestrer des appels LLM, des outils externes et de la mémoire dans une même application cohérente.

Ce que LangChain résout concrètement : Sans framework, construire une application LLM signifie gérer manuellement les appels API, la gestion du contexte, la sérialisation des messages, la gestion des erreurs et les retries, l'intégration d'outils externes, et la persistance de l'historique de conversation. LangChain abstrait tout cela avec des interfaces standardisées.

Les composants principaux de LangChain :

• LLMs et ChatModels : interfaces unifiées pour GPT, Claude, Mistral, Gemini, Ollama et plus de 50 autres modèles
• PromptTemplates : gestion structurée des prompts avec variables et formatage
• Chains : séquences d'opérations composables (prompt → LLM → parser → tool → ...)
• Agents : systèmes autonomes qui décident quels outils utiliser selon la requête
• Tools : fonctions exposées à l'agent (recherche web, calcul, API, base de données)
• Memory : gestion de l'historique conversationnel
• Retrievers : interfaces pour la recherche de documents (RAG)
• Output Parsers : structuration de la sortie LLM en objets Python

LangChain vs LangGraph vs LlamaIndex : lequel choisir ?

Règle pratique : Commencez avec LangChain pour 90 % des projets. Ajoutez LangGraph si votre agent doit gérer des états complexes ou des cycles. Utilisez LlamaIndex si votre projet est centré sur l'ingestion de documents (vous pouvez combiner LlamaIndex pour le RAG et LangChain pour l'agent).

Installation et configuration de l'environnement

Un environnement Python propre est la base de tout projet LangChain sérieux. Voici la procédure recommandée :

1. Créer l'environnement virtuel :

# Créer et activer l'environnement virtuel
python -m venv .venv
source .venv/bin/activate  # Linux/Mac
# .venv\Scripts\activate   # Windows

# Vérifier la version Python
python --version  # 3.11.x ou 3.12.x recommandé

2. Installer LangChain et ses dépendances :

# Core LangChain
pip install langchain langchain-core langchain-community

# Intégration OpenAI (ou choisissez votre LLM)
pip install langchain-openai

# Variables d'environnement
pip install python-dotenv

# Utilitaires
pip install httpx pydantic

3. Configurer les clés API dans un fichier .env :

# .env — NE JAMAIS committer ce fichier
OPENAI_API_KEY=sk-proj-...
# ANTHROPIC_API_KEY=sk-ant-...
# MISTRAL_API_KEY=...
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls__...  # Pour LangSmith (optionnel)

Les composants essentiels de LangChain

Avant d'écrire du code, comprendre les 5 abstractions clés de LangChain vous évitera beaucoup de confusion :

1. ChatModels : les wrappers LLM. ChatOpenAI, ChatAnthropic, ChatMistralAI... Ils exposent tous la même interface : invoke(messages), stream(messages), batch(list_messages). Changer de LLM = changer une ligne.

2. Messages : les types de messages LangChain respectent le format OpenAI : HumanMessage (utilisateur), AIMessage (assistant), SystemMessage (instruction système), ToolMessage (résultat d'outil). Tout est typé avec Pydantic.

3. PromptTemplates : ChatPromptTemplate vous permet de définir des prompts paramétriques réutilisables. Les variables sont injectées avec {variable}.

4. Output Parsers : transforment la réponse string du LLM en objets Python structurés. StrOutputParser (texte brut), JsonOutputParser, PydanticOutputParser (vers un modèle Pydantic).

5. Runnables : l'interface commune de LCEL. Tout composant LangChain moderne est un Runnable avec les méthodes invoke, stream, batch, ainvoke (async). Les Runnables se composent avec l'opérateur |.

Créer sa première chain LangChain

Une chain est une séquence de Runnables composés avec LCEL. Voici un exemple complet et fonctionnel :

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

load_dotenv()

# 1. Définir le modèle
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)

# 2. Définir le prompt
prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant expert en {domaine}. Réponds en français, de façon concise et pratique."),
    ("human", "{question}")
])

# 3. Parser la sortie
parser = StrOutputParser()

# 4. Composer la chain avec LCEL (pipe operator)
chain = prompt | llm | parser

# 5. Utiliser la chain
reponse = chain.invoke({
    "domaine": "automatisation des processus",
    "question": "Quels sont les 3 premiers processus à automatiser dans une PME ?"
})
print(reponse)

La puissance de LCEL réside dans la facilité de composition. Vous pouvez ajouter des étapes n'importe où dans le pipe, passer des inputs en parallèle avec RunnableParallel, ou ajouter de la logique conditionnelle avec RunnableBranch.

Streaming la réponse :

# Streaming token par token pour une meilleure UX
for chunk in chain.stream({"domaine": "RH", "question": "Comment automatiser l'onboarding ?"}):
    print(chunk, end="", flush=True)

Créer un agent LangChain avec des outils

Un agent va plus loin qu'une chain : il décide de manière autonome quels outils utiliser et dans quel ordre, en fonction de la requête. Le LLM joue le rôle d'un "cerveau" qui planifie et délègue.

Définir des outils avec le décorateur @tool :

from langchain_core.tools import tool
from datetime import datetime

@tool
def get_current_date() -> str:
    """Retourne la date et l'heure actuelles en français."""
    now = datetime.now()
    return now.strftime("%A %d %B %Y à %H:%M")

@tool
def calculate(expression: str) -> str:
    """Calcule une expression mathématique simple. Exemples: '2 + 2', '150 * 0.20'"""
    try:
        result = eval(expression, {"__builtins__": {}})
        return f"Résultat : {result}"
    except Exception as e:
        return f"Erreur de calcul : {str(e)}"

tools = [get_current_date, calculate]

Créer l'agent avec AgentExecutor :

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile. Utilise les outils disponibles pour répondre précisément. Réponds toujours en français."),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# Tester l'agent
result = agent_executor.invoke({"input": "Quel jour sommes-nous et combien font 15% de 3500 euros ?"})
print(result["output"])

Gérer la mémoire conversationnelle

Par défaut, chaque appel à un agent est stateless : il ne se souvient pas des échanges précédents. Pour un chatbot, c'est rédhibitoire. LangChain propose plusieurs approches selon vos besoins.

RunnableWithMessageHistory (approche moderne recommandée) :

from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# Stockage en mémoire (dict de sessions)
store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# Adapter le prompt pour inclure l'historique
prompt_with_history = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant commercial expert. Réponds en français."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{input}"),
])

chain = prompt_with_history | llm | StrOutputParser()

chain_with_memory = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="input",
    history_messages_key="history",
)

# Utiliser avec un session_id
config = {"configurable": {"session_id": "user_123"}}
reponse1 = chain_with_memory.invoke({"input": "Mon budget est de 5000 euros."}, config=config)
reponse2 = chain_with_memory.invoke({"input": "Quelles solutions me recommandes-tu ?"}, config=config)

Types de mémoire selon le cas d'usage :

• ChatMessageHistory (in-memory) : idéal pour les tests et prototypes. Les données sont perdues au redémarrage.
• RedisChatMessageHistory : persistance Redis pour la production. Gère plusieurs utilisateurs simultanés.
• SQLChatMessageHistory : persistance SQL pour les environnements sans Redis.
• Fenêtre glissante : conservez seulement les N derniers messages pour maîtriser les coûts de tokens.

LCEL : la syntaxe moderne de LangChain

LCEL (LangChain Expression Language) est la syntaxe de composition introduite en LangChain 0.2 qui remplace toutes les classes de chains héritées. Elle repose sur l'opérateur | (pipe) et des primitives simples.

Composition parallèle avec RunnableParallel :

from langchain_core.runnables import RunnableParallel, RunnablePassthrough

# Exécuter deux analyses en parallèle
analyse_parallele = RunnableParallel(
    resume=prompt_resume | llm | StrOutputParser(),
    points_cles=prompt_points_cles | llm | StrOutputParser(),
)

# RunnablePassthrough passe l'input tel quel
chain_avec_contexte = (
    RunnableParallel({"context": retriever, "question": RunnablePassthrough()})
    | prompt_rag
    | llm
    | StrOutputParser()
)

Avantages de LCEL :

• Streaming automatique : chaque composant peut streamer sa sortie vers le suivant
• Batch natif : chain.batch([input1, input2, input3]) pour le traitement en masse
• Async natif : await chain.ainvoke(input) sans configuration supplémentaire
• Observabilité : chaque étape est automatiquement tracée dans LangSmith

Déboguer et monitorer avec LangSmith

LangSmith est la plateforme d'observabilité officielle de LangChain. Elle trace chaque appel LLM, chaque étape de chain et chaque appel d'outil avec tous les inputs/outputs, latences et coûts.

Activer LangSmith en 2 variables d'environnement :

# Dans votre .env
LANGCHAIN_TRACING_V2=true
LANGCHAIN_API_KEY=ls__votre_cle_api
LANGCHAIN_PROJECT=mon-projet-pme  # optionnel

C'est tout. Dès que ces variables sont définies, toutes vos chains et agents envoient automatiquement leurs traces à LangSmith. Aucune modification de code n'est nécessaire.

Ce que vous pouvez faire avec LangSmith :

• Inspecter chaque étape d'une chain avec les inputs/outputs exacts
• Identifier les étapes lentes (latence par step)
• Suivre les coûts en tokens par requête et par projet
• Créer des datasets de test à partir de traces réelles
• Comparer les performances entre deux versions d'un prompt
• Détecter les erreurs et les réponses de mauvaise qualité

Déployer son agent avec FastAPI

Une fois votre agent fonctionnel, exposez-le via une API FastAPI pour l'intégrer à votre site web, votre application ou vos outils internes.

from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from pydantic import BaseModel
from dotenv import load_dotenv

load_dotenv()
app = FastAPI(title="Agent IA AutomateIA")

app.add_middleware(
    CORSMiddleware,
    allow_origins=["https://votre-site.fr"],
    allow_methods=["POST"],
    allow_headers=["*"],
)

class ChatRequest(BaseModel):
    message: str
    session_id: str = "default"

class ChatResponse(BaseModel):
    response: str

@app.post("/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    try:
        config = {"configurable": {"session_id": request.session_id}}
        result = await chain_with_memory.ainvoke(
            {"input": request.message},
            config=config
        )
        return ChatResponse(response=result)
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
def health():
    return {"status": "ok"}

Démarrer le serveur :

pip install fastapi uvicorn
uvicorn main:app --host 0.0.0.0 --port 8000 --reload

3 exemples concrets pour PME françaises

Voici trois cas d'usage représentatifs que nous implémentons régulièrement avec nos clients :

Exemple 1 : Chatbot FAQ sur la documentation produit

Architecture : LangChain + RAG (LlamaIndex pour l'ingestion) + pgvector. Le chatbot répond aux questions clients en s'appuyant sur vos fiches techniques, manuels et FAQ. Les réponses incluent automatiquement les sources. Temps de mise en place : 5 à 8 jours. Bénéfice typique : réduction de 40 à 60 % des tickets support de niveau 1.

Exemple 2 : Agent de recherche et synthèse

Architecture : LangChain Agent + outils web (Tavily Search) + outil de résumé. L'agent recherche des informations sur vos concurrents, les actualités de votre secteur ou des appels d'offres, et produit une synthèse structurée directement dans votre outil de reporting. Temps de mise en place : 3 à 5 jours. Bénéfice typique : 2 à 4 heures de veille manuelle économisées par semaine.

Exemple 3 : Résumeur et extracteur de documents

Architecture : LangChain Chain + Map-Reduce pour les longs documents + PydanticOutputParser. Traite en batch des contrats, rapports ou emails pour en extraire les informations clés dans un format structuré (JSON) directement intégrable dans votre CRM ou ERP. Temps de mise en place : 2 à 4 jours. Bénéfice typique : traitement de 50 documents en 5 minutes au lieu de 5 heures.

LangChain abaisse considérablement la barrière technique pour construire des agents IA opérationnels. Un développeur Python débutant peut produire un premier prototype fonctionnel en quelques jours. La clé pour passer du prototype à la production est l'évaluation rigoureuse, le monitoring via LangSmith, et une architecture de mémoire adaptée à vos volumes.

Si vous souhaitez être accompagné dans la construction de votre premier agent LangChain ou dans le déploiement d'un système complet, AutomateIA peut vous apporter son expertise technique et sa connaissance des cas d'usage PME.