LangChain : construction d'agents

LangChain est un framework pour construire des applications LLM, transformant les appels de modèles en systèmes d'application composables, contrôlables et évolutifs.

Ce que LangChain résout n'est pas comment appeler des modèles, mais :

  • Comment organiser un raisonnement multi-étapes
  • Comment intégrer des données externes
  • Comment les outils peuvent être appelés en toute sécurité par les modèles
  • Comment le contexte est géré sur le long terme

Dépôt open source :https://github.com/langchain-ai/langchain。

Tutoriel LangChain :https://www.example.com/langchain/langchain-tutorial.html

Imaginez que vous construisez un assistant robot intelligent. Cet assistant doit comprendre vos questions, rechercher des informations auprès de diverses sources, effectuer un raisonnement logique et enfin vous répondre en langage naturel. Utiliser uniquement un modèle de langage comme GPT, c'est comme donner au robot seulement un cerveau intelligent, mais il lui manque encore des mains et des yeux—il ne sait pas comment obtenir des données externes ni exécuter des tâches spécifiques.

LangChainC'est exactement un tel framework, jouant le rôle de connecteur et de coordinateur.

LangChainIl connecte intelligemment des modèles de langage puissants (tels que GPT-4, DeepSeek) à des sources de données externes, des outils de calcul et des systèmes de mémoire afin de créer des applications d'IA puissantes et pratiques.

En termes simples, la valeur essentielle de LangChain réside dans :Rendre les modèles de langage utiles, ce qui répond à plusieurs limites clés des grands modèles de langage (LLM) :

  1. Connaissance en temps réel: les données d'entraînement des LLM ont une date limite et ne permettent pas d'obtenir les informations les plus récentes.
  2. Spécialisation par domaine: les LLM généraux manquent de connaissances privées propres à un secteur ou à une entreprise.
  3. Capacité d'action: les LLM eux-mêmes ne peuvent pas effectuer d'actions telles que des calculs, des requêtes de base de données, des appels d'API, etc.
  4. Cohérence de la conversation: dans les conversations à plusieurs tours, les LLM doivent se souvenir de l'historique de discussion précédent.

LangChain organise ces capacités au moyen d'une série de chaînes et de composants standardisés, permettant aux développeurs de construire rapidement des applications d'IA complexes comme avec des briques de construction.

Background Top: Your AI Application Your AI Application Arrow: from top to middle layer Middle layer: LangChain framework (large box) LangChain Framework First row modules Models Model Interfaces Prompts Prompts Chains Chains/Flows Second row modules Memory Memory Retrieval Retrieval Agents & Tools Agents and Tools Arrow: from middle layer to bottom Bottom: External Resources LLM API Vector Database External Tools/APIs Arrow Legend

Aperçu des modules de LangChain :

  • LLMs / ChatModels: Interfaces de modèles
  • Modèles de prompts: Structuration des prompts
  • Chaînes: Orchestration des workflows
  • Mémoire: Gestion du contexte
  • Récupérateurs / VectorStores: Récupération de connaissances
  • Agents et outils: Prise de décision et exécution automatiques

Préparation de l’environnement

Installer en utilisant un miroir domestique :

pip install langchain langchain-openai langchain-community python-dotenv -i https://mirrors.aliyun.com/pypi/simple/

Si vous utilisez OpenAI, vous pouvez configurer les variables d’environnement :

export OPENAI_API_KEY=你的key

Testez ensuite avec le code suivant :

Exemple

from langchain_openai import ChatOpenAI


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


resp = llm.invoke("Expliquez ce qu’est LangChain en une phrase")
print(resp.content)

En Chine, nous pouvons utiliser le grand modèle DeepSeek pour les tests. Si vous n'en avez pas encore, vous devez d'abord vous rendre surhttps://platform.deepseek.com/api_keysCréer une clé API.

Référence pour la documentation de l'API DeepSeek :https://api-docs.deepseek.com/zh-cn/。

Si vous devez gérer de manière centralisée plusieurs modèles de tiers, vous pouvez choisir d'installer LiteLLM comme passerelle de modèles :

pip install -U litellm

Cependant, les exemples de cet article utilisent directementChatOpenAIavecopenai_api_basele paramètre pour se connecter à DeepSeek, sans avoir besoin d'installer LiteLLM séparément.

Exemple

import os
from langchain_openai import ChatOpenAI

# Il est recommandé de placer la clé d'API dans une variable d'environnement, ou de la définir directement ici (ne la codez pas en dur en production).
# os.environ["DEEPSEEK_API_KEY"] = "sk-your-DeepSeek-secret-key"

# Initialiser le modèle
llm = ChatOpenAI(
    model="deepseek-v4-pro",             # Nom du modèle DeepSeek V4
    openai_api_key="sk-your-Key",        # Renseignez votre clé d'API DeepSeek
    openai_api_base="https://api.deepseek.com", # Point de terminaison de l'API DeepSeek
    temperature=0.7,
    max_tokens=1024
)

# Testez-le
response = llm.invoke("Bonjour, DeepSeek ! Veuillez faire une brève présentation de vous-même.")
print(response.content)

L'exécution du code ci-dessus affichera :

你好!很高兴认识你!

我是DeepSeek,由深度求索公司创造的AI助手。我的特点包括:
。。。

Création de chaînes LCEL (LangChain Expression Language)

Appeler simplement le modèle n'est pas suffisamment puissant ; nous devons construire un pipeline de traitement standard :

Prompt -> LLM -> OutputParser
Background Step 1: User Input User Input {"concept": "quantum entanglement"} Arrow 1 + Pipe | Step 2: Prompt Template Prompt Template Fill variables Arrow 2 + Pipe | Step 3: ChatModel ChatModel DeepSeek / GPT Arrow 3 + Pipe | Step 4: OutputParser OutputParser Parse output Arrow 4 Step 5: Output Result Output Result Plain text Bottom note LCEL uses the pipe operator | to connect components, and data flows from left to right. Arrow definitions

Le code complet est le suivant :

Exemple

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

# 1. Définir le modèle (Model)
llm = ChatOpenAI(
    model="deepseek-v4-pro",
    openai_api_key="your_DEEPSEEK_API_KEY",
    openai_api_base="https://api.deepseek.com"
)

# 2. Définir le modèle de prompt (Prompt)
# system: Définir le rôle de l'IA
# user: L'entrée spécifique de l'utilisateur
prompt = ChatPromptTemplate.from_messages([
    ("system", "Vous êtes un expert technique senior qui excelle dans l'explication de concepts technologiques complexes dans un langage simple et facile à comprendre. Votre explication doit inclure une analogie vivante."),
    ("user", "{concept}")
])

# 3. Définir l'analyseur de sortie (Output Parser)
# Convertir directement l'objet Message du modèle en une chaîne de caractères simple
parser = StrOutputParser()

# 4. Construire la chaîne (Chain) - utiliser l'opérateur pipe | pour connecter
# Flux : dictionnaire d'entrée -> remplir le Prompt -> envoyer au LLM -> analyser la sortie
chain = prompt | llm | parser

# 5. Appeler la chaîne
concept_to_explain = Intrication quantique
print(fExplication du concept : {concept_to_explain}...\n")

result = chain.invoke({"concept": concept_to_explain})

print(--- Réponse DeepSeek ---)
print(result)

Sortie en streaming

Dans les applications réelles (comme les chatbots), nous devons afficher le texte caractère par caractère comme ChatGPT, plutôt que de tout afficher d'un coup une fois la génération terminée.

LangChain prend en charge cela très simplement, en utilisant.stream()au lieu de.invoke():

Exemple

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

# 1. Définir le modèle
llm = ChatOpenAI(
    model="deepseek-v4-pro",
    openai_api_key=your_DEEPSEEK_API_KEY,
    openai_api_base="https://api.deepseek.com"
)

# 2. Définir le modèle de prompt
# system: Définir le rôle de l'IA
# user: L'entrée spécifique de l'utilisateur
prompt = ChatPromptTemplate.from_messages([
    ("system", "Vous êtes un expert technique senior, doué pour expliquer des concepts techniques complexes dans un langage courant simple et facile à comprendre. Votre explication doit inclure une métaphore vivante."),
    ("user", "{concept}")
])

# 3. Définir l'analyseur de sortie
# Convertir directement l'objet Message du modèle en une chaîne simple
parser = StrOutputParser()

# 4. Construire la chaîne - en utilisant le pipe | pour connecter
# Flux : dictionnaire d'entrée -> remplir le Prompt -> envoyer au LLM -> analyser la sortie
chain = prompt | llm | parser

# 5. Appeler la chaîne
concept_to_explain = Intrication quantique
print(fExplication du concept : {concept_to_explain} (sortie en flux)...\n")

# Ici, chunk est l'extrait généré à chaque fois
for chunk in chain.stream({"concept": Réseau de neurones récursif}):
    print(chunk, end="", flush=True)

Structure du code

Prompt

  • ChatPromptTemplateDistinguer clairementsystem / user
  • Prompt estune fonction d'entrée structurée, pas une chaîne de caractères

LLM

  • ChatOpenAIsimplement une interface unifiée
  • LangChain n'améliore pas les capacités du modèle, améliore seulementla contrôlabilité

OutputParser

  • La sortie du modèle est toujoursMessage
  • StrOutputParserOuiconversion de type explicite
  • Sans Parser, le projet est incontrôlable.

Explication des composants principaux

1. Modèles

LangChain fournit une interface d'abstraction unifiée. Actuellement, il est principalement recommandé d'utiliserChat Models, car les modèles actuels (tels que DeepSeek, GPT-4) sont majoritairement optimisés pour la conversation.

  • Chat Models: les entrées et les sorties sont des messages structurés.
  • SystemMessage: Définir le rôle de l'IA.
  • HumanMessage: Messages envoyés par l'utilisateur.
  • AIMessage: Le message renvoyé par l'IA.

2. Prompts

Dans la nouvelle version, il est recommandé d'utiliserChatPromptTemplatepour construire des prompts conversationnels, ce qui correspond mieux aux conventions d'appel des LLM grand public actuels.

from langchain_core.prompts import ChatPromptTemplate

# 使用 from_messages 构建结构化模板
prompt_template = ChatPromptTemplate.from_messages([
    ("system", "你是一位专业的{role}。"),
    ("user", "{content}")
])

# 动态填充变量
prompt = prompt_template.invoke({"role": "美食评论家", "content": "评价一下这碗炸酱面"})
# 输出:包含 SystemMessage 和 HumanMessage 的列表

3. Chaînes et LCEL

Mises à jour importantes : LLMChaina été déprécié. Utilisez désormaisLCEL (opérateur pipe|)syntaxe. Cette approche est plus flexible et prend en charge la sortie asynchrone et en streaming.

# 现代写法:Prompt | Model | OutputParser
from langchain_core.output_parsers import StrOutputParser

# 这里的 llm 是 ChatOpenAI(model="deepseek-v4-pro") 的实例
chain = prompt_template | llm | StrOutputParser()

# 调用链
result = chain.invoke({"role": "导游", "content": "介绍一下故宫"})
print(result) # 直接输出字符串

4. Index et récupération

C'estRAG (Retrieval-Augmented Generation)au cœur. La nouvelle version met l'accent sur le processus de transformation des documents en "retrievers".

  • Processus: DocumentLoaders(Chargement) ->TextSplitter(Découpage) ->Embeddings(Vectorisation) ->VectorStore(Stockage).
  • Retriever: Il ne s'agit plus seulement d'une recherche dans une base de données ; c'est un composant qui peut être intégré dans une chaîne.
# 将向量库转为检索器
retriever = vectorstore.as_retriever()
# 在新版链中引用
# chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm

Exemple pratique complet de RAG

Ci-dessous, nous allons implémenter une application RAG complète. Tout d'abord, nous devons installer des dépendances supplémentaires :

pip install langchain-community faiss-cpu sentence-transformers -i https://mirrors.aliyun.com/pypi/simple/

Exemple

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_community.embeddings import HuggingFaceEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain_community.vectorstores import FAISS
from langchain.text_splitter import RecursiveCharacterTextSplitter

# Charger les variables d'environnement
load_dotenv()

# Initialiser le modèle et l'Embedding
llm = ChatOpenAI(
    model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
    openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
    openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# Utiliser un modèle d'Embedding local gratuit (téléchargé automatiquement lors de la première exécution)
embeddings = HuggingFaceEmbeddings(
    model_name="sentence-transformers/all-MiniLM-L6-v2"
)

# --- 1. Préparer les documents de connaissances ---
# Dans de vrais projets, ces documents peuvent être chargés depuis des fichiers, des pages web, des bases de données, etc.
documents = [
    "LangChain est un framework open source pour créer des applications de grands modèles de langage, créé par Harrison Chase en 2022.",
    "Les composants principaux de LangChain incluent : interfaces de modèle, modèles de prompt, chaînes, mémoire, récupération et agents.",
    "LCEL (LangChain Expression Language) est la syntaxe de nouvelle génération de LangChain pour construire des chaînes, utilisant l'opérateur pipe | pour connecter des composants.",
    "RAG (Retrieval-Augmented Generation) récupère les documents pertinents avant la génération, permettant aux LLM de répondre à des questions au-delà des données d'entraînement.",
    "LangGraph est un nouveau framework publié par l'équipe LangChain, spécifiquement pour construire des workflows complexes d'agents IA à plusieurs étapes.",
    "LangSmith est la plateforme d'observabilité de LangChain pour le débogage, les tests et la surveillance des applications LLM.",
]

# --- 2. Découpage du texte ---
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=100,
    chunk_overlap=20
)
# Les documents ici sont déjà courts ; dans des scénarios réels, les documents longs sont divisés en plusieurs segments
texts = text_splitter.create_documents(documents)

# --- 3. Vectoriser et stocker dans FAISS ---
vectorstore = FAISS.from_documents(texts, embeddings)

# --- 4. Créer un récupérateur ---
retriever = vectorstore.as_retriever(search_kwargs={"k": 2})

# --- 5. Construire la chaîne RAG ---
rag_prompt = ChatPromptTemplate.from_messages([
    ("system", Vous êtes un assistant de connaissances. Répondez à la question en vous basant sur le contexte récupéré ci-dessous. Si la réponse ne figure pas dans le contexte, dites que vous ne savez pas.\n\nContexte : {context}),
    ("human", "{question}")
])

# Fonction utilitaire : concaténer les documents récupérés en une chaîne
def format_docs(docs):
    return "\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

# --- 6. Tester RAG ---
question = Quels sont les composants principaux de LangChain ?
print(fQuestion : {question})
print(fRéponse : {rag_chain.invoke(question)})
Explication des points techniques clés de RAG :
  • FAISSC'est la bibliothèque open source de recherche de similarité vectorielle de Facebook, adaptée au développement et aux tests locaux, avec les données stockées en mémoire.
  • Environnement de productionIl est recommandé d'utiliser des bases de données vectorielles professionnelles telles que Pinecone, Milvus, Chroma et Weaviate, qui prennent en charge la persistance et le déploiement distribué.
  • Modèle d'embedding: : Cet exemple utilise celui de HuggingFaceall-MiniLM-L6-v2Modèle : sera automatiquement téléchargé lors de la première exécution (environ 80MB).
  • Si vous disposez d'une clé API OpenAI, vous pouvez également l'utiliser.OpenAIEmbeddingsObtenez de meilleurs résultats en chinois.
  • Recommandé pour les scénarios chinois domestiques.BAAI/bge-small-zh-v1.5etc. Modèles d'embedding chinois
  • chunk_sizeetchunk_overlapDoivent être ajustés en fonction des caractéristiques réelles du document ; une valeur trop grande peut faire perdre en précision, une valeur trop petite peut faire perdre le contexte.

5. Mémoire

Mise à jour importante :traditionnelConversationBufferMemoryIl est relativement difficile de l'intégrer dans des chaînes LCEL complexes. La dernière recommandation est d'utiliserChatMessageHistorycoopérationRunnableWithMessageHistory。

  • Logique centraleLa mémoire n'est plus une propriété de la chaîne, mais un dépôt de messages indépendant, viasession_idDistinguer entre différents utilisateurs.
  • persistancePrend en charge le stockage dans Redis, PostgreSQL ou en mémoire.

6. Agents

Agent est l'une des fonctionnalités les plus puissantes de LangChain. Contrairement à Chain, les agents peuvent agir en fonction des entrées de l'utilisateur.Prise de décision autonomeQuels outils appeler, et dans quel ordre les exécuter, voilà le véritable « agent ».

Boucle principale de l'Agent : recevoir une tâche -> réfléchir (choisir un outil) -> exécuter l'outil -> observer le résultat -> continuer à réfléchir ou donner la réponse finale.

Background Left: User Input User input Arrow: user input to thinking. Loop region background Agent decision loop Step 1: Think/Reason Think/Reason LLM analyzes the task Step 2: Select tool Select tool Decide which one to call Step 3: Execute tool Execute tool Call and get result Step 4: Observe result Observe result Analyze the tool's return Loop arrow Annotation: Need more information Need more Information Right side: Final answer Final answer Task complete Arrow: from observe result to final answer Task complete Arrow definition

Utilisation@toolLe décorateur peut transformer n'importe quelle fonction Python en un outil appelable par un LLM. LangChain transmet automatiquement le nom de la fonction et la docstring au modèle, permettant au modèle de savoir quand et comment utiliser cet outil.

Voici un exemple pratique complet d'Agent, contenant trois outils : requête météo, calcul mathématique et recherche de connaissances :

Exemple

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

# Charger les variables d'environnement
load_dotenv()

# Initialiser le modèle DeepSeek
llm = ChatOpenAI(
    model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
    openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
    openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# --- Définir les outils ---
# En utilisant le décorateur @tool, LangChain informe automatiquement le modèle du nom de la fonction et de sa docstring

@tool
def get_current_weather(city: str) -> str:
    """Obtenir les informations météorologiques actuelles pour une ville spécifiée. Utiliser cet outil lorsque l'utilisateur pose des questions sur la météo."""
    # Dans de vraies applications, une véritable API météo serait appelée ici.
    weather_data = {
        "Beijing": "Ensoleillé, température 28°C, humidité 45%",
        "Shanghai": "Nuageux, température 25°C, humidité 70%",
        "Shenzhen": "Averses orageuses, température 30°C, humidité 85%",
    }
    return weather_data.get(city, f"Désolé, aucune donnée météo disponible pour {city}.")

@tool
def calculate(expression: str) -> str:
    """Calculer des expressions mathématiques. Utilisez cet outil lorsque l'utilisateur a besoin d'effectuer des calculs mathématiques.
Prend en charge les quatre opérations arithmétiques de base, par exemple '2 + 3 * 4'."""

    import ast
    import operator
   
    # Mappage sécurisé des opérateurs
    ops = {
        ast.Add: operator.add,
        ast.Sub: operator.sub,
        ast.Mult: operator.mul,
        ast.Div: operator.truediv,
        ast.Pow: operator.pow,
        ast.USub: operator.neg,
    }
   
    def safe_eval(node):
        if isinstance(node, ast.Expression):
            return safe_eval(node.body)
        elif isinstance(node, ast.Constant):
            return node.value
        elif isinstance(node, ast.BinOp):
            left = safe_eval(node.left)
            right = safe_eval(node.right)
            return ops[type(node.op)](left, right)
        elif isinstance(node, ast.UnaryOp):
            operand = safe_eval(node.operand)
            return ops[type(node.op)](operand)
        else:
            raise ValueError(f"Type d'expression non pris en charge : {type(node)}")
   
    try:
        tree = ast.parse(expression, mode='eval')
        result = safe_eval(tree)
        return f"Résultat du calcul : {expression} = {result}"
    except Exception as e:
        return f"Erreur de calcul : {e}"

@tool
def search_knowledge(query: str) -> str:
    """Recherchez dans la base de connaissances pour obtenir des informations pertinentes. Utilisez cet outil lorsque l'utilisateur pose des questions factuelles."""
    # Dans les applications réelles, cela se connecterait à une base de données vectorielle ou à un moteur de recherche.
    knowledge = {
        "LangChain": LangChain est un framework open source pour créer des applications LLM, prenant en charge les appels en chaîne, la gestion de la mémoire et l'intégration d'outils.,
        "Python": Python est un langage de programmation de haut niveau connu pour sa simplicité et sa lisibilité, largement utilisé en IA, science des données et dans d'autres domaines.,
    }
    for key, value in knowledge.items():
        if key.lower() in query.lower():
            return value
    return f"Aucune information relative à '{query}' n'a été trouvée"

# --- Assembler la liste des outils ---
tools = [get_current_weather, calculate, search_knowledge]

# --- Créer l'invite de l'Agent ---
prompt = ChatPromptTemplate.from_messages([
    ("system", Vous êtes un assistant IA puissant qui peut utiliser des outils pour aider les utilisateurs. En fonction de la question de l'utilisateur, déterminez si un outil est nécessaire et choisissez l'outil le plus approprié pour obtenir des informations.),
    ("human", "{input}"),
    MessagesPlaceholder(variable_name="agent_scratchpad"),
])

# --- Créer l'Agent ---
agent = create_tool_calling_agent(llm, tools, prompt)

# --- Créer AgentExecutor (exécuteur d'agent) ---
# verbose=True vous permet de voir tout le processus de réflexion de l'Agent
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# --- Agent de test ---
# Test 1 : Requête météo
print("=" * 50)
response = agent_executor.invoke({"input": Quel temps fait-il à Pékin aujourd'hui ?})
print(f"\nRéponse finale : {response['output']}")

# Test 2 : Calcul mathématique
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": Aide-moi à calculer combien fait (15 * 37 + 228) / 3})
print(f"\nRéponse finale : {response['output']}")

# Test 3 : Question complète (l'Agent doit décider quel outil utiliser)
print("\n" + "=" * 50)
response = agent_executor.invoke({"input": Qu'est-ce que LangChain ? Aide-moi aussi à calculer 2 à la puissance 10.})
print(f"\nRéponse finale : {response['output']}")

Exécutez le code ci-dessus et vous verrez(sortie de chaîne de raisonnement lorsque verbose=True) :

==================================================

> Entering new AgentExecutor chain...
Invoking: `get_current_weather` with `{'city': '北京'}`

晴天,气温 28°C,湿度 45%

根据查询结果,北京今天的天气是晴天,气温 28°C,湿度 45%。

> Finished chain.

Final answer: 北京今天天气晴朗,气温 28°C,湿度 45%,适合外出活动。

==================================================

> Entering new AgentExecutor chain...
Invoking: `calculate` with `{'expression': '(15 * 37 + 228) / 3'}`

计算结果:(15 * 37 + 228) / 3 = 261.0

> Finished chain.

Final answer: (15 * 37 + 228) / 3 的计算结果是 261.0

==================================================

> Entering new AgentExecutor chain...
Invoking: `search_knowledge` with `{'query': 'LangChain'}`
Invoking: `calculate` with `{'expression': '2 ** 10'}`

LangChain 是一个用于构建 LLM 应用的开源框架...
计算结果:2 ** 10 = 1024

> Finished chain.

Final answer: LangChain 是一个用于构建 LLM 应用的开源框架,支持链式调用、记忆管理和工具集成。另外,2 的 10 次方等于 1024。
Conseil de sécurité :Cet exemple utilise une analyse AST sécurisée au lieu de eval(). Dans de vrais projets, n'utilisez jamais eval() directement sur une entrée utilisateur, car cela présente un risque sérieux d'exécution de code à distance.
Comprendre le "processus de réflexion" de l'Agent :
  • verbose=TrueCela nous permet de voir la chaîne de décision complète de l'Agent, ce qui facilite le débogage et la compréhension de son comportement.
  • L'Agent détermine automatiquement quels outils appeler, sans qu'il soit nécessaire de spécifier manuellement l'ordre des appels.
  • Si la question ne nécessite pas d'outils (par exemple, une simple conversation informelle), l'Agent répondra directement en utilisant ses propres connaissances.
  • Pour les problèmes complexes, l'Agent peut appeler des outils plusieurs fois, ou même appeler plusieurs outils en parallèle.

Démarrage rapide : Créez votre première application LangChain

Découvrons la commodité de LangChain avec un exemple simple.

Dans un développement réel, nous pouvons enregistrer les informations liées à l'API dans le répertoire racine du projet.envDans le fichier, pour une utilisation pratique.

# .env 文件内容
DEEPSEEK_API_KEY=sk-xxx
DEEPSEEK_BASE_URL=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-v4-pro
Lors de l'utilisation de ChatOpenAI de LangChain, il est recommandé de configurer openai_api_base sur https://api.deepseek.com, pas besoin d'ajouter manuellement /v1, LangChain concaténera automatiquement le chemin.

Exemple 1 : Chaîne de questions-réponses de base

Exemple

import os
from dotenv import load_dotenv
# Chemin d'import correct
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI

# Charger les variables d'environnement
load_dotenv()

llm = ChatOpenAI(
    model=os.getenv('DEEPSEEK_MODEL'),
    openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
    openai_api_base=os.getenv('DEEPSEEK_BASE_URL'),
)

# Créer un modèle de prompt
template = """
Vous êtes un assistant amical.
Veuillez répondre à la question suivante :

Question : {question}
Réponse :
"""

prompt = PromptTemplate.from_template(template)

# Créer une chaîne avec la syntaxe LCEL (approche recommandée)
# Structure : Prompt -> LLM -> convertir en chaîne
chain = prompt | llm | StrOutputParser()

# Exécuter la chaîne
question = "Qu'est-ce que LangChain ? Quels sont ses principaux usages ?"

response = chain.invoke({"question": question})

print("Question :", question)
print("-" * 20)
print("Réponse :", response)

Exemple 2 : Chaîne de conversation avec mémoire

Créons un chatbot simple qui peut se souvenir de l'historique de conversation.

Exemple

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.chat_history import BaseChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

# 1. Charger la configuration
load_dotenv()

# 2. Initialiser le modèle DeepSeek
llm = ChatOpenAI(
    model=os.getenv('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
    openai_api_key=os.getenv('DEEPSEEK_API_KEY'),
    openai_api_base=os.getenv('DEEPSEEK_BASE_URL', 'https://api.deepseek.com'),
)

# 3. Définir le modèle de prompt
# MessagesPlaceholder sera rempli avec l'historique de conversation à l'exécution
prompt = ChatPromptTemplate.from_messages([
    ("system", "Vous êtes un assistant IA utile."),
    MessagesPlaceholder(variable_name="history"),
    ("human", "{question}"),
])

# 4. Construire la chaîne
chain = prompt | llm

# 5. Gérer la mémoire : créer un dictionnaire pour stocker les enregistrements d'historique pour différents utilisateurs
store = {}

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

# 6. Envelopper notre chaîne avec RunnableWithMessageHistory
# De cette manière, LangChain gérera automatiquement la lecture et la mise à jour des enregistrements d'historique
with_message_history = RunnableWithMessageHistory(
    chain,
    get_session_history,
    input_messages_key="question",
    history_messages_key="history",
)

# 7. Entrer dans la boucle de conversation
print("--- Mode de chat DeepSeek activé (tapez 'exit' pour quitter) ---")
session_config = {"configurable": {"session_id": "user_001"}} # Distinguer les identifiants des différentes sessions

while True:
    user_input = input("Vous : ")
    if user_input.lower() in ["exit", "quit", "exit"]:
        break
       
    # Appeler la chaîne avec mémoire
    response = with_message_history.invoke(
        {"question": user_input},
        config=session_config
    )
   
    print(f"AI: {response.content}"\n")

Exécutez le code ci-dessus, vous verrez:

--- 已进入 DeepSeek 聊天模式 (输入 'exit' 退出) ---
You: 你好
AI: 你好!很高兴见到你! 有什么我可以帮助你的吗?无论是回答问题、聊天,还是协助解决问题,我都很乐意为你提供帮助!

You: 我叫小明
AI: 你好,小明!很高兴认识你! 
如果你有任何问题、想法,或者需要帮助的地方,随时告诉我哦~

You: 我叫什么记得吗?
AI: 当然记得!你刚刚告诉我你叫**小明**~  
我会认真记住我们的对话内容,在之后的交流中尽量保持上下文连贯。不过如果对话过长或间隔太久,我可能需要你提醒一下哦~  
有什么想聊的或需要帮助的吗? 

Résumé

Cet article présente les concepts fondamentaux et les applications pratiques du framework LangChain. LangChain permet aux développeurs de créer rapidement des applications d'IA puissantes grâce à des composants standardisés et des appels chaînés.

Le tableau suivant résume les points clés abordés dans cet article :

Concept Description Code clé
Chaîne LCEL Utilisez l'opérateur pipe | pour connecter Prompt, Model, Parser chain = prompt | llm | parser
Modèle de prompt Prompt structuré, distinction des rôles système/utilisateur ChatPromptTemplate.from_messages()
Sortie en streaming Sortie mot par mot pour améliorer l'expérience utilisateur chain.stream()
Mémoire de conversation Gérer l'historique de conversation multi-tours via session_id RunnableWithMessageHistory
RAG (génération augmentée par récupération) Intégration de connaissances externes pour dépasser les limites de connaissances des LLM retriever | format_docs
Agent Prise de décision autonome pour appeler des outils, la fonctionnalité avancée la plus centrale create_tool_calling_agent()

Parcours d'apprentissage recommandé

Background Step 1 LangChain basics Arrow 1 Step 2 LCEL chain Arrow 2 Step 3 RAG application Arrow 3 Step 4 Agent Arrow 4 Step 5 LangGraph workflow Arrow 5 Step 6 LangSmith monitoring Arrow definitions
Autres extensions