Même si la construction d'invites efficaces pour les grands modèles de langage (LLM) n'est pas une mince affaire, l'utilisation de ces modèles est généralement plus facile. D'un autre côté, programmer avec des modèles de langage peut s'avérer difficile. C'est là que le framework de développement d'applications basées sur des modèles de langage LangChain a tout son intérêt. LangChain peut servir à créer des chatbots ou des assistants personnels, pour résumer, analyser ou générer des questions/réponses sur des documents ou des données structurées, écrire ou comprendre du code, interagir avec des API, et pour créer d'autres applications qui tirent parti de l'IA générative. Actuellement, LangChain existe en deux versions, l'une en Python et l'autre en TypeScript/JavaScript. Grâce à LangChain, les modèles de langage peuvent se connecter à des sources de données et interagir avec leur environnement. Les composants de LangChain sont des abstractions modulaires et des collections d'implémentations de ces abstractions. Les chaînes LangChain prêtes à l'emploi sont des assemblages structurés de composants avec lesquels on peut exécuter des tâches spécifiques de haut niveau. Les composants peuvent servir à personnaliser les chaînes existantes et en créer de nouvelles.

Il convient de préciser qu'il existe deux types de modèles de langage, les LLM et les modèles de chat. Les LLM prennent une chaîne en entrée et renvoient une chaîne. Les modèles de chat prennent une liste de messages en entrée et renvoient un message de chat. Les messages de chat contiennent deux éléments : le contenu et un rôle. Les rôles précisent l'origine du contenu : un humain, une IA, le système, un appel de fonction ou une entrée générique. En général, les LLM utilisent des modèles d'invite pour leurs entrées. Un modèle d'invite permet de spécifier le rôle que l’on veut que prenne le LLM ou le modèle de chat, par exemple « un assistant utile qui traduit l'anglais en français ». Il permet également d'appliquer le modèle à de nombreuses instances de contenu, comme une liste de phrases à traduire.

Les modules, base du fonctionnement de LangChain

LangChain comporte six modules :

- Model I/O qui sert d’interface avec les modèles de langage ;
- Data Connection : une connexion de données pour interagir avec les données spécifiques à l'application ;
- Chains : des chaînes qui construisent des séquences d'appels ;
- Agents : ils permettent aux chaînes de choisir les outils à utiliser en fonction de directives de haut niveau ;
- Memory : une mémoire qui conserve l'état de l'application entre les exécutions d'une chaîne ;
- Callbacks : des rappels, qui enregistrent et diffusent les étapes intermédiaires d'une chaîne.

Model I/O permet de gérer les invites, d'appeler des modèles de langage par le biais d'interfaces communes et d'extraire des informations des outputs du modèle. (Crédit : IDG)

Les applications complexes nécessitent d’enchaîner les LLM, soit entre eux, soit avec d'autres composants. LangChain fournit l'interface Chain pour des applications « chaînées ». Un système conversationnel doit pouvoir accéder directement à une fenêtre de messages antérieurs. C’est ce qu’apporte LangChain avec sa capacité Memory.

Data Connection fournit les éléments de base pour charger, transformer, stocker et interroger les données. (Crédit : IDG)

Contrairement aux chaînes, qui codent en dur les séquences, les Agents utilisent un modèle de langage comme moteur de raisonnement pour déterminer les actions à entreprendre et l’ordre dans lequel les exécuter. Les callbacks permettent de se connecter aux différentes étapes de l’application LLM. Ils sont utiles pour la journalisation, la surveillance, le streaming et d'autres tâches. 

Les callbacks sont utiles pour la journalisation, la surveillance, le streaming et d'autres tâches. (Crédit : IDG)

Débogage avec LangSmith

LangSmith aide à tracer et à évaluer les applications LLM LangChain et les agents intelligents afin de passer plus facilement du prototype à la production. Pour l’instant, LangSmith est encore en version bêta fermée. Une démonstration et la documentation de LangSmith sont accessibles sans avoir à participer au bêta-test.

Intégrations LangChain

À ce jour, on compte environ 163 intégrations LangChain. Elles comprennent cinq Callbacks, neuf modèles de chat, 115 chargeurs de documents, six transformateurs de documents, 54 LLM, 11 façons d'implémenter la mémoire (principalement avec des bases de données), 22 récupérateurs (principalement des méthodes de recherche), 31 modèles d'intégration de texte, 21 boîtes à outils d'agents, 34 outils et 42 magasins de vecteurs. Les intégrations sont également disponibles groupées par fournisseur. LangChain sert essentiellement de hub neutre pour toutes ces capacités.

Installation de LangChain pour Python et JavaScript

Pour installer LangChain pour Python, on peut utiliser pip ou conda. La meilleure pratique consiste à installer les paquets Python dans des environnements virtuels afin d'éviter les conflits de version sur les dépendances. Voir ci-dessous pour l’installation avec les commandes pip. Pour les commandes conda, voir la page d'installation et cliquer sur Conda.

L'installation de base, minimale, est : pip install langchain.

Pour information, c'est ce que j'ai utilisé. Cette installation n'inclut pas les modules pour les fournisseurs de modèles, les magasins de données ou d'autres intégrations. Je prévois d'installer ceux dont j'aurai besoin, quand j'en aurai besoin.

Pour installer LangChain et les modèles de langage communs, utilisez pip install langchain[llms]

Pour installer LangChain et toutes les intégrations, utilisez pip install langchain[all]

Si vous utilisez zsh, qui est le shell par défaut sur les versions récentes de macOS, il faut placer les expressions entre crochets. Sinon, sans les guillemets, le shell interprète les crochets comme indiquant des tableaux. Par exemple : pip install 'langchain[all]'

Pour installer LangChain pour JavaScript, utilisez npm, Yarn ou pnpm, par exemple : npm install -S langchain.

On peut utiliser LangChain for JavaScript dans Node.js, Cloudflare Workers, Vercel / Next.js (Browser, Serverless, et Edge functions), Supabase Edge Functions, les navigateurs web, et Deno.

Pour en savoir plus sur LangChain pour JavaScript, rendez-vous sur la page d'installation de LangChain pour JavaScript.

Exemple d'utilisation de LangChain

Même s’il y a des centaines d'exemples dans la documentation LangChain, je n’en présenterai ici qu’un seul. Ce code Python se trouve à la fin du Quickstart et illustre une chaîne LLMC. Cette chaîne prend des variables d’inputs, les passe à un modèle d'invite pour créer une invite, passe l'invite à un LLM (ChatOpenAI), puis passe l’output CSV à travers un analyseur de sortie (optionnel) pour créer un tableau de chaînes de caractères Python.

from langchain.chat_models import ChatOpenAI
from langchain.prompts.chat import (

         ChatPromptTemplate,
         SystemMessagePromptTemplate,
         HumanMessagePromptTemplate,

)

from langchain.chains import LLMChain
from langchain.schema import BaseOutputParser

class CommaSeparatedListOutputParser(BaseOutputParser):
          """Parse the output of an LLM call to a comma-separated list."""

           def parse(self, text: str):

                       """Parse the output of an LLM call."""
            return text.strip().split(", ")

template = """You are a helpful assistant who generates comma separated lists. A user will pass in a category, and you should generate 5 objects in that category in a comma separated list in ONLY return a comma separated list, and nothing more."""

system_message_prompt = SystemMessagePromptTemplate.from_template(template)
human_template = "{text}"
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([system_message_prompt, human_message_prompt])
chain = LLMChain(
      llm=ChatOpenAI(),
      prompt=chat_prompt,
      output_parser=CommaSeparatedListOutputParser()

)

chain.run("colors")

# >> ['red', 'blue', 'green', 'yellow', 'orange']

LangChain Expression Language (LCEL)

Le LangChain Expression Language est un moyen déclaratif de composer des chaînes et d'obtenir le support du streaming, du batch et de l'asynchrone dès le départ. LCEL facilite l'utilisation de LangChain. On peut utiliser toutes les builds LangChain existantes pour créer des chaînes comme on le ferait en les composant en code, puisque LCEL est essentiellement une alternative de haut niveau à la création de chaînes en Python ou TypeScript/JavaScript.

On peut aussi exécuter le LangChain existant de manière interactive pour apprendre LCEL, même s’il faut d'abord installer LangChain pour Python. Notez que je n'ai pas pu exécuter Langchain Teacher. Il semble qu'il y ait un bogue dépendant de la version. Les expressions LCEL utilisent des caractères pipe (|) pour relier les variables en chaînes. Par exemple, une chaîne commune de base utilise un modèle et une invite :

chain = prompt | model

Dans ce contexte, on pourrait avoir ce programme Python :

from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatOpenAI

model = ChatOpenAI()
prompt = ChatPromptTemplate.from_template("tell me a joke about {foo}")

chain = prompt | model

chain.invoke({"foo": "bears"})

L’output (tel qu'il est donné sur le site) est le suivant :

AIMessage(content='Why don\'t bears use cell phones? \n\nBecause they always get terrible "grizzly" reception!', additional_kwargs={}, example=False).

Comme on a pu le voir, LangChain apporte un moyen puissant de créer des applications d'IA générative alimentées par des modèles de langage et des données, connectés en chaînes. Cet article offre un aperçu de quelques exemples en Python ainsi qu'un lien vers les exemples en JavaScript. Il est également possible de programmer LangChain en R à l'aide d'un shim Python, comme l'explique Sharon Machlis d'InfoWorld dans son article « Generative AI with LangChain, RStudio, and just enough Python » (De l'IA générative avec LangChain, RStudio et juste assez de Python). Le blog LangChain qui publie un court article presque chaque jour offre par ailleurs une autre base de ressources utiles.