Weave (Weights & Biases)

0.52.36 · active · verified Sun Apr 12

Weave by Weights & Biases is a Python toolkit designed for developing, observing, and evaluating Generative AI applications. It enables users to log and debug inputs, outputs, and traces of language models, build rigorous evaluations, and organize information across the LLM workflow, from experimentation to production. The library is currently at version 0.52.36 and has an active release cadence.

Warnings

gotcha There is an older, unrelated Python library also named 'weave' (scipy.weave) for embedding C/C++ code. Ensure you are installing and importing the 'weave' library from Weights & Biases for AI application development.
Fix: Always verify the source and purpose of the 'weave' package; for AI/LLM use cases, it's `pip install weave` from Weights & Biases.
gotcha Custom Python objects in Weave traces might be truncated if not explicitly converted. For full data retention of complex objects, ensure they are converted into a dictionary of strings before logging.
Fix: Implement a `to_dict()` method on custom objects or explicitly convert them to a dictionary of strings (e.g., `{'key': str(obj_value)}`) before they are passed to Weave operations.
breaking Weave requires Python 3.10 or higher. Older Python versions are not supported.
Fix: Upgrade your Python environment to version 3.10 or newer.
gotcha Weave's `.call()` method captures exceptions by default, storing them in `call.exception` rather than re-raising. This can obscure immediate error feedback.
Fix: To force exceptions to be re-raised during execution, set the `__should_raise=True` parameter when calling an `@weave.op` decorated function (e.g., `my_op.call(__should_raise=True)`).
gotcha Full functionality and logging require authentication with a Weights & Biases account. Your W&B API key must be provided.
Fix: Set the `WANDB_API_KEY` environment variable or pass `api_key` to `weave.init()` (though environment variables are recommended for security) before running Weave-enabled code.

Install

pip install weave Install Weave

Imports

weave
```
import weave
```
op
```
from weave import op
```
The `op` decorator is typically imported directly or accessed as `weave.op` after a general `import weave`.

Quickstart

This quickstart demonstrates how to initialize Weave, decorate a function with `@weave.op` to trace its execution, and capture LLM interactions. It uses OpenAI as an example, requiring both W&B and OpenAI API keys.

import os
import weave
from openai import OpenAI

# Ensure you have your Weights & Biases API key set as an environment variable
# os.environ['WANDB_API_KEY'] = 'YOUR_WANDB_API_KEY'
# Ensure you have your OpenAI API key set as an environment variable
# os.environ['OPENAI_API_KEY'] = 'YOUR_OPENAI_API_KEY'

# Initialize Weave with your project name
# This will create a new project or connect to an existing one in W&B
weave.init(project_name=os.environ.get('WANDB_PROJECT_NAME', 'my-llm-project'))

client = OpenAI()

@weave.op()
def extract_dinos(sentence: str) -> dict:
    """Extracts dinosaur names and diets from a sentence using OpenAI."""
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "In JSON format extract a list of `dinosaurs`, with their `name`, their `common_name`, and whether its `diet` is a herbivore or carnivore."},
            {"role": "user", "content": sentence}
        ],
        response_model=dict # Placeholder if a Pydantic model is not used here
    )
    return response.choices[0].message.content if response.choices else {}

@weave.op()
def main():
    sentence = "The mighty Tyrannosaurus Rex (T-Rex), a carnivore, hunted the herbivorous Triceratops."
    dinosaur_info = extract_dinos(sentence)
    print("Extracted Dinosaur Info:", dinosaur_info)

if __name__ == "__main__":
    main()

view raw JSON →