Name

Lynn Mikami

Published on 30/04/2024

Introduction à LangChain pour les grands modèles de langage

Les grands modèles de langage (LLM) ont révolutionné le domaine du traitement du langage naturel, permettant la création d'applications puissantes telles que des chatbots, des systèmes de réponses aux questions et des outils de génération de texte. Cependant, la construction de ces applications à partir de zéro peut être difficile et chronophage. C'est là que LangChain intervient - une bibliothèque Python qui facilite le développement d'applications alimentées par LLM.

Dans cet article, nous plongerons dans LangChain et explorerons comment il peut être utilisé pour construire des applications alimentées par LLM. Nous aborderons l'installation, les concepts clés, et fournirons des exemples de code pour vous aider à démarrer.

Qu'est-ce que LangChain ?

LangChain est une bibliothèque open source qui fournit une interface standard pour travailler avec LLM. Il abstrait bon nombre des complexités de l'interaction directe avec les LLM, permettant aux développeurs de se concentrer sur la construction de leurs applications.

Parmi les principales fonctionnalités de LangChain, on peut citer :

• Prise en charge de plusieurs fournisseurs LLM comme OpenAI, Cohere, Hugging Face, etc.
• Composants modulaires tels que les invitations, les chaînes, les agents et la mémoire
• Utilitaires pour travailler avec des documents, des embeddings et des vecteurs
• Intégration avec d'autres outils et frameworks

En utilisant LangChain, les développeurs peuvent rapidement prototyper et déployer des applications alimentées par LLM sans avoir à se soucier des détails de bas niveau des API LLM.

Installation

Pour commencer avec LangChain, vous devrez l'installer en utilisant pip. Il est recommandé de créer d'abord un environnement virtuel :

python -m venv langchain-env
source langchain-env/bin/activate
pip install langchain

Vous devrez également installer les packages du fournisseur LLM que vous souhaitez utiliser. Par exemple, pour utiliser les modèles d'OpenAI :

pip install openai

Assurez-vous d'avoir une clé API pour le fournisseur que vous utilisez. Vous pouvez la définir en tant que variable d'environnement. :

export OPENAI_API_KEY=your_api_key_here

Concepts clés

Invitations

Les invitations sont les instructions ou le contexte que vous fournissez au LLM pour guider sa sortie. LangChain fournit une classe PromptTemplate pour faciliter la création et l'utilisation d'invitations.

Voici un exemple de création d'un modèle d'invitation :

from langchain import PromptTemplate
 
template = """
Vous êtes un assistant qui aide les utilisateurs à rédiger des e-mails professionnels.
 
Étant donné le contexte suivant :
{context}
 
Rédigez une réponse d'e-mail professionnelle. Signez l'e-mail en tant que "John".
"""
 
prompt = PromptTemplate(
    input_variables=["context"],
    template=template,
)

Vous pouvez ensuite utiliser l'invitation en passant les variables d'entrées :

context = "Je dois informer mon patron que je prendrai des vacances la semaine prochaine."
print(prompt.format(context=context))

Cela affichera l'invitation complétée avec le contexte fourni.

LLMs

LangChain fournit une interface standard pour interagir avec différents fournisseurs de LLM via la classe LLM.

Voici un exemple d'utilisation du modèle text-davinci-003 d'OpenAI :

from langchain.llms import OpenAI
 
llm = OpenAI(model_name="text-davinci-003")
 
result = llm("Quelle est la capitale de la France ?")
print(result)

Cela affichera la réponse du modèle à la question.

Chaînes

Les chaînes vous permettent de combiner plusieurs composants, tels que les invitations et les LLM, pour créer des applications plus complexes. LangChain propose plusieurs chaînes intégrées, ainsi que la possibilité de créer des chaînes personnalisées.

Voici un exemple de chaîne séquentielle simple qui prend une invitation, la transmet à un LLM, puis transmet la sortie du LLM à une deuxième invitation :

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate
 
first_prompt = PromptTemplate(
    input_variables=["product"],
    template="Quel est un bon nom pour une entreprise qui fabrique des {product} ?",
)
 
second_prompt = PromptTemplate(
    input_variables=["company_name"],
    template="Rédigez un slogan pour l'entreprise suivante : {company_name}",
)
 
chain = LLMChain(llm=llm, prompt=first_prompt)
second_chain = LLMChain(llm=llm, prompt=second_prompt)
 
result = chain.run("chaussettes colorées")
print(f"Nom de l'entreprise : {result}")
 
result = second_chain.run(result)
print(f"Slogan : {result}")

Cela générera un nom d'entreprise basé sur le produit "chaussettes colorées", puis générera un slogan pour ce nom d'entreprise.

Agents

Les agents sont des systèmes qui utilisent les LLM pour déterminer dynamiquement quelles actions entreprendre en fonction de l'entrée de l'utilisateur. Ils peuvent utiliser des outils pour interagir avec le monde extérieur et prendre des décisions sur ce qu'il faut faire ensuite.

Voici un exemple d'un agent simple qui utilise un outil de recherche et un outil de calculatrice :

from langchain.agents import initialize_agent, Tool
from langchain.tools import BaseTool
from langchain.llms import OpenAI
 
def search_api(query):
    return "Les résultats de recherche pour {query} seraient renvoyés ici"
 
def calculator(expression):
    return eval(expression)
 
search_tool = Tool(
    name="Recherche",
    func=search_api,
    description="Utile pour rechercher des informations sur internet."
)
 
calculator_tool = Tool(
    name="Calculatrice",
    func=calculator,
    description="Utile pour effectuer des calculs mathématiques."
)
 
tools = [search_tool, calculator_tool]
 
llm = OpenAI(temperature=0)
agent = initialize_agent(tools, llm, agent="zero-shot-react-description", verbose=True)
 
result = agent.run("Quelle est la population du Canada divisée par la population des États-Unis ?")
print(result)

Cet agent cherchera d'abord les populations du Canada et des États-Unis, extraira les nombres des résultats de recherche, puis utilisera la calculatrice pour les diviser.

Conclusion

LangChain est une bibliothèque puissante qui facilite le développement d'applications basées sur LLM. En fournissant une interface standard et des composants modulaires, il permet aux développeurs de se concentrer sur la création de leurs applications plutôt que de se préoccuper des détails des APIs LLM.

Dans cet article, nous avons couvert les bases de LangChain, y compris l'installation, les concepts clés tels que les prompts, les LLMs, les chaînes et les agents, et nous avons fourni des exemples de code pour vous aider à démarrer.

Pour en savoir plus sur LangChain, consultez la documentation officielle à l'adresse https://langchain.readthedocs.io/ (opens in a new tab). Vous pouvez également explorer le répertoire des exemples dans le dépôt GitHub pour des cas d'utilisation et des idées plus avancées.

À mesure que les LLM continuent à évoluer, des outils tels que LangChain joueront un rôle de plus en plus important pour les rendre accessibles et faciles à utiliser dans une large gamme d'applications. En tirant parti de LangChain, vous pouvez créer des applications puissantes basées sur le langage et être à la pointe de ce domaine passionnant.