LangChain pour Débutants : Construisez Votre Premier Agent IA

LangChain est le framework le plus populaire pour construire des applications d'intelligence artificielle en production. Si vous utilisez déjà l'API OpenAI directement, LangChain vous propulsera au niveau supérieur : des agents qui recherchent sur internet, lisent vos documents et exécutent des tâches complexes.

Qu'est-ce que LangChain ?

LangChain est un framework open-source en Python (et JavaScript) qui simplifie la construction d'applications avec des LLMs. Au lieu de gérer manuellement les prompts, la mémoire et les outils, LangChain abstrait tout avec des composants réutilisables.

Problèmes qu'il résout :

• Donner de la mémoire à l'IA entre les conversations
• Connecter l'IA à vos documents et bases de données
• Construire des agents qui utilisent des outils (recherche web, calculatrice, APIs)
• Enchaîner plusieurs appels IA dans des pipelines

Installation

pip install langchain langchain-openai langchain-community chromadb python-dotenv

Créez un fichier .env :

OPENAI_API_KEY=votre-clé-api-ici

Concepts Fondamentaux

Models (Modèles)

from langchain_openai import ChatOpenAI
model = ChatOpenAI(model="gpt-4o-mini", temperature=0)

Prompt Templates

from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un expert en {sujet}."),
    ("user", "{question}")
])

Chains (Chaînes)

LangChain Expression Language (LCEL) connecte les composants avec | :

from langchain_core.output_parsers import StrOutputParser

chain = prompt | model | StrOutputParser()
résultat = chain.invoke({"sujet": "Python", "question": "Que sont les décorateurs ?"})

Ajouter de la Mémoire à Votre Chatbot

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage, AIMessage

model = ChatOpenAI(model="gpt-4o-mini")

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant utile."),
    MessagesPlaceholder(variable_name="historique"),
    ("user", "{input}")
])

chain = prompt | model
historique = []

def chat(message: str) -> str:
    réponse = chain.invoke({
        "historique": historique,
        "input": message
    })
    historique.append(HumanMessage(content=message))
    historique.append(AIMessage(content=réponse.content))
    return réponse.content

print(chat("Bonjour, je m'appelle Marie"))
print(chat("Comment je m'appelle ?"))  # Se souvient !

Système RAG : IA qui Répond depuis Vos Documents

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain_core.documents import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

documents = [
    Document(page_content="LearnGeni propose 30 guides IA à 5$ chacun."),
    Document(page_content="Les utilisateurs ont un accès à vie après l'achat."),
]

embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents, embeddings)
retriever = vectorstore.as_retriever()

prompt = ChatPromptTemplate.from_template("""
Répondez en utilisant le contexte :

Contexte : {contexte}
Question : {question}
""")

model = ChatOpenAI(model="gpt-4o-mini")

chain = (
    {"contexte": retriever, "question": RunnablePassthrough()}
    | prompt
    | model
)

résultat = chain.invoke("Combien coûtent les guides LearnGeni ?")
print(résultat.content)

Votre Premier Agent avec Outils

from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.tools import tool

@tool
def obtenir_meteo(ville: str) -> str:
    """Obtient la météo d'une ville."""
    return f"Météo à {ville} : 18°C, ensoleillé"

@tool
def calculer(expression: str) -> str:
    """Calcule une expression mathématique."""
    try:
        return str(eval(expression))
    except:
        return "Erreur de calcul"

outils = [obtenir_meteo, calculer]
model = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Tu es un assistant qui peut utiliser des outils."),
    ("user", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

agent = create_tool_calling_agent(model, outils, prompt)
executor = AgentExecutor(agent=agent, tools=outils, verbose=True)

résultat = executor.invoke({"input": "Quel temps fait-il à Paris ? Et combien font 15 × 23 ?"})
print(résultat["output"])

Vous voulez apprendre LangChain de zéro à niveau avancé ? Le guide complet de LearnGeni inclut des projets réels, du code exécutable et les meilleures pratiques de 2026. Voir tous les guides.