> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# LangChain
> Utilisez Weave pour suivre et journaliser tous les appels effectués via la bibliothèque Python LangChain
Weave suit et journalise les appels effectués via la [bibliothèque Python LangChain](https://github.com/langchain-ai/langchain).
Lorsque vous travaillez avec des LLM, le débogage fait partie du quotidien. Qu’un appel de modèle échoue, qu’une sortie soit mal formatée ou que des appels de modèle imbriqués prêtent à confusion, il peut être difficile d’identifier précisément l’origine des problèmes. Les applications LangChain comportent souvent plusieurs étapes et de nombreux appels LLM ; il est donc utile de comprendre le fonctionnement interne de vos chaînes et de vos agents.
Weave capture automatiquement les traces de vos applications [LangChain](https://docs.langchain.com/oss/python/langchain/overview). Vous pouvez ainsi surveiller et analyser les performances de votre application, ce qui facilite le débogage et l’optimisation de vos flux de travail LLM.
Ce guide s’adresse aux développeurs qui créent des applications LangChain et souhaitent y ajouter le traçage, l’évaluation et l’observabilité avec Weave. Il explique comment activer le traçage automatique, joindre des métadonnées, contrôler manuellement le traçage et encapsuler des chaînes LangChain sous forme de modèles Weave afin de les évaluer.
Premiers pas
Pour commencer, appelez `weave.init()` au début de votre script. `weave.init()` prend en argument un nom de projet, que Weave utilise pour organiser vos traces.
```python lines {6} theme={"system"}
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialiser Weave avec le nom de votre projet
weave.init("langchain_demo")
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
output = llm_chain.invoke({"number": 2})
print(output)
```
Les métadonnées personnalisées vous permettent de filtrer et d’analyser les traces dans l’interface de Weights & Biases. Pour suivre les métadonnées de vos appels LangChain, utilisez le gestionnaire de contexte [`weave.attributes`](/fr/products/wandb/weave/reference/python-sdk#function-attributes). Ce gestionnaire de contexte vous permet de définir des métadonnées personnalisées pour un bloc de code précis, comme une chaîne ou une requête individuelle.
```python lines {6,13} theme={"system"}
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialiser Weave avec le nom de votre projet
weave.init("langchain_demo")
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
with weave.attributes({"my_awesome_attribute": "value"}):
output = llm_chain.invoke()
print(output)
```
Weave suit automatiquement les métadonnées en les associant à la trace de l’appel LangChain. Vous pouvez consulter ces métadonnées dans l’interface web de Weave.
[
](https://forge.coreweave.com/wandb/parambharat/langchain_demo/weave/traces?cols=%7B%22attributes.weave.client_version%22%3Afalse%2C%22attributes.weave.os_name%22%3Afalse%2C%22attributes.weave.os_release%22%3Afalse%2C%22attributes.weave.os_version%22%3Afalse%2C%22attributes.weave.source%22%3Afalse%2C%22attributes.weave.sys_version%22%3Afalse%7D)
Traces
Stocker les traces de vos applications LLM dans une base de données centralisée s’avère utile aussi bien en développement qu’en production. Ces traces constituent un jeu de données qui vous permet de déboguer et d’améliorer votre application.
Weave capture automatiquement les traces de vos applications LangChain. Weave suit et journalise les appels effectués via la bibliothèque LangChain, notamment les modèles de prompt, les chaînes, les appels LLM, les outils et les étapes des agents. Vous pouvez consulter les traces dans l’interface web de Weave.
[
](https://forge.coreweave.com/wandb/parambharat/langchain_demo/weave/calls)
Tracer manuellement les appels
Outre le traçage automatique, vous pouvez tracer manuellement les appels à l’aide du callback `WeaveTracer` ou du gestionnaire de contexte `weave_tracing_enabled`. Ces méthodes s’apparentent à l’utilisation de callbacks de requête dans certaines parties d’une application LangChain. Utilisez-les lorsque vous souhaitez tracer des chaînes ou des invocations précises plutôt que l’ensemble de votre application.
Les sections suivantes décrivent chaque approche.
Remarque : par défaut, Weave trace les `Runnables` LangChain dès que vous appelez `weave.init()`. Vous pouvez désactiver ce comportement en définissant la variable d’environnement `WEAVE_TRACE_LANGCHAIN` sur `"false"` avant d’appeler `weave.init()`. Vous pouvez ainsi contrôler le comportement de traçage de certaines chaînes, voire de requêtes individuelles, dans votre application.
Utiliser `WeaveTracer`
Vous pouvez transmettre le callback `WeaveTracer` à des composants LangChain précis pour tracer certaines requêtes spécifiques.
```python lines {11,13,15,22} theme={"system"}
import os
os.environ["WEAVE_TRACE_LANGCHAIN"] = "false" # <- désactive explicitement le traçage global.
from weave.integrations.langchain import WeaveTracer
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
import weave
# Initialiser Weave avec le nom de votre projet
weave.init("langchain_demo") # <-- le traçage n’est pas activé ici, car la variable d’environnement est explicitement définie sur `false`
weave_tracer = WeaveTracer()
config = {"callbacks": [weave_tracer]}
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
output = llm_chain.invoke({"number": 2}, config=config) # <-- active le traçage uniquement pour cet appel de la chaîne.
llm_chain.invoke({"number": 4}) # <-- le traçage ne sera pas activé pour les appels LangChain, mais les appels OpenAI seront toujours tracés
```
Utiliser le gestionnaire de contexte `weave_tracing_enabled`
Vous pouvez également utiliser le gestionnaire de contexte `weave_tracing_enabled` pour activer le traçage sur des blocs de code précis.
```python lines {11,18} theme={"system"}
import os
os.environ["WEAVE_TRACE_LANGCHAIN"] = "false" # <- désactive explicitement le traçage global.
from weave.integrations.langchain import weave_tracing_enabled
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
import weave
# Initialiser Weave avec le nom de votre projet
weave.init("langchain_demo") # <-- le traçage n'est pas activé ici, car la variable d'environnement est explicitement définie sur `false`
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
with weave_tracing_enabled(): # <-- active le traçage uniquement pour cette invocation de la chaîne.
output = llm_chain.invoke({"number": 2})
llm_chain.invoke({"number": 4}) # <-- le traçage ne sera pas activé pour les appels LangChain, mais les appels OpenAI seront tout de même tracés
```
Configuration
Lorsque vous appelez `weave.init()`, Weave active le traçage en définissant la variable d’environnement `WEAVE_TRACE_LANGCHAIN` sur `"true"`. Weave peut ainsi capturer automatiquement les traces de vos applications LangChain. Pour désactiver ce comportement, définissez cette variable d’environnement sur `"false"`.
Lien avec les callbacks LangChain
Cette section explique comment le traçage de Weave s’intègre au système de callbacks de LangChain, afin que vous puissiez choisir l’approche la plus adaptée à votre application.
Journalisation automatique
La journalisation automatique fournie par `weave.init()` équivaut à transmettre un callback de constructeur à chaque composant d’une application LangChain. Weave suit ainsi toutes les interactions de manière globale dans l’ensemble de votre application, notamment les modèles de prompts, les chaînes, les appels LLM, les outils et les étapes des agents.
Journalisation manuelle
Les méthodes de journalisation manuelle (`WeaveTracer` et `weave_tracing_enabled`) s’apparentent à l’utilisation de callbacks de requête dans certaines parties d’une application LangChain. Elles vous permettent de contrôler plus finement les parties de votre application tracées par Weave :
* **Callbacks de constructeur :** s’appliquent à l’ensemble de la chaîne ou du composant et journalisent toutes les interactions de manière uniforme.
* **Callbacks de requête :** s’appliquent à des requêtes spécifiques et fournissent un traçage détaillé de certaines invocations.
En intégrant Weave à LangChain, vous bénéficiez de la journalisation et de la surveillance de vos applications LLM, ce qui facilite le débogage et l’optimisation des performances.
Pour plus d'informations, voir la [documentation de LangChain](https://python.langchain.com/v0.2/docs/how_to/debugging/#tracing).
Modèles et évaluations
Organiser et évaluer des LLM pour différents cas d’usage devient plus difficile à mesure que vous ajoutez des composants tels que des prompts, des configurations de modèle et des paramètres d’inférence. Avec [`weave.Model`](/fr/products/wandb/weave/guides/core-types/models), vous pouvez capturer et organiser les détails de vos expériences, comme les prompts système ou les modèles utilisés, ce qui facilite la comparaison des itérations.
Les sections suivantes montrent comment encapsuler une chaîne LangChain dans un `weave.Model`, puis l’évaluer.
L’exemple suivant montre comment encapsuler une chaîne LangChain dans un `WeaveModel` :
```python lines {10,12,16} theme={"system"}
import json
import asyncio
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialisez Weave avec le nom de votre projet
weave.init("langchain_demo")
class ExtractFruitsModel(weave.Model):
model_name: str
prompt_template: str
@weave.op()
async def predict(self, sentence: str) -> dict:
llm = ChatOpenAI(model=self.model_name, temperature=0.0)
prompt = PromptTemplate.from_template(self.prompt_template)
llm_chain = prompt | llm
response = llm_chain.invoke({"sentence": sentence})
result = response.content
if result is None:
raise ValueError("No response from model")
parsed = json.loads(result)
return parsed
model = ExtractFruitsModel(
model_name="gpt-3.5-turbo-1106",
prompt_template='Extract fields ("fruit": , "color": , "flavor": ) from the following text, as json: {sentence}',
)
sentence = "There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy."
prediction = asyncio.run(model.predict(sentence))
# si vous travaillez dans un Jupyter Notebook, exécutez :
# prediction = await model.predict(sentence)
print(prediction)
```
Ce code crée un modèle que vous pouvez visualiser dans l’interface de Weights & Biases :
[
](https://forge.coreweave.com/wandb/parambharat/langchain_demo/weave/object-versions?filter=%7B%22baseObjectClass%22%3A%22Model%22%7D\&peekPath=%2Fparambharat%2Flangchain_demo%2Fobjects%2FExtractFruitsModel%2Fversions%2FBeoL6WuCH8wgjy6HfmuBMyKzArETg1oAFpYaXZSq1hw%3F%26)
Vous pouvez également utiliser les modèles Weave avec `serve` et avec les [`Evaluations`](/fr/products/wandb/weave/guides/core-types/evaluations).
Évaluations
Les évaluations vous aident à mesurer les performances de vos modèles. La classe [`weave.Evaluation`](/fr/products/wandb/weave/guides/core-types/evaluations) permet de capturer les performances de votre modèle sur des tâches ou des jeux de données spécifiques. Vous pouvez ainsi comparer plus facilement différents modèles et différentes itérations de votre application. L’exemple suivant montre comment évaluer le modèle précédent :
```python lines theme={"system"}
from weave.scorers import MultiTaskBinaryClassificationF1
sentences = [
"There are many fruits that were found on the recently discovered planet Goocrux. There are neoskizzles that grow there, which are purple and taste like candy.",
"Pounits are a bright green color and are more savory than sweet.",
"Finally, there are fruits called glowls, which have a very sour and bitter taste which is acidic and caustic, and a pale orange tinge to them.",
]
labels = [
{"fruit": "neoskizzles", "color": "purple", "flavor": "candy"},
{"fruit": "pounits", "color": "bright green", "flavor": "savory"},
{"fruit": "glowls", "color": "pale orange", "flavor": "sour and bitter"},
]
examples = [
{"id": "0", "sentence": sentences[0], "target": labels[0]},
{"id": "1", "sentence": sentences[1], "target": labels[1]},
{"id": "2", "sentence": sentences[2], "target": labels[2]},
]
@weave.op()
def fruit_name_score(target: dict, output: dict) -> dict:
return {"correct": target["fruit"] == output["fruit"]}
evaluation = weave.Evaluation(
dataset=examples,
scorers=[
MultiTaskBinaryClassificationF1(class_names=["fruit", "color", "flavor"]),
fruit_name_score,
],
)
scores = asyncio.run(evaluation.evaluate(model)))
# si vous travaillez dans un Jupyter Notebook, exécutez :
# scores = await evaluation.evaluate(model)
print(scores)
```
Ce code génère une trace d’évaluation que vous pouvez visualiser dans l’interface de Weights & Biases :
[
](https://forge.coreweave.com/wandb/parambharat/langchain_demo/weave/calls?filter=%7B%22traceRootsOnly%22%3Atrue%7D\&peekPath=%2Fparambharat%2Flangchain_demo%2Fcalls%2F44c3f26c-d9d3-423e-b434-651ea5174be3)
Problèmes connus
**Traçage des appels asynchrones** : en raison d’un bug dans l’implémentation de l’`AsyncCallbackManager` de LangChain, les appels asynchrones ne sont pas tracés dans le bon ordre. Weave a soumis une [PR](https://github.com/langchain-ai/langchain/pull/23909) pour corriger ce problème. En attendant, l’ordre des appels dans la trace peut être inexact lorsque vous utilisez les méthodes `ainvoke`, `astream` et `abatch` dans les `Runnables` LangChain.
## Related topics
- [Exemples de code et notebooks](/fr/products/wandb/examples.md)