De zéro à l’ingénierie de prompt avancée avec Langchain en Python

Un aspect important des modèles de langage à grande échelle (LLM) est le nombre de paramètres que ces modèles utilisent pour l’apprentissage. Plus un modèle a de paramètres, mieux il peut comprendre la relation entre les mots et les phrases. Cela signifie que les modèles avec des milliards de paramètres ont la capacité de générer divers formats de texte créatifs et de répondre à des questions ouvertes et difficiles de manière informative.

Les LLM tels que ChatGPT, qui utilisent le modèle Transformer, sont compétents dans la compréhension et la génération de la langue humaine, ce qui les rend utiles pour les applications qui nécessitent une compréhension du langage naturel. Cependant, ils ne sont pas sans limites, qui incluent des connaissances obsolètes, l’incapacité d’interagir avec des systèmes externes, le manque de compréhension du contexte et parfois la génération de réponses plausibles mais incorrectes ou sans sens, entre autres.

La résolution de ces limites nécessite l’intégration des LLM avec des sources de données externes et des capacités, ce qui peut présenter des complexités et exiger des compétences en codage et en gestion de données étendues. Cela, couplé aux défis de la compréhension des concepts d’IA et des algorithmes complexes, contribue à la courbe d’apprentissage associée au développement d’applications utilisant les LLM.

Cependant, l’intégration des LLM avec d’autres outils pour former des applications alimentées par LLM pourrait redéfinir notre paysage numérique. Le potentiel de telles applications est vaste, notamment en améliorant l’efficacité et la productivité, en simplifiant les tâches, en améliorant la prise de décision et en offrant des expériences personnalisées.

Dans cet article, nous allons approfondir ces questions, en explorant les techniques avancées d’ingénierie de prompt avec Langchain, en offrant des explications claires, des exemples pratiques et des instructions étape par étape sur la façon de les mettre en œuvre.

Langchain, une bibliothèque de pointe, apporte de la commodité et de la flexibilité à la conception, à la mise en œuvre et à la mise à jour des prompts. Alors que nous déballons les principes et les pratiques de l’ingénierie de prompt, vous apprendrez à utiliser les fonctionnalités puissantes de Langchain pour exploiter les forces des modèles d’IA génératifs de pointe comme GPT-4.

Comprendre les prompts

Avant de plonger dans les aspects techniques de l’ingénierie de prompt, il est essentiel de saisir le concept de prompts et leur importance.

Un ‘prompt‘ est une séquence de jetons utilisés comme entrée pour un modèle de langage, lui indiquant de générer un type de réponse particulier. Les prompts jouent un rôle crucial dans la direction du comportement d’un modèle. Ils peuvent avoir un impact sur la qualité du texte généré, et lorsqu’ils sont bien conçus, peuvent aider le modèle à fournir des résultats pertinents, précis et spécifiques au contexte.

L’ingénierie de prompt est l’art et la science de la conception de prompts efficaces. L’objectif est d’obtenir la sortie souhaitée d’un modèle de langage. En sélectionnant et en structurant soigneusement les prompts, on peut guider le modèle vers la génération de réponses plus précises et plus pertinentes. Dans la pratique, cela implique l’affinement des phrases d’entrée pour répondre aux biais de formation et structurels du modèle.

La sophistication de l’ingénierie de prompt va des techniques simples, telles que l’alimentation du modèle avec des mots-clés pertinents, à des méthodes plus avancées impliquant la conception de prompts structurés complexes qui utilisent les mécanismes internes du modèle à son avantage.

Langchain : l’outil de prompt le plus en croissance

LangChain, lancé en octobre 2022 par Harrison Chase, est devenu l’un des cadres open-source les plus évalués sur GitHub en 2023. Il offre une interface simplifiée et standardisée pour intégrer les modèles de langage à grande échelle (LLM) dans les applications. Il fournit également une interface riche en fonctionnalités pour l’ingénierie de prompt, permettant aux développeurs d’expérimenter avec différentes stratégies et d’évaluer leurs résultats. En utilisant Langchain, vous pouvez effectuer des tâches d’ingénierie de prompt de manière plus efficace et plus intuitive.

LangFlow sert d’interface utilisateur pour orchestrer les composants LangChain en un flux de travail exécutable, permettant une prototypage et une expérimentation rapides.

LangChain comble une lacune cruciale dans le développement d’IA pour les masses. Il permet une gamme d’applications de traitement automatique du langage naturel (TAL) telles que les assistants virtuels, les générateurs de contenu, les systèmes de questions-réponses, et plus encore, pour résoudre une gamme de problèmes du monde réel.

Plutôt que d’être un modèle ou un fournisseur autonome, LangChain simplifie l’interaction avec divers modèles, étendant les capacités des applications LLM au-delà des limites d’un simple appel d’API.

L’architecture de LangChain

Les principaux composants de LangChain incluent la sortie/entrée du modèle, les modèles de prompt, la mémoire, les agents et les chaînes.

Sortie/entrée du modèle

LangChain facilite une connexion transparente avec divers modèles de langage en les entourant d’une interface standardisée appelée sortie/entrée du modèle. Cela facilite un commutation de modèle sans effort pour l’optimisation ou de meilleures performances. LangChain prend en charge divers fournisseurs de modèles de langage, notamment OpenAI, HuggingFace, Azure, Fireworks, et plus encore.

Modèles de prompt

Ces derniers sont utilisés pour gérer et optimiser les interactions avec les LLM en fournissant des instructions ou des exemples concis. L’optimisation des prompts améliore les performances du modèle, et leur flexibilité contribue de manière significative au processus d’entrée.

Un exemple simple de modèle de prompt :

<p>from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=[&amp;quot;subject&amp;quot;],
template=&amp;quot;Quels sont les progrès récents dans le domaine de {subject}?&amp;quot;)
print(prompt.format(subject=&amp;quot;Traitement automatique du langage naturel&amp;quot;))</p>

À mesure que nous avançons dans la complexité, nous rencontrons des modèles plus sophistiqués dans LangChain, tels que le modèle ReAct (Reason and Act). ReAct est un modèle vital pour l’exécution d’actions où l’agent attribue une tâche à un outil approprié, personnalise l’entrée pour cet outil et analyse sa sortie pour accomplir la tâche. L’exemple Python suivant illustre un modèle ReAct. Il montre comment un prompt est structuré dans LangChain, en utilisant une série de pensées et d’actions pour raisonner à travers un problème et produire une réponse finale :

PREFIX = """Répondez à la question suivante en utilisant les outils donnés :"""
FORMAT_INSTRUCTIONS = """Suivez ce format :
Question : {input_question}
Pensée : votre pensée initiale sur la question
Action : votre action choisie parmi [{tool_names}]
Entrée d'action : votre entrée pour l'action
Observation : le résultat de l'action"""
SUFFIX = """Commencez !
Question : {input}
Pensée :{agent_scratchpad}"""

Mémoire

La mémoire est un concept crucial dans LangChain, permettant aux LLM et aux outils de conserver des informations dans le temps. Ce comportement étatique améliore les performances des applications LangChain en stockant les réponses précédentes, les interactions utilisateur, l’état de l’environnement et les objectifs de l’agent. Les stratégies de mémoire ConversationBufferMemory et ConversationBufferWindowMemory aident à conserver la totalité ou les parties récentes d’une conversation, respectivement. Pour une approche plus sophistiquée, la stratégie de mémoire ConversationKGMemory permet de coder la conversation sous forme de graphe de connaissances qui peut être réinjecté dans les prompts ou utilisé pour prédire des réponses sans appeler le LLM.

Agents

Un agent interagit avec le monde en effectuant des actions et des tâches. Dans LangChain, les agents combinent des outils et des chaînes pour l’exécution de tâches. Il peut établir une connexion avec le monde extérieur pour la récupération d’informations afin d’augmenter les connaissances des LLM, surmontant ainsi leurs limites inhérentes. Ils peuvent décider de passer des calculs à un calculateur ou à un interpréteur Python en fonction de la situation.

Les agents sont équipés de sous-composants :

• Outils : Ce sont des composants fonctionnels.
• Boîtes à outils : Collections d’outils.
• Exécuteurs d’agents : Il s’agit du mécanisme d’exécution qui permet de choisir entre les outils.

Les agents dans LangChain suivent également le modèle ReAct à zéro tir, où la décision est basée uniquement sur la description de l’outil. Ce mécanisme peut être étendu avec de la mémoire pour prendre en compte l’historique complet de la conversation. Avec ReAct, au lieu de demander à un LLM de compléter votre texte, vous pouvez le solliciter pour répondre dans une boucle de pensée/action/observation.

Chaînes

Les chaînes, comme le terme le suggère, sont des séquences d’opérations qui permettent à la bibliothèque LangChain de traiter les entrées et les sorties des modèles de langage de manière transparente. Ces composants intégraux de LangChain sont fondamentalement constitués de liens, qui peuvent être d’autres chaînes ou des primitives telles que des prompts, des modèles de langage ou des utilitaires.

Imaginez une chaîne comme un tapis roulant dans une usine. Chaque étape de ce tapis représente une opération spécifique, qui pourrait être l’invocation d’un modèle de langage, l’application d’une fonction Python à un texte ou même le promptage du modèle d’une manière particulière.

LangChain catégorise ses chaînes en trois types : les chaînes d’utilité, les chaînes génériques et les chaînes de combinaison de documents. Nous allons nous concentrer sur les chaînes d’utilité et les chaînes génériques pour notre discussion.

• Chaînes d’utilité sont spécifiquement conçues pour extraire des réponses précises des modèles de langage pour des tâches étroitement définies. Par exemple, prenons la LLMMathChain. Cette chaîne d’utilité permet aux modèles de langage d’effectuer des calculs mathématiques. Elle accepte une question en langage naturel, et le modèle de langage génère un extrait de code Python qui est ensuite exécuté pour produire la réponse.
• Chaînes génériques, en revanche, servent de blocs de construction pour d’autres chaînes mais ne peuvent pas être utilisées seules. Ces chaînes, telles que la LLMChain, sont fondamentales et sont souvent combinées avec d’autres chaînes pour accomplir des tâches complexes. Par exemple, la LLMChain est fréquemment utilisée pour interroger un objet de modèle de langage en formatant l’entrée en fonction d’un modèle de prompt fourni, puis en le passant au modèle de langage.

Mise en œuvre étape par étape de l’ingénierie de prompt avec Langchain

Nous allons vous guider à travers le processus de mise en œuvre de l’ingénierie de prompt en utilisant Langchain. Avant de procéder, assurez-vous d’avoir installé les logiciels et les packages nécessaires.

Vous pouvez utiliser des outils populaires tels que Docker, Conda, Pip et Poetry pour configurer LangChain. Les fichiers d’installation pertinents pour chacune de ces méthodes peuvent être trouvés dans le référentiel LangChain à https://github.com/benman1/generative_ai_with_langchain. Cela inclut un Dockerfile pour Docker, un requirements.txt pour Pip, un pyproject.toml pour Poetry et un fichier langchain_ai.yml pour Conda.

Dans notre article, nous allons utiliser Pip, le gestionnaire de packages standard pour Python, pour faciliter l’installation et la gestion des bibliothèques tierces. Si Pip n’est pas inclus dans votre distribution Python, vous pouvez l’installer en suivant les instructions à https://pip.pypa.io/.

Pour installer une bibliothèque avec Pip, utilisez la commande pip install library_name.

Cependant, Pip ne gère pas les environnements par lui-même. Pour gérer différents environnements, nous utilisons l’outil virtualenv.

Dans la section suivante, nous allons discuter des intégrations de modèles.

Étape 1 : Configuration de Langchain

Tout d’abord, vous devez installer le package Langchain. Nous utilisons le système d’exploitation Windows. Exécutez la commande suivante dans votre terminal pour l’installer :

pip install langchain

Étape 2 : Importation de Langchain et des modules nécessaires

Ensuite, importez Langchain ainsi que les modules nécessaires. Ici, nous importons également la bibliothèque transformers, qui est largement utilisée pour les tâches de TAL.

<p>import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Étape 3 : Chargement du modèle pré-entraîné

Open AI

OpenAI modèles peuvent être facilement intégrés avec la bibliothèque LangChain ou la bibliothèque client OpenAI Python. Notamment, OpenAI fournit une classe d’incrustation pour les modèles d’incrustation de texte. Deux modèles LLM clés sont GPT-3.5 et GPT-4, qui diffèrent principalement par la longueur du jeton. Les tarifs pour chaque modèle peuvent être trouvés sur le site Web d’OpenAI. Alors qu’il existe des modèles plus sophistiqués comme GPT-4-32K qui ont une acceptation de jetons plus élevée, leur disponibilité via l’API n’est pas toujours garantie.

L’accès à ces modèles nécessite une clé API OpenAI. Cela peut être fait en créant un compte sur la plateforme OpenAI, en configurant les informations de facturation et en générant une nouvelle clé secrète.

<p>import os
os.environ[&amp;quot;OPENAI_API_KEY&amp;quot;] = &#039;votre-jeton-openai&#039;</p>

Après avoir créé la clé avec succès, vous pouvez la définir comme variable d’environnement (OPENAI_API_KEY) ou la passer comme paramètre lors de l’instanciation de la classe pour les appels OpenAI.

Envisagez un script LangChain pour illustrer l’interaction avec les modèles OpenAI :

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# Le LLM prend un prompt comme entrée et produit une sortie
prompt = "qui est le président des États-Unis d'Amérique ?"
completion = llm(prompt)

<p>Le président actuel des États-Unis d'Amérique est Joe Biden.</p>

Dans cet exemple, un agent est initialisé pour effectuer des calculs. L’agent prend une entrée, une tâche d’addition simple, la traite en utilisant le modèle OpenAI fourni et retourne le résultat.

Hugging

Hugging Face est une bibliothèque Transformers Python GRATUITE, compatible avec PyTorch, TensorFlow et JAX, et inclut des implémentations de modèles tels que BERT, T5, etc.

Hugging Face propose également le Hugging Face Hub, une plateforme pour héberger des référentiels de code, des modèles d’apprentissage automatique, des ensembles de données et des applications Web.

Pour utiliser Hugging Face comme fournisseur de modèles, vous aurez besoin d’un compte et de clés API, que vous pouvez obtenir sur leur site Web. Le jeton peut être rendu disponible dans votre environnement en tant que HUGGINGFACEHUB_API_TOKEN.

Envisagez l’extrait de code Python suivant qui utilise un modèle open source développé par Google (GOOGL ), le modèle Flan-T5-XXL :

from langchain.llms import HuggingFaceHub

<p>llm = HuggingFaceHub(model_kwargs={&amp;quot;temperature&amp;quot;: 0.5, &amp;quot;max_length&amp;quot;: 64},repo_id=&amp;quot;google/flan-t5-xxl&amp;quot;)
prompt = &amp;quot;Dans quel pays se trouve Tokyo ?&amp;quot;
completion = llm(prompt)
print(completion)</p>

Ce script prend une question comme entrée et retourne une réponse, mettant en évidence les capacités de connaissance et de prédiction du modèle.

Étape 4 : Ingénierie de prompt de base

Pour commencer, nous allons générer un prompt simple et voir comment le modèle répond.

prompt = 'Traduisez le texte anglais suivant en français : "{0}"'
input_text = 'Bonjour, comment allez-vous ?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dans l’extrait de code ci-dessus, nous fournissons un prompt pour traduire le texte anglais en français. Le modèle de langage tente ensuite de traduire le texte donné en fonction du prompt.

Étape 5 : Ingénierie de prompt avancée

Alors que l’approche ci-dessus fonctionne bien, elle ne tire pas pleinement parti de la puissance de l’ingénierie de prompt. Améliorons-la en introduisant des structures de prompt plus complexes.

prompt = 'En tant que traducteur français très compétent, traduisez le texte anglais suivant en français : "{0}"'
input_text = 'Bonjour, comment allez-vous ?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')

<p>generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

Dans cet extrait de code, nous modifions le prompt pour suggérer que la traduction est effectuée par un « traducteur français très compétent ». Le changement dans le prompt peut conduire à de meilleures traductions, car le modèle suppose maintenant une personnalité d’expert.

Construire un système de questions-réponses de littérature académique avec Langchain

Nous allons construire un système de questions-réponses de littérature académique en utilisant LangChain capable de répondre à des questions sur des articles académiques récemment publiés.

Tout d’abord, pour configurer notre environnement, nous installons les dépendances nécessaires.

pip install langchain arxiv openai transformers faiss-cpu

Après l’installation, nous créons un nouveau notebook Python et importons les bibliothèques nécessaires :

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

Le cœur de notre système de questions-réponses est la capacité à récupérer des articles académiques pertinents liés à un domaine spécifique, ici le traitement automatique du langage naturel (TAL), en utilisant la base de données académique arXiv. Pour ce faire, nous définissons une fonction get_arxiv_data(max_results=10). Cette fonction collecte les résumés des articles TAL les plus récents d’arXiv et les encapsule dans des objets de document LangChain, en utilisant le résumé comme contenu et l’ID d’entrée unique comme source.

Nous allons utiliser l’API arXiv pour récupérer les articles récents liés au TAL :

<p>def get_arxiv_data(max_results=10):
search = arxiv.Search(
query=&amp;quot;TAL&amp;quot;,
max_results=max_results,
sort_by=arxiv.SortCriterion.SubmittedDate,
)</p>

documents = []

<p>for result in search.results():
documents.append(Document(
page_content=result.summary,
metadata={&amp;quot;source&amp;quot;: result.entry_id},
))</p>

return documents

Cette fonction récupère les résumés des articles TAL les plus récents d’arXiv et les convertit en objets de document LangChain. Nous utilisons le résumé de l’article et son ID d’entrée unique (URL vers l’article) comme contenu et source, respectivement.

def print_answer(question):
print(
chain(
{
"input_documents": sources,
"question": question,
},
return_only_outputs=True,
)["output_text"]
)

Définissons maintenant notre corpus et configurons LangChain :

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Avec notre système de questions-réponses académiques maintenant prêt, nous pouvons le tester en posant une question :

print_answer("Quels sont les progrès récents dans le domaine du TAL ?")

La sortie sera la réponse à votre question, en citant les sources à partir desquelles les informations ont été extraites. Par exemple :

<p>Les progrès récents dans le domaine du TAL incluent les modèles de récupération et d'exécution d'instructions, ainsi qu'un nouveau cadre de calcul pour résoudre les problèmes de flux de puissance alternatif (ACOPF) en utilisant des unités de traitement graphique (GPU).
SOURCES : http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Vous pouvez facilement basculer entre les modèles ou modifier le système selon vos besoins. Par exemple, nous changeons ici pour GPT-4, ce qui nous donne une réponse beaucoup plus détaillée.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

<p>Les progrès récents dans le traitement automatique du langage naturel (TAL) incluent le développement de modèles de récupération et d'exécution d'instructions pour les tâches de recherche d'informations telles que la question-réponse (QR). Ces modèles peuvent être adaptés à divers domaines d'information et de tâches sans formation supplémentaire. Cependant, ils ont souvent du mal à rester fidèles aux connaissances fournies et peuvent halluciner dans leurs réponses. Un autre progrès est l'introduction d'un cadre de calcul pour résoudre les problèmes de flux de puissance alternatif (ACOPF) en utilisant des unités de traitement graphique (GPU). Cette approche utilise une abstraction de données à instruction unique, multiples données (SIMD) des programmes non linéaires (NLP) et emploie une méthode de point intérieur avec une stratégie de relaxation des inégalités. Cette stratégie permet la factorisation de la matrice KKT sans pivotage numérique, ce qui a précédemment entravé la parallélisation de l'algorithme IPM.
SOURCES : http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un jeton dans GPT-4 peut être aussi court qu’un caractère ou aussi long qu’un mot. Par exemple, GPT-4-32K peut traiter jusqu’à 32 000 jetons en une seule exécution, tandis que GPT-4-8K et GPT-3.5-turbo prennent en charge 8 000 et 4 000 jetons, respectivement. Cependant, il est important de noter que chaque interaction avec ces modèles est associée à un coût qui est directement proportionnel au nombre de jetons traités, qu’il s’agisse d’entrée ou de sortie.

Dans le contexte de notre système de questions-réponses, si un article académique dépasse la limite de jetons maximale, le système échouera à le traiter dans son intégralité, affectant ainsi la qualité et l’exhaustivité des réponses. Pour contourner ce problème, le texte peut être divisé en parties plus petites qui respectent la limite de jetons.

FAISS (Facebook AI Similarity Search) (META ) aide à trouver rapidement les parties de texte les plus pertinentes liées à la question de l’utilisateur. Il crée une représentation vectorielle de chaque partie de texte et utilise ces vecteurs pour identifier et récupérer les parties les plus similaires à la représentation vectorielle d’une question donnée.

Il est important de se rappeler que même avec l’utilisation d’outils comme FAISS, la nécessité de diviser le texte en parties plus petites en raison des limites de jetons peut parfois entraîner une perte de contexte, affectant la qualité des réponses. Par conséquent, une gestion et une optimisation soigneuses de l’utilisation des jetons sont cruciales lors de la travail avec ces grands modèles de langage.

pip install faiss-cpu langchain CharacterTextSplitter

Après avoir vérifié que les bibliothèques ci-dessus sont installées, exécutez

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores.faiss import FAISS
from langchain.text_splitter import CharacterTextSplitter
documents = get_arxiv_data(max_results=10) # Nous pouvons maintenant utiliser davantage de données
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
for chunk in splitter.split_text(document.page_content):
document_chunks.append(Document(page_content=chunk, metadata=document.metadata))

<p>search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())</p>

<p>chain = load_qa_with_sources_chain(OpenAI(temperature=0))</p>

<p>def print_answer(question):
print(
chain(
{
&amp;quot;input_documents&amp;quot;: search_index.similarity_search(question, k=4),
&amp;quot;question&amp;quot;: question,
},
return_only_outputs=True,
)[&amp;quot;output_text&amp;quot;]
)

Avec le code complet, nous disposons maintenant d’un outil puissant pour interroger la littérature académique la plus récente dans le domaine du TAL.

Les progrès récents dans le domaine du TAL incluent l'utilisation de réseaux de neurones profonds (DNN) pour l'analyse automatique de texte et les tâches de TAL telles que la vérification orthographique, la détection de langue, l'extraction d'entités, la détection d'auteur, la question-réponse, et d'autres tâches.
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1

Conclusion

L’intégration des modèles de langage à grande échelle (LLM) dans les applications a accéléré l’adoption dans plusieurs domaines, notamment la traduction de langage, l’analyse de sentiment et la récupération d’informations. L’ingénierie de prompt est un outil puissant pour maximiser le potentiel de ces modèles, et Langchain est à la pointe de la simplification de cette tâche complexe. Son interface standardisée, ses modèles de prompt flexibles, son intégration de modèle robuste et l’utilisation innovante des agents et des chaînes garantissent des résultats optimaux pour les performances des LLM.

Cependant, malgré ces progrès, il est important de garder à l’esprit quelques conseils. Lorsque vous utilisez Langchain, il est essentiel de comprendre que la qualité de la sortie dépend fortement de la formulation du prompt. Expérimenter avec différents styles et structures de prompt peut conduire à de meilleurs résultats. De plus, rappelez-vous que même si Langchain prend en charge une variété de modèles de langage, chacun d’eux a ses forces et ses faiblesses. Choisir le bon modèle pour votre tâche spécifique est crucial. Enfin, il est important de se rappeler que l’utilisation de ces modèles est associée à des considérations de coût, car le traitement de jetons influence directement le coût des interactions.

Comme le montre le guide étape par étape, Langchain peut alimenter des applications robustes, telles que le système de questions-réponses de littérature académique. Avec une communauté d’utilisateurs en croissance et une importance croissante dans le paysage open-source, Langchain promet d’être un outil crucial pour exploiter pleinement le potentiel des LLM comme GPT-4.