Tutoriel Python LangChain : Guide complet pour débutants
Ce guide vous accompagne dans la configuration de LangChain, un framework Python pour la création d'applications d'IA, en mettant en lumière ses composants et fonctionnalités principaux.
LangChaîne est une Python Un framework qui simplifie le processus de création d'applications d'IA basées sur de grands modèles de langage (LLM). Il fournit des outils pour gérer les invites, conserver la mémoire et intégrer des systèmes externes, permettant ainsi aux développeurs de créer des workflows complexes tels que des chatbots, des analyseurs de documents et des assistants de recherche. Contrairement aux appels d'API de base, LangChaîne Structure des processus en plusieurs étapes, facilitant ainsi la création de solutions d'IA évolutives. Que vous automatisiez le support client ou résumiez des documents, LangChaîne contribue à rationaliser le développement, économisant ainsi du temps et des efforts.
Pour les novices en IA, ce tutoriel propose un guide étape par étape pour configurer LangChain, couvrant tous les aspects, de l'installation de packages à la création de workflows. Des outils comme Laténode Vous pouvez visualiser et prototyper ces flux de travail sans codage complexe. À l'issue de cette formation, vous serez en mesure de créer des applications d'IA prêtes à la production et adaptées à vos besoins.
LangChaîne Maîtrise en 2025 | Cours complet de 5 heures [LangChaîne v0.3]
Configuration de votre LangChain Python Environnement
Un environnement bien préparé permet de gagner du temps lors du dépannage et de vous concentrer sur la création d’applications d’IA.
Installation de LangChain et des packages nécessaires
Pour démarrer avec LangChain, assurez-vous d'avoir installé Python 3.8 ou une version ultérieure. Vous pouvez vérifier votre version de Python en exécutant :
python --version
Si vous avez besoin d'une mise à jour, téléchargez la dernière version depuis python.org.
Ensuite, installez LangChain en utilisant pip :
pip install langchain
Cette opération installe la bibliothèque principale, mais des packages supplémentaires sont souvent nécessaires selon les besoins de votre projet. Par exemple :
Pour s'intégrer à OpenAI modèles, installez le OpenAI emballage:
pip install langchain-openaiPour Étreindre le visage modèles, utilisez le package communautaire :
pip install langchain-communityPour les tâches de traitement de documents telles que les systèmes de questions-réponses ou l'analyse de documents, installez :
pip install langchain-text-splitters pypdf
Il est recommandé de créer un environnement virtuel pour votre projet afin d'éviter les conflits de dépendances. Configurez-le avec :
python -m venv langchain_env
<span class="hljs-built_in">source</span> langchain_env/bin/activate <span class="hljs-comment"># On Windows: langchain_env\Scripts\activate</span>
Une fois activé, installez les packages requis. Cela permet d'isoler et de gérer les dépendances de votre projet.
Configuration des clés API et des variables d'environnement
L'utilisation efficace de LangChain implique souvent de se connecter à des services externes, comme l'API d'OpenAI. Pour ce faire, vous devrez configurer des clés API sécurisées.
Commencez par générer votre clé API sur la plateforme OpenAI à l'adresse plateforme.openai.comAccédez à la section Clés API, créez une nouvelle clé et copiez-la immédiatement, car elle ne sera affichée qu'une seule fois.
Pour stocker vos clés API en toute sécurité, utilisez des variables d'environnement. Voici comment les configurer :
Pour Windows, utilisez l'invite de commande :
setx OPENAI_API_KEY "your-api-key-here"Redémarrez votre terminal pour appliquer des modifications permanentes. Pour des tests temporaires, utilisez :
<span class="hljs-built_in">set</span> OPENAI_API_KEY=your-api-key-herePour macOS et Linux, ajoutez la ligne suivante à votre profil shell (par exemple,
.bashrcor.zshrc):<span class="hljs-built_in">export</span> OPENAI_API_KEY=<span class="hljs-string">"your-api-key-here"</span>Appliquer les modifications avec
source ~/.bashrcou redémarrez votre terminal.
Alternativement, vous pouvez utiliser un .env Dans le répertoire de votre projet, utilisez un fichier pour gérer les variables d'environnement. Cela permet de centraliser les informations d'identification :
OPENAI_API_KEY=your-api-key-here
ANTHROPIC_API_KEY=your-anthropic-key-here
HUGGINGFACE_API_TOKEN=your-hf-token-here
Installez l' python-dotenv package pour charger ces variables dans vos scripts :
pip install python-dotenv
Ensuite, incluez cet extrait au début de vos fichiers Python :
<span class="hljs-keyword">from</span> dotenv <span class="hljs-keyword">import</span> load_dotenv
load_dotenv()
Cette méthode garantit que vos clés API restent sécurisées et accessibles dans différents environnements.
Conseils de configuration spécifiques à la plate-forme
Différents systèmes d'exploitation peuvent présenter des difficultés spécifiques lors de la configuration de LangChain. Voici comment les résoudre :
WindowsLes problèmes liés au chemin d'accès et aux interférences antivirus sont fréquents. Si vous rencontrez l'erreur « commande introuvable », assurez-vous que votre répertoire de scripts Python se trouve dans le chemin d'accès de votre système. Pour les utilisateurs de WSL (sous-système Windows pour Linux), installez LangChain dans l'environnement Linux afin d'éviter les problèmes de compatibilité.
macOSLes utilisateurs de puces Apple Silicon (M1/M2) peuvent bénéficier de performances optimisées, mais peuvent nécessiter des versions de package spécifiques. Si l'installation de pip échoue, essayez d'utiliser conda :
conda install langchain -c conda-forgeCertaines dépendances peuvent également nécessiter des outils de ligne de commande Xcode, que vous pouvez installer avec :
xcode-select --installLinuxL'installation est généralement plus fluide, mais les gestionnaires de paquets varient. Pour Ubuntu ou Debian, assurez-vous que les en-têtes de développement Python sont installés :
<span class="hljs-built_in">sudo</span> apt-get install python3-dev python3-pipSur CentOS ou RHEL, utilisez :
<span class="hljs-built_in">sudo</span> yum install python3-devel python3-pip
Quelle que soit votre plateforme, gardez à l'esprit que travailler localement avec des modèles linguistiques volumineux nécessite une quantité importante de RAM. Si 8 Go peuvent suffire pour les modèles plus petits, 16 Go ou plus sont recommandés pour la production. Par ailleurs, les API cloud comme OpenAI éliminent les contraintes de mémoire locale, ce qui en fait un choix pratique pour de nombreux projets.
Pour les débutants, des outils visuels comme Latenode peuvent simplifier l'apprentissage. Latenode permet d'expérimenter les workflows LangChain dans une interface intuitive par glisser-déposer. Cette approche est particulièrement utile pour les débutants, car elle leur permet de comprendre les concepts de manière concrète avant de se lancer dans le code.
Une fois votre environnement prêt, vous êtes prêt à explorer les composants principaux de LangChain et à commencer à créer des solutions basées sur l'IA.
Composants principaux de LangChain
LangChain est construit avec des éléments modulaires qui permettent aux développeurs de créer Flux de travail pilotés par l'IA efficacement. En comprenant ses composants clés, vous pouvez exploiter le potentiel de création d'applications d'IA diversifiées et efficaces.
LLM et modèles de chat
LangChain prend en charge deux types clés de modèles de langage : LLM (Grands modèles de langage) et Modèles de discussionChacun a un objectif unique, influençant la manière dont vous concevez les invites et gérez les réponses.
LLM Conçus pour la saisie semi-automatique de texte, ils sont efficaces pour générer du texte, résumer des informations ou créer du contenu. Par exemple :
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAI
llm = OpenAI(temperature=<span class="hljs-number">0.7</span>)
response = llm.invoke(<span class="hljs-string">"Write a brief explanation of machine learning:"</span>)
<span class="hljs-built_in">print</span>(response)
Modèles de discussion, en revanche, sont conçus pour les conversations structurées. Ils gèrent des rôles tels que « système », « humain » et « assistant », ce qui les rend idéaux pour les dialogues interactifs :
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.schema <span class="hljs-keyword">import</span> HumanMessage, SystemMessage
chat = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
messages = [
SystemMessage(content=<span class="hljs-string">"You are a helpful AI assistant."</span>),
HumanMessage(content=<span class="hljs-string">"Explain the difference between Python lists and tuples."</span>)
]
response = chat.invoke(messages)
<span class="hljs-built_in">print</span>(response.content)
L'espace la réactivité Le paramètre joue un rôle crucial dans la définition des résultats. Des valeurs faibles (par exemple, 0.1 à 0.3) produisent des réponses plus précises et cohérentes, tandis que des valeurs élevées (par exemple, 0.7 à 1.0) encouragent la créativité et la variabilité.
Ensuite, nous explorerons comment les modèles d’invite simplifient et standardisent les interactions avec ces modèles.
Modèles d'invite
Les modèles d'invites sont un moyen pratique de créer des invites structurées et réutilisables. Ils vous permettent de définir un modèle une fois pour toutes et d'insérer dynamiquement des variables, ce qui permet de gagner du temps et de garantir la cohérence.
Un basique Modèle d'invite fonctionne comme une f-string Python mais offre une validation et un formatage supplémentaires :
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
template = PromptTemplate(
input_variables=[<span class="hljs-string">"product"</span>, <span class="hljs-string">"audience"</span>],
template=<span class="hljs-string">"Write a marketing email for {product} targeting {audience}. Keep it under 200 words and include a clear call-to-action."</span>
)
prompt = template.<span class="hljs-built_in">format</span>(product=<span class="hljs-string">"AI writing software"</span>, audience=<span class="hljs-string">"small business owners"</span>)
Pour les conversations multi-rôles, Modèle d'invite de discussion fournit une manière structurée de gérer les entrées dynamiques :
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> ChatPromptTemplate
chat_template = ChatPromptTemplate.from_messages([
(<span class="hljs-string">"system"</span>, <span class="hljs-string">"You are an expert {domain} consultant with 10 years of experience."</span>),
(<span class="hljs-string">"human"</span>, <span class="hljs-string">"I need advice about {problem}. Please provide 3 specific recommendations."</span>)
])
formatted_prompt = chat_template.format_messages(
domain=<span class="hljs-string">"digital marketing"</span>,
problem=<span class="hljs-string">"improving email open rates"</span>
)
Invite à quelques tirs est une autre technique qui inclut des exemples dans le modèle pour guider la compréhension du modèle :
few_shot_template = PromptTemplate(
input_variables=[<span class="hljs-string">"input_text"</span>],
template=<span class="hljs-string">"""
Classify the sentiment of these examples:
Text: "I love this product!"
Sentiment: Positive
Text: "This is terrible quality."
Sentiment: Negative
Text: "It's okay, nothing special."
Sentiment: Neutral
Text: "{input_text}"
Sentiment:
"""</span>
)
Les modèles d’invite facilitent la gestion des flux de travail complexes en standardisant la manière dont les entrées sont construites.
Chaînes
Les chaînes sont des flux de travail qui relient plusieurs composants pour réaliser des tâches complexes. Chaque étape s'appuie sur les résultats de la précédente, créant ainsi un processus fluide.
L'exemple le plus simple est un LLMChaîne, qui combine un modèle de langage avec un modèle d'invite :
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> LLMChain
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"Write a 3-paragraph blog post introduction about {topic}"</span>
)
chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run(topic=<span class="hljs-string">"sustainable energy solutions"</span>)
Pour des flux de travail plus complexes, Chaînes séquentielles Permet d'enchaîner plusieurs étapes. Par exemple, vous pouvez créer un plan de blog, rédiger une introduction, puis une conclusion :
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SimpleSequentialChain
<span class="hljs-comment"># First chain: Generate outline</span>
outline_chain = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"Create a detailed outline for a blog post about {topic}"</span>
)
)
<span class="hljs-comment"># Second chain: Write introduction based on outline</span>
intro_chain = LLMChain(
llm=llm,
prompt=PromptTemplate(
input_variables=[<span class="hljs-string">"outline"</span>],
template=<span class="hljs-string">"Based on this outline, write an engaging introduction:{outline}"</span>
)
)
<span class="hljs-comment"># Combine chains</span>
overall_chain = SimpleSequentialChain(
chains=[outline_chain, intro_chain],
verbose=<span class="hljs-literal">True</span>
)
final_result = overall_chain.run(<span class="hljs-string">"artificial intelligence in healthcare"</span>)
Chaînes de routeurs Ajoutez des capacités de prise de décision en dirigeant les entrées vers des sous-chaînes spécifiques en fonction du contenu. Ceci est particulièrement utile pour gérer divers types d'entrées nécessitant des réponses personnalisées.
Pour une approche plus visuelle, des outils comme Latenode peuvent simplifier la conception et la gestion de ces workflows. En visualisant la logique de la chaîne, vous pouvez mieux comprendre et affiner vos solutions d'IA.
Agents et outils
Les agents apportent de la flexibilité à vos flux de travail en prenant des décisions et en choisissant des actions de manière dynamique. Contrairement aux chaînes, qui suivent une séquence fixe, les agents adaptent leur comportement en fonction de la situation.
Outils Ce sont des fonctions que les agents peuvent utiliser pour interagir avec des systèmes externes. LangChain propose des outils intégrés, mais vous pouvez également en créer des personnalisés.
Voici un exemple d’outil intégré pour la recherche Google :
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> Tool
<span class="hljs-keyword">from</span> langchain.utilities <span class="hljs-keyword">import</span> GoogleSearchAPIWrapper
search = GoogleSearchAPIWrapper()
search_tool = Tool(
name=<span class="hljs-string">"Google Search"</span>,
description=<span class="hljs-string">"Search Google for current information"</span>,
func=search.run
)
Et voici un outil personnalisé pour calculer les variations en pourcentage :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">calculate_percentage</span>(<span class="hljs-params">input_string</span>):
<span class="hljs-string">"""Calculate percentage change between two numbers"""</span>
<span class="hljs-keyword">try</span>:
numbers = [<span class="hljs-built_in">float</span>(x.strip()) <span class="hljs-keyword">for</span> x <span class="hljs-keyword">in</span> input_string.split(<span class="hljs-string">','</span>)]
<span class="hljs-keyword">if</span> <span class="hljs-built_in">len</span>(numbers) == <span class="hljs-number">2</span>:
change = ((numbers[<span class="hljs-number">1</span>] - numbers[<span class="hljs-number">0</span>]) / numbers[<span class="hljs-number">0</span>]) * <span class="hljs-number">100</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Percentage change: <span class="hljs-subst">{change:<span class="hljs-number">.2</span>f}</span>%"</span>
<span class="hljs-keyword">return</span> <span class="hljs-string">"Please provide exactly two numbers separated by a comma"</span>
<span class="hljs-keyword">except</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"Invalid input format"</span>
calc_tool = Tool(
name=<span class="hljs-string">"Percentage Calculator"</span>,
description=<span class="hljs-string">"Calculate percentage change between two numbers. Input: 'old_value, new_value'"</span>,
func=calculate_percentage
)
Agents ReAct (Raisonnement et action) combinent prise de décision et utilisation d'outils. Ils analysent la situation, décident d'une action, utilisent des outils et évaluent le résultat.
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> create_react_agent, AgentExecutor
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
llm = ChatOpenAI(temperature=<span class="hljs-number">0</span>)
tools = [search_tool, calc_tool]
<span class="hljs-comment"># Create agent</span>
agent = create_react_agent(
llm=llm,
tools=tools,
prompt=PromptTemplate.from_template(<span class="hljs-string">"""
You are a helpful assistant. Use the available tools to answer questions accurately.
Available tools: {tool_names}
Tool descriptions: {tools}
Question: {input}
Thought: {agent_scratchpad}
"""</span>)
)
<span class="hljs-comment"># Execute agent</span>
agent_executor = AgentExecutor(agent=agent)
Les agents et les outils offrent l'adaptabilité nécessaire aux applications dynamiques du monde réel, faisant de LangChain un cadre polyvalent pour le développement de l'IA.
sbb-itb-23997f1
Créer votre première application LangChain
Apprenez à créer une application LangChain à partir de zéro pour approfondir votre compréhension de ses capacités.
Appel de base au LLM
Un appel basique au Large Language Model (LLM) constitue le point de départ pour la construction de workflows LangChain plus avancés. Voici un exemple d'application simple de génération de texte :
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> OpenAI
<span class="hljs-keyword">import</span> os
<span class="hljs-comment"># Set your API key</span>
os.environ[<span class="hljs-string">"OPENAI_API_KEY"</span>] = <span class="hljs-string">"your-api-key-here"</span>
<span class="hljs-comment"># Initialize the LLM (temperature determines creativity: 0.1-0.3 for factual, 0.7-0.9 for creative)</span>
llm = OpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Generate a response</span>
response = llm.invoke(<span class="hljs-string">"Write a professional email subject line for a product launch announcement"</span>)
<span class="hljs-built_in">print</span>(response)
Pour une application de type questions-réponses, vous pouvez structurer l'interaction avec une fonction :
<span class="hljs-keyword">def</span> <span class="hljs-title function_">ask_question</span>(<span class="hljs-params">question</span>):
prompt = <span class="hljs-string">f"""
Answer the following question clearly and concisely:
Question: <span class="hljs-subst">{question}</span>
Answer:
"""</span>
<span class="hljs-keyword">return</span> llm.invoke(prompt)
<span class="hljs-comment"># Test the function</span>
result = ask_question(<span class="hljs-string">"What are the benefits of using renewable energy?"</span>)
<span class="hljs-built_in">print</span>(result)
Cette approche simple crée une application d'IA fonctionnelle. Bien que simple, elle sert de base à des workflows plus avancés, que vous pouvez développer à l'aide de chaînes à plusieurs étapes.
Construire une chaîne à plusieurs étapes
Les chaînes à plusieurs étapes permettent un traitement séquentiel de l'information, chaque étape s'appuyant sur la précédente. Voici un exemple de générateur d'articles de blog qui décrit les sujets, rédige une introduction et ajoute un appel à l'action :
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SimpleSequentialChain
<span class="hljs-keyword">from</span> langchain.prompts <span class="hljs-keyword">import</span> PromptTemplate
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-comment"># Initialize the model</span>
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Step 1: Create an outline</span>
outline_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>],
template=<span class="hljs-string">"""
Create a detailed 5-point outline for a blog post about {topic}.
Include main points and 2-3 sub-points for each section.
Format as a numbered list.
"""</span>
)
outline_chain = outline_prompt | llm
<span class="hljs-comment"># Step 2: Write the introduction</span>
intro_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"outline"</span>],
template=<span class="hljs-string">"""
Based on this outline, write an engaging 200-word introduction:
{outline}
Make it compelling and include a hook to grab readers' attention.
"""</span>
)
intro_chain = intro_prompt | llm
<span class="hljs-comment"># Step 3: Add a call-to-action</span>
cta_prompt = PromptTemplate(
input_variables=[<span class="hljs-string">"introduction"</span>],
template=<span class="hljs-string">"""
Based on this introduction, suggest 3 relevant call-to-action options:
{introduction}
Format as: 1. [Action] - [Brief description]
"""</span>
)
cta_chain = cta_prompt | llm
<span class="hljs-comment"># Combine all steps</span>
blog_chain = SimpleSequentialChain(
chains=[outline_chain, intro_chain, cta_chain],
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Execute the chain</span>
final_result = blog_chain.invoke({<span class="hljs-string">"input"</span>: <span class="hljs-string">"sustainable web development practices"</span>})
<span class="hljs-built_in">print</span>(final_result)
Vous pouvez également créer des flux de travail qui combinent plusieurs entrées et sorties à différentes étapes :
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> SequentialChain
<span class="hljs-comment"># Research and analysis chain</span>
research_chain = PromptTemplate(
input_variables=[<span class="hljs-string">"topic"</span>, <span class="hljs-string">"audience"</span>],
template=<span class="hljs-string">"Research key points about {topic} for {audience}. List 5 main insights."</span>
) | llm
analysis_chain = PromptTemplate(
input_variables=[<span class="hljs-string">"research"</span>, <span class="hljs-string">"business_goal"</span>],
template=<span class="hljs-string">"""
Analyze this research: {research}
Create actionable recommendations for: {business_goal}
Provide 3 specific strategies with expected outcomes.
"""</span>
) | llm
<span class="hljs-comment"># Combine chains</span>
combined_chain = SequentialChain(
chains=[research_chain, analysis_chain],
input_variables=[<span class="hljs-string">"topic"</span>, <span class="hljs-string">"audience"</span>, <span class="hljs-string">"business_goal"</span>],
output_variables=[<span class="hljs-string">"final_analysis"</span>]
)
Ces chaînes multi-étapes transforment les appels d'IA simples en workflows capables de gérer des tâches complexes, permettant ainsi des résultats structurés et professionnels. Une fois ces chaînes en place, vous pouvez améliorer votre application avec des fonctionnalités telles que la mémoire et les agents.
Ajout de mémoire et d'agents
La mémoire et les agents apportent une prise de conscience du contexte et une prise de décision dynamique aux applications LangChain.
ConversationTamponMémoire garde une trace de l'intégralité de la conversation, ce qui le rend idéal pour les chatbots ou les systèmes interactifs :
<span class="hljs-keyword">from</span> langchain.memory <span class="hljs-keyword">import</span> ConversationBufferMemory
<span class="hljs-keyword">from</span> langchain.chains <span class="hljs-keyword">import</span> ConversationChain
<span class="hljs-keyword">from</span> langchain_openai <span class="hljs-keyword">import</span> ChatOpenAI
<span class="hljs-comment"># Set up memory and model</span>
memory = ConversationBufferMemory()
llm = ChatOpenAI(temperature=<span class="hljs-number">0.7</span>)
<span class="hljs-comment"># Create a conversation chain with memory</span>
conversation = ConversationChain(
llm=llm,
memory=memory,
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Test the conversation</span>
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"Hi, I'm working on a Python project about data analysis."</span>))
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"What libraries would you recommend?"</span>))
<span class="hljs-built_in">print</span>(conversation.predict(<span class="hljs-built_in">input</span>=<span class="hljs-string">"Can you explain pandas in more detail?"</span>))
<span class="hljs-comment"># View conversation history</span>
<span class="hljs-built_in">print</span>(<span class="hljs-string">"Conversation History:"</span>)
<span class="hljs-built_in">print</span>(memory.buffer)
Pour les applications nécessitant une gestion efficace de la mémoire, Mémoire de résumé de conversation condense les interactions plus anciennes :
<span class="hljs-keyword">from</span> langchain.memory <span class="hljs-keyword">import</span> ConversationSummaryMemory
summary_memory = ConversationSummaryMemory(
llm=llm,
max_token_limit=<span class="hljs-number">1000</span>
)
<span class="hljs-comment"># Automatically summarizes older conversations</span>
conversation_with_summary = ConversationChain(
llm=llm,
memory=summary_memory
)
Agents avec outils activer des applications dynamiques qui interagissent avec des systèmes externes et exécutent des tâches en temps réel :
<span class="hljs-keyword">from</span> langchain.agents <span class="hljs-keyword">import</span> create_react_agent, AgentExecutor
<span class="hljs-keyword">from</span> langchain.tools <span class="hljs-keyword">import</span> Tool
<span class="hljs-comment"># Custom tool for weather data</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">get_weather</span>(<span class="hljs-params">city</span>):
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Current weather in <span class="hljs-subst">{city}</span>: 72°F, partly cloudy"</span>
weather_tool = Tool(
name=<span class="hljs-string">"Weather"</span>,
description=<span class="hljs-string">"Get current weather for any city"</span>,
func=get_weather
)
<span class="hljs-comment"># Custom tool for calculations</span>
<span class="hljs-keyword">def</span> <span class="hljs-title function_">calculate</span>(<span class="hljs-params">expression</span>):
<span class="hljs-keyword">try</span>:
result = <span class="hljs-built_in">eval</span>(expression.replace(<span class="hljs-string">"^"</span>, <span class="hljs-string">"**"</span>))
<span class="hljs-keyword">return</span> <span class="hljs-string">f"Result: <span class="hljs-subst">{result}</span>"</span>
<span class="hljs-keyword">except</span>:
<span class="hljs-keyword">return</span> <span class="hljs-string">"Invalid mathematical expression"</span>
calc_tool = Tool(
name=<span class="hljs-string">"Calculator"</span>,
description=<span class="hljs-string">"Perform mathematical calculations"</span>,
func=calculate
)
<span class="hljs-comment"># Create an agent with tools and memory</span>
tools = [weather_tool, calc_tool]
agent_memory = ConversationBufferMemory(memory_key=<span class="hljs-string">"chat_history"</span>)
agent = create_react_agent(
llm=llm,
tools=tools,
prompt=<span class="hljs-string">"""You are a helpful assistant with access to tools.
Available tools: {tool_names}
Tool descriptions: {tools}
Use tools when needed to provide accurate information.
Previous conversation: {chat_history}
Human: {input}
{agent_scratchpad}"""</span>
)
agent_executor = AgentExecutor(
agent=agent,
tools=tools,
memory=agent_memory,
verbose=<span class="hljs-literal">True</span>
)
<span class="hljs-comment"># Test the agent</span>
result = agent_executor.invoke({<span class="hljs-string">"input"</span>: <span class="hljs-string">"What's the weather in San Francisco and what's 15 * 24?"</span>})
<span class="hljs-built_in">print</span>(result)
Bien que LangChain Python offre un framework de programmation robuste, de nombreux développeurs apprécient l'interface visuelle de Latenode comme un excellent complément. Grâce à Latenode, vous pouvez prototyper des workflows tels que Requête HTTP → OpenAI GPT-4 → Stockage mémoire → Formatage de réponse sans vous plonger dans le code, renforçant ainsi votre compréhension de ces concepts tout en créant des applications fonctionnelles.
Cette combinaison de mémoire et d’agents permet des applications qui conservent le contexte, prennent des décisions éclairées et interagissent de manière transparente avec les systèmes externes.
Apprendre LangChain avec Laténode Flux de travail visuels
Les workflows visuels offrent un moyen unique de concevoir et de comprendre les comportements des agents en les présentant sous forme graphique. Cette approche permet d'inclure facilement des branches et des boucles conditionnelles. Si le framework Python de LangChain est indéniablement robuste, le générateur de workflows visuels de Latenode offre une approche pratique et intuitive pour appréhender les concepts de l'IA et créer des applications fonctionnelles. Il simplifie les idées complexes et les rend plus accessibles, notamment pour les novices en workflows d'IA.
Générateur de flux de travail visuel pour LangChain
L'interface glisser-déposer de Latenode transforme les concepts abstraits de LangChain en workflows clairs et visuels. Au lieu de vous attaquer à la syntaxe Python, vous pouvez vous concentrer sur la circulation des données entre les composants.
Dans ce système, les éléments LangChain sont représentés par des nœuds interconnectés. Par exemple, un Requête HTTP le nœud pourrait déclencher un OpenAI GPT-4 nœud. La sortie pourrait alors être acheminée vers un Stockage de mémoire nœud et enfin passer par un Formatage des réponses Nœud de présentation. Cette configuration reproduit le code habituel en Python, mais supprime les barrières syntaxiques, ce qui la rend particulièrement utile pour les débutants.
La représentation visuelle de la plateforme donne vie aux concepts de LangChain, permettant aux apprenants de comprendre le fonctionnement des workflows d'IA. Les intégrations et les modèles d'IA pris en charge vous offrent la liberté d'expérimenter des outils que vous utiliserez ultérieurement dans des applications concrètes. Par exemple, lors de l'exploration de LangChain ConversationTamponMémoire, vous pouvez visualiser l'historique des conversations d'une interaction à l'autre. Cette clarté pratique rend les idées abstraites plus tangibles et accélère l'apprentissage par rapport aux méthodes de codage traditionnelles, où le débogage des problèmes de mémoire nécessite souvent une journalisation approfondie.
Création de prototypes Visual LangChain
Latenode vous permet de créer des prototypes fonctionnels dès le départ. Par exemple, vous pouvez reproduire un générateur d'articles de blog en plusieurs étapes sous forme de workflow visuel : Webhook HTTP → OpenAI GPT-4 (Aperçu) → OpenAI GPT-4 (Introduction) → OpenAI GPT-4 (appel à l'action) → Google Sheets pour le stockage.
Cette approche visuelle simplifie la logique des workflows. Les flux conditionnels et les transformations de données sont représentés par des nœuds individuels, facilitant ainsi la compréhension de chaque étape. Par exemple, lors de la création d'un agent météo, vous pouvez connecter un API Météo nœud à un OpenAI GPT-4 nœud, puis utilisez des nœuds logiques pour ramifier la sortie en fonction de conditions spécifiques.
Latenode comprend également un Copilote de code IA, qui génère des extraits JavaScript conformes aux modèles Python de LangChain. Cette fonctionnalité comble le fossé entre les workflows visuels et le codage, permettant aux apprenants de visualiser les aspects conceptuels et techniques de leurs projets. De nombreux utilisateurs trouvent cette double approche utile pour comprendre les workflows avant de les implémenter en Python. Le débogage est également simplifié, car le format visuel permet de surveiller l'état de l'agent et le processus décisionnel à chaque étape.
Avantages de Latenode pour les débutants
Latenode offre plusieurs avantages aux débutants avec LangChain. L'un de ses principaux avantages est la rapidité d'itération. Le développement Python traditionnel implique souvent la configuration d'environnements, la gestion des dépendances et la résolution des erreurs de syntaxe avant même de pouvoir tester vos workflows. Latenode élimine ces obstacles et vous permet d'entrer directement dans la compréhension de l'architecture de LangChain.
La plateforme est également rentable pour l'expérimentation. Son modèle de tarification basé sur l'exécution facture uniquement le temps d'exécution réel, et non par appel d'API, ce qui la rend idéale pour les tests en phase d'apprentissage. Plan gratuit, qui comprend 300 crédits d'exécution par mois, offre une grande marge de manœuvre pour l'expérimentation et le prototypage.
Au-delà de l'apprentissage des concepts de LangChain, Latenode vous initie aux intégrations concrètes. Vous pouvez travailler avec des outils tels que Notion, Google Sheets, Stripe et WhatsApp, en acquérant une expérience pratique avec des applications prêtes à être déployées en production. Cette expérience pratique vous prépare à créer des solutions opérationnelles.
Latenode étend également les capacités de LangChain à l'automatisation web grâce à sa fonctionnalité de navigateur headless. Vous pouvez créer des workflows qui extraient des données, remplissent des formulaires et interagissent avec des applications web tout en appliquant les modèles de mémoire et d'agent de LangChain. Cette application concrète comble le fossé entre concepts théoriques et cas d'utilisation pratiques.
Enfin, le format visuel de Latenode encourage la collaboration. Les équipes peuvent facilement examiner, modifier et comprendre les workflows sans avoir besoin de connaissances approfondies en Python. Cela en fait un outil idéal pour les environnements éducatifs et les équipes de développement, favorisant l'apprentissage partagé et des progrès plus rapides.
Prochaines étapes : de l’apprentissage à la production
Maîtriser LangChain Python ouvre la voie à la création d'applications d'IA avancées. Cependant, passer de l'apprentissage à la production nécessite une planification minutieuse et des outils adaptés pour garantir le succès.
Ressources pour l'apprentissage avancé
L'espace Documentation LangChain est une ressource essentielle pour approfondir des sujets avancés. Elle fournit des guides détaillés sur la composition de chaînes complexes et les fonctionnalités de streaming. De plus, LangSmith documentation d'intégration est inestimable pour le débogage et la surveillance des applications dans les environnements de production.
Pour des informations pratiques, Dépôts GitHub proposent des exemples concrets qui vont au-delà des tutoriels de base. Modèles LangChain Le référentiel est particulièrement utile, fournissant des projets de démarrage prêts à la production pour des tâches telles que les systèmes de questions-réponses sur les documents, les agents SQL et les applications multimodales. Ces modèles mettent l'accent sur des aspects essentiels tels que la gestion des erreurs, la journalisation et la gestion de la configuration, souvent négligés dans les ressources pour débutants.
S'engager avec ressources communautaires Des plateformes comme le serveur Discord LangChain et les communautés Reddit peuvent également être utiles. Les développeurs partagent fréquemment leurs expériences face aux défis de production, offrant des conseils sur l'optimisation des performances et la gestion des coûts des applications gourmandes en API.
Pour ceux qui cherchent à approfondir leur expertise, le Livre de recettes LangChain est un ouvrage incontournable. Il présente des techniques avancées de gestion de la mémoire, d'intégration d'outils et d'orchestration d'agents. Les sections sur les outils personnalisés et les systèmes multi-agents sont particulièrement utiles pour créer des solutions métier complexes et évolutives.
Ces ressources fournissent la base de connaissances nécessaire pour faire passer vos projets LangChain du développement à la production.
Passer à des solutions prêtes à l'emploi
La mise en production de votre application implique de prendre en compte plusieurs aspects critiques, notamment la gestion des erreurs, l’évolutivité et la surveillance.
Limitation de débit devient essentiel lorsque l'on travaille avec des API comme OpenAI ou AnthropiqueLe dépassement des quotas peut entraîner des interruptions de service, impactant l'expérience utilisateur.
Gestion de l'environnement prend également une importance accrue. Au-delà du simple stockage de clés API, les configurations de production bénéficient de configurations structurées adaptées aux environnements de développement, de préproduction et de production. Des outils de gestion des identifiants sécurisés, tels que AWS Secrets Manager or Azure Key Vault, peut aider à protéger les informations sensibles.
Journalisation et observabilité sont essentiels pour comprendre les performances des applications et les interactions des utilisateurs. Bien que LangSmith propose un traçage intégré pour les applications LangChain, de nombreuses équipes implémentent également une journalisation personnalisée pour suivre les indicateurs métier.
À mesure que l'utilisation augmente, optimisation des coûts devient une priorité. Des techniques comme la mise en cache, l'optimisation rapide et le choix de modèles adaptés peuvent contribuer à réduire les dépenses sans compromettre les fonctionnalités.
Tester des applications d'IA nécessite une approche différente de celle des logiciels traditionnels. Les cadres d'évaluation doivent mesurer des aspects tels que la qualité des réponses, l'exactitude factuelle et la cohérence. Certaines équipes utilisent également des jeux de données de référence pour réaliser des tests de régression, garantissant ainsi la fiabilité de leurs applications au fil de leur évolution.
Pour les équipes cherchant à simplifier ces défis de production, Latenode propose une solution puissante pour automatiser et gérer efficacement les flux de travail.
Utilisation de Latenode pour l'automatisation des activités
Latenode comble le fossé entre les prototypes et les solutions prêtes à être produites, éliminant ainsi une grande partie de la complexité de l'infrastructure.
Son poids record base de données intégrée Permet aux développeurs de stocker l'historique des conversations, les préférences des utilisateurs et l'état des applications directement dans les workflows. Cela élimine le besoin de stockage de données externe, simplifie l'architecture et accélère le déploiement.
L'espace automatisation du navigateur sans tête Cette fonctionnalité étend les capacités de LangChain aux workflows web. Les entreprises peuvent ainsi créer des agents d'IA qui interagissent avec les applications web : remplir des formulaires, extraire des données et maintenir le contexte conversationnel avec les systèmes de mémoire de LangChain.
Avec plus de XNUMX études cliniques à notre actif, nous proposons des solutions avancées et faciles à utiliser pour la maison et en clinique ; approuvées par les professionnels, conçues pour la vie des gens. 300 intégrations d'applicationsLatenode facilite l'automatisation de processus métier complexes. Par exemple, un flux de production peut intégrer Salesforce, OpenAI GPT-4, Slacket Google Sheets pour automatiser des tâches telles que la qualification et le suivi des prospects. Ces workflows, qui nécessitent généralement un développement Python personnalisé approfondi, peuvent être créés rapidement grâce à la plateforme Latenode.
Pour les entreprises qui évoluent au-delà de l'expérimentation, Latenode Plan d'entreprise À partir de 299 $/mois, cette offre offre des crédits d'exécution illimités et un historique de 60 jours. Les organisations manipulant des données sensibles peuvent également opter pour l'option option d'auto-hébergement, garantissant le respect des exigences internes et réglementaires.
De nombreuses équipes adoptent une approche hybride, utilisant Latenode comme pilier de l'automatisation de la production tout en conservant des applications Python LangChain personnalisées pour une logique d'IA spécialisée. Cette stratégie allie la fiabilité et les capacités d'intégration de Latenode à la flexibilité du développement sur mesure, offrant ainsi des solutions robustes et évolutives.
Questions Fréquentes Posées
Qu'est-ce qui fait de LangChain un meilleur choix que les appels API traditionnels pour le développement de l'IA ?
LangChain se distingue des appels d'API traditionnels par sa valeur ajoutée pour la création d'applications d'IA. Il prend en charge flux de travail structurés en offrant des fonctionnalités telles que la gestion de la mémoire, le raisonnement multi-étapes et l'intégration transparente des outils. Ces capacités permettent aux développeurs de concevoir des systèmes d'IA à la fois avancés et évolutifs.
En simplifiant l'orchestration de workflows complexes, LangChain contribue à réduire les délais de développement tout en favorisant la modularité et la réutilisabilité des composants. Cela en fait un excellent framework pour la création d'applications d'IA modernes, notamment celles qui nécessitent une prise de décision intelligente ou des interactions utilisateur dynamiques.
Comment LangChain gère-t-il les défis de configuration sur différents systèmes d’exploitation ?
La configuration de LangChain peut parfois s'avérer complexe, car elle dépend de votre système d'exploitation et de votre matériel. Les défis courants incluent la gestion des dépendances, la résolution des problèmes de compatibilité des packages et la prise en charge des exigences matérielles spécifiques, comme les GPU pour les tâches avancées.
Pour simplifier le processus, des guides étape par étape sont disponibles pour des systèmes spécifiques, comme macOS ou Windows. Ces guides abordent les problèmes d'installation courants et fournissent des instructions claires, même pour les appareils plus récents comme le MacBook Pro M2. Grâce à ces ressources, vous pouvez simplifier le processus d'installation et commencer à utiliser LangChain en toute simplicité.
Les débutants peuvent-ils utiliser le générateur de flux de travail visuel de Latenode pour créer des applications LangChain sans compétences de codage avancées ?
Les débutants trouveront Latenode générateur de flux de travail visuel Un outil accessible pour créer et prototyper des applications LangChain, même sans connaissances avancées en codage. interface glisser-déposer simplifie le processus de conception des flux de travail d'IA, permettant aux utilisateurs de donner la priorité à la compréhension des concepts plutôt qu'à la lutte contre une programmation complexe.
Grâce à son approche de cartographie visuelle, Latenode aide les nouveaux utilisateurs à comprendre et à mettre en œuvre rapidement les fonctionnalités de LangChain, telles que les chaînes, les agents et la mémoire. Cette méthode pratique accélère l'apprentissage et produit des résultats immédiats, ce qui en fait un excellent point de départ pour les débutants en développement d'IA.
articles similaires
