LlamaIndex

Tracez et déboguez les applications LlamaIndex avec Weave, en capturant automatiquement les appels LLM, les pipelines RAG, les étapes de l’agent et les évaluations.

Weave est conçu pour simplifier le suivi et la journalisation de tous les appels effectués via la bibliothèque Python LlamaIndex.

Lorsque vous travaillez avec des LLM, le débogage est inévitable. Qu’un appel au modèle échoue, qu’une sortie soit mal formatée ou que des appels de modèle imbriqués sèment la confusion, il peut être difficile d’identifier précisément les problèmes. Les applications LlamaIndex comportent souvent plusieurs étapes et appels LLM, ce qui rend essentiel de comprendre le fonctionnement interne de vos chaînes et de vos agents.

Weave simplifie ce processus en capturant automatiquement les traces de vos applications LlamaIndex. Cela vous permet de surveiller et d’analyser les performances de votre application, afin de faciliter le débogage et l’optimisation de vos flux de travail LLM. Weave vous aide également dans vos flux de travail d’évaluation.

​

Premiers pas

Pour commencer, il vous suffit d’appeler weave.init() au début de votre script. L’argument de weave.init() est un nom de projet qui vous aidera à organiser vos traces.

import weave
from llama_index.core.chat_engine import SimpleChatEngine

# Initialisez Weave avec le nom de votre projet
weave.init("llamaindex_demo")

chat_engine = SimpleChatEngine.from_defaults()
response = chat_engine.chat(
    "Say something profound and romantic about fourth of July"
)
print(response)

Dans l’exemple ci-dessus, nous créons un moteur de chat LlamaIndex simple qui, en coulisses, effectue un appel à OpenAI. Consultez la trace ci-dessous :

​

Tracing

LlamaIndex est connu pour sa facilité à connecter des données à des LLM. Une application RAG simple nécessite une étape d’embedding, une étape de récupération et une étape de synthèse de la réponse. À mesure que la complexité augmente, il devient important de stocker, dans une base de données centrale, les traces de chaque étape, aussi bien en développement qu’en production.

Ces traces sont essentielles pour déboguer et améliorer votre application. Weave suit automatiquement tous les appels effectués via la bibliothèque LlamaIndex, y compris les modèles de prompt, les appels LLM, les outils et les étapes de l’agent. Vous pouvez consulter les traces dans l’interface web de Weave.

Vous trouverez ci-dessous un exemple de pipeline RAG simple tiré du Tutoriel de démarrage (OpenAI) de LlamaIndex :

import weave
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Initialiser Weave avec le nom de votre projet
weave.init("llamaindex_demo")

# En supposant que vous ayez un fichier `.txt` dans le répertoire `data`
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")
print(response)

La chronologie de la trace capture non seulement les “événements”, mais aussi le temps d’exécution, le coût et le nombre de tokens, le cas échéant. Développez la trace pour voir les entrées et les sorties de chaque étape.

​

Observabilité en un clic 🔭

LlamaIndex propose une observabilité en un clic 🔭 pour vous permettre de créer des applications LLM rigoureuses en production.

Notre intégration exploite cette fonctionnalité de LlamaIndex et affecte automatiquement WeaveCallbackHandler() à llama_index.core.global_handler. Ainsi, si vous utilisez LlamaIndex et Weave, il vous suffit d’initialiser un run Weave - weave.init(<name-of-project>)

​

Créer un Model pour faciliter l’expérimentation

Organiser et évaluer des LLM dans des applications pour différents cas d’usage est complexe, car cela implique plusieurs composants, comme les prompts, les configurations de modèles et les paramètres d’inférence. Avec weave.Model, vous pouvez consigner et organiser des détails expérimentaux, comme les prompts système ou les modèles que vous utilisez, ce qui facilite la comparaison des différentes itérations.

L’exemple suivant montre comment créer un moteur de requête LlamaIndex dans un WeaveModel, à partir de données disponibles dans le dossier weave/data :

import weave

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.core.node_parser import SentenceSplitter
from llama_index.llms.openai import OpenAI
from llama_index.core import PromptTemplate


PROMPT_TEMPLATE = """
You are given with relevant information about Paul Graham. Answer the user query only based on the information provided. Don't make up stuff.

User Query: {query_str}
Context: {context_str}
Answer:
"""

class SimpleRAGPipeline(weave.Model):
    chat_llm: str = "gpt-4"
    temperature: float = 0.1
    similarity_top_k: int = 2
    chunk_size: int = 256
    chunk_overlap: int = 20
    prompt_template: str = PROMPT_TEMPLATE

    def get_llm(self):
        return OpenAI(temperature=self.temperature, model=self.chat_llm)

    def get_template(self):
        return PromptTemplate(self.prompt_template)

    def load_documents_and_chunk(self, data):
        documents = SimpleDirectoryReader(data).load_data()
        splitter = SentenceSplitter(
            chunk_size=self.chunk_size,
            chunk_overlap=self.chunk_overlap,
        )
        nodes = splitter.get_nodes_from_documents(documents)
        return nodes

    def get_query_engine(self, data):
        nodes = self.load_documents_and_chunk(data)
        index = VectorStoreIndex(nodes)

        llm = self.get_llm()
        prompt_template = self.get_template()

        return index.as_query_engine(
            similarity_top_k=self.similarity_top_k,
            llm=llm,
            text_qa_template=prompt_template,
        )

    @weave.op()
    def predict(self, query: str):
        query_engine = self.get_query_engine(
            # Ces données sont disponibles dans le dépôt weave sous data/paul_graham
            "data/paul_graham",
        )
        response = query_engine.query(query)
        return {"response": response.response}

weave.init("test-llamaindex-weave")

rag_pipeline = SimpleRAGPipeline()
response = rag_pipeline.predict("What did the author do growing up?")
print(response)

Cette classe SimpleRAGPipeline, une sous-classe de weave.Model, regroupe les paramètres importants de ce pipeline RAG. Décorer la méthode query avec weave.op() permet d’activer le Tracing.

​

Effectuer une évaluation avec weave.Evaluation

Les évaluations vous aident à mesurer les performances de vos applications. En utilisant la classe weave.Evaluation, vous pouvez mesurer les performances de votre modèle sur des tâches ou des jeux de données spécifiques, ce qui facilite la comparaison entre différents modèles et différentes itérations de votre application. L’exemple suivant montre comment évaluer le modèle que nous avons créé :

import asyncio
from llama_index.core.evaluation import CorrectnessEvaluator

eval_examples = [
    {
        "id": "0",
        "query": "What programming language did Paul Graham learn to teach himself AI when he was in college?",
        "ground_truth": "Paul Graham learned Lisp to teach himself AI when he was in college.",
    },
    {
        "id": "1",
        "query": "What was the name of the startup Paul Graham co-founded that was eventually acquired by Yahoo?",
        "ground_truth": "The startup Paul Graham co-founded that was eventually acquired by Yahoo was called Viaweb.",
    },
    {
        "id": "2",
        "query": "What is the capital city of France?",
        "ground_truth": "I cannot answer this question because no information was provided in the text.",
    },
]

llm_judge = OpenAI(model="gpt-4", temperature=0.0)
evaluator = CorrectnessEvaluator(llm=llm_judge)

@weave.op()
def correctness_evaluator(query: str, ground_truth: str, output: dict):
    result = evaluator.evaluate(
        query=query, reference=ground_truth, response=output["response"]
    )
    return {"correctness": float(result.score)}

evaluation = weave.Evaluation(dataset=eval_examples, scorers=[correctness_evaluator])

rag_pipeline = SimpleRAGPipeline()

asyncio.run(evaluation.evaluate(rag_pipeline))

Cette évaluation s’appuie sur l’exemple de la section précédente. Pour évaluer avec weave.Evaluation, vous avez besoin d’un jeu de données d’évaluation, d’une fonction de scorer et d’un weave.Model. Voici quelques points à noter sur ces trois composants clés :

• Assurez-vous que les clés des dict d’échantillons d’évaluation correspondent aux arguments de la fonction de scorer et de la méthode predict du weave.Model.
• Le weave.Model doit avoir une méthode nommée predict, infer ou forward. Décorez cette méthode avec weave.op() pour le Tracing.
• La fonction de scorer doit être décorée avec weave.op() et doit avoir output comme argument nommé.

En intégrant Weave à LlamaIndex, vous pouvez assurer une journalisation et une surveillance complètes de vos applications LLM, ce qui facilite le débogage et l’optimisation des performances à l’aide de l’évaluation.